hipe-gorillagrammar 0.0.1beta

data/spec/range_spec.rb

@@ -0,0 +1,47 @@
+# rake spec SPEC=spec/range_spec.rb 
+require 'hipe-gorillagrammar'
+
+module Hipe
+
+  describe GorillaGrammar::RangeOf  do
+   
+    it "should not allow an empty grammar" do
+      lambda {
+        Hipe.GorillaGrammar { zero_or_more() }
+      }.should raise_error(GorillaGrammar::GrammarGrammarException, 'Arguments must be non-zero length')
+    end
+   
+    it "should pass if the grammar allows it" do 
+      grammar = Hipe.GorillaGrammar do
+        zero_or_more 'a','b','c'
+      end
+      result = grammar.parse []
+      result.should be_a_kind_of GorillaGrammar::ParseTree
+    end
+   
+    it "should fail unless the grammar allows it" do
+      grammar = Hipe.GorillaGrammar do 
+        one_or_more 'a','b','c'
+      end
+      result = grammar.parse []
+      result.should be_a_kind_of GorillaGrammar::ParseFailure
+    end
+   
+    it "should parse several tokens" do
+      grammar = Hipe.GorillaGrammar do
+        one_or_more 'a','b','c'
+      end
+      result = grammar.parse ['a','b','b','a']  
+    end
+    
+    it "should inspect as a grammar" do
+      g = Hipe.GorillaGrammar { :sammy =~ (1..more).of('a','b','c') }
+      s = g.inspect
+      s.should match %r|sammy.*1.*"a".*"b".*"c"|m
+    end
+    
+    it "is unlikely to have a minimum of two or more" do 
+      Hipe.GorillaGrammar{(2..more).of('jon','ringo','george','paul')}.parse(['jon','ringo']).is_error?.should == false
+    end
+  end  # when given non-zero
+end

data/spec/regexp_spec.rb

@@ -0,0 +1,24 @@
+#rake spec SPEC=spec/regexp_spec.rb
+require 'hipe-gorillagrammar'
+include Hipe::GorillaGrammar
+
+
+describe RegexpTerminal, 'in the context of parsing' do
+  before :all do
+    @g = Hipe.GorillaGrammar {                                                            
+      :sentence =~ [:color[/^(red|green)$/], 'beans', 'and', :food[/^salad|rice$/]]
+    }
+  end
+  
+  it "cannot parse on its own" do
+    g = Hipe.GorillaGrammar{ :item =~ //   }
+    lambda{ t = g.parse ['alpha'] }.should raise_error NoMethodError, /undefined method `parse'/ 
+  end
+
+  it "should fail with simple regexp" do
+    g = @g                                         
+    tree = @g.parse(['blue','beans','and','rice'])
+    tree.is_error?.should == true
+  end
+
+end

data/spec/runtime_spec.rb

@@ -0,0 +1,66 @@
+#rake spec SPEC=spec/runtime_spec.rb 
+require 'hipe-gorillagrammar'
+include Hipe::GorillaGrammar
+
+describe Runtime do
+  
+  it "shortcuts should fail" do
+    lambda {
+      Runtime.not_there
+    }.should raise_error(NoMethodError)
+  end
+  
+  it "should return nil" do
+    Runtime.current_grammar.should == nil    
+  end
+  
+  it "should return nil again" do
+    Runtime.current_grammar.should == nil    
+  end
+
+  it "should throw when there's no current grammar" do
+    lambda{
+      Runtime.current_grammar!
+    }.should raise_error(UsageFailure)
+  end
+  
+  it "should work violently" do
+    g = nil     
+    Hipe::GorillaGrammar.define {
+      g = Runtime.current_grammar!
+      ['']
+    }
+    g.should be_an_instance_of Grammar
+  end
+  
+  it "should work calmly" do
+    g = nil
+    Hipe::GorillaGrammar.define {
+      g = Runtime.current_grammar
+      ['']      
+    }
+    g.should be_an_instance_of Grammar     
+  end
+  
+  it "should not allow doubles" do
+    lambda{
+      Hipe::GorillaGrammar.define {
+        Hipe::GorillaGrammar.define {}
+        ['']        
+      }
+    }.should raise_error(UsageFailure)
+  end  
+  
+  it "should work after" do
+    Hipe::GorillaGrammar.define {['']}
+    Runtime.current_grammar.should == nil
+  end  
+
+  it "grammar can only take symbols" do
+    g = Hipe::GorillaGrammar.define {['']}
+    lambda{ g[:a_symbol] = :not_a_symbol }.should raise_error(
+      GorillaException, %{Expecting GorillaSymbol had :not_a_symbol}
+    )
+  end
+
+end

data/spec/sequence_spec.rb

@@ -0,0 +1,85 @@
+#rake spec SPEC=spec/sequence_spec.rb 
+require 'hipe-gorillagrammar'
+
+module Hipe
+
+  describe GorillaGrammar::Sequence do
+   
+    before(:each) do 
+      @abc = Hipe.GorillaGrammar do
+        sequence 'a','b','c'
+      end
+    end
+   
+    it "should fail on empty sequence (s1)" do
+      lambda {
+        Hipe.GorillaGrammar { sequence() }
+      }.should raise_error(GorillaGrammar::GrammarGrammarException, 'Arguments must be non-zero length')
+    end
+   
+    it "should fail on empty input (s2)" do 
+      result = @abc.parse []
+      result.should be_a_kind_of GorillaGrammar::ParseFailure
+    end
+    
+    class MockyOneOff; # we couldn't use rspec for this because of marshaling
+      include GorillaGrammar::GorillaSymbol
+      def match(a); :/ ; end
+      def status; :/ end
+    end
+    
+    it "should compalin when symbol returns bad status (s3)" do
+      mok = MockyOneOff.new
+      g = Hipe.GorillaGrammar do
+       :a =~ mok
+       :sentence =~ [:a]
+     end
+     lambda{g.parse ['a','b'] }.should raise_error(GorillaGrammar::GorillaException, /bad status/)
+    end
+   
+    it "should parse a simple one (s4)" do
+      result = @abc.parse ['a','b','c']
+      result.should be_a_kind_of GorillaGrammar::ParseTree
+      result.should == ['a','b','c']
+    end
+    
+    # s5 moved to parsing spec
+    
+    it "should work for simple compound (s6)" do
+      grammar = Hipe.GorillaGrammar do
+        sequence one_or_more('b','e'),'c'
+      end
+      result = grammar.parse ['b','c']
+      result.is_error?.should == false
+      result.to_a.should == [['b'],'c']
+    end
+    
+     it "should parse a little more complex (s7)" do
+       grammar = Hipe.GorillaGrammar do
+         sequence 'a',one_or_more('b','e'),'c'
+       end
+       result = grammar.parse(['a','b','e','b','c'])
+       result.is_error?.should == false
+       result.to_a.should == ['a',['b','e','b'],'c']
+     end    
+     
+     it "should render expecting message jumping btwn two frames (s8)" do
+       grammar = Hipe.GorillaGrammar do
+         sequence zero_or_more('b','e'),'c'
+       end      
+       result = grammar.parse(['d'])
+       result.is_error?.should == true
+       result.message.should match(/expecting(:? you to say)? "b", "e" or "c"/)
+     end
+     
+     it "should handle zero or more at begin(s9)" do
+       grammar = Hipe.GorillaGrammar do
+         sequence zero_or_more('b','e'),'c'
+       end
+       result = grammar.parse(['b','e','c'])
+       result.is_error?.should == false
+       result.to_a.should == [['b','e'],'c']
+       
+     end     
+  end
+end 

data/spec/shorthand_spec.rb

@@ -0,0 +1,186 @@
+#rake spec SPEC=spec/shorthand_spec.rb
+require File.dirname(__FILE__)+'/helpers.rb'
+require 'hipe-gorillagrammar'
+include Hipe::GorillaGrammar
+
+class Grammar
+  include Helpers
+ # only for irb -- tokenize a string thru the shell.  careful!  
+  def parz str; 
+    tox = shell!(str); 
+    puts "your tokens tokenized from shell:"
+    pp tox
+    parse tox
+  end 
+end
+
+describe Hipe::GorillaGrammar, " in the context of Shorthands" do
+  it "should bark on missing method" do
+    lambda {
+      Hipe::GorillaGrammar.define {
+        bork()
+      }
+    }.should raise_error(NameError)
+  end
+  
+  it "should bark when undefined rangeof method (h1)" do
+    Grammar.register_shorthand :nonexistant_method, RangeOf
+    lambda{ 
+      Hipe.GorillaGrammar{ nonexistant_method('x') }
+    }.should raise_error(UsageFailure, /invalid name str/)
+  end
+  
+
+  it "every one should construct (h2)" do
+    a = {}
+    Hipe::GorillaGrammar(){                                                            
+      a[:ro56] = range_of(         5..6, 'alpha','beta','gamma')      
+      a[:ro11] = one(           'delta','epsilon')               
+      a[:ro01] = zero_or_one(   'zeta')                                  
+      a[:ro1i] = one_or_more(   'eta','theta')                           
+      a[:ro0i] = zero_or_more(  'iota')                                   
+      a[:seq1] = sequence(         'kappa','lambda','mu')             
+      a[:rexp] = regexp(           /^.$/)                           
+    }                              
+    a[:ro56].group.should ==   ["alpha","beta","gamma"]
+    a[:ro56].range.should == (5..6)
+    a[:ro11].group.should ==   ["delta","epsilon"]
+    a[:ro11].range.should == (1..1)
+    a[:ro01].group.should ==   ['zeta']                    
+    a[:ro01].range.should == (0..1)
+    a[:ro1i].group.should ==   ['eta','theta']
+    a[:ro1i].range.should == (1..Infinity)
+    a[:ro0i].group.should ==   ['iota']
+    a[:ro01].range.should == (0..1)           
+    a[:seq1].group.should ==   ['kappa','lambda','mu']
+    a[:rexp].should ==   /^.$/      
+  end
+
+  it "should turn pipe into RangeOf (h3)" do
+    rangey = nil
+    g = Hipe.GorillaGrammar {
+      rangey = 'you' | 'i'
+    }
+    rangey.class.ancestors.include?(RangeOf).should == true
+  end
+
+  it "muliple strings with pipe (h4)" do
+    rangey = nil
+    g = Hipe.GorillaGrammar {
+      rangey = 'you' | 'i' | 'him'
+    }
+    rangey.class.ancestors.include?(RangeOf).should == true
+  end
+
+  it "should do Fixnum.of (h5)" do
+    rangey = nil
+    g = Hipe.GorillaGrammar {
+      rangey = 1.of 'you','i'
+    }
+    rangey.class.ancestors.include?(RangeOf).should == true
+  end
+
+  it "different kind of pipies should be equal (h6)" do
+    range_of_1=range_of_2=range_of_3=range_of_4=range_of_5=target=nil
+    g = Hipe.GorillaGrammar {
+      range_of_1 = 1.of 'you','i','he'
+      range_of_2 = 'you' | 'i' | 'he'
+      range_of_3 = (1..1).of 'you','i','he'
+      range_of_4 = range_of 1..1, 'you','i','he'
+      range_of_5 = one 'you', 'i', 'he'
+      :main =~ ['']
+    }
+    target = RangeOf.new(1..1, ['you','i','he'])
+    target_str = target.inspect
+    target_str.should match(/.{11}/)
+    range_of_1.inspect.should == target_str
+    range_of_2.inspect.should == target_str
+    range_of_3.inspect.should == target_str
+    range_of_4.inspect.should == target_str
+    range_of_5.inspect.should == target_str    
+  end
+
+  it "should complain on bad symbol (h7)" do
+    lambda {
+      Hipe.GorillaGrammar {
+        :some_symbol =~ 123
+      }
+    }.should raise_error(UsageFailure, %{Can't determine symbol type for "123"})
+  end
+
+  it "should complain on re-definition (h8)" do
+    lambda {
+      Hipe.GorillaGrammar {
+        :symbol =~ ['this']
+        :symbol =~ ['this']
+      }
+    }.should raise_error(GrammarGrammarException, %r{can't redefine symbol}i)
+  end
+
+  it "two ways one grammar (h9)" do
+    g = Hipe.GorillaGrammar(:name =>:beuford) { :x =~ '.' }
+    Runtime.get_grammar(:beuford).should equal(g)
+  end
+
+  it "should store symbols (h10)" do
+    g = Hipe.GorillaGrammar(:name=>:grammar1) {
+      :subject   =~ 'you'|'i'|'he'|'she'
+      :verb      =~ 1.of('run','walk','blah')
+      :adverb    =~ 'quickly'|'slowly'|['without', 'hesitation']
+      :predicate =~ (0..1).of(:adverb, :verb, :object[/^.*$/])
+      :sentence  =~ [:subject,:predicate]
+    }
+    g[:subject   ].inspect.should match /1.*1.*you.*i.*he.*she/
+    g[:verb      ].inspect.should match /1.*1.*run.*walk.*blah/
+    g[:adverb    ].inspect.should match /1.*1.*quickly.*slowly.*without.*hesitation/
+    g[:predicate ].inspect.should match /0.*1.*adverb.*verb.*object/
+    g[:sentence  ].inspect.should match /subject.*predicate/
+  end
+  
+  it "should work with symbol references (h11)" do
+    g = Hipe.GorillaGrammar(:name=>:grammar2) {
+      :alpha  =~ 'a'
+      :beta   =~ 'b'
+      :gamma  =~ 'c'
+      :sentence  =~ [:alpha,:beta,:gamma]
+    }
+    result = g.parse ['a','b','c']
+    result.is_error?.should == false
+  end
+  
+  it "should report expecting right at the start of a branch (h12)" do
+    g = Hipe.GorillaGrammar {
+      :sentence =~ [
+        'i','want','my', 
+         :manufacturer[1.of(['jimmy','dean'],['hickory','farms'])],
+      'sausage' ]
+    }
+    thing = g.parse ['i','want','my']
+    thing.is_error?.should == true
+    thing.should be_kind_of UnexpectedEndOfInput
+    thing.tree.expecting.should == %w("jimmy" "hickory")  # strings with quotes in them
+  end
+  
+  it "parse sequence 1 branch 2 x 2 x 1 (h13)" do
+    g = Hipe.GorillaGrammar {
+      :sentence =~ [:manufacturer[ one %w(jimmy dean), %w(hickory farms) ] ]
+    }
+    thing = g.parse []
+    thing.is_error?.should == true
+    thing.should be_kind_of UnexpectedEndOfInput
+    thing.tree.expecting.should == %w("jimmy" "hickory") 
+  end  
+  
+  it "parse sequence 2 branch 2 x 2 x 1 (h14)" do                                              
+    g = Hipe.GorillaGrammar {                                                            
+      :sentence =~ ['want','jimmy']  
+    }                                                                                                                                                 
+    thing = g.parse ['want']                                                     
+    thing.is_error?.should == true                                                       
+    thing.should be_kind_of UnexpectedEndOfInput                                         
+    thing.tree.expecting.should == %w("jimmy")
+  end                                     
+
+  # h15 moved to another file (parsing)
+
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--diff
+--color
+--debug
+-b

data/spec/symbol_reference_spec.rb

@@ -0,0 +1,28 @@
+#rake spec SPEC=spec/symbol_reference_spec.rb 
+require 'hipe-gorillagrammar'
+include Hipe::GorillaGrammar
+
+describe SymbolReference do
+
+#  it "parse sequence 2 branch 2 x 2 x 1 trailing union w/o symbol references (sr1)" do
+#    g = Hipe.GorillaGrammar {
+#      :sentence =~ ['want', one( %w(jimmy dean), %w(hickory farms) ) ]
+#    }
+#    thing = g.parse ['want','jimmy']
+#    thing.is_error?.should == true
+#    thing.should be_kind_of UnexpectedEndOfInput
+#    thing.tree.expecting.should == %w("dean") 
+#  end
+#
+  it "parse sequence 2 branch 2 x 2 x 1 (h15)" do
+    g = Hipe.GorillaGrammar {
+      :sentence =~ ['want', :manufacturer[ one %w(jimmy dean), %w(hickory farms) ] ]
+    }
+#    debugger
+    thing = g.parse ['want','jimmy']
+    thing.is_error?.should == true
+    thing.should be_kind_of UnexpectedEndOfInput
+    thing.tree.expecting.should == %w("dean") 
+  end
+  
+end