walrus 0.1

data/spec/grammar/parslet_choice_spec.rb

@@ -0,0 +1,49 @@
+# 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/parslet_choice_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 Parslet Choice' do
+      
+      setup do
+        @p1 = 'foo'.to_parseable
+        @p2 = 'bar'.to_parseable
+      end
+      
+      it 'hashes should be the same if initialized with the same parseables' do
+        ParsletChoice.new(@p1, @p2).hash.should == ParsletChoice.new(@p1, @p2).hash
+        ParsletChoice.new(@p1, @p2).should eql(ParsletChoice.new(@p1, @p2))
+      end
+      
+      it 'hashes should (ideally) be different if initialized with different parseables' do
+        ParsletChoice.new(@p1, @p2).hash.should_not == ParsletChoice.new('baz'.to_parseable, 'abc'.to_parseable).hash
+        ParsletChoice.new(@p1, @p2).should_not eql(ParsletChoice.new('baz'.to_parseable, 'abc'.to_parseable))
+      end
+      
+      it 'hashes should be different compared to other similar classes even if initialized with the same parseables' do
+        ParsletChoice.new(@p1, @p2).hash.should_not == ParsletSequence.new(@p1, @p2).hash
+        ParsletChoice.new(@p1, @p2).should_not eql(ParsletSequence.new(@p1, @p2))
+      end
+      
+      it 'should be able to use Parslet Choice instances as keys in a hash' do
+        hash = {}
+        key1 = ParsletChoice.new(@p1, @p2)
+        key2 = ParsletChoice.new('baz'.to_parseable, 'abc'.to_parseable)
+        hash[:key1] = 'foo'
+        hash[:key2] = 'bar'
+        hash[:key1].should == 'foo'
+        hash[:key2].should == 'bar'
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/parslet_combining_spec.rb

@@ -0,0 +1,287 @@
+# 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/parslet_combining_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 shorthand operators to combine String, Symbol and Regexp parsers' do
+      
+      it 'should be able to chain a String and a Regexp together' do
+        
+        # try in one order
+        sequence = 'foo' & /\d+/
+        sequence.parse('foo1000').should == ['foo', '1000']
+        lambda { sequence.parse('foo') }.should raise_error(ParseError) # first part alone is not enough
+        lambda { sequence.parse('1000') }.should raise_error(ParseError) # neither is second part alone
+        lambda { sequence.parse('1000foo') }.should raise_error(ParseError) # order matters
+        
+        # same test but in reverse order
+        sequence = /\d+/ & 'foo'
+        sequence.parse('1000foo').should == ['1000', 'foo']
+        lambda { sequence.parse('foo') }.should raise_error(ParseError) # first part alone is not enough
+        lambda { sequence.parse('1000') }.should raise_error(ParseError) # neither is second part alone
+        lambda { sequence.parse('foo1000') }.should raise_error(ParseError) # order matters
+        
+      end
+      
+      it 'should be able to choose between a String and a Regexp' do
+        
+        # try in one order
+        sequence = 'foo' | /\d+/
+        sequence.parse('foo').should == 'foo'
+        sequence.parse('100').should == '100'
+        lambda { sequence.parse('bar') }.should raise_error(ParseError)
+        
+        # same test but in reverse order
+        sequence = /\d+/ | 'foo'
+        sequence.parse('foo').should == 'foo'
+        sequence.parse('100').should == '100'
+        lambda { sequence.parse('bar') }.should raise_error(ParseError)
+        
+      end
+      
+      it 'should be able to freely intermix String and Regexp objects when chaining and choosing' do
+        
+        sequence = 'foo' & /\d+/ | 'bar' & /[XYZ]{3}/
+        sequence.parse('foo123').should == ['foo', '123']
+        sequence.parse('barZYX').should == ['bar', 'ZYX']
+        lambda { sequence.parse('foo') }.should raise_error(ParseError)
+        lambda { sequence.parse('123') }.should raise_error(ParseError)
+        lambda { sequence.parse('bar') }.should raise_error(ParseError)
+        lambda { sequence.parse('XYZ') }.should raise_error(ParseError)
+        lambda { sequence.parse('barXY') }.should raise_error(ParseError)
+        
+      end
+      
+      it 'should be able to specify minimum and maximum repetition using shorthand methods' do
+        
+        # optional (same as "?" in regular expressions)
+        sequence = 'foo'.optional
+        sequence.parse('foo').should == 'foo'
+        lambda { sequence.parse('bar') }.should throw_symbol(:ZeroWidthParseSuccess)
+        
+        # zero_or_one (same as optional; "?" in regular expressions)
+        sequence = 'foo'.zero_or_one
+        sequence.parse('foo').should == 'foo'
+        lambda { sequence.parse('bar') }.should throw_symbol(:ZeroWidthParseSuccess)
+        
+        # zero_or_more (same as "*" in regular expressions)
+        sequence = 'foo'.zero_or_more
+        sequence.parse('foo').should == 'foo'
+        sequence.parse('foofoofoobar').should == ['foo', 'foo', 'foo']
+        lambda { sequence.parse('bar') }.should throw_symbol(:ZeroWidthParseSuccess)
+        
+        # one_or_more (same as "+" in regular expressions)
+        sequence = 'foo'.one_or_more
+        sequence.parse('foo').should == 'foo'
+        sequence.parse('foofoofoobar').should == ['foo', 'foo', 'foo']
+        lambda { sequence.parse('bar') }.should raise_error(ParseError)
+        
+        # repeat (arbitary limits for min, max; same as {min, max} in regular expressions) 
+        sequence = 'foo'.repeat(3, 5)
+        sequence.parse('foofoofoobar').should == ['foo', 'foo', 'foo']
+        sequence.parse('foofoofoofoobar').should == ['foo', 'foo', 'foo', 'foo']
+        sequence.parse('foofoofoofoofoobar').should == ['foo', 'foo', 'foo', 'foo', 'foo']
+        sequence.parse('foofoofoofoofoofoobar').should == ['foo', 'foo', 'foo', 'foo', 'foo']
+        lambda { sequence.parse('bar') }.should raise_error(ParseError)
+        lambda { sequence.parse('foo') }.should raise_error(ParseError)
+        lambda { sequence.parse('foofoo') }.should raise_error(ParseError)
+        
+      end
+      
+      it 'should be able to apply repetitions to other combinations wrapped in parentheses' do
+        sequence = ('foo' & 'bar').one_or_more
+        sequence.parse('foobar').should == ['foo', 'bar']
+        sequence.parse('foobarfoobar').should == [['foo', 'bar'], ['foo', 'bar']] # fails: just returns ['foo', 'bar']
+      end
+      
+      it 'should be able to combine use of repetition shorthand methods with other shorthand methods' do
+        
+        # first we test with chaining
+        sequence = 'foo'.optional & 'bar' & 'abc'.one_or_more
+        sequence.parse('foobarabc').should == ['foo', 'bar', 'abc']
+        sequence.parse('foobarabcabc').should == ['foo', 'bar', ['abc', 'abc']]
+        sequence.parse('barabc').should == ['bar', 'abc']
+        lambda { sequence.parse('abc') }.should raise_error(ParseError)
+        
+        # similar test but with alternation
+        sequence = 'foo' | 'bar' | 'abc'.one_or_more
+        sequence.parse('foobarabc').should == 'foo'
+        sequence.parse('barabc').should == 'bar'
+        sequence.parse('abc').should == 'abc'
+        sequence.parse('abcabc').should == ['abc', 'abc']
+        lambda { sequence.parse('nothing') }.should raise_error(ParseError)
+        
+        # test with defective sequence (makes no sense to use "optional" with alternation, will always succeed)
+        sequence = 'foo'.optional | 'bar' | 'abc'.one_or_more
+        sequence.parse('foobarabc').should == 'foo'
+        lambda { sequence.parse('nothing') }.should throw_symbol(:ZeroWidthParseSuccess)
+        
+      end
+      
+      it 'should be able to chain a "not predicate"' do
+        sequence = 'foo' & 'bar'.not!
+        sequence.parse('foo').should == 'foo' # fails with ['foo'] because that's the way ParserState works...
+        sequence.parse('foo...').should == 'foo' # same
+        lambda { sequence.parse('foobar') }.should raise_error(ParseError)
+      end
+      
+      it 'an isolated "not predicate" should return a zero-width match' do
+        sequence = 'foo'.not!
+        lambda { sequence.parse('foo') }.should raise_error(ParseError)
+        lambda { sequence.parse('bar') }.should throw_symbol(:NotPredicateSuccess)
+      end
+      
+      it 'two "not predicates" chained together should act like a union' do
+        
+        # this means "not followed by 'foo' and not followed by 'bar'"
+        sequence = 'foo'.not! & 'bar'.not!
+        lambda { sequence.parse('foo') }.should raise_error(ParseError)
+        lambda { sequence.parse('bar') }.should raise_error(ParseError)
+        lambda { sequence.parse('abc') }.should throw_symbol(:NotPredicateSuccess) 
+        
+      end
+      
+      it 'should be able to chain an "and predicate"' do
+        sequence = 'foo' & 'bar'.and?
+        sequence.parse('foobar').should == 'foo' # same problem, returns ['foo']
+        lambda { sequence.parse('foo...') }.should raise_error(ParseError)
+        lambda { sequence.parse('foo') }.should raise_error(ParseError)
+      end
+      
+      it 'an isolated "and predicate" should return a zero-width match' do
+        sequence = 'foo'.and?
+        lambda { sequence.parse('bar') }.should raise_error(ParseError)
+        lambda { sequence.parse('foo') }.should throw_symbol(:AndPredicateSuccess)
+      end
+      
+      it 'should be able to follow an "and predicate" with other parslets or combinations' do
+        
+        # this is equivalent to "foo" if followed by "bar", or any three characters
+        sequence = 'foo' & 'bar'.and? | /.../
+        sequence.parse('foobar').should == 'foo' # returns ['foo']
+        sequence.parse('abc').should == 'abc'
+        lambda { sequence.parse('') }.should raise_error(ParseError)
+        
+        # it makes little sense for the predicate to follows a choice operator so we don't test that
+        
+      end
+      
+      it 'should be able to follow a "not predicate" with other parslets or combinations' do
+        
+        # this is equivalent to "foo" followed by any three characters other than "bar"
+        sequence = 'foo' & 'bar'.not! & /.../
+        sequence.parse('fooabc').should == ['foo', 'abc']
+        lambda { sequence.parse('foobar') }.should raise_error(ParseError)
+        lambda { sequence.parse('foo') }.should raise_error(ParseError)
+        lambda { sequence.parse('') }.should raise_error(ParseError)
+        
+      end
+      
+      it 'should be able to include a "not predicate" when using a repetition operator' do
+        
+        # basic example
+        sequence = ('foo' & 'bar'.not!).one_or_more
+        sequence.parse('foo').should == 'foo'
+        sequence.parse('foofoobar').should == 'foo'
+        sequence.parse('foofoo').should == ['foo', 'foo']
+        lambda { sequence.parse('bar') }.should raise_error(ParseError)
+        lambda { sequence.parse('foobar') }.should raise_error(ParseError)
+        
+        # variation: note that greedy matching alters the behaviour
+        sequence = ('foo' & 'bar').one_or_more & 'abc'.not!
+        sequence.parse('foobar').should == ['foo', 'bar']
+        sequence.parse('foobarfoobar').should == [['foo', 'bar'], ['foo', 'bar']]
+        lambda { sequence.parse('foobarabc') }.should raise_error(ParseError)
+        
+      end
+      
+      it 'should be able to use regular expression shortcuts in conjunction with predicates' do
+        
+        # match "foo" as long as it's not followed by a digit 
+        sequence = 'foo' & /\d/.not!
+        sequence.parse('foo').should == 'foo'
+        sequence.parse('foobar').should == 'foo'
+        lambda { sequence.parse('foo1') }.should raise_error(ParseError)
+        
+        # match "word" characters as long as they're not followed by whitespace
+        sequence = /\w+/ & /\s/.not!
+        sequence.parse('foo').should == 'foo'
+        lambda { sequence.parse('foo ') }.should raise_error(ParseError)
+        
+      end
+      
+    end
+    
+    describe 'omitting tokens from the output using the "skip" method' do
+      
+      it 'should be able to skip quotation marks delimiting a string' do
+        sequence = '"'.skip & /[^"]+/ & '"'.skip
+        sequence.parse('"hello world"').should == 'hello world' # note this is returning a ParserState object
+      end
+      
+      it 'should be able to skip within a repetition expression' do
+        sequence = ('foo'.skip & /\d+/).one_or_more
+        sequence.parse('foo1...').should == '1'        
+        sequence.parse('foo1foo2...').should == ['1', '2'] # only returns 1
+        sequence.parse('foo1foo2foo3...').should == ['1', '2', '3'] # only returns 1
+      end
+      
+      it 'should be able to skip commas separating a list' do
+        
+        # closer to real-world use: a comma-separated list
+        sequence = /\w+/ & (/\s*,\s*/.skip & /\w+/).zero_or_more
+        sequence.parse('a').should == 'a'
+        sequence.parse('a, b').should == ['a', 'b']
+        sequence.parse('a, b, c').should == ['a', ['b', 'c']]
+        sequence.parse('a, b, c, d').should == ['a', ['b', 'c', 'd']]
+        
+        # again, using the ">>" operator
+        sequence = /\w+/ >> (/\s*,\s*/.skip & /\w+/).zero_or_more
+        sequence.parse('a').should == 'a'
+        sequence.parse('a, b').should == ['a', 'b']
+        sequence.parse('a, b, c').should == ['a', 'b', 'c']
+        sequence.parse('a, b, c, d').should == ['a', 'b', 'c', 'd']
+        
+      end
+      
+    end
+    
+    describe 'using the shorthand ">>" pseudo-operator' do
+      
+      it 'should be able to chain the operator multiple times' do
+        
+        # comma-separated words followed by comma-separated digits
+        sequence = /[a-zA-Z]+/ >> (/\s*,\s*/.skip & /[a-zA-Z]+/).zero_or_more >> (/\s*,\s*/.skip & /\d+/).one_or_more
+        sequence.parse('a, 1').should == ['a', '1']
+        sequence.parse('a, b, 1').should == ['a', 'b', '1']
+        sequence.parse('a, 1, 2').should == ['a', '1', '2']
+        sequence.parse('a, b, 1, 2').should == ['a', 'b', '1', '2']
+        
+        # same, but enclosed in quotes
+        sequence = '"'.skip & /[a-zA-Z]+/ >> (/\s*,\s*/.skip & /[a-zA-Z]+/).zero_or_more >> (/\s*,\s*/.skip & /\d+/).one_or_more & '"'.skip
+        sequence.parse('"a, 1"').should == ['a', '1']
+        sequence.parse('"a, b, 1"').should == ['a', 'b', '1']
+        sequence.parse('"a, 1, 2"').should == ['a', '1', '2']
+        sequence.parse('"a, b, 1, 2"').should == ['a', 'b', '1', '2']
+        
+        # alternative construction of same
+        sequence = /[a-zA-Z]+/ >> (/\s*,\s*/.skip & /[a-zA-Z]+/).zero_or_more & /\s*,\s*/.skip & /\d+/ >> (/\s*,\s*/.skip & /\d+/).zero_or_more
+        sequence.parse('a, 1').should == ['a', '1']
+        sequence.parse('a, b, 1').should == ['a', 'b', '1']
+        sequence.parse('a, 1, 2').should == ['a', '1', '2']
+        sequence.parse('a, b, 1, 2').should == ['a', 'b', '1', '2']
+        
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/parslet_merge_spec.rb

@@ -0,0 +1,33 @@
+# 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/parslet_merge_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 Parslet Merge' do
+      
+      it 'should be able to compare for equality' do
+        ParsletMerge.new('foo', 'bar').should eql(ParsletMerge.new('foo', 'bar'))
+        ParsletMerge.new('foo', 'bar').should_not eql(ParsletOmission.new('foo')) # wrong class
+      end
+      
+      it 'ParsletMerge and ParsletSequence hashs should not match even if created using the same parseable instances' do
+        parseable1 = 'foo'.to_parseable
+        parseable2 = 'bar'.to_parseable
+        p1 = ParsletMerge.new(parseable1, parseable2)
+        p2 = ParsletSequence.new(parseable1, parseable2)
+        p1.hash.should_not == p2.hash
+        p1.should_not eql(p2)
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/parslet_omission_spec.rb

@@ -0,0 +1,58 @@
+# 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/parslet_omission_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 Parslet Omission' do
+      
+      it 'should raise if "parseable" argument is nil' do
+        lambda { ParsletOmission.new(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'should complain if pass nil string for parsing' do
+        lambda { ParsletOmission.new('foo'.to_parseable).parse(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'should let parse errors from lower levels fall through' do
+        lambda { ParsletOmission.new('foo'.to_parseable).parse('bar') }.should raise_error(ParseError)
+      end
+      
+      it 'should indicate parse errors with a SubstringSkippedException' do
+        lambda { ParsletOmission.new('foo'.to_parseable).parse('foo') }.should raise_error(SkippedSubstringException)
+      end
+      
+      it 'the raised SubstringSkippedException should include the parsed substring' do
+        begin
+          ParsletOmission.new('foo'.to_parseable).parse('foobar')
+        rescue SkippedSubstringException => e
+          substring = e.to_s
+        end
+        substring.should == 'foo'
+      end
+      
+      it 'the parsed substring should be an empty string in the case of a zero-width parse success at a lower level' do
+        begin
+          ParsletOmission.new('foo'.optional).parse('bar') # a contrived example
+        rescue SkippedSubstringException => e
+          substring = e.to_s
+        end
+        substring.should == ''
+      end
+      
+      it 'should be able to compare for equality' do
+        ParsletOmission.new('foo').should eql(ParsletOmission.new('foo'))
+        ParsletOmission.new('foo').should_not eql(ParsletOmission.new('bar'))
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/parslet_repetition_spec.rb

@@ -0,0 +1,77 @@
+# 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/parslet_repetition_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 Parslet Repetition' do
+      
+      it 'should raise if "parseable" argument is nil' do
+        lambda { ParsletRepetition.new(nil, 0) }.should raise_error(ArgumentError)
+      end
+      
+      it 'should raise if "min" argument is nil' do
+        lambda { ParsletRepetition.new('foo'.to_parseable, nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'should raise if pass nil string for parsing' do
+        lambda { ParsletRepetition.new('foo'.to_parseable, 0).parse(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'should be able to match "zero or more" times (like "*" in regular expressions)' do
+        parslet = ParsletRepetition.new('foo'.to_parseable, 0)
+        lambda { parslet.parse('bar') }.should throw_symbol(:ZeroWidthParseSuccess)   # zero times
+        parslet.parse('foo').should == 'foo'                                  # one time
+        parslet.parse('foofoo').should == ['foo', 'foo']                      # two times
+        parslet.parse('foofoofoobar').should == ['foo', 'foo', 'foo']         # three times
+      end
+      
+      it 'should be able to match "zero or one" times (like "?" in regular expressions)' do
+        parslet = ParsletRepetition.new('foo'.to_parseable, 0, 1)
+        lambda { parslet.parse('bar') }.should throw_symbol(:ZeroWidthParseSuccess)   # zero times
+        parslet.parse('foo').should == 'foo'                                  # one time
+        parslet.parse('foofoo').should == 'foo'                               # stop at one time        
+      end
+      
+      it 'should be able to match "one or more" times (like "+" in regular expressions)' do
+        parslet = ParsletRepetition.new('foo'.to_parseable, 1)
+        lambda { parslet.parse('bar') }.should raise_error(ParseError)        # zero times (error)
+        parslet.parse('foo').should == 'foo'                                  # one time
+        parslet.parse('foofoo').should == ['foo', 'foo']                      # two times
+        parslet.parse('foofoofoobar').should == ['foo', 'foo', 'foo']         # three times
+      end
+      
+      it 'should be able to match "between X and Y" times (like {X, Y} in regular expressions)' do
+        parslet = ParsletRepetition.new('foo'.to_parseable, 2, 3)
+        lambda { parslet.parse('bar') }.should raise_error(ParseError)        # zero times (error)
+        lambda { parslet.parse('foo') }.should raise_error(ParseError)        # one time (error)
+        parslet.parse('foofoo').should == ['foo', 'foo']                      # two times
+        parslet.parse('foofoofoo').should == ['foo', 'foo', 'foo']            # three times
+        parslet.parse('foofoofoofoo').should == ['foo', 'foo', 'foo']         # stop at three times
+      end
+      
+      it 'matches should be greedy' do
+        
+        # here the ParsletRepetition should consume all the "foos", leaving nothing for the final parslet
+        parslet = ParsletRepetition.new('foo'.to_parseable, 1) & 'foo'
+        lambda { parslet.parse('foofoofoofoo') }.should raise_error(ParseError)
+        
+      end
+      
+      it 'should be able to compare for equality' do
+        ParsletRepetition.new('foo'.to_parseable, 1).should eql(ParsletRepetition.new('foo'.to_parseable, 1))
+        ParsletRepetition.new('foo'.to_parseable, 1).should_not eql(ParsletRepetition.new('bar'.to_parseable, 1))
+        ParsletRepetition.new('foo'.to_parseable, 1).should_not eql(ParsletRepetition.new('foo'.to_parseable, 2))
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/parslet_sequence_spec.rb

@@ -0,0 +1,49 @@
+# 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/parslet_sequence_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 Parslet Sequence' do
+      
+      setup do
+        @p1 = 'foo'.to_parseable
+        @p2 = 'bar'.to_parseable
+      end
+
+      it 'hashes should be the same if initialized with the same parseables' do
+        ParsletSequence.new(@p1, @p2).hash.should == ParsletSequence.new(@p1, @p2).hash
+        ParsletSequence.new(@p1, @p2).should eql(ParsletSequence.new(@p1, @p2))
+      end
+
+      it 'hashes should (ideally) be different if initialized with different parseables' do
+        ParsletSequence.new(@p1, @p2).hash.should_not == ParsletSequence.new('baz'.to_parseable, 'abc'.to_parseable).hash
+        ParsletSequence.new(@p1, @p2).should_not eql(ParsletSequence.new('baz'.to_parseable, 'abc'.to_parseable))
+      end
+
+      it 'hashes should be different compared to other similar classes even if initialized with the same parseables' do
+        ParsletSequence.new(@p1, @p2).hash.should_not == ParsletChoice.new(@p1, @p2).hash
+        ParsletSequence.new(@p1, @p2).should_not eql(ParsletChoice.new(@p1, @p2))
+      end
+
+      it 'should be able to use Parslet Choice instances as keys in a hash' do
+        hash = {}
+        key1 = ParsletSequence.new(@p1, @p2)
+        key2 = ParsletSequence.new('baz'.to_parseable, 'abc'.to_parseable)
+        hash[:key1] = 'foo'
+        hash[:key2] = 'bar'
+        hash[:key1].should == 'foo'
+        hash[:key2].should == 'bar'
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/parslet_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/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 parslet' do
+      
+      it 'should complain if sent "parse" message (Parslet is an abstract superclass, "parse" is the responsibility of the subclasses)' do
+        lambda { Parslet.new.parse('bar') }.should raise_error(NotImplementedError)
+      end
+      
+    end
+    
+  end # class Grammar
+end # module Walrus

data/spec/grammar/predicate_spec.rb

@@ -0,0 +1,53 @@
+# 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/predicate_spec.rb 6702 2007-04-09T15:04:40.448669Z wincent  $
+
+require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+
+module Walrus
+  class Grammar
+    
+    autoload(:AndPredicate, 'walrus/grammar/and_predicate')
+    autoload(:NotPredicate, 'walrus/grammar/not_predicate')
+    
+    describe 'using a predicate' do
+      
+      it 'should raise an ArgumentError if initialized with nil' do
+        lambda { Predicate.new(nil) }.should raise_error(ArgumentError)
+      end
+      
+      it 'should complain if sent "parse" message (Predicate abstract superclass, "parse" is the responsibility of the subclasses)' do
+        lambda { Predicate.new('foo').parse('bar') }.should raise_error(NotImplementedError)
+      end
+      
+      it 'should be able to compare predicates for equality' do
+        Predicate.new('foo').should eql(Predicate.new('foo'))
+        Predicate.new('foo').should_not eql(Predicate.new('bar'))
+      end
+      
+      it '"and" and "not" predicates should yield different hashes even if initialized with the same "parseable"' do
+        
+        parseable = 'foo'.to_parseable
+        p1 = Predicate.new(parseable)
+        p2 = AndPredicate.new(parseable)
+        p3 = NotPredicate.new(parseable)
+        
+        p1.hash.should_not == p2.hash
+        p2.hash.should_not == p3.hash
+        p3.hash.should_not == p1.hash
+        
+        p1.should_not eql(p2)
+        p2.should_not eql(p3)
+        p3.should_not eql(p1)
+        
+      end
+      
+      
+    end
+    
+  end # class Grammar
+end # module Walrus