babel_bridge 0.1.0

data/lib/nodes.rb

@@ -0,0 +1,256 @@
+module BabelBridge
+
+  # this is just so we can distinguish between normal arrays and arrays of matches
+  # - since a match can be an Array in the case of Poly-matches
+  class MultiMatchesArray < Array
+  end
+
+  # base class for all parse-tree nodes
+  class Node
+    attr_accessor :src,:offset,:match_length,:parent,:parser
+    
+    def to_s
+      text
+    end
+
+    def node_init(parent_or_parser)
+      self.match_length=0
+      case parent_or_parser
+      when Parser then
+        self.parser=parent_or_parser
+        self.offset=0
+        self.src=parser.src
+      when Node then
+        self.parent=parent_or_parser
+        self.parser=parent.parser
+        self.offset=parent.next
+        self.src=parent.src
+        raise "parent node does not have parser set" unless parser
+      else
+        raise "parent_or_parser(#{parent_or_parser.class}) must be a Node or a Parser"
+      end
+    end
+
+    def initialize(parent)
+      node_init(parent)
+    end
+
+    #********************
+    # info methods
+    #********************
+    def next; offset+match_length end       # index of first character after match
+    def text; src[offset,match_length] end  # the substring in src matched
+
+    # length returns the number of sub-nodes
+    def length
+      0
+    end
+
+    def parent_list
+      return parent ? parent.parent_list+[parent] : []
+    end
+
+    def node_path
+      "#{parent && (parent.node_path+' > ')}#{self.class}(#{offset})"
+    end
+
+    #*****************************
+    # Array interface implementation
+    #*****************************
+    def matches # override this with function that returns array of matches to be used for Array indexing and iteration
+      []
+    end
+
+    include Enumerable
+    def length
+      matches.length
+    end
+
+    def <<(node)
+      matches<<node
+    end
+
+    def add_delimiter(node)
+      delimiter_matches<<node
+    end
+
+    def [](i)
+      matches[i]
+    end
+
+    def each(&block)
+      matches.each(&block)
+    end
+end
+
+  class RootNode < Node
+  end
+
+  # non-terminal node
+  # subclassed automatically by parser.rule for each unique non-terminal
+  class NodeNT < Node
+    attr_accessor :matches,:match_names
+
+    def match_names
+      @match_names ||= []
+    end
+    def matches
+      @matches ||= []
+    end
+
+    # length returns the number of sub-nodes
+    def length
+      matches.length
+    end
+
+    def matches_by_name
+      @matches_by_name||= begin
+        raise "matches.length #{matches.length} != match_names.length #{match_names.length}" unless matches.length==match_names.length
+        mbn={}
+        mn=match_names
+        matches.each_with_index do |match,i|
+          name=mn[i]
+          next unless name
+          if current=mbn[name] # name already used
+            # convert to MultiMatchesArray if not already
+            mbn[name]=MultiMatchesArray.new([current]) if !current.kind_of? MultiMatchesArray
+            # add to array
+            mbn[name]<<match
+          else
+            mbn[name]=match
+          end
+        end
+        mbn
+      end
+    end
+
+    def inspect(options={})
+      return "#{self.class}" if matches.length==0
+      matches_inspected=matches.collect{|a|a.inspect(options)}.compact
+      if matches_inspected.length==0 then nil
+      elsif matches_inspected.length==1
+        m=matches_inspected[0]
+        ret="#{self.class} > "+matches_inspected[0]
+        if options[:simple]
+          ret=if m["\n"] then m
+          else
+            # just show the first and last nodes in the chain
+            ret.gsub(/( > [A-Z][a-zA-Z0-9:]+ > (\.\.\. > )?)/," > ... > ")
+          end
+        end
+        ret
+      else
+        (["#{self.class}"]+matches_inspected).join("\n").gsub("\n","\n  ")
+      end
+    end
+
+    #********************
+    # alter methods
+    #********************
+    def reset_matches_by_name
+      @matches_by_name=nil
+    end
+
+    def method_missing(method_name, *args)  #method_name is a symbol
+      unless matches_by_name.has_key? method_name
+        if matches[0]
+          puts "sending #{method_name.inspect} to #{matches[0].class}"      
+          return matches[0].send(method_name,*args)
+        end
+        raise "#{self.class}: missing method #{method_name.inspect} / doesn't match named pattern element: #{matches_by_name.keys.inspect}"
+      end
+      matches_by_name[method_name]
+    end
+
+    # adds a match with name (optional)
+    # returns self so you can chain add_match or concat methods
+    def add_match(match,name=nil)
+      raise "match must be a Node (match is a #{match.class})" unless match.kind_of?(Node)
+      raise "name must be a Symbol or nil (name is a #{name.class})" if name && !name.kind_of?(Symbol)
+      reset_matches_by_name
+      matches<<match
+      match_names<<name
+
+      self.match_length=match.next - offset
+      self
+    end
+
+    # concatinate all matches from another node
+    # returns self so you can chain add_match or concat methods
+    def concat(node)
+      names=node.match_names
+      node.matches.each_with_index { |match,i| add_match(match,names[i])}
+      self
+    end
+  end
+
+  # generated by a :poly PatternElement
+  # Not subclassed
+  class ManyNode < Node
+    attr_accessor :matches,:delimiter_matches
+    def initialize(parent)
+      node_init(parent)
+      self.matches=[]
+      self.delimiter_matches=[]
+      self.match_length=nil   # use match_length as an override; if nil, then match_length is determined by the last node and delimiter_match
+    end
+
+    def match_length; @match_length || (self.next-offset) end
+    def next
+      return offset+@match_length if @match_length
+      ret=nil
+      ret=matches[-1].next if matches[-1] && (!ret || matches[-1].next > ret)
+      ret=delimiter_matches[-1].next if delimiter_matches[-1] && (!ret || delimiter_matches[-1].next > ret)
+      ret||=parent.next
+    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 (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
+  end
+
+  # used for String and Regexp PatternElements
+  # not subclassed
+  class TerminalNode < Node
+    attr_accessor :pattern
+    def initialize(parent,match_length,pattern)
+      node_init(parent)
+      self.match_length=match_length
+      self.pattern=pattern
+    end
+
+    def inspect(options={})
+      "#{text.inspect}" unless options[:simple] && text[/^\s*$/] # if simple && node only matched white-space, return nil 
+    end
+
+    def matches; [self]; end
+  end
+
+  # used when a PatternElement matchs the empty string
+  # Example: when the PatternElement is optional and doesn't match
+  # not subclassed
+  class EmptyNode < Node
+    def inspect(options={})
+      "EmptyNode" unless options[:simple]
+    end
+  end
+end

data/test/test_bb.rb

@@ -0,0 +1,387 @@
+require File.dirname(__FILE__) + "/../lib/babel_bridge"
+require File.dirname(__FILE__) + "/test_helper"
+
+class BBTests < TestHelper
+
+  def new_module
+   @module_counter||=0
+   @module_counter+=1
+   "TestModule#{@module_counter}"
+  end
+
+  def new_parser(&block)
+    @parser_counter||=0
+    @parser_counter+=1
+    Object.const_set(klass_name="TestParser#{@parser_counter}",Class.new(BabelBridge::Parser,&block))
+    Object.const_get(klass_name).new
+  end
+
+  def test_foobar
+    parser=new_parser do #Class.new BabelBridge::Parser do
+      rule :foo, "foo", :bar
+      rule :bar, "bar"
+    end
+
+    assert_nil parser.parse("foo")
+    assert parser.parse("foobar")
+  end
+
+  def test_as
+    parser=new_parser do
+      rule :foo, match("foo").as(:boo)
+    end
+
+    assert parser.parse("foo")
+    assert_equal "foo", parser.parse("foo").boo.text
+  end
+
+  def test_many_as
+    parser=new_parser do
+      rule :foo, many("foo").as(:boo)
+    end
+
+    assert parser.parse("foo")
+    assert parser.parse("foofoo")
+    assert_equal "foofoo", parser.parse("foofoo").boo.text
+  end
+
+  def test_negative
+    parser=new_parser do
+      rule :foo, match!("boo"), /[a-zA-Z]+/
+    end
+
+    assert_nil parser.parse("boo")
+    assert parser.parse("foo")
+    assert parser.parse("boO")
+    assert parser.parse("abc")
+  end
+
+  def test_foo
+    parser=new_parser do
+      rule :foo, ["foo"]
+    end
+
+    assert p=parser.parse("foo")
+    assert_equal 0,p.offset
+    assert_equal 3,p.match_length
+  end
+
+  def test_regex
+    parser=new_parser do
+      rule :foo, [/[0-9]+/]
+    end
+
+    %w{ 0 1 10 123 1001 }.each do |numstr|
+      assert_equal numstr,parser.parse(numstr).text
+    end
+  end
+
+  def test_optional
+    parser=new_parser do
+      rule :foo, ["foo", :bar?]
+      rule :bar, ["bar"]
+    end
+
+    assert parser.parse("foo")
+    assert parser.parse("foobar")
+  end
+
+  def test_could
+    parser=new_parser do
+      rule :foo, could.match(/[a-z]/), /[a-zA-Z]+/
+    end
+    assert_nil parser.parse("FOO")
+    assert parser.parse("fOO")
+    assert parser.parse("foo")
+  end
+
+  def test_optional_middle
+    parser=new_parser do
+      rule :foo, ["foo", :bar?, "foo"]
+      rule :bar, ["bar"]
+    end
+
+    assert parser.parse("foofoo")
+    assert parser.parse("foobarfoo")
+  end
+
+  def test_greedy_optional_middle
+    parser=new_parser do
+      rule :foo, ["foo", :bar?, "foo"]
+      rule :bar, ["foo"]
+    end
+
+    assert_nil parser.parse("foofoo")
+    assert parser.parse("foofoofoo")
+  end
+
+  def test_not
+    parser=new_parser do
+      rule :foo, ["foo", :bar!]
+      rule :bar, ["bar"]
+    end
+
+    assert_nil parser.parse("foofud") # this should fail because it doesn't match the entire input
+    assert parser.parse("foofud",0,:foo)
+    assert parser.parse("foo")
+    assert_nil parser.parse("foobar")
+  end
+
+  def test_recursive
+    parser=new_parser do
+      rule :foo, ["foo", :foo?]
+    end
+
+    assert parser.parse("foo")
+    assert parser.parse("foofoo")
+    assert f=parser.parse("foofoofoo")
+
+#    assert_nil parser[:foo].parse("foobar")
+  end
+
+  def test_alternate
+    v1=nil
+    v2=nil
+    parser=new_parser do
+      v1=rule :foo, ["foo"]
+      v2=rule :foo, ["bar"]
+    end
+
+    assert r1=parser.parse("foo")
+    assert r2=parser.parse("bar")
+    assert_equal v1,r1.class
+    assert_equal v2,r2.class
+  end
+
+  def test_add
+    parser=new_parser do
+      rule :add, [:number,"+",:number]
+      rule :number, [/[0-9]+/]
+    end
+
+    assert parser.parse("1+1")
+    assert parser.parse("987+123")
+  end
+
+  def test_method
+    parser=new_parser do
+      rule :number, [/[0-9]+/] do
+        def number
+          text.to_i
+        end
+      end
+    end
+
+    assert p=parser.parse("123")
+    assert_equal 123,p.number
+  end
+
+  def test_adder
+    parser=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
+
+
+    assert p=parser.parse("123+654")
+    assert_equal 777,p.answer
+  end
+
+  def test_adder_multiplier
+    parser=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
+
+    assert_equal 123,parser.parse("123").value
+    assert_equal 369,parser.parse("123*3").value
+    assert_equal 370,parser.parse("123*3+1").value
+    assert_equal 129,parser.parse("123+3*2").value
+    assert_equal 777,parser.parse("123+654").value
+    assert_equal 281,parser.parse("20*4+1+100*2").value
+  end
+
+  def test_rule_class
+    parser=new_parser do
+      rule :foo, "foo"
+      rule :foo, "bar"
+      node_class :foo do
+        def value; text end
+      end
+    end
+
+    assert_equal "foo",parser.parse("foo").value
+    assert_equal "bar",parser.parse("bar").value
+  end
+
+  def test_indexed_match_reference_with_optional
+    parser=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
+
+    assert_equal "1,2", parser.parse("1,2").outter
+    assert_equal "1,3", parser.parse("1,A,3").outter
+
+  end
+
+  def test_verbose
+    parser=new_parser do
+      rule :foo, {:match=>"foo"}, {:match=>"bar",:optional=>true}
+    end
+
+    assert parser.parse("foo")
+    assert parser.parse("foobar")
+  end
+
+  def test_custom_parser
+    parser=new_parser do
+      rule :foo, {:parser=>lambda do |parent_node|
+        offset=parent_node.next
+        src=parent_node.src
+        if src.index(/[A-Z]+/,offset)==offset
+          endpattern=$~.to_s
+          if i=src.index(endpattern,offset+endpattern.length)
+            BabelBridge::TerminalNode.new(parent_node,i+endpattern.length-offset,"endpattern")
+          end
+        end
+      end}
+    end
+
+    assert parser.parse("END this is in the middle END")
+    assert_equal "END this is in END",parser.parse("END this is in END the middle END",0,:foo).text
+    assert_nil parser.parse("END this is in the middle EN")
+  end
+
+  def test_poly
+    parser=new_parser do
+      rule :foo, many("foo").as(:foo)
+    end
+    assert_equal ["foo"], parser.parse("foo").foo.collect {|f| f.text}
+    assert_equal ["foo","foo"], parser.parse("foofoo").foo.collect {|f| f.text}
+    assert_equal ["foo","foo","foo"], parser.parse("foofoofoo").foo.collect {|f| f.text}
+  end
+
+  def test_poly_delimiter
+    parser=new_parser do
+      rule :foo, many("foo",/ +/).as(:foo)
+    end
+    assert_equal ["foo"], parser.parse("foo").foo.collect {|f| f.text}
+    assert parser.parse("foo     foo")
+    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), "end"
+    end
+
+    assert_equal 0,parser.parse("end").foo.length
+    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?(/ +/))
+    end
+    assert parser.parse(";")
+    assert parser.parse_and_puts_errors(";;")
+    assert parser.parse(";    ;   ;")
+  end
+
+  def test_many
+    assert_equal({:many=>";",:match=>true}, BabelBridge::Parser.many(";"))
+  end
+
+  def test_many?
+    assert_equal({:many=>";", :optionally=>true, :match=>true}, BabelBridge::Parser.many?(";"))
+  end
+
+  def test_many!
+    assert_equal({:many=>";", :dont=>true, :match=>true}, BabelBridge::Parser.many!(";"))
+  end
+
+  def test_match
+    assert_equal({:match=>";"}, BabelBridge::Parser.match(";"))
+  end
+
+  def test_match?
+    assert_equal({:match=>";",:optionally=>true}, BabelBridge::Parser.match?(";"))
+  end
+
+  def test_match!
+    assert_equal({:match=>";",:dont=>true}, BabelBridge::Parser.match!(";"))
+  end
+
+  def test_dont
+    assert_equal({:match=>";",:dont=>true}, BabelBridge::Parser.dont.match(";"))
+  end
+
+  def test_optionally
+    assert_equal({:match=>";",:optionally=>true}, BabelBridge::Parser.optionally.match(";"))
+  end
+
+  def test_could
+    assert_equal({:match=>";",:could=>true}, BabelBridge::Parser.could.match(";"))
+  end
+
+  def disabled_test_recursive_block
+    # PEG does have this problem, so this isn't really an error
+    # But maybe in the future we'll handle it better.
+    # SBD: Disabled 2010-10-24
+    parser=new_parser do
+      rule :foo, :foo, ";"
+      rule :foo, "-"
+
+    end
+    parser.parse "-"
+  end
+end
+
+tests=BBTests.new
+
+
+
+tests.run_tests(ARGV.length>0 && ARGV)