babel_bridge 0.4.1 → 0.5.0

data/spec/inspect_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe "ManyNode#inspect" do
+  include TestParserGenerator
+
+  def basic_many_parser
+    new_parser do
+      rule :foobar, many("foo", ",")
+    end
+  end
+
+  def inspect_test(a,options={})
+    a.inspect(options).rstrip.gsub(/[ \t]+\n/,"\n")+"\n"
+  end
+
+  it "with no options should look like this" do
+    basic_many_parser
+    test_parse("foo").inspect.should == 'FoobarNode1 > "foo"'
+    inspect_test(test_parse("foo,foo,foo")).should == <<ENDINSPECT
+FoobarNode1
+  "foo"
+  "foo"
+  "foo"
+ENDINSPECT
+  end
+
+  it "with :simple=>true should look like this" do
+    basic_many_parser
+    test_parse("foo").inspect(:simple=>true).should == 'FoobarNode1 > "foo"'
+    inspect_test(test_parse("foo,foo,foo"),:simple=>true).should == <<ENDINSPECT
+FoobarNode1
+  "foo"
+  "foo"
+  "foo"
+ENDINSPECT
+  end
+
+  it "with :verbose=>true should look like this" do
+    basic_many_parser
+    test_parse("foo").inspect(:verbose=>true).should == 'FoobarNode1 > "foo"'
+    inspect_test(test_parse("foo,foo,foo"),:verbose=>true).should == <<ENDINSPECT
+FoobarNode1
+  "foo"
+  ","
+  "foo"
+  ","
+  "foo"
+ENDINSPECT
+  end
+end

data/spec/many_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe "many parsing" do
+  include TestParserGenerator
+
+  it "anonymous manys should work" do
+    new_parser do
+      rule :foo, many("bar")
+    end
+
+    test_parse("bar").matches.length.should == 1
+    test_parse("barbar").matches.length.should == 2
+  end
+
+  it "named manys should work" do
+    new_parser do
+      rule :foo, many(:bar)
+      rule :bar, "bar"
+    end
+
+    test_parse("bar").bar.class.should == BabelBridge::MultiMatchesArray
+    test_parse("barbar").bar.class.should == BabelBridge::MultiMatchesArray
+  end
+
+  it "parse that matches nothing on a many? on the first character should still report valid parser_failure_info" do
+    new_parser do
+      rule :foo, many?("foo")
+    end
+
+    res = parser.parse "bar"
+    parser.parser_failure_info(:verbose => true).class.should == String
+  end
+
+  it "many with .as should work" do
+    new_parser do
+      rule :foo, many("foo").as(:boo)
+    end
+
+    test_parse("foo").boo.join(',').should == "foo"
+    test_parse("foofoo").boo.join(',').should == "foo,foo"
+    test_parse("foofoofoo").boo.join(',').should == "foo,foo,foo"
+  end
+
+  it "many with delimiter" do
+    new_parser do
+      rule :foo, many("foo",";").as(:foo)
+    end
+    test_parse("foo").foo.collect {|f| f.text}.should == %w{foo}
+    test_parse("foo;foo").foo.collect {|f| f.text}.should == %w{foo foo}
+  end
+
+  it "test_poly_optional_delimiter" do
+    parser=new_parser do
+      rule :foo, many(";",match?(/ +/))
+    end
+    test_parse ";"
+    test_parse ";;"
+    test_parse ";    ;   ;"
+  end
+end

data/spec/node_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe "basic parsing" do
+  include TestParserGenerator
+
+  it "offset, matchs, text, and length" do
+    new_parser do
+      rule :foo, "foo", match?("bar")
+    end
+
+    test_parse("foo").offset.should == 0
+    test_parse("foobar").matches[1].offset.should == 3
+    test_parse("foo").length.should == 1
+    test_parse("foobar").length.should == 2
+    test_parse("foo").text.should == "foo"
+    test_parse("foobar").to_s.should == "foobar"
+  end
+
+  it "test custom node methods" do
+    new_parser do
+      rule :number, /[0-9]+/ do
+        def number
+          text.to_i
+        end
+      end
+    end
+
+    test_parse("123").number.should == 123
+  end
+
+  def test_adder
+    new_parser do
+      rule :adder, :number, "+", :number do
+        def answer;
+          number[0].number + number[1].number
+        end
+      end
+      rule :number, /[0-9]+/ do
+        def number; text.to_i end
+      end
+    end
+
+
+    test_parser("123+654").answer.should == 777
+  end
+
+  def test_adder_multiplier
+    new_parser do
+
+      rule :adder, :multiplier, "+", :adder do
+        def value
+          multiplier.value + adder.value
+        end
+      end
+
+      rule :adder, :multiplier do
+        def value
+          multiplier.value
+        end
+      end
+
+      rule :multiplier, :number, "*", :multiplier do
+        def value
+          number.value * multiplier.value
+        end
+      end
+
+      rule :multiplier, :number do
+        def value
+          number.value
+        end
+      end
+
+      rule :number, /[0-9]+/ do
+        def value; text.to_i end
+      end
+
+    end
+
+    test_parse("123").value.should == 123
+    test_parse("123*3").value.should == 123*3
+    test_parse("123*3+1").value.should == 123*3+1
+    test_parse("123+3*2").value.should == 123+3*2
+    test_parse("123+654").value.should == 123+654
+    test_parse("20*4+1+100*2").value.should == 20*4+1+100*2
+  end
+
+
+  it "test_indexed_match_reference_with_optional" do
+    new_parser do
+      rule :foo, :bar, :boo?, :bar do
+        def outter
+          bar[0].text + bar[1].text
+        end
+      end
+      rule :bar, /[0-9]+,?/
+      rule :boo, /[A-Z]+,?/
+    end
+
+    test_parse("1,2").outter.should == "1,2"
+    test_parse("1,A,3").outter.should == "1,3"
+  end
+
+
+  it "test_rule_class" do
+    new_parser do
+      rule :foo, "foo"
+      rule :foo, "bar"
+      node_class :foo do
+        def value; text end
+      end
+    end
+
+    test_parse("foo").value.should=="foo"
+    test_parse("bar").value.should=="bar"
+  end
+end

data/spec/pattern_generators_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe "basic parsing" do
+  include TestParserGenerator
+
+  it "test_many" do
+    BabelBridge::Parser.many(";").hash.should == {:many=>";",:match=>true}
+  end
+
+  it "test_many?" do
+    BabelBridge::Parser.many?(";").hash.should == {:many=>";", :optionally=>true, :match=>true}
+  end
+
+  it "test_many!" do
+    BabelBridge::Parser.many!(";").hash.should == {:many=>";", :dont=>true, :match=>true}
+  end
+
+  it "test_match" do
+    BabelBridge::Parser.match(";").hash.should == {:match=>";"}
+  end
+
+  it "test_match?" do
+    BabelBridge::Parser.match?(";").hash.should == {:match=>";",:optionally=>true}
+  end
+
+  it "test_match!" do
+    BabelBridge::Parser.match!(";").hash.should == {:match=>";",:dont=>true}
+  end
+
+  it "test_dont" do
+    BabelBridge::Parser.dont.match(";").hash.should == {:match=>";",:dont=>true}
+  end
+
+  it "test_optionally" do
+    BabelBridge::Parser.optionally.match(";").hash.should == {:match=>";",:optionally=>true}
+  end
+
+  it "test_could" do
+    BabelBridge::Parser.could.match(";").hash.should == {:match=>";",:could=>true}
+  end
+end

data/spec/rule_parsing_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe "more complex rule structure parsing" do
+  include TestParserGenerator
+
+  it "sub-rules should work" do
+    new_parser do
+      rule :foo, "foo", :bar
+      rule :bar, "bar"
+    end
+
+    test_parse "foo", :should_fail_at => 3
+    test_parse "foobar"
+  end
+
+  it "optional rule" do
+    new_parser do
+      rule :foo, "foo", :bar?
+      rule :bar, "bar"
+    end
+
+    test_parse "foo"
+    test_parse "foobar"
+  end
+
+  it "not-match rule" do
+    new_parser do
+      rule :foo, :boo!, /[a-zA-Z]+/
+      rule :boo, "boo"
+    end
+
+    test_parse "boo", :should_fail_at => 0
+    test_parse "foo"
+    test_parse "boO"
+  end
+
+  it "rule variants should work" do
+    v1=nil
+    v2=nil
+    new_parser do
+      v1=rule :foo, "foo"
+      v2=rule :foo, "bar"
+    end
+
+    test_parse("foo").class.should == v1
+    test_parse("bar").class.should == v2
+    test_parse "baz", :should_fail_at => 0
+  end
+
+  it "test right-recursive" do
+    new_parser do
+      rule :foo, "foo", :foo?
+    end
+
+    test_parse "foo"
+    test_parse "foofoo"
+    test_parse "foofoofoo"
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require File.join(File.dirname(__FILE__),"..","lib","babel_bridge")
+
+module TestParserGenerator
+
+  attr_accessor :parser
+
+  def new_parser(&block)
+    $parser_counter||=0
+    $parser_counter+=1
+    Object.const_set(klass_name="TestParser#{$parser_counter}",Class.new(BabelBridge::Parser,&block))
+    @parser=Object.const_get(klass_name).new
+  end
+
+  #options
+  #   :parser
+  #   :failure_ok
+  def test_parse(string,options={},&block)
+    parser = options[:parser] || @parser
+    res = parser.parse(string,options)
+    yield res if res && block
+    if options[:should_fail_at]
+      res.should == nil
+      parser.failure_index.should == options[:should_fail_at]
+    elsif !options[:failure_ok]
+      puts parser.parser_failure_info :verbose => true unless res
+      res.should_not == nil
+    end
+    res
+  end
+
+end

data/spec/tools_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe "Tools::" do
+  include TestParserGenerator
+
+
+  it "line_col" do
+    "".           line_col(0).should == [1,1]
+    " ".          line_col(0).should == [1,1]
+    "a\nbb\nccc". line_col(0).should == [1,1]
+    "a\nbb\nccc". line_col(1).should == [1,2]
+    "a\nbb\nccc". line_col(2).should == [2,1]
+    "a\nbb\nccc". line_col(3).should == [2,2]
+    "a\nbb\nccc". line_col(4).should == [2,3]
+    "a\nbb\nccc". line_col(5).should == [3,1]
+    "a\nbb\nccc". line_col(6).should == [3,2]
+    "a\nbb\nccc". line_col(7).should == [3,3]
+    "a\nbb\nccc". line_col(8).should == [3,4]
+    "a\nbb\nccc". line_col(9).should == [3,4]
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: babel_bridge
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -55,15 +55,24 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README
+- Rakefile
 - babel_bridge.gemspec
-- test/test_bb.rb
-- test/test_helper.rb
+- spec/advanced_parsers_spec.rb
+- spec/basic_parsing_spec.rb
 - spec/bb_spec.rb
+- spec/ignore_whitespace_spec.rb
+- spec/inspect_spec.rb
+- spec/many_spec.rb
+- spec/node_spec.rb
+- spec/pattern_generators_spec.rb
+- spec/rule_parsing_spec.rb
+- spec/spec_helper.rb
+- spec/tools_spec.rb
 - lib/babel_bridge.rb
 - lib/nodes/empty_node.rb
-- lib/nodes/many_node.rb
 - lib/nodes/node.rb
 - lib/nodes/non_terminal_node.rb
+- lib/nodes/root_node.rb
 - lib/nodes/rule_node.rb
 - lib/nodes/terminal_node.rb
 - lib/nodes.rb

data/lib/nodes/many_node.rb

@@ -1,53 +0,0 @@
-=begin
-Copyright 2011 Shane Brinkman-Davis
-See README for licence information.
-http://babel-bridge.rubyforge.org/
-=end
-
-module BabelBridge
-# generated by a :poly PatternElement
-# Not subclassed
-class ManyNode < NonTerminalNode
-
-  def delimiter_matches
-    @delimiter_matches||=[]
-  end
-
-  def separate_delimiter_matches
-    count = 0
-    @matches, @delimiter_matches = matches.partition {|el| count+=1;(count%2==1)}
-    @delimiter_matches = @delimiter_matches[0..@matches.length-2] #delimiter_matches should be exactly 1 shorter
-    update_match_length
-  end
-
-  def inspect_helper(list,options)
-    simple=options[:simple]
-    ret=list.collect {|a|a.inspect(options)}.compact
-    ret= if ret.length==0 then simple ? nil : "[]"
-    elsif ret.length==1 && !ret[0]["\n"] then (simple ? ret[0] : "[#{ret[0]}]")
-    else
-      ret = ret.collect {|a| "  "+a.gsub("\n","\n  ")}
-      (simple ? ret : ["[",ret,"]"]).flatten.join("\n") #.gsub("\n","\n  ")
-    end
-    ret
-  end
-
-  def inspect(options={})
-    if options[:simple]
-      c=[]
-      matches.each_with_index {|n,i| c<<n;c<<delimiter_matches[i]}
-      c=c.compact
-      inspect_helper(c,options)
-    else
-      ret=inspect_helper(matches,options)
-      ret+=" delimiters="+inspect_helper(delimiter_matches,options) if delimiter_matches.length>0
-      ret
-    end
-  end
-
-  def method_missing(method_name, *args)  #method_name is a symbol
-    self.map {|match| match.send(method_name,*args)}
-  end
-
-end
-end