walrus 0.1 → 0.2

data/spec/grammar/additions/string_spec.rb

@@ -1,106 +0,0 @@
-# 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

@@ -1,29 +0,0 @@
-# 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

@@ -1,23 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-# 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

@@ -1,112 +0,0 @@
-# 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

@@ -1,126 +0,0 @@
-# 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

@@ -1,29 +0,0 @@
-# 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

@@ -1,172 +0,0 @@
-# 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