walrus 0.1 → 0.2

data/spec/grammar/proc_parslet_spec.rb

@@ -1,52 +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/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

@@ -1,347 +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/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

@@ -1,94 +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/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

@@ -1,143 +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/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

@@ -1,30 +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/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