walrus 0.1

data/spec/grammar/additions/string_spec.rb

@@ -0,0 +1,106 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: /mirrors/Walrus/trunk/walrus/spec/grammar/additions/string_spec.rb 6702 2007-04-09T15:04:40.448669Z wincent  $
+
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper.rb')
+
+module Walrus
+  class Grammar
+    
+    describe 'iterating over a string' do
+      
+      # formerly a bug: the StringScanner used under the covers was returnin nil (stopping) on hitting a newline
+      it 'should be able to iterate over strings containing newlines' do
+        chars = []
+        "hello\nworld".each_char { |c| chars << c }
+        chars.length.should == 11
+        chars[0].should == 'h'
+        chars[1].should == 'e'
+        chars[2].should == 'l'
+        chars[3].should == 'l'
+        chars[4].should == 'o'
+        chars[5].should == "\n"
+        chars[6].should == 'w'
+        chars[7].should == 'o'
+        chars[8].should == 'r'
+        chars[9].should == 'l'
+        chars[10].should == 'd'
+      end
+      
+    end
+    
+    describe 'working with Unicode strings' do
+      
+      setup do
+        @string = 'Unicode €!' # € (Euro) is a three-byte UTF-8 glyph: "\342\202\254"
+      end
+      
+      it 'the "each_char" method should work with multibyte characters' do
+        chars = []
+        @string.each_char { |c| chars << c }
+        chars.length.should == 10
+        chars[0].should == 'U'
+        chars[1].should == 'n'
+        chars[2].should == 'i'
+        chars[3].should == 'c'
+        chars[4].should == 'o'
+        chars[5].should == 'd'
+        chars[6].should == 'e'
+        chars[7].should == ' '
+        chars[8].should == '€'
+        chars[9].should == '!'
+      end
+      
+      it 'the "chars" method should work with multibyte characters' do
+        @string.chars.should == ['U', 'n', 'i', 'c', 'o', 'd', 'e', ' ', '€', '!']
+      end
+      
+      it 'should be able to use "enumerator" convenience method to get a string enumerator' do
+        enumerator = 'hello€'.enumerator
+        enumerator.next.should == 'h'
+        enumerator.next.should == 'e'
+        enumerator.next.should == 'l'
+        enumerator.next.should == 'l'
+        enumerator.next.should == 'o'
+        enumerator.next.should == '€'
+        enumerator.next.should be_nil
+      end
+      
+      it 'the "jlength" method should correctly report the number of characters in a string' do
+        @string.jlength.should  == 10
+        "€".jlength.should      == 1  # three bytes long, but one character
+      end
+      
+    end
+    
+    # For more detailed specification of the StringParslet behaviour see string_parslet_spec.rb.
+    describe 'using shorthand to get StringParslets from String instances' do
+      
+      it 'chaining two Strings with the "&" operator should yield a two-element sequence' do
+        sequence = 'foo' & 'bar'
+        sequence.parse('foobar').should == ['foo', 'bar']
+        lambda { sequence.parse('no match') }.should raise_error(ParseError)
+      end
+      
+      it 'chaining three Strings with the "&" operator should yield a three-element sequence' do
+        sequence = 'foo' & 'bar' & '...'
+        sequence.parse('foobar...').should == ['foo', 'bar', '...']
+        lambda { sequence.parse('no match') }.should raise_error(ParseError)
+      end
+      
+      it 'alternating two Strings with the "|" operator should yield a single string' do
+        sequence = 'foo' | 'bar'
+        sequence.parse('foo').should == 'foo'
+        sequence.parse('foobar').should == 'foo'
+        sequence.parse('bar').should == 'bar'
+        lambda { sequence.parse('no match') }.should raise_error(ParseError)
+      end
+      
+    end
+  
+  end # class Grammar
+end # module Walrus

data/spec/grammar/and_predicate_spec.rb

@@ -0,0 +1,29 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: /mirrors/Walrus/trunk/walrus/spec/grammar/and_predicate_spec.rb 6702 2007-04-09T15:04:40.448669Z wincent  $
+
+require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+
+module Walrus
+  class Grammar
+    
+    describe 'using an "and predicate"' do
+      
+      it 'should complain on trying to parse a nil string' do
+        lambda { AndPredicate.new('irrelevant').parse(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'should be able to compare for equality' do
+        AndPredicate.new('foo').should eql(AndPredicate.new('foo'))      # same
+        AndPredicate.new('foo').should_not eql(AndPredicate.new('bar'))  # different
+        AndPredicate.new('foo').should_not eql(Predicate.new('foo'))     # same, but different classes
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/continuation_wrapper_exception_spec.rb

@@ -0,0 +1,23 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: /mirrors/Walrus/trunk/walrus/spec/grammar/continuation_wrapper_exception_spec.rb 6702 2007-04-09T15:04:40.448669Z wincent  $
+
+require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+
+module Walrus
+  class Grammar
+    
+    describe 'creating a continuation wrapper exception' do
+      
+      it 'should complain if initialized with nil' do
+        lambda { ContinuationWrapperException.new(nil) }.should raise_error(ArgumentError)
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/match_data_wrapper_spec.rb

@@ -0,0 +1,41 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: /mirrors/Walrus/trunk/walrus/spec/grammar/match_data_wrapper_spec.rb 6702 2007-04-09T15:04:40.448669Z wincent  $
+
+require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+
+module Walrus
+  class Grammar
+    
+    describe 'using a match data object' do
+      
+      setup do
+        'hello agent' =~ /(\w+)(\s+)(\w+)/
+        @match        = MatchDataWrapper.new($~)
+      end
+      
+      it 'should raise if initialized with nil' do
+        lambda { MatchDataWrapper.new(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'stored match data should persist after multiple matches are executed' do
+        original      = @match.match_data     # store original value
+        'foo'         =~ /foo/                # clobber $~
+        @match.match_data.should == original  # confirm that stored value is still intact
+      end
+      
+      it 'comparisons with Strings should work automatically without having to call the "to_s" method' do
+        @match.should         == 'hello agent'  # normal order
+        'hello agent'.should  == @match         # reverse order
+        @match.should_not     == 'foobar'       # inverse test sense (not equal)
+        'foobar'.should_not   == @match
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/memoizing_cache_spec.rb

@@ -0,0 +1,112 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: /mirrors/Walrus/trunk/walrus/spec/grammar/memoizing_cache_spec.rb 6702 2007-04-09T15:04:40.448669Z wincent  $
+
+require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+
+module Walrus
+  class Grammar
+    
+    class MemoizingCache
+      
+      describe 'using the NoValueForKey class' do
+        
+        it 'NoValueForKey should be a singleton' do
+          lambda { NoValueForKey.new }.should raise_error
+          NoValueForKey.instance.object_id.should == NoValueForKey.instance.object_id
+        end
+        
+        it 'should be able to use NoValueForKey as the default value for a hash' do
+          hash = Hash.new(NoValueForKey.instance)
+          hash.default.should == NoValueForKey.instance
+          hash[:foo].should == NoValueForKey.instance
+          hash[:foo] = 'bar'
+          hash[:foo].should == 'bar'
+          hash[:bar].should == NoValueForKey.instance
+        end
+        
+      end
+      
+    end
+    
+    describe 'using a memoizing cache' do
+      
+      it 'should be able to parse with memoizing turned on' do
+        
+      end
+      
+      it 'should be able to parse with memoizing turned on' do
+        
+      end
+      
+      it 'parsing with memoization turned on should be faster' do
+        
+      end
+      
+    end
+    
+    # left-recursion is enabled by code in the memoizer and elsewhere; keep the specs here for want of a better place
+    describe 'working with left-recursive rules' do
+      
+      it 'circular rules should cause a short-circuit' do
+        grammar = Grammar.subclass('InfiniteLoop') do
+          starting_symbol :a
+          rule            :a, :a # a bone-headed rule
+        end
+        lambda { grammar.parse('anything') }.should raise_error(LeftRecursionException)
+      end
+      
+      it 'shortcuiting should not be fatal if a valid alternative is present' do
+        grammar = Grammar.subclass('AlmostInfinite') do
+          starting_symbol :a
+          rule            :a, :a | :b # slightly less bone-headed
+          rule            :b, 'foo'
+        end
+        grammar.parse('foo').should == 'foo'
+      end
+      
+      it 'should retry after short-circuiting if valid continuation point' do
+        
+        grammar = Grammar.subclass('MuchMoreRealisticExample') do
+          starting_symbol :a
+          rule            :a, :a & :b | :b
+          rule            :b, 'foo'
+        end
+        
+        # note the right associativity
+        grammar.parse('foo').should == 'foo'
+        grammar.parse('foofoo').should == ['foo', 'foo']
+        grammar.parse('foofoofoo').should == [['foo', 'foo'], 'foo']
+        grammar.parse('foofoofoofoo').should == [[['foo', 'foo'], 'foo'], 'foo']
+        grammar.parse('foofoofoofoofoo').should == [[[['foo', 'foo'], 'foo'], 'foo'], 'foo']
+        
+      end
+      
+      it 'right associativity should work when building AST nodes' do
+        
+        grammar = Grammar.subclass('RightAssociativeAdditionExample') do
+          starting_symbol :addition_expression
+          rule            :term, /\d+/
+          rule            :addition_expression, :addition_expression & '+'.skip & :term | :term
+          production      :addition_expression.build(:node, :left, :right)
+          
+          # TODO: syntax for expressing alternate production?
+          
+        end
+        
+        
+        
+        
+        
+        
+        
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/node_spec.rb

@@ -0,0 +1,126 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: /mirrors/Walrus/trunk/walrus/spec/grammar/node_spec.rb 6702 2007-04-09T15:04:40.448669Z wincent  $
+
+require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+
+module Walrus
+  class Grammar
+    
+    describe 'working in the default namespace' do
+      
+      it 'should complain if passed nil as subclass name' do
+        lambda { Node.subclass(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'should be able to create a Node subclass (default namespace)' do
+        
+        # passing a string
+        Node.subclass('FooNode').should_not be_nil
+        FooNode.class.should == Class # meta class
+        FooNode.new('blah').class.should == FooNode
+        
+        # passing a symbol
+        Node.subclass(:BarNode).should_not be_nil
+        BarNode.class.should == Class # meta class
+        BarNode.new('blah').class.should == BarNode
+        
+      end
+      
+      it 'should be able to create a Node subclass (explicit namespace, Walrus::Grammar)' do
+        
+        # default accessor, lexeme
+        Node.subclass('ExplicitNamespaceNode', Walrus::Grammar).should_not be_nil
+        ExplicitNamespaceNode.new('hi').lexeme.should == 'hi'
+        
+        # override default accessor
+        Node.subclass('ExplicitNamespaceNode2', Walrus::Grammar, :foo).should_not be_nil
+        ExplicitNamespaceNode2.new('hi').foo.should == 'hi'
+        
+        # multiple accessors
+        Node.subclass('ExplicitNamespaceNode3', Walrus::Grammar, :foo, :bar).should_not be_nil
+        n = ExplicitNamespaceNode3.new('hi', 'world')
+        n.foo.should == 'hi'
+        n.bar.should == 'world'
+        
+      end
+      
+      it 'should be able to create a Node subclass (totally custom namespace)' do
+        
+        # default accessor, lexeme
+        Node.subclass('CustomNamespaceNode', Walrus).should_not be_nil
+        CustomNamespaceNode.new('hi').lexeme.should == 'hi'
+        
+        # override default accessor
+        Node.subclass('CustomNamespaceNode2', Walrus, :foo).should_not be_nil
+        CustomNamespaceNode2.new('hi').foo.should == 'hi'
+        
+        # multiple accessors
+        Node.subclass('CustomNamespaceNode3', Walrus, :foo, :bar).should_not be_nil
+        n = CustomNamespaceNode3.new('hi', 'world')
+        n.foo.should == 'hi'
+        n.bar.should == 'world'
+        
+      end
+      
+      it 'read accessors should work on a Node subclasses' do
+        
+        # default accessor, lexeme
+        Node.subclass('AmazingNode')
+        AmazingNode.new('xyz').lexeme.should == 'xyz'
+        
+        # single custom accessor
+        Node.subclass('AmazingerNode', Walrus::Grammar, :foo)
+        AmazingerNode.new('bar').foo.should == 'bar'
+        
+        # two custom accessors
+        Node.subclass('AmazingestNode', Walrus::Grammar, :bar, :baz)
+        node = AmazingestNode.new('hello', 'world')
+        node.bar.should == 'hello'
+        node.baz.should == 'world'
+        
+      end
+      
+      it 'should complain if initialize called with missing arguments' do
+        
+        # default accessor, lexeme
+        Node.subclass('AmazingNode2')
+        lambda { AmazingNode2.new }.should raise_error(ArgumentError)
+        
+        # single custom accessor
+        Node.subclass('AmazingerNode2', Walrus::Grammar, :foo)
+        lambda { AmazingerNode2.new }.should raise_error(ArgumentError)
+        
+        # two custom accessors
+        Node.subclass('AmazingestNode2', Walrus::Grammar, :bar, :baz)
+        lambda { AmazingestNode2.new }.should raise_error(ArgumentError) # missing both arguments
+        lambda { AmazingestNode2.new('hello') }.should raise_error(ArgumentError) # missing one argument
+        
+      end
+      
+      it 'should be able to subclass a Node subclass' do
+        
+        Node.subclass('FirstSubclass')
+        FirstSubclass.subclass('Grandchild').should_not be_nil
+        Grandchild.new('foo').class.should == Grandchild
+        Grandchild.new('hello').lexeme.should == 'hello'
+        
+      end
+      
+      it 'read accessors should work on a subclass of a Node subclass' do
+        Node.subclass('MySubclass')
+        MySubclass.subclass('OtherSubclass', Walrus::Grammar, :from, :to).should_not be_nil
+        s = OtherSubclass.new('Bob', 'Alice')
+        s.from.should == 'Bob'
+        s.to.should == 'Alice'
+      end
+      
+    end
+    
+  end # class Grammar  
+end # module Walrus
+

data/spec/grammar/not_predicate_spec.rb

@@ -0,0 +1,29 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: /mirrors/Walrus/trunk/walrus/spec/grammar/not_predicate_spec.rb 6702 2007-04-09T15:04:40.448669Z wincent  $
+
+require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+
+module Walrus
+  class Grammar
+    
+    describe 'using a "not predicate"' do
+      
+      it 'should complain on trying to parse a nil string' do
+        lambda { NotPredicate.new('irrelevant').parse(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'should be able to compare for equality' do
+        NotPredicate.new('foo').should eql(NotPredicate.new('foo'))      # same
+        NotPredicate.new('foo').should_not eql(NotPredicate.new('bar'))  # different
+        NotPredicate.new('foo').should_not eql(Predicate.new('foo'))     # same, but different classes
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/parser_state_spec.rb

@@ -0,0 +1,172 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: /mirrors/Walrus/trunk/walrus/spec/grammar/parser_state_spec.rb 6702 2007-04-09T15:04:40.448669Z wincent  $
+
+require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+
+module Walrus
+  class Grammar
+    
+    describe 'using a parser state object' do
+      
+      setup do
+        @base_string = 'this is the string to be parsed'
+        @state = ParserState.new(@base_string)
+      end
+      
+      it 'should raise an ArgumentError if initialized with nil' do
+        lambda { ParserState.new(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'before parsing has started "remainder" should equal the entire string' do
+        @state.remainder.should == @base_string
+      end
+      
+      it 'before parsing has started "remainder" should equal the entire string (when string is an empty string)' do
+        ParserState.new('').remainder.should == ''
+      end
+      
+      it 'before parsing has started "results" should be empty' do
+        @state.results.should be_empty
+      end
+      
+      it '"parsed" should complain if passed nil' do
+        lambda { @state.parsed(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it '"skipped" should complain if passed nil' do
+        lambda { @state.skipped(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it '"parsed" should return the remainder of the string' do
+        @state.parsed('this is the ').should  == 'string to be parsed'
+        @state.parsed('string ').should       == 'to be parsed'
+        @state.parsed('to be parsed').should  == ''
+      end
+      
+      it '"skipped" should return the remainder of the string' do
+        @state.skipped('this is the ').should == 'string to be parsed'
+        @state.skipped('string ').should      == 'to be parsed'
+        @state.skipped('to be parsed').should == ''
+      end
+      
+      it '"results" should return an unwrapped parsed result (for single results)' do
+        @state.parsed('this')
+        @state.results.should == 'this'
+      end
+      
+      it 'skipped substrings should not appear in "results"' do
+        @state.skipped('this')
+        @state.results.should be_empty
+      end
+      
+      it 'should return an array of the parsed results (for multiple results)' do
+        @state.parsed('this ')
+        @state.parsed('is ')
+        @state.results.should == ['this ', 'is ']
+      end
+      
+      it 'should work when the entire string is consumed in a single operation (using "parsed")' do
+        @state.parsed(@base_string).should == ''
+        @state.results.should == @base_string
+      end
+      
+      it 'should work when the entire string is consumed in a single operation (using "skipped")' do
+        @state.skipped(@base_string).should == ''
+        @state.results.should be_empty
+      end
+      
+      it '"parsed" should complain if passed something that doesn\'t respond to the "line_end" and "column_end" messages' do
+        
+        # line_end
+        my_mock = mock('mock_which_does_not_implement_line_end', :null_object => true) 
+        my_mock.should_receive(:line_end).and_raise(NoMethodError) 
+        lambda { @state.parsed(my_mock) }.should raise_error(NoMethodError)
+        
+        # column_end
+        my_mock = mock('mock_which_does_not_implement_column_end', :null_object => true) 
+        my_mock.should_receive(:column_end).and_raise(NoMethodError) 
+        lambda { @state.parsed(my_mock) }.should raise_error(NoMethodError)
+        
+      end
+      
+      it '"skipped" should complain if passed something that doesn\'t respond to the "line_end" and "column_end" messages' do
+        
+        # line_end
+        my_mock = mock('mock_which_does_not_implement_line_end', :null_object => true) 
+        my_mock.should_receive(:line_end).and_raise(NoMethodError) 
+        lambda { @state.skipped(my_mock) }.should raise_error(NoMethodError)
+        
+        # column_end
+        my_mock = mock('mock_which_does_not_implement_column_end', :null_object => true) 
+        my_mock.should_receive(:column_end).and_raise(NoMethodError) 
+        lambda { @state.skipped(my_mock) }.should raise_error(NoMethodError)
+        
+      end
+      
+      it 'should be able to mix use of "parsed" and "skipped" methods' do
+        
+        # first example
+        @state.skipped('this is the ').should  == 'string to be parsed'
+        @state.results.should be_empty
+        @state.parsed('string ').should       == 'to be parsed'
+        @state.results.should == 'string '
+        @state.skipped('to be parsed').should  == ''
+        @state.results.should == 'string '
+        
+        # second example (add this test to isolate a bug in another specification)
+        state = ParserState.new('foo1...')
+        state.skipped('foo').should == '1...'
+        state.remainder.should == '1...'
+        state.results.should be_empty
+        state.parsed('1').should == '...'
+        state.remainder.should == '...'
+        state.results.should == '1'
+        
+      end
+      
+      it '"parsed" and "results" methods should work with multi-byte Unicode strings' do
+        
+        # basic test
+        state = ParserState.new('400€, foo')
+        state.remainder.should == '400€, foo'
+        state.parsed('40').should == '0€, foo'
+        state.results.should == '40'
+        state.parsed('0€, ').should == 'foo'
+        state.results.should == ['40', '0€, ']
+        state.parsed('foo').should == ''
+        state.results.should == ['40', '0€, ', 'foo']
+        
+        # test with newlines before and after multi-byte chars
+        state = ParserState.new("400\n or more €...\nfoo")
+        state.remainder.should == "400\n or more €...\nfoo"
+        state.parsed("400\n or more").should == " €...\nfoo"
+        state.results.should == "400\n or more"
+        state.parsed(' €..').should == ".\nfoo"
+        state.results.should == ["400\n or more", ' €..']
+        state.parsed(".\nfoo").should == ''
+        state.results.should == ["400\n or more", ' €..', ".\nfoo"]
+        
+      end
+      
+      it '"skipped" and "results" methods should work with multi-byte Unicode strings' do
+        state = ParserState.new('400€, foo')
+        state.remainder.should == '400€, foo'
+        state.skipped('4').should == '00€, foo'
+        state.results.should be_empty
+        state.parsed('0').should == '0€, foo'
+        state.results.should == '0'
+        state.skipped('0€, ').should == 'foo'
+        state.results.should == '0'
+        state.parsed('foo').should == ''
+        state.results.should == ['0', 'foo']
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus