walrus 0.1 → 0.2

data/spec/grammar/parslet_choice_spec.rb

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

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

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

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

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

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

@@ -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/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

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