hipe-gorillagrammar 0.0.1beta

data/spec/argv.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+# this is for debugging with how the shell parses strings into tokens
+puts Marshal.dump(ARGV)

data/spec/extensions/syntax_spec.rb

@@ -0,0 +1,41 @@
+#rake spec SPEC=spec/extensions/syntax_spec.rb
+require 'hipe-gorillagrammar'
+include Hipe::GorillaGrammar
+require 'hipe-gorillagrammar/extensions/syntax'
+
+describe ParseTree, 'in the context of Parsing' do
+
+  before :all do
+    @g = Hipe.GorillaGrammar {
+      :dry             =~ zero_or_one([zero_or_one('as'),'dry',zero_or_one('run')])
+      :delete_command  =~ ['delete',zero_or_one('deleted')]
+      :add_command     =~ ['add',one('untracked','modified','both')]
+      :help_command    =~ 'help'; :version_command =~ 'version'; :info_command =~ 'info'
+      :command         =~ :add_command | :delete_command | :help_command | 
+                          :version_command | :info_command
+      :add_file        =~ ['add',one_or_more(:file)]
+      :never_using_this =~ [(1..3).of(:blah)]
+      :commands        =~ [:command,zero_or_more(['and',:command])]
+    }
+  end
+ 
+  it "should put square brackets around zero or one (sx1)"  do
+    @g[:delete_command].syntax.should == 'delete [deleted]'
+  end
+  
+  it "should do a parenthesis and pipe thing for inline one (sx2)" do
+    @g[:add_command].syntax.should == 'add (untracked|modified|both)'
+  end
+  
+  it "should capitalize symbol references and put square brackets with ellipses around zero or more (sx3)" do
+    @g[:commands].syntax.should == 'COMMAND [and COMMAND [...]]'
+  end
+  
+  it "it should do the one or more thing (sx4)" do
+    @g[:add_file].syntax.should == 'add FILE [FILE [...]]'
+  end
+  
+  it "whatever ridiculous" do
+    @g[:never_using_this].syntax.should == '(1..3) of (BLAH)'    
+  end
+end

data/spec/grammar_spec.rb

@@ -0,0 +1,91 @@
+#rake spec SPEC=spec/grammar_spec.rb
+require 'hipe-gorillagrammar'
+include Hipe::GorillaGrammar
+
+describe Grammar,'in general' do
+  it "should allow basic reflection" do
+    g = Hipe.GorillaGrammar{ :items =~ [:item[//]] }
+    g.should be_a_kind_of Grammar
+    g.size.should == 2
+    (g.names - [:item,:items]).should == []
+  end
+end
+
+describe Grammar,'in general' do
+  it "should have entries in the symbol table for all its children" do
+    g = Hipe.GorillaGrammar{ :items =~ [:item[//]] }
+    g[:items].should_not == nil
+    g[:item].should_not == nil  
+  end
+end
+
+describe Grammar,'with respect to naming' do
+  it "should get anonymous sequential names" do
+    Runtime.instance.instance_variable_set '@grammars', {} 
+    g1 = Hipe.GorillaGrammar{ :items =~ [:item[//]] }
+    g2 = Hipe.GorillaGrammar{ :items =~ [:item[//]] }
+    g3 = Hipe.GorillaGrammar{ :items =~ [:item[//]] }
+    g4 = Hipe.GorillaGrammar(:name=>'yo, g'){ :items =~ [:item[//]] }
+    g1.name.should == 'grammar1'
+    g2.name.should == 'grammar2'    
+    g3.name.should == 'grammar3'
+    g4.name.should == 'yo, g'
+  end
+end
+
+describe "In grammars, the bracket operator" do
+  it "when there is only one native element in it which represents a terminal symbol, it should add such a symbol to the table" do
+    g = Hipe.GorillaGrammar{ :items =~ [:item[//]] }
+    g[:items].should be_kind_of Sequence
+    g[:item].should be_kind_of RegexpTerminal    
+  end  
+end
+
+describe Grammar do
+  it "should not allow redefinitions of symbols" do
+    lambda {
+      Hipe.GorillaGrammar {
+        :once =~ /espresso/
+        :twice =~ ['i','love',:once[/coffee/]]
+      }
+    }.should raise_error GrammarGrammarException, /multiple definitions for :once/i
+  end
+end
+
+describe Grammar, 'with respect to anonymous symbols' do
+  it("still get entries in the symbol table if they're the last one") {
+    g = Hipe.GorillaGrammar{[:item[//]]}
+    g.size.should == 2
+    g['__main__'].should be_kind_of Sequence    
+  }
+end
+
+describe Grammar," with respect to brackets and symbol tables" do
+  before :each do 
+    @g1 = Hipe.GorillaGrammar {
+      :thing       =~ "beans"
+      :color       =~ /^(red|green)$/
+      :noun_phrase =~ [:color, :thing]
+    }
+    @g2 = Hipe.GorillaGrammar {
+      :noun_phrase =~ [:color[/^(red|green)$/], :thing["beans"]]
+    }
+    @g3 = Hipe.GorillaGrammar {
+      :noun_phrase =~ [:color[/^(red|green)$/], :thing["beans"]]
+      :billy =~ 'bob thornton'
+    }
+  end
+ 
+  it "brackets should put entries in the symbol table and return symbol references" do
+    g1,g2,g3 = @g1, @g2, @g3
+    s1,s2    = '', ''
+    PP.pp g1, s1
+    PP.pp g2, s2
+    s1.should == s2
+    (g1==g2).should == true
+    (g2==g1).should == true
+    (g2==g3).should == false
+  end
+  
+end
+

data/spec/helpers.rb

@@ -0,0 +1,5 @@
+module Helpers
+  def shell! str # danger -- will execute any arbitrary string 
+    Marshal.load %x{ruby #{File.dirname(__FILE__)}/argv.rb #{str}}
+  end
+end

data/spec/parse_tree_spec.rb

@@ -0,0 +1,64 @@
+#rake spec SPEC=spec/parse_tree_spec.rb
+require 'hipe-gorillagrammar'
+include Hipe::GorillaGrammar
+
+
+describe "ParseTree with fun grammar" do
+
+  before :each do
+    @g1 = Hipe.GorillaGrammar {
+      :mode      =~    one(['bike'],['walk'],['take','the','train'])
+      :person    =~    /\A.*\Z/
+      :modes     =~    [:mode, zero_or_more(['and', :mode])]
+      :sentence  =~    [:person, 'will', :modes, 'home']
+    }
+  end
+
+  it "should parse this fun grammar (pt1)" do 
+    g = @g1
+    res = g.parse %w(mark will take the train home)
+    res.is_error?.should == false
+    res.size.should == 4
+    
+    res = g.parse %w(fecetious will swim)
+    res.is_error?.should == true
+    res.tree.expecting.should == %w("bike" "walk" "take")
+          
+    res = g.parse(%w(yoko will bike and walk and take the train home))
+    res.is_error?.should == false
+  end
+  
+  it "should pp this fun grammar (pt2)" do
+    res = @g1.parse(%w(yoko will bike and walk and take the train home))
+    num_of_things_deleted = res.recurse{ |x| x.prune! }
+    num_of_things_deleted.should be > 30
+    num_of_things_deleted.should be < 80   # was 59 at one point.  whatever
+    # puts %{number of things deleted: #{num_of_things_deleted}}
+    PP.pp(res,s = '')
+    s.should be_kind_of String
+    s.length.should be_close(650, 350)
+  end
+
+  it "should unparse (pt3)" do
+    # this is such a small example but i can't explain how awesome it is.
+    res = @g1.parse(%w(yoko will bike and walk and take the train home))
+    tokens = res.recurse{|x| x.tokens}
+    tokens.should == %w(yoko will bike and walk and take the train home)
+  end
+  
+end
+
+describe RangeOf,' in the context of ParseTrees' do
+  it "should create or-lists correctly (ptro1)" do
+    RangeOf.join(['a','b','c','d'],', ',' or '){|x| %{"#{x}"}}.should == 
+      %{"a", "b", "c" or "d"}
+    RangeOf.join(['a','b','c'],', ',' or '){|x| %{"#{x}"}}.should == 
+      %{"a", "b" or "c"}
+    RangeOf.join(['a','b'],', ',' or '){|x| %{"#{x}"}}.should == 
+      %{"a" or "b"}
+    RangeOf.join(['a'],', ',' or '){|x| %{"#{x}"}}.should == 
+      %{"a"}
+    RangeOf.join([],', ',' or '){|x| %{"#{x}"}}.should == 
+      %{}
+  end
+end

data/spec/parsing_spec.rb

@@ -0,0 +1,304 @@
+#rake spec SPEC=spec/parsing_spec.rb
+require 'hipe-gorillagrammar'
+include Hipe::GorillaGrammar
+
+
+describe ParseTree, 'in the context of Parsing' do
+
+  it("should parse with the empty grammar")   { 
+    Hipe.GorillaGrammar{ (0..more).of('') }.parse([]).is_error?.should == false
+  }
+
+  it("should parse with the one token grammar") {
+    g = Hipe.GorillaGrammar{[:item[//]]}
+    tree = g.parse(['abc'])
+    tree.is_error?.should == false
+  }
+  
+end
+
+describe "in the context of Parsing, a simple union grammar" do
+  before :each do 
+    @g_union = Hipe.GorillaGrammar { :base =~  'mac' | 'whopper' }
+  end
+  
+  it "(u0) should allow two ways to define union -- pipe and named functions" do
+    g1 = @g_union
+    g2 = Hipe.GorillaGrammar{ :base =~  one('mac','whopper') }
+    g3 = Hipe.GorillaGrammar{ :base =~  one('mac','whopper',['bk','broiler']) }    
+    g1.should == g2
+    g1.should_not == g3
+  end
+  
+  it "(u1) should raise unexpected end when zero tokens" do 
+    g = @g_union
+    result = g.parse []
+    result.is_error?.should == true
+    result.should be_kind_of UnexpectedEndOfInput
+    result.message.should be_kind_of String
+  end
+  
+  it "(u2) should parse one correct token" do
+    result = @g_union.parse ['mac']
+    result.is_error?.should == false
+    result.should be_kind_of(RangeOf)
+    result.size.should == 1
+    result[0].should == 'mac'
+  end
+  
+  it "(u3) should raise unexpected with one incorrect token" do
+    result = @g_union.parse ['falafel']
+    result.is_error?.should == true
+    result.should be_kind_of(UnexpectedInput)
+    result.message.should be_kind_of(String)
+  end
+  
+  it "(u4) should raise unexpected with extra token" do
+    result = @g_union.parse ['mac','falafel']
+    result.is_error?.should == true
+    result.should be_kind_of(UnexpectedInput)
+    result.message.should be_kind_of(String)
+  end  
+end
+  
+describe "in the context of Parsing, a simple concatenated grammar" do  
+  
+  before :each do 
+    @g_concat = Hipe.GorillaGrammar { :base =~ [ 'big' , 'mac' ] }
+  end  
+  
+  it "(c1) should raise unexpected end when it has zero tokens" do 
+    g = @g_concat
+    result = g.parse []
+    result.is_error?.should == true
+    result.should be_kind_of UnexpectedEndOfInput
+    result.message.should be_kind_of String
+  end
+  
+  it "(c2) should raise unexpected end when nonzero not enough tokens" do 
+    g = @g_concat
+    result = g.parse ['big']
+    result.is_error?.should == true
+    result.should be_kind_of UnexpectedEndOfInput
+    result.message.should be_kind_of String
+  end
+  
+  it "(c3) should raise unexpected with one bad token " do
+    g = @g_concat
+    result = g.parse ['falafel']
+    result.is_error?.should == true
+    result.should be_kind_of UnexpectedInput
+    result.message.should be_kind_of String   
+  end  
+  
+  it "(c4) should parse correctly " do
+    g = @g_concat
+    result = g.parse ['big','mac']
+    result.is_error?.should == false
+    result.should be_kind_of Sequence
+    result.size.should == 2
+  end
+  
+  it "(c5) with the second token being bad should raise unexpected" do 
+    g = @g_concat
+    result = g.parse ['big','falafel']
+    result.is_error?.should == true
+    result.should be_kind_of UnexpectedInput
+    result.message.should be_kind_of String
+  end
+  
+  it "(c6) with too many tokens should raise unexpected" do 
+    g = @g_concat
+    result = g.parse ['big','mac','attack']
+    result.is_error?.should == true
+    result.should be_kind_of UnexpectedInput
+    result.message.should be_kind_of String
+  end
+  
+end
+
+describe "in the context of Parsing a simple sequence (same as concat)" do
+  before(:each) do 
+    @abc = Hipe.GorillaGrammar do
+      sequence 'a','b','c'
+    end
+  end
+
+  it "should fail with a message when expecting more (s5)" do
+    result = @abc.parse(['a','b'])
+    result.is_error?.should == true
+    result.message.should match(/unexpected end of input/i)      
+    result.message.should match(/expecting(?: you to say) "c"/i)
+  end
+
+end
+
+  
+describe "in the context of Parsing, an integrated union and concat with leading union" do
+  before :each do
+    @g1 = Hipe.GorillaGrammar do
+      sequence zero_or_more('real','big'),'burger'
+    end
+  end
+  
+  it "(i1) should fail on zero" do
+    r = @g1.parse []
+    r.is_error?.should == true
+    r.should be_kind_of(UnexpectedEndOfInput)
+    r.message.should match(/expecting.*real.*big.*burger/i)
+  end
+  
+  it "(i2) should fail on one bad token" do
+    r = @g1.parse ['falafel']
+    r.is_error?.should == true
+    r.should be_kind_of(UnexpectedInput)
+    r.message.should match(/expecting.*real.*big.*burger/i)
+  end
+  
+  it "(i3) should fail on a second bad token" do
+    r = @g1.parse ['real','falafel']
+    r.is_error?.should == true
+    r.should be_kind_of(UnexpectedInput)
+    r.message.should match(/expecting.*real.*big.*burger/i)
+  end
+  
+  it "(i4) should fail on a third bad token A" do
+    r = @g1.parse ['real','big','falafel']
+    r.is_error?.should == true
+    r.should be_kind_of(UnexpectedInput)
+    r.message.should match(/expecting.*real.*big.*burger/i)
+  end
+
+  it "(i5) should fail on a an extra token" do
+    r = @g1.parse ['real','big','burger','falafel']
+    r.is_error?.should == true
+    r.should be_kind_of(UnexpectedInput)
+    r.message.should match(/wasn't expecting/i)
+  end
+
+  it "(i6) should parse correctly A" do
+    r = @g1.parse ['burger']
+    r.is_error?.should == false
+    r.size.should == 2
+  end
+
+  it "(i7) should parse correctly B" do
+    r = @g1.parse ['real','burger']
+    r.is_error?.should == false
+    r.size.should == 2
+  end
+
+  it "(i8) should parse correctly C" do
+    r = @g1.parse ['real','big','burger']
+    r.is_error?.should == false
+    r.size.should == 2
+  end
+
+  it "(i9) should parse correctly D" do
+    r = @g1.parse ['real','big','real','burger']
+    r.is_error?.should == false
+    r.size.should == 2
+  end
+
+end  
+  
+
+describe "in the context of Parsing, an integrated union and concat with trailing union" do
+  before :each do
+    @g1 = Hipe.GorillaGrammar do
+      sequence one('burger','goat'),zero_or_more(['with','fries'],['with','falafel'])
+    end
+  end
+
+  it "(j1) should fail on zero" do
+    r = @g1.parse []
+    r.is_error?.should == true
+    r.should be_kind_of(UnexpectedEndOfInput)
+    r.message.should match(/expecting.*burger.*goat/i)
+  end
+
+  it "(j2) should fail on one bad token" do
+    r = @g1.parse ['falafel']
+    r.is_error?.should == true
+    r.should be_kind_of(UnexpectedInput)
+    r.message.should match(/expecting.*burger.*goat/i)
+  end
+
+  it "(j3) should fail on a second bad token (and do uniq on expecting tokens)" do
+    r = @g1.parse ['burger','without']
+    r.is_error?.should == true
+    r.should be_kind_of(UnexpectedInput)
+    r.message.should match(/expecting.*with/i)
+  end
+
+  it "(j4) should fail on a third bad token A" do
+    r = @g1.parse ['burger','with','toast']
+    r.is_error?.should == true
+    r.should be_kind_of(UnexpectedInput)
+    r.message.should match(/expecting.*fries.*falafel.*end/i)
+  end
+
+  it "(j5) should fail on two extra tokens" do
+    r = @g1.parse ['burger','with','fries','to','go']
+    r.is_error?.should == true
+    r.should be_kind_of(UnexpectedInput)
+    r.message.should match(/(?:wasn't expecting|don't know what you mean by).*to.*end/i)
+  end
+
+  it "(j6) should parse correctly A" do
+    r = @g1.parse ['burger']
+    r.is_error?.should == false
+    r.size.should == 1
+  end
+
+  it "(j7) should parse correctly B" do
+    r = @g1.parse ['burger','with','falafel']
+    r.is_error?.should == false
+    r.size.should == 2
+  end
+
+  it "(j8) should parse correctly C" do
+    r = @g1.parse ['goat','with','fries']
+    r.is_error?.should == false
+    r.size.should == 2
+  end
+
+  # no j9.  there are only 3 permutations of correct productions
+
+  
+  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) ] ]
+    }
+    $stop =1 
+    thing = g.parse ['want','jimmy']
+    thing.is_error?.should == true
+    thing.should be_kind_of UnexpectedEndOfInput
+    thing.tree.expecting.should == %w("dean") 
+  end
+
+end
+  
+describe "test" do
+
+  it "union of concat"
+end    
+
+describe 'in the context of Parsing, an "and-list" gramar' do
+  before(:all){ 
+    @g = Hipe.GorillaGrammar{ :items  =~ [:item[/^.+$/],(0..more).of(['and', :item])]} 
+    @g = Hipe.GorillaGrammar{ [:item[/^.+$/]] }
+  }
+  it("uno")   { 
+    @g.parse(['abc']).is_error?.should == false                        
+  }
+end
+
+
+describe 'in the context of Parsing, an "and-list" gramar' do
+  before(:all){ @g = Hipe.GorillaGrammar{ :items  =~ [:item[/^.+$/],(0..more).of(['and', :item])]} }
+  it("uno")   { @g.parse(['abc']).is_error?.should == false                        }
+  it("uno.5") { @g.parse(['abc','and']).is_error?.should == true                   }
+  it("dos")   { @g.parse(['abc','and','def']).is_error?.should == false            }
+  it("tres")  { @g.parse(['abc','and','def','and','hij']).is_error?.should ==false }
+end