babel_bridge 0.4.1 → 0.5.0

data/spec/basic_parsing_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe "basic parsing" do
+  include TestParserGenerator
+
+  it "string literal should work" do
+    new_parser do
+      rule :foo, "foo"
+    end
+
+    test_parse "foo"
+    test_parse("foo").offset.should == 0
+    test_parse("foo").text.length.should == 3
+  end
+
+  it ".as option should work" do
+    new_parser do
+      rule :foo, match("foo").as(:boo)
+    end
+
+    test_parse "foo"
+    test_parse("foo").boo.text.should == "foo"
+  end
+
+  it "regexp should work" do
+    new_parser do
+      rule :foo, /[0-9]+/
+    end
+
+    %w{ 0 1 10 123 1001 }.each do |numstr|
+      test_parse numstr
+    end
+  end
+
+  # bb uses some regexp optimizations which could fail if not matched @ the first character of the source
+  it "regexp should work even when it isn't the first match" do
+    new_parser do
+      rule :foo, /[0-9]+/
+      rule :foo, "hi", /[0-9]+/
+    end
+
+    test_parse "123"
+    test_parse "hi123"
+  end
+
+  it "test optional" do
+    new_parser do
+      rule :foo, "foo", :bar?
+      rule :bar, "bar"
+    end
+
+    test_parse "foo"
+    test_parse "foobar"
+  end
+
+  it "test could" do
+    new_parser do
+      rule :foo, could.match(/[a-z]/), /[a-zA-Z]+/
+    end
+    test_parse "FOO", :should_fail_at => 0
+    test_parse "fOO"
+    test_parse "foo"
+  end
+
+  it "test optional in the middle" do
+    new_parser do
+      rule :foo, "foo", match?("bar"), "foo"
+    end
+
+    test_parse "foofoo"
+    test_parse "foobarfoo"
+  end
+
+  # this seems a little strange, but it is correct behavior for a Parsing-Expression-Grammar parser
+  it "test_greedy_optional_middle" do
+    new_parser do
+      rule :foo, "foo", match?("foo"), "foo"
+    end
+
+    test_parse "foofoo", :should_fail_at => 6
+    test_parse "foofoofoo"
+  end
+
+  it "! (not-match) should work" do
+    new_parser do
+      rule :foo, match!("boo"), /[a-zA-Z]+/
+    end
+
+    test_parse "boo", :should_fail_at => 0
+    test_parse "foo"
+    test_parse "boO"
+  end
+
+end

data/spec/bb_spec.rb

@@ -1,44 +1,7 @@
-require File.join(File.dirname(__FILE__),"..","lib","babel_bridge")
+require 'spec_helper'
 
 describe BabelBridge do
-  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)
-    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
-
-  it "ignore_whitespace should work" do
-    new_parser do
-      ignore_whitespace
-      rule :foobar, "foo", "bar"
-    end
-
-    test_parse "foobar"
-    test_parse "foo bar"
-    test_parse "foo  \t \r \f \n    bar"
-    test_parse " foobar"
-    test_parse "foobar "
-  end
+  include TestParserGenerator
 
   it "the failure_index should be the furthest point reached, even if we managed to successfully match less" do
     new_parser do
@@ -65,71 +28,6 @@ describe BabelBridge do
     parser.parser_failure_info[partial_match_string].should == nil
   end
 
-  it "include_whitespace should work" do
-    new_parser do
-      ignore_whitespace
-
-      rule :pair, :statement, :end_statement, :statement
-      rule :end_statement, rewind_whitespace, /([\t ]*[\n;])+/
-      rule :statement, "0"
-    end
-
-    test_parse "0;0"
-    test_parse "0\n0"
-    test_parse "0   ;   0"
-    test_parse "0   ; ;  0"
-    test_parse "0   \n   0"
-    test_parse "0   \n \n  0"
-    test_parse "0   \n ;  \n  0"
-    test_parse "0  ;  \n  ;0"
-    test_parse "0      0", :should_fail_at => 1
-  end
-
-  it "include_whitespace should work even with EmptyNodes" do
-    new_parser do
-      ignore_whitespace
-
-      rule :pair, :statement, :end_statement, :statement
-      rule :end_statement, rewind_whitespace, /([\t ]*[\n;])+/
-      rule :statement, "0", :one?, :one?, :one?
-      rule :one, "1"
-    end
-
-    test_parse "0;0"
-    test_parse "01;0"
-    test_parse "0\n0"
-    test_parse "01\n0"
-    test_parse "011\n0"
-    test_parse "0111\n0"
-  end
-
-  it "include_whitespace should work with many" do
-    new_parser do
-      ignore_whitespace
-      rule :statements, many(:statement,:end_statement)
-      rule :end_statement, rewind_whitespace, /([\t ]*[;\n])+/
-      rule :statement, "0"
-    end
-
-    test_parse "0"
-    test_parse "0\n0"
-  end
-
-  it "custom ignore_whitespace should work" do
-    new_parser do
-      ignore_whitespace /[_\s]*/
-
-      rule :foobar, "foo", "bar"
-    end
-
-    test_parse "foobar"
-    test_parse "foo_bar"
-    test_parse "foo_ bar"
-    test_parse "foo _ bar"
-    test_parse "foo bar"
-    test_parse "foo-bar", :should_fail_at => 3
-  end
-
   it "should work to have many-many parsing" do
     new_parser do
       rule :top, many(:bottom,";")
@@ -144,68 +42,14 @@ describe BabelBridge do
     test_parse "0,0,0;0;0,0,0"
   end
 
-  it "should work to have many parsing with whitespace tricks" do
+  it "if a name can be optionally matched more than one time, it should always be an array of matchs" do
     new_parser do
-      ignore_whitespace
-      rule :statements, many(:statement,:end_statement)
-      rule :end_statement, rewind_whitespace, /([\t ]*[;\n])+/
-      rule :statement, :bin_op
-      binary_operators_rule :bin_op, :int, ["**", [:/, :*], [:+, "-"]], :right_operators => ["**"]
-      rule :int, /\d+/
-    end
-
-    test_parse "0"
-    test_parse <<ENDCODE
-      3+4
-      9-2
-      4
-ENDCODE
-  end
-
-  it "should work to rewind_whitespace, :rule" do
-    new_parser do
-      ignore_whitespace
-      rule :all, :identifier, :parameter?, :identifier do
-        def to_model
-          [[identifier[0].to_sym, parameter && parameter.to_sym], identifier[1].to_sym]
-        end
-      end
-      rule :parameter, rewind_whitespace, /[ \t]*/, rewind_whitespace, :identifier
-      rule :identifier, /[_a-zA-Z][_a-zA-Z0-9]*/
-    end
-
-    test_parse("fred\nbar") {|parsed|parsed.to_model.should == [[:fred,nil],:bar]}
-    test_parse("fred foo\nbar") {|parsed|parsed.to_model.should == [[:fred,:foo],:bar]}
-  end
-
-  it "should work to rewind_whitespace, many" do
-    new_parser do
-      ignore_whitespace
-      rule :all, :identifier, :parameters?, :identifier do
-        def to_model
-          [[identifier[0].to_sym, parameters && parameters.to_s], identifier[1].to_sym]
-        end
-      end
-      rule :parameters, rewind_whitespace, /[ \t]*/, rewind_whitespace, many(:identifier,",")
-      rule :identifier, /[_a-zA-Z][_a-zA-Z0-9]*/
-    end
-
-    test_parse("fred\nbar")           {|parsed| parsed.to_model.should==[[:fred,nil],:bar]}
-    test_parse("fred foo\nbar")       {|parsed| parsed.to_model.should==[[:fred,"foo"],:bar]}
-    test_parse("fred foo, bar\nbar")  {|parsed| parsed.to_model.should==[[:fred,"foo, bar"],:bar]}
-  end
-
-  it "dont.match shouldn't consume any whitespace" do
-    new_parser do
-      ignore_whitespace
-      rule :statements, :statement, "bar"
-      rule :statement, :identifier, :parameters?
-      rule :parameters, rewind_whitespace, / */, rewind_whitespace, :identifier
-      rule :identifier, dont.match("end"), /[_a-zA-Z][_a-zA-Z0-9]*/
+      rule :foo, :bar, :bar?
+      rule :bar, "bar"
     end
 
-    test_parse("fred\nbar")
-    test_parse("fred foo\nbar")
+    test_parse("bar").bar.class.should == BabelBridge::MultiMatchesArray
+    test_parse("barbar").bar.class.should == BabelBridge::MultiMatchesArray
   end
 
 end

data/spec/ignore_whitespace_spec.rb

@@ -0,0 +1,227 @@
+require 'spec_helper'
+
+describe "ignore_whitespace" do
+  include TestParserGenerator
+
+  it "ignore_whitespace should work" do
+    new_parser do
+      ignore_whitespace
+      rule :foobar, "foo", "bar"
+    end
+
+#    test_parse "foobar"
+#    test_parse "foo bar"
+#    test_parse "foo  \t \r \f \n    bar"
+#    test_parse " foobar"
+    test_parse "foobar "
+  end
+
+  it "ignore_whitespace should work with many" do
+    new_parser do
+      ignore_whitespace
+      rule :foobar, many("foo")
+    end
+
+    test_parse "foo"
+    test_parse "foofoo"
+    test_parse "foo     foo"
+    test_parse "foo foo\nfoo"
+  end
+
+  it "custom delimiter should work" do
+    new_parser do
+      ignore_whitespace
+      rule :pair, "0", "0", :delimiter => /-*/
+    end
+
+    test_parse "00"
+    test_parse "0-0"
+    test_parse " 0-0"
+    test_parse " 0-0 "
+    test_parse " 0--0 "
+  end
+
+  it "custom // delimiter should work" do
+    new_parser do
+      ignore_whitespace
+      rule :pair, "0", "0", :delimiter => //
+    end
+
+    test_parse "00"
+    test_parse " 00"
+    test_parse " 00 "
+    test_parse "0 0", :should_fail_at => 1
+  end
+
+
+  it "custom delimiter should work" do
+    new_parser do
+      ignore_whitespace
+
+      rule :pair, :statement, :end_statement, :statement, :delimiter => //
+      rule :end_statement, /([\t ]*[\n;])+([\t ]*)?/
+      rule :statement, "0"
+    end
+
+    test_parse "0;0"
+    test_parse "0\n0"
+    test_parse "0   ;   0"
+    test_parse "0   ; ;  0"
+    test_parse "0   \n   0"
+    test_parse "0   \n \n  0"
+    test_parse "0   \n ;  \n  0"
+    test_parse "0  ;  \n  ;0"
+    test_parse "0      0", :should_fail_at => 1
+  end
+
+  it "custom delimiters should work even with EmptyNodes" do
+    new_parser do
+      ignore_whitespace
+
+      rule :pair, :statement, :end_statement, :statement, :delimiter => //
+      rule :end_statement, /([\t ]*[\n;])+([\t ]*)?/
+      rule :statement, "0", :one?, :one?, :one?
+      rule :one, "1"
+    end
+
+    test_parse "0;0"
+    test_parse "01;0"
+    test_parse "0\n0"
+    test_parse "01\n0"
+    test_parse "011\n0"
+    test_parse "0111\n0"
+  end
+
+  it "custom delimiters should work with many" do
+    new_parser do
+      ignore_whitespace
+      rule :statements, many(:statement,:end_statement), :delimiter => //
+      rule :end_statement, /([\t ]*[\n;])+([\t ]*)?/
+      rule :statement, "0"
+    end
+
+    test_parse "0"
+    test_parse "0\n0"
+    test_parse "0\n0;0"
+    test_parse "0 0", :should_fail_at => 2
+  end
+
+  it "custom global delimiter should work" do
+    new_parser do
+      delimiter /[_\s]*/
+
+      rule :foobar, "foo", "bar"
+    end
+
+    test_parse "foobar"
+    test_parse "foo_bar"
+    test_parse "foo_ bar"
+    test_parse "foo _ bar"
+    test_parse "foo bar"
+    test_parse "foo-bar", :should_fail_at => 3
+  end
+
+
+  it "should work to rewind_whitespace, :rule" do
+    new_parser do
+      ignore_whitespace
+      rule :two, :statement, :statement do
+        def to_model
+          statement.map {|a|a.to_model}
+        end
+      end
+      rule :statement, :identifier, :parameter?, :delimiter => // do
+        def to_model
+          [identifier.to_sym, parameter && parameter.identifier.to_sym]
+        end
+      end
+      rule :parameter, /[ \t]*/, :identifier, :delimiter => //
+      rule :identifier, /[_a-zA-Z][_a-zA-Z0-9]*/
+    end
+
+    test_parse("fred\nbar") {|parsed|parsed.to_model.should == [[:fred,nil],[:bar,nil]]}
+    test_parse("fred foo\nbar") {|parsed|parsed.to_model.should == [[:fred,:foo],[:bar,nil]]}
+  end
+
+  it "should work to have nested custom delimiters" do
+    new_parser do
+      ignore_whitespace
+      rule :all, :call, :call do
+        def to_model
+          call.collect &:to_model
+        end
+      end
+      rule :call, :identifier, :parameters?, :delimiter => // do
+        def to_model
+          [identifier.to_sym, parameters && parameters.to_s]
+        end
+      end
+      rule :parameters, /[ \t]*/, many(:identifier,","), :delimiter => //
+      rule :identifier, /[_a-zA-Z][_a-zA-Z0-9]*/
+    end
+
+    test_parse("fred\nbar")           {|parsed| parsed.to_model.should==[[:fred,nil],[:bar,nil]]}
+    test_parse("fred foo\nbar")       {|parsed| parsed.to_model.should==[[:fred," foo"],[:bar,nil]]}
+    test_parse("fred foo,bar\nbar")   {|parsed| parsed.to_model.should==[[:fred," foo,bar"],[:bar,nil]]}
+  end
+
+  it "dont.match shouldn't consume any whitespace" do
+    new_parser do
+      ignore_whitespace
+      rule :statements, :statement, "bar"
+      rule :statement, :identifier, :parameters?, :delimiter => //
+      rule :parameters, / */, :identifier, :delimiter => //
+      rule :identifier, dont.match("end"), /[_a-zA-Z][_a-zA-Z0-9]*/
+    end
+
+    test_parse("fred\nbar")
+    #test_parse("fred foo\nbar")
+  end
+
+  it "delimiter should work" do
+    new_parser do
+      delimiter :custom_delimiter
+      rule :foobar, "foo", "bar"
+      rule :custom_delimiter, /-*/
+    end
+
+    test_parse "foobar"
+    test_parse "foo-bar"
+    test_parse "foo---bar"
+  end
+
+  it "should work to have many parsing with whitespace tricks" do
+    new_parser do
+      ignore_whitespace
+      #rule :statements, many(:statement,:end_statement), :delimiter => //
+      #rule :end_statement, /([\t ]*[;\n])+/
+      #rule :statement, :bin_op
+      binary_operators_rule :bin_op, :int, ["**", [:/, :*], [:+, "-"]], :right_operators => ["**"]
+      rule :int, /\d+/
+    end
+
+=begin
+NOTES: the problem is the post-parsing results method-missing methods don't work well.
+
+If a named pattern is never matched, method-missing will fail. It should return nil.
+If a named pattern may match 1 or more times, you will get back a singleton OR an array depending on the number of times.
+
+I think the right answer is to drop method-missing entirely. Instead, when the rule is declared, create the accessor methods explicitly.
+
+If a named pattern could match more than once, it will always return an array.
+
+If it could match 0 times, it will work and return nil, if 0 times were indeed matched.
+
+=end
+    test_parse "3"
+=begin
+    test_parse "3+4"
+    test_parse <<ENDCODE
+      3+4
+      9-2
+      4
+ENDCODE
+=end
+  end
+
+end