walrus 0.1

data/spec/grammar/proc_parslet_spec.rb

@@ -0,0 +1,52 @@
+# 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/proc_parslet_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 ProcParslet' do
+      
+      setup do
+        @parslet = lambda do |string, options|
+          if string == 'foobar' : string
+          else                    raise ParseError.new('expected foobar by got "%s"' + string.to_s)
+          end
+        end.to_parseable
+      end
+      
+      it 'should raise an ArgumentError if initialized with nil' do
+        lambda { ProcParslet.new(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'should complain if asked to parse nil' do
+        lambda { @parslet.parse(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'should raise ParseError if unable to parse' do
+        lambda { @parslet.parse('bar') }.should raise_error(ParseError)
+      end
+      
+      it 'should return a parsed value if able to parse' do
+        @parslet.parse('foobar').should == 'foobar'
+      end
+      
+      it 'should be able to compare parslets for equality' do
+        
+        # in practice only parslets created with the exact same Proc instance will be eql because Proc returns different hashes for each
+        @parslet.should eql(@parslet.clone)
+        @parslet.should eql(@parslet.dup)
+        @parslet.should_not eql(lambda { nil }.to_parseable)
+        
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/regexp_parslet_spec.rb

@@ -0,0 +1,347 @@
+# 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/regexp_parslet_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 regexp parslet' do
+      
+      setup do
+        @parslet = RegexpParslet.new(/[a-zA-Z_][a-zA-Z0-9_]*/)
+      end
+      
+      it 'should raise an ArgumentError if initialized with nil' do
+        lambda { RegexpParslet.new(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'parse should succeed if the input string matches' do
+        lambda { @parslet.parse('an_identifier') }.should_not raise_error
+        lambda { @parslet.parse('An_Identifier') }.should_not raise_error
+        lambda { @parslet.parse('AN_IDENTIFIER') }.should_not raise_error
+        lambda { @parslet.parse('an_identifier1') }.should_not raise_error
+        lambda { @parslet.parse('An_Identifier1') }.should_not raise_error
+        lambda { @parslet.parse('AN_IDENTIFIER1') }.should_not raise_error
+        lambda { @parslet.parse('a') }.should_not raise_error
+        lambda { @parslet.parse('A') }.should_not raise_error
+        lambda { @parslet.parse('a9') }.should_not raise_error
+        lambda { @parslet.parse('A9') }.should_not raise_error
+        lambda { @parslet.parse('_identifier') }.should_not raise_error
+        lambda { @parslet.parse('_Identifier') }.should_not raise_error
+        lambda { @parslet.parse('_IDENTIFIER') }.should_not raise_error
+        lambda { @parslet.parse('_9Identifier') }.should_not raise_error
+        lambda { @parslet.parse('_') }.should_not raise_error
+      end
+      
+      it 'parse should succeed if the input string matches, even if it continues after the match' do
+        lambda { @parslet.parse('an_identifier, more') }.should_not raise_error
+        lambda { @parslet.parse('An_Identifier, more') }.should_not raise_error
+        lambda { @parslet.parse('AN_IDENTIFIER, more') }.should_not raise_error
+        lambda { @parslet.parse('an_identifier1, more') }.should_not raise_error
+        lambda { @parslet.parse('An_Identifier1, more') }.should_not raise_error
+        lambda { @parslet.parse('AN_IDENTIFIER1, more') }.should_not raise_error
+        lambda { @parslet.parse('a, more') }.should_not raise_error
+        lambda { @parslet.parse('A, more') }.should_not raise_error
+        lambda { @parslet.parse('a9, more') }.should_not raise_error
+        lambda { @parslet.parse('A9, more') }.should_not raise_error
+        lambda { @parslet.parse('_identifier, more') }.should_not raise_error
+        lambda { @parslet.parse('_Identifier, more') }.should_not raise_error
+        lambda { @parslet.parse('_IDENTIFIER, more') }.should_not raise_error
+        lambda { @parslet.parse('_9Identifier, more') }.should_not raise_error
+        lambda { @parslet.parse('_, more') }.should_not raise_error
+      end
+      
+      it 'parse should return a MatchDataWrapper object' do
+        @parslet.parse('an_identifier').should == 'an_identifier'
+        @parslet.parse('an_identifier, more').should == 'an_identifier'
+      end
+      
+      it 'parse should raise an ArgumentError if passed nil' do
+        lambda { @parslet.parse(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'parse should raise a ParseError if the input string does not match' do
+        lambda { @parslet.parse('9') }.should raise_error(ParseError)           # a number is not a valid identifier
+        lambda { @parslet.parse('9fff') }.should raise_error(ParseError)        # identifiers must not start with numbers
+        lambda { @parslet.parse(' identifier') }.should raise_error(ParseError) # note the leading whitespace
+        lambda { @parslet.parse('') }.should raise_error(ParseError)            # empty strings can't match
+      end
+      
+      it 'should be able to compare parslets for equality' do
+        /foo/.to_parseable.should eql(/foo/.to_parseable)        # equal
+        /foo/.to_parseable.should_not eql(/bar/.to_parseable)    # different
+        /foo/.to_parseable.should_not eql(/Foo/.to_parseable)    # differing only in case
+        /foo/.to_parseable.should_not eql('foo')                 # totally different classes
+      end
+      
+      it 'should accurately pack line and column ends into whatever gets returned from "parse"' do
+        
+        # single word
+        parslet = /.+/m.to_parseable
+        result = parslet.parse('hello')
+        result.line_end.should == 0
+        result.column_end.should == 5
+        
+        # single word with newline at end (UNIX style)
+        result = parslet.parse("hello\n")
+        result.line_end.should == 1
+        result.column_end.should == 0
+        
+        # single word with newline at end (Classic Mac style)
+        result = parslet.parse("hello\r")
+        result.line_end.should == 1
+        result.column_end.should == 0
+        
+        # single word with newline at end (Windows style)
+        result = parslet.parse("hello\r\n")
+        result.line_end.should == 1
+        result.column_end.should == 0
+        
+        # two lines (UNIX style)
+        result = parslet.parse("hello\nworld")
+        result.line_end.should == 1
+        result.column_end.should == 5
+        
+        # two lines (Classic Mac style)
+        result = parslet.parse("hello\rworld")
+        result.line_end.should == 1
+        result.column_end.should == 5
+        
+        # two lines (Windows style)
+        result = parslet.parse("hello\r\nworld")
+        result.line_end.should == 1
+        result.column_end.should == 5
+        
+      end
+      
+      # in the case of RegexpParslets, the "last successfully scanned position" is always 0, 0
+      it 'line and column end should reflect last succesfully scanned position prior to failure' do
+        
+        # fail right at start
+        parslet = /hello\r\nworld/.to_parseable
+        begin
+          parslet.parse('foobar')
+        rescue ParseError => e
+          exception = e
+        end
+        exception.line_end.should == 0
+        exception.column_end.should == 0
+        
+        # fail after 1 character
+        begin
+          parslet.parse('hfoobar')
+        rescue ParseError => e
+          exception = e
+        end
+        exception.line_end.should == 0
+        exception.column_end.should == 0
+        
+        # fail after end-of-line
+        begin
+          parslet.parse("hello\r\nfoobar")
+        rescue ParseError => e
+          exception = e
+        end
+        exception.line_end.should == 0
+        exception.column_end.should == 0
+        
+      end
+      
+    end
+    
+    describe 'chaining two regexp parslets together' do
+      
+      it 'parslets should work in specified order' do
+        parslet = RegexpParslet.new(/foo.\d/) & RegexpParslet.new(/bar.\d/)
+        parslet.parse('foo_1bar_2').should == ['foo_1', 'bar_2']
+      end
+      
+      # Parser Expression Grammars match greedily
+      it 'parslets should match greedily' do
+        
+        # the first parslet should gobble up the entire string, preventing the second parslet from succeeding
+        parslet = RegexpParslet.new(/foo.+\d/) & RegexpParslet.new(/bar.+\d/)
+        lambda { parslet.parse('foo_1bar_2') }.should raise_error(ParseError)
+        
+      end
+      
+    end
+    
+    describe 'alternating two regexp parslets' do
+      
+      it 'either parslet should apply to generate a match' do
+        parslet = RegexpParslet.new(/\d+/) | RegexpParslet.new(/[A-Z]+/)
+        parslet.parse('ABC').should == 'ABC'
+        parslet.parse('123').should == '123'
+      end
+      
+      it 'should fail if no parslet generates a match' do
+        parslet = RegexpParslet.new(/\d+/) | RegexpParslet.new(/[A-Z]+/)
+        lambda { parslet.parse('abc') }.should raise_error(ParseError)
+      end
+      
+      it 'parslets should be tried in left-to-right order' do
+        
+        # in this case the first parslet should win even though the second one is also a valid match
+        parslet = RegexpParslet.new(/(.)(..)/) | RegexpParslet.new(/(..)(.)/)
+        match_data = parslet.parse('abc').match_data
+        match_data[1].should == 'a'
+        match_data[2].should == 'bc'
+        
+        # here we swap the order; again the first parslet should win
+        parslet = RegexpParslet.new(/(..)(.)/) | RegexpParslet.new(/(.)(..)/)
+        match_data = parslet.parse('abc').match_data
+        match_data[1].should == 'ab'
+        match_data[2].should == 'c'
+        
+      end
+      
+    end
+    
+    describe 'chaining three regexp parslets' do
+      
+      it 'parslets should work in specified order' do
+        parslet = RegexpParslet.new(/foo.\d/) & RegexpParslet.new(/bar.\d/) & RegexpParslet.new(/.../)
+        parslet.parse('foo_1bar_2ABC').should == ['foo_1', 'bar_2', 'ABC']        
+      end
+      
+    end
+    
+    describe 'alternating three regexp parslets' do
+      
+      it 'any parslet should apply to generate a match' do
+        parslet = RegexpParslet.new(/\d+/) | RegexpParslet.new(/[A-Z]+/) | RegexpParslet.new(/[a-z]+/)
+        parslet.parse('ABC').should == 'ABC'
+        parslet.parse('123').should == '123'
+        parslet.parse('abc').should == 'abc'
+      end
+      
+      it 'should fail if no parslet generates a match' do
+        parslet = RegexpParslet.new(/\d+/) | RegexpParslet.new(/[A-Z]+/) | RegexpParslet.new(/[a-z]+/)
+        lambda { parslet.parse(':::') }.should raise_error(ParseError)
+      end
+      
+      it 'parslets should be tried in left-to-right order' do
+        
+        # in this case the first parslet should win even though the others also produce valid matches
+        parslet = RegexpParslet.new(/(.)(..)/) | RegexpParslet.new(/(..)(.)/) | RegexpParslet.new(/(...)/)
+        match_data = parslet.parse('abc').match_data
+        match_data[1].should == 'a'
+        match_data[2].should == 'bc'
+        
+        # here we swap the order; again the first parslet should win
+        parslet = RegexpParslet.new(/(..)(.)/) | RegexpParslet.new(/(.)(..)/) | RegexpParslet.new(/(...)/)
+        match_data = parslet.parse('abc').match_data
+        match_data[1].should == 'ab'
+        match_data[2].should == 'c'
+        
+        # similar test but this time the first parslet can't win (doesn't match)
+        parslet = RegexpParslet.new(/foo/) | RegexpParslet.new(/(...)/) | RegexpParslet.new(/(.)(..)/)
+        match_data = parslet.parse('abc').match_data
+        match_data[1].should == 'abc'
+        
+      end
+      
+    end
+    
+    describe 'combining chaining and alternation' do
+      
+      it 'chaining should having higher precedence than alternation' do
+        
+        # equivalent to /foo/ | ( /bar/ & /abc/ )
+        parslet = RegexpParslet.new(/foo/) | RegexpParslet.new(/bar/) & RegexpParslet.new(/abc/)
+        parslet.parse('foo').should == 'foo'                                            # succeed on first choice
+        parslet.parse('barabc').should == ['bar', 'abc']                                # succeed on alternate path
+        lambda { parslet.parse('bar...') }.should raise_error(ParseError)               # fail half-way down alternate path
+        lambda { parslet.parse('lemon') }.should raise_error(ParseError)                # fail immediately
+        
+        # swap the order, now equivalent to: ( /bar/ & /abc/ ) | /foo/
+        parslet = RegexpParslet.new(/bar/) & RegexpParslet.new(/abc/) | RegexpParslet.new(/foo/)
+        parslet.parse('barabc').should == ['bar', 'abc']                                # succeed on first choice
+        parslet.parse('foo').should == 'foo'                                            # succeed on alternate path
+        lambda { parslet.parse('bar...') }.should raise_error(ParseError)               # fail half-way down first path
+        lambda { parslet.parse('lemon') }.should raise_error(ParseError)                # fail immediately
+        
+      end
+      
+      it 'should be able to override precedence using parentheses' do
+        
+        # take first example above and make it ( /foo/ | /bar/ ) & /abc/
+        parslet = (RegexpParslet.new(/foo/) | RegexpParslet.new(/bar/)) & RegexpParslet.new(/abc/)
+        parslet.parse('fooabc').should == ['foo', 'abc']                                # first choice
+        parslet.parse('barabc').should == ['bar', 'abc']                                # second choice
+        lambda { parslet.parse('foo...') }.should raise_error(ParseError)               # fail in second half
+        lambda { parslet.parse('bar...') }.should raise_error(ParseError)               # another way of failing in second half
+        lambda { parslet.parse('foo') }.should raise_error(ParseError)                  # another way of failing in second half
+        lambda { parslet.parse('bar') }.should raise_error(ParseError)                  # another way of failing in second half
+        lambda { parslet.parse('lemon') }.should raise_error(ParseError)                # fail immediately
+        lambda { parslet.parse('abcfoo') }.should raise_error(ParseError)               # order matters
+        
+        # take second example above and make it /bar/ & ( /abc/ | /foo/ )
+        parslet = RegexpParslet.new(/bar/) & (RegexpParslet.new(/abc/) | RegexpParslet.new(/foo/))
+        parslet.parse('barabc').should == ['bar', 'abc']                                # succeed on first choice
+        parslet.parse('barfoo').should == ['bar', 'foo']                                # second choice
+        lambda { parslet.parse('bar...') }.should raise_error(ParseError)               # fail in second part
+        lambda { parslet.parse('bar') }.should raise_error(ParseError)                  # another way to fail in second part
+        lambda { parslet.parse('lemon') }.should raise_error(ParseError)                # fail immediately
+        lambda { parslet.parse('abcbar') }.should raise_error(ParseError)               # order matters
+        
+      end
+      
+      it 'should be able to include long runs of sequences' do
+        
+        # A & B & C & D | E
+        parslet = RegexpParslet.new(/a/) & RegexpParslet.new(/b/) & RegexpParslet.new(/c/) & RegexpParslet.new(/d/) | RegexpParslet.new(/e/)
+        parslet.parse('abcd').should == ['a', 'b', 'c', 'd']
+        parslet.parse('e').should == 'e'
+        lambda { parslet.parse('f') }.should raise_error(ParseError)
+        
+      end
+      
+      it 'should be able to include long runs of options' do
+        
+        # A | B | C | D & E
+        parslet = RegexpParslet.new(/a/) | RegexpParslet.new(/b/) | RegexpParslet.new(/c/) | RegexpParslet.new(/d/) & RegexpParslet.new(/e/)
+        parslet.parse('a').should == 'a'
+        parslet.parse('b').should == 'b'
+        parslet.parse('c').should == 'c'
+        parslet.parse('de').should == ['d', 'e']
+        lambda { parslet.parse('f') }.should raise_error(ParseError)
+        
+      end
+      
+      it 'should be able to alternate repeatedly between sequences and choices' do
+        
+        # A & B | C & D | E
+        parslet = RegexpParslet.new(/a/) & RegexpParslet.new(/b/) | RegexpParslet.new(/c/) & RegexpParslet.new(/d/) | RegexpParslet.new(/e/)
+        parslet.parse('ab').should == ['a', 'b']
+        parslet.parse('cd').should == ['c', 'd']
+        parslet.parse('e').should == 'e'
+        lambda { parslet.parse('f') }.should raise_error(ParseError)
+        
+      end
+      
+      it 'should be able to combine long runs with alternation' do
+        
+        # A & B & C | D | E | F & G & H
+        parslet = RegexpParslet.new(/a/) & RegexpParslet.new(/b/) & RegexpParslet.new(/c/) | 
+                  RegexpParslet.new(/d/) | RegexpParslet.new(/e/) | RegexpParslet.new(/f/) &
+                  RegexpParslet.new(/g/) & RegexpParslet.new(/h/)
+        parslet.parse('abc').should == ['a', 'b', 'c']
+        parslet.parse('d').should == 'd'
+        parslet.parse('e').should == 'e'
+        parslet.parse('fgh').should == ['f', 'g', 'h']
+        lambda { parslet.parse('i') }.should raise_error(ParseError)
+        
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/string_enumerator_spec.rb

@@ -0,0 +1,94 @@
+# 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/string_enumerator_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 string enumerator' do
+      
+      it 'should raise an ArgumentError if initialized with nil' do
+        lambda { StringEnumerator.new(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'should return characters one by one until end of string, then return nil' do
+        enumerator = StringEnumerator.new('hello')
+        enumerator.next.should == 'h'
+        enumerator.next.should == 'e'
+        enumerator.next.should == 'l'
+        enumerator.next.should == 'l'
+        enumerator.next.should == 'o'
+        enumerator.next.should be_nil
+      end
+      
+      it 'enumerators should be Unicode-aware (UTF-8)' do
+        enumerator = StringEnumerator.new('€ cañon')
+        enumerator.next.should == '€'
+        enumerator.next.should == ' '
+        enumerator.next.should == 'c'
+        enumerator.next.should == 'a'
+        enumerator.next.should == 'ñ'
+        enumerator.next.should == 'o'
+        enumerator.next.should == 'n'
+        enumerator.next.should be_nil
+      end
+      
+      # this was a bug
+      it 'enumerators should continue past newlines' do
+        enumerator = StringEnumerator.new("hello\nworld")
+        enumerator.next.should == 'h'
+        enumerator.next.should == 'e'
+        enumerator.next.should == 'l'
+        enumerator.next.should == 'l'
+        enumerator.next.should == 'o'
+        enumerator.next.should == "\n" # was returning nil here
+        enumerator.next.should == 'w'
+        enumerator.next.should == 'o'
+        enumerator.next.should == 'r'
+        enumerator.next.should == 'l'
+        enumerator.next.should == 'd'
+      end
+      
+      it 'should be able to peek at the next character without actually enumerating' do
+        enumerator = StringEnumerator.new('h€llo')
+        enumerator.peek.should == 'h' # peek but don't advance
+        enumerator.next.should == 'h' # advance
+        enumerator.peek.should == '€' # peek a multi-byte character
+        enumerator.next.should == '€' # advance a multi-byte character
+        enumerator.peek.should == 'l' # peek
+        enumerator.peek.should == 'l' # peek the same character again
+        enumerator.next.should == 'l' # advance
+        enumerator.next.should == 'l' # advance
+        enumerator.next.should == 'o' # advance
+        enumerator.peek.should == nil # at end should return nil
+        enumerator.next.should == nil # nothing left to scan
+      end
+      
+      it 'should be able to recall the last character using the "last" method' do
+        enumerator = StringEnumerator.new('h€llo')
+        enumerator.last.should == nil # nothing scanned yet
+        enumerator.next.should == 'h' # advance
+        enumerator.last.should == nil # still no previous character
+        enumerator.next.should == '€' # advance
+        enumerator.last.should == 'h'
+        enumerator.next.should == 'l' # advance
+        enumerator.last.should == '€'
+        enumerator.next.should == 'l' # advance
+        enumerator.last.should == 'l'
+        enumerator.next.should == 'o' # advance
+        enumerator.last.should == 'l'
+        enumerator.next.should == nil # nothing left to scan
+        enumerator.last.should == 'o'
+        enumerator.last.should == 'o' # didn't advance, so should return the same as last time
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/string_parslet_spec.rb

@@ -0,0 +1,143 @@
+# 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/string_parslet_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 string parslet' do
+      
+      setup do
+        @parslet = StringParslet.new('HELLO')
+      end
+      
+      it 'should raise an ArgumentError if initialized with nil' do
+        lambda { StringParslet.new(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'parse should succeed if the input string matches' do
+        lambda { @parslet.parse('HELLO') }.should_not raise_error
+      end
+      
+      it 'parse should succeed if the input string matches, even if it continues after the match' do
+        lambda { @parslet.parse('HELLO...') }.should_not raise_error
+      end
+      
+      it 'parse should return parsed string' do
+        @parslet.parse('HELLO').should == 'HELLO'
+        @parslet.parse('HELLO...').should == 'HELLO'
+      end
+      
+      it 'parse should raise an ArgumentError if passed nil' do
+        lambda { @parslet.parse(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'parse should raise a ParseError if the input string does not match' do
+        lambda { @parslet.parse('GOODBYE') }.should raise_error(ParseError)        # total mismatch
+        lambda { @parslet.parse('GOODBYE, HELLO') }.should raise_error(ParseError) # eventually would match, but too late
+        lambda { @parslet.parse('HELL...') }.should raise_error(ParseError)        # starts well, but fails
+        lambda { @parslet.parse(' HELLO') }.should raise_error(ParseError)         # note the leading whitespace
+        lambda { @parslet.parse('') }.should raise_error(ParseError)               # empty strings can't match
+      end
+      
+      it 'parse exceptions should include a detailed error message' do
+        # TODO: catch the raised exception and compare the message
+        lambda { @parslet.parse('HELL...') }.should raise_error(ParseError)
+        lambda { @parslet.parse('HELL') }.should raise_error(ParseError)
+      end
+      
+      it 'should be able to compare string parslets for equality' do
+        'foo'.to_parseable.should eql('foo'.to_parseable)           # equal
+        'foo'.to_parseable.should_not eql('bar'.to_parseable)       # different
+        'foo'.to_parseable.should_not eql('Foo'.to_parseable)       # differing only in case
+        'foo'.to_parseable.should_not eql(/foo/)                    # totally different classes
+      end
+      
+      it 'should accurately pack line and column ends into whatever is returned by "parse"' do
+        
+        # single word
+        parslet = 'hello'.to_parseable
+        result = parslet.parse('hello')
+        result.line_end.should == 0
+        result.column_end.should == 5
+        
+        # single word with newline at end (UNIX style)
+        parslet = "hello\n".to_parseable
+        result = parslet.parse("hello\n")
+        result.line_end.should == 1
+        result.column_end.should == 0
+        
+        # single word with newline at end (Classic Mac style)
+        parslet = "hello\r".to_parseable
+        result = parslet.parse("hello\r")
+        result.line_end.should == 1
+        result.column_end.should == 0
+        
+        # single word with newline at end (Windows style)
+        parslet = "hello\r\n".to_parseable
+        result = parslet.parse("hello\r\n")
+        result.line_end.should == 1
+        result.column_end.should == 0
+        
+        # two lines (UNIX style)
+        parslet = "hello\nworld".to_parseable
+        result = parslet.parse("hello\nworld")
+        result.line_end.should == 1
+        result.column_end.should == 5
+        
+        # two lines (Classic Mac style)
+        parslet = "hello\rworld".to_parseable
+        result = parslet.parse("hello\rworld")
+        result.line_end.should == 1
+        result.column_end.should == 5
+        
+        # two lines (Windows style)
+        parslet = "hello\r\nworld".to_parseable
+        result = parslet.parse("hello\r\nworld")
+        result.line_end.should == 1
+        result.column_end.should == 5
+        
+      end
+      
+      it 'line and column end should reflect last succesfully scanned position prior to failure' do
+        
+        # fail right at start
+        parslet = "hello\r\nworld".to_parseable
+        begin
+          parslet.parse('foobar')
+        rescue ParseError => e
+          exception = e
+        end
+        exception.line_end.should == 0
+        exception.column_end.should == 0
+        
+        # fail after 1 character
+        begin
+          parslet.parse('hfoobar')
+        rescue ParseError => e
+          exception = e
+        end
+        exception.line_end.should == 0
+        exception.column_end.should == 1
+        
+        # fail after end-of-line
+        begin
+          parslet.parse("hello\r\nfoobar")
+        rescue ParseError => e
+          exception = e
+        end
+        exception.line_end.should == 1
+        exception.column_end.should == 0
+        
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/symbol_parslet_spec.rb

@@ -0,0 +1,30 @@
+# 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/symbol_parslet_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 symbol parslet' do
+      
+      it 'should raise an ArgumentError if initialized with nil' do
+        lambda { SymbolParslet.new(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'should be able to compare symbol parslets for equality' do
+        :foo.to_parseable.should eql(:foo.to_parseable)           # equal
+        :foo.to_parseable.should_not eql(:bar.to_parseable)       # different
+        :foo.to_parseable.should_not eql(:Foo.to_parseable)       # differing only in case
+        :foo.to_parseable.should_not eql(/foo/)                   # totally different classes
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus