babel_bridge 0.3.1 → 0.4.0

data/lib/rule.rb

@@ -4,10 +4,10 @@ class Rule
   attr_accessor :name, :variants, :parser, :node_class
 
   private
-  # creates a subclass of the NonTerminalNode for this Rule's node_class
+  # creates a subclass of the RuleNode for this Rule's node_class
   def create_node_class
     class_name = "#{parser.module_name}_#{name}_node".camelize
-    parser.const_set class_name, Class.new(NonTerminalNode)
+    parser.const_set class_name, Class.new(RuleNode)
   end
 
   # creates a new sub_class of the node_class for a variant
@@ -59,4 +59,4 @@ class Rule
     "#{variants.collect {|v|v.to_s}.join("\n\t")}"
   end
 end
-end
+end

data/lib/shell.rb

@@ -7,19 +7,42 @@ class Shell
     @parser = parser
   end
 
-  def evaluate(parse_tree_node)
-    if parse_tree_node.respond_to? :evaluate
-      " => "+parse_tree_node.evaluate.inspect
+  def pretty_print_parse_tree(parse_tree_node)
+    puts "\nParse tree:\n  #{parse_tree_node.inspect.gsub("\n","\n  ")}\n\n"
+  end
+
+  # Providing a block overrides all evaluate behavor and simply:  yield parse_tree_node, self
+  # elsif parse_tree_node responds to "evaluate":                 puts_result parse_tree_node.evaluate
+  # else                                                          pretty-print the parse-tree
+  # rescue and pretty-print errors
+  def evaluate(parse_tree_node, &block)
+    if block
+      yield parse_tree_node, self
+    elsif parse_tree_node.respond_to? :evaluate
+      puts_result parse_tree_node.evaluate
     else
-      "\nParse tree:\n  "+
-      parse_tree_node.inspect.gsub("\n","\n  ")+"\n\n"
+      pretty_print_parse_tree parse_tree_node
     end
   rescue Exception => e
-    @stderr.puts "Error evaluating parse tree: #{e}\n  "+e.backtrace.join("\n  ")+"\nParse Tree:\n"+parse_tree_node.inspect
+    errputs "Error evaluating parse tree: #{e}\n" + ["Backtrace:",e.backtrace].flatten.join("\n  ")
+    pretty_print_parse_tree parse_tree_node
+  end
+
+  def puts(str)
+    @stdout.puts str
+  end
+
+  def puts_result(str)
+    @stdout.puts " => "+str.inspect
+  end
+
+  def errputs(str)
+    @stderr.puts str
   end
 
-  # if block is provided, successful parsers are yield to block
-  # Otherwise, succuessful parsers are sent the "eval" method
+  # Each line of input is parsed.
+  # If parser fails, output explaination of why.
+  # If parser succeeds, evaluate parse_tree_node, &block
   def start(options={},&block)
     @stdout = options[:stdout] || $stdout
     @stderr = options[:stdout] || @stdout
@@ -27,15 +50,11 @@ class Shell
     while line = @stdin == $stdin ? Readline.readline("> ", true) : @stdin.gets      
       line.strip!
       next if line.length==0
-      ret = parser.parse line
-      if ret
-        if block
-          yield ret
-        else
-          @stdout.puts evaluate(ret)
-        end
+      parse_tree_node = parser.parse line
+      if parse_tree_node
+        evaluate parse_tree_node, &block
       else
-        @stderr.puts parser.parser_failure_info :verbose => true
+        errputs parser.parser_failure_info :verbose => true
       end
     end
   end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module BabelBridge
-  VERSION = "0.3.1"
-end
+  VERSION = "0.4.0"
+end

data/spec/bb_spec.rb

@@ -0,0 +1,164 @@
+require File.join(File.dirname(__FILE__),"..","lib","babel_bridge")
+
+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={})
+    parser = options[:parser] || @parser
+    res = parser.parse(string)
+    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
+
+  it "the failure_index should be the furthest point reached, even if we managed to successfully match less" do
+    new_parser do
+      ignore_whitespace
+
+      rule :statement, "while", :statement, "end"
+      rule :statement, "0"
+      rule :statement, /[_a-zA-Z][_a-zA-Z0-9]*/
+    end
+
+    res = test_parse "while 0 foo", :should_fail_at => 8
+  end
+
+  it "parsing twice when the first didn't match all input should, but the second just failed, shouldn't report 'did not match entire input'" do
+    new_parser do
+      rule :foo, "foo"
+    end
+
+    partial_match_string = "did not match entire input"
+
+    test_parse "foobar", :failure_ok => true
+    parser.parser_failure_info[partial_match_string].should == partial_match_string
+    test_parse "bar", :failure_ok => true
+    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, include_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, include_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, include_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,";")
+      rule :bottom, many("0",",")
+    end
+
+    test_parse "0"
+    test_parse "0;0"
+    test_parse "0,0"
+    test_parse "0,0;0"
+    test_parse "0;0,0"
+    test_parse "0,0,0;0;0,0,0"
+  end
+
+  it "should work to have many many parsing with whitespace tricks" do
+    new_parser do
+      ignore_whitespace
+      rule :statements, many(:statement,:end_statement)
+      rule :end_statement, include_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
+
+end

data/test/test_bb.rb

@@ -292,7 +292,8 @@ class BBTests < TestHelper
         if src[offset..-1].index(/\A[A-Z]+/)==0
           endpattern=$~.to_s
           if i=src.index(endpattern,offset+endpattern.length)
-            BabelBridge::TerminalNode.new(parent_node,i+endpattern.length-offset,"endpattern")
+            range = offset..(i+endpattern.length)
+            BabelBridge::TerminalNode.new(parent_node,range,"endpattern")
           end
         end
       end}
@@ -322,20 +323,6 @@ class BBTests < TestHelper
     assert_equal ["foo","foo"], parser.parse("foo     foo").foo.collect {|f| f.text}
   end
 
-  def test_poly_post_delimiter
-    parser=new_parser do
-      rule :foo, many?("foo",/ +/,true).as(:foo), match("end").as(:end)
-    end
-
-    assert_equal nil,parser.parse("end").foo
-    assert_equal "end",parser.parse("end").end.to_s
-    assert_equal nil,parser.parse(" end")
-    assert_equal nil,parser.parse("foofoo end")
-    assert_equal ["foo"], parser.parse("foo end").foo.collect {|f| f.text}
-    assert_equal ["foo","foo"], parser.parse("foo     foo end").foo.collect {|f| f.text}
-    assert_equal 5, parser.parse("foo   foo       foo foo  foo end").foo.length
-  end
-
   def test_poly_optional_delimiter
     parser=new_parser do
       rule :foo, many(";",match?(/ +/))
@@ -395,11 +382,11 @@ class BBTests < TestHelper
   def test_binary_operator_rule
     parser=new_parser do
       binary_operators_rule :bin_op, :int, ["**", [:/, :*], [:+, "-"]], :right_operators => ["**"] do
-        def evaluate  
+        def evaluate
           "(#{left.evaluate}#{operator}#{right.evaluate})"
         end
       end
-     
+
       rule :int, /[-]?[0-9]+/ do
         def evaluate; to_s; end
       end
@@ -413,6 +400,14 @@ class BBTests < TestHelper
     assert_equal "(5**(6**7))", parser.parse("5**6**7").evaluate
   end
 
+  def test_dont_parser
+    parser = new_parser do
+      rule :option, dont.match(/msg.*/), /.*/
+    end
+    assert_nil parser.parse "msg test"
+    assert parser.parse "non test"
+  end
+
   def test_line_col
     assert_equal [1,1], "".line_col(0)
     assert_equal [1,1], " ".line_col(0)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: babel_bridge
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,10 +10,45 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2010-11-28 00:00:00.000000000 Z
-dependencies: []
-description: ! "Babel Bridge is an object oriented parser generator for parsing expression
-  grammars (PEG). \nGenerate memoizing packrat parsers 100% in Ruby code with a simple
-  embedded DSL.\n"
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'Babel Bridge is an object oriented parser generator for parsing expression
+  grammars (PEG).
+
+  Generate memoizing packrat parsers 100% in Ruby code with a simple embedded DSL.
+
+'
 email: shanebdavis@gmail.com
 executables: []
 extensions: []
@@ -23,11 +58,13 @@ files:
 - babel_bridge.gemspec
 - test/test_bb.rb
 - test/test_helper.rb
+- spec/bb_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/rule_node.rb
 - lib/nodes/terminal_node.rb
 - lib/nodes.rb
 - lib/parser.rb
@@ -43,6 +80,7 @@ files:
 - examples/test.rb
 - examples/turing/examples.turing
 - examples/turing/notes.rb
+- examples/turing/turing++.rb
 - examples/turing/turing.rb
 - examples/turing/turing00.rb
 - examples/turing/turing01.rb
@@ -83,3 +121,4 @@ signing_key:
 specification_version: 3
 summary: A Ruby-based parser-generator based on Parsing Expression Grammars.
 test_files: []
+has_rdoc: false