]> git.wincent.com - walrat.git/blob - spec/memoizing_cache_spec.rb
Update to RSpec 3.1.0
[walrat.git] / spec / memoizing_cache_spec.rb
1 # Copyright 2007-2014 Greg Hurrell. All rights reserved.
2 # Licensed under the terms of the BSD 2-clause license.
3
4 require 'spec_helper'
5
6 describe Walrat::MemoizingCache::NoValueForKey do
7   it 'is a singleton' do
8     expect do
9       Walrat::MemoizingCache::NoValueForKey.new
10     end.to raise_error(NoMethodError, /private method/)
11
12     Walrat::MemoizingCache::NoValueForKey.instance.object_id.
13       should == Walrat::MemoizingCache::NoValueForKey.instance.object_id
14   end
15
16   it 'should be able to use NoValueForKey as the default value for a hash' do
17     hash = Hash.new Walrat::MemoizingCache::NoValueForKey.instance
18     hash.default.should == Walrat::MemoizingCache::NoValueForKey.instance
19     hash[:foo].should == Walrat::MemoizingCache::NoValueForKey.instance
20     hash[:foo] = 'bar'
21     hash[:foo].should == 'bar'
22     hash[:bar].should == Walrat::MemoizingCache::NoValueForKey.instance
23   end
24 end
25
26 describe Walrat::MemoizingCache do
27   it 'parses with memoizing turned on'
28   it 'parses with memoizing turned off'
29   it 'parses faster with memoization turned on'
30 end
31
32 # left-recursion is enabled by code in the memoizer and elsewhere; keep the
33 # specs here for want of a better place
34 describe 'working with left-recursive rules' do
35   specify 'circular rules should cause a short-circuit' do
36     class InfiniteLoop < Walrat::Grammar
37       starting_symbol :a
38       rule            :a, :a # a bone-headed rule
39     end
40
41     grammar = InfiniteLoop.new
42     expect do
43       grammar.parse('anything')
44     end.to raise_error(Walrat::LeftRecursionException)
45   end
46
47   specify 'shortcuiting is not be fatal if a valid alternative is present' do
48     class AlmostInfinite < Walrat::Grammar
49       starting_symbol :a
50       rule            :a, :a | :b # slightly less bone-headed
51       rule            :b, 'foo'
52     end
53
54     grammar = AlmostInfinite.new
55     grammar.parse('foo').should == 'foo'
56   end
57
58   it 'retries after short-circuiting if valid continuation point' do
59     class MuchMoreRealisticExample < Walrat::Grammar
60       starting_symbol :a
61       rule            :a, :a & :b | :b
62       rule            :b, 'foo'
63     end
64
65     # note the right associativity
66     grammar = MuchMoreRealisticExample.new
67     grammar.parse('foo').should == 'foo'
68     grammar.parse('foofoo').should == ['foo', 'foo']
69     grammar.parse('foofoofoo').should == [['foo', 'foo'], 'foo']
70     grammar.parse('foofoofoofoo').should == [[['foo', 'foo'], 'foo'], 'foo']
71     grammar.parse('foofoofoofoofoo').should == [[[['foo', 'foo'], 'foo'], 'foo'], 'foo']
72   end
73
74   specify 'right associativity should work when building AST nodes' do
75     class RightAssociativeAdditionExample < Walrat::Grammar
76       starting_symbol :addition_expression
77       rule            :term, /\d+/
78       rule            :addition_expression,
79                       :addition_expression & '+'.skip & :term | :term
80       node            :addition_expression
81       production      :addition_expression, :left, :right
82
83       # TODO: syntax for expressing alternate production?
84     end
85
86     pending
87     grammar = RightAssociativeAdditionExample.new
88     result = grammar.parse('1+2')
89   end
90 end