babel_bridge 0.4.1 → 0.5.0

data/lib/pattern_element.rb

@@ -6,11 +6,20 @@ http://babel-bridge.rubyforge.org/
 
 module BabelBridge
 # hash which can be used declaratively
-class PatternElementHash < Hash
+class PatternElementHash
+  attr_accessor :hash
+
+  def initialize
+    @hash = {}
+  end
+
+  def [](key) @hash[key] end
+  def []=(key,value) @hash[key]=value end
+
   def method_missing(method_name, *args)  #method_name is a symbol
     return self if args.length==1 && !args[0] # if nil is provided, don't set anything
     raise "More than one argument is not supported. #{self.class}##{method_name} args=#{args.inspect}" if args.length > 1
-    self[method_name]=args[0] || true # on the other hand, if no args are provided, assume true
+    @hash[method_name] = args[0] || true # on the other hand, if no args are provided, assume true
     self
   end
 end
@@ -20,32 +29,55 @@ end
 #   :many
 #   :optional
 class PatternElement
-  attr_accessor :parser,:optional,:negative,:name,:terminal,:could_match
-  attr_accessor :match,:rule_variant,:rewind_whitespace
+  attr_accessor :parser, :optional, :negative, :name, :terminal, :could_match
+  attr_accessor :match, :rule_variant, :parser_class
+
+  # true if this is a delimiter
+  attr_accessor :delimiter
 
   #match can be:
   # true, Hash, Symbol, String, Regexp
-  def initialize(match,rule_variant)
-    self.rule_variant=rule_variant
-    init(match)
-
+  # options
+  #   :rule_varient
+  #   :parser
+  def initialize(match, options={})
+    @init_options = options.clone
+    @rule_variant = options[:rule_variant]
+    @parser_class = options[:parser_class]
+    @delimiter = options[:delimiter]
+    @name = options[:name]
+    raise "rule_variant or parser_class required" unless @rule_variant || @parser_class
+
+    init match
     raise "pattern element cannot be both :dont and :optional" if negative && optional
   end
 
   def inspect
-    "<PatternElement rule_variant=#{rule_variant.variant_node_class} match=#{match.inspect}>"
+    "<PatternElement #{rule_variant && "rule_variant=#{rule_variant.variant_node_class} "}match=#{match.inspect}#{" delimiter" if delimiter}>"
   end
 
   def to_s
     match.inspect
   end
 
+  def parser_class
+    @parser_class || rule_variant.rule.parser
+  end
+
+  def rules
+    parser_class.rules
+  end
+
   # attempt to match the pattern defined in self.parser in parent_node.src starting at offset parent_node.next
   def parse(parent_node)
-    return RollbackWhitespaceNode.new(parent_node) if rewind_whitespace
 
     # run element parser
-    match = parser.call(parent_node)
+    begin
+      parent_node.parser.matching_negative if negative
+      match = parser.call(parent_node)
+    ensure
+      parent_node.parser.unmatching_negative if negative
+    end
 
     # Negative patterns (PEG: !element)
     match = match ? nil : EmptyNode.new(parent_node) if negative
@@ -56,11 +88,13 @@ class PatternElement
     # Could-match patterns (PEG: &element)
     match.match_length = 0 if match && could_match
 
-    if !match && terminal
+    if !match && (terminal || negative)
       # log failures on Terminal patterns for debug output if overall parse fails
-      parent_node.parser.log_parsing_failure(parent_node.next,:pattern=>self.match,:node=>parent_node)
+      parent_node.parser.log_parsing_failure parent_node.next, :pattern => self.match, :node => parent_node
     end
 
+    match.delimiter = delimiter if match
+
     # return match
     match
   end
@@ -70,12 +104,13 @@ class PatternElement
   # initialize PatternElement based on the type of: match
   def init(match)
     self.match = match
+    match = match[0] if match.kind_of?(Array) && match.length == 1
     case match
     when TrueClass then init_true
     when String then    init_string match
     when Regexp then    init_regex match
     when Symbol then    init_rule match
-    when Hash then      init_hash match
+    when PatternElementHash then      init_hash match
     else                raise "invalid pattern type: #{match.inspect}"
     end
   end
@@ -96,7 +131,7 @@ class PatternElement
     self.parser=lambda do |parent_node|
       offset = parent_node.next
       if parent_node.src[offset..-1].index(optimized_regex)==0
-        range=$~.offset(0)
+        range = $~.offset(0)
         range = (range.min+offset)..(range.max+offset)
         TerminalNode.new(parent_node,range,regex)
       end
@@ -109,11 +144,11 @@ class PatternElement
     rule_name.to_s[/^([^?!]*)([?!])?$/]
     rule_name = $1.to_sym
     option = $2
-    match_rule = rule_variant.rule.parser.rules[rule_name]
+    match_rule = rules[rule_name]
     raise "no rule for #{rule_name}" unless match_rule
 
     self.parser = lambda {|parent_node| match_rule.parse(parent_node)}
-    self.name = rule_name
+    self.name ||= rule_name
     case option
     when "?"  then self.optional = true
     when "!"  then self.negative = true
@@ -128,9 +163,6 @@ class PatternElement
       init_many hash
     elsif hash[:match]
       init hash[:match]
-    elsif hash[:rewind_whitespace]
-      self.rewind_whitespace = true
-      return
     else
       raise "extended-options patterns (specified by a hash) must have either :parser=> or a :match=> set"
     end
@@ -144,41 +176,37 @@ class PatternElement
   # initialize the PatternElement as a many-parser from hashed parameters (hash[:many] is assumed to be set)
   def init_many(hash)
     # generate single_parser
-    init hash[:many]
-    single_parser = parser
+    pattern_element = PatternElement.new(hash[:many], @init_options.merge(name:hash[:as]))
 
     # generate delimiter_pattern_element
-    delimiter_pattern_element = hash[:delimiter] && PatternElement.new(hash[:delimiter],rule_variant)
+    many_delimiter_pattern_element = hash[:delimiter] && PatternElement.new(hash[:delimiter], @init_options.merge(name:hash[:delimiter_name]))
 
     # generate many-parser
     self.parser = lambda do |parent_node|
-      many_node = ManyNode.new parent_node
+      parent_node.match_name_is_poly(pattern_element.name)
+
+      # fail unless we can match at least one
+      return unless parent_node.match pattern_element
 
-      if delimiter_pattern_element
+      if many_delimiter_pattern_element
+        parent_node.match_name_is_poly(many_delimiter_pattern_element.name)
         # delimited matching
-        while true
-          #match primary
-          match = single_parser.call many_node
-          break unless match
-          many_node.add_match match
-
-          #match delimiter
-          delimiter_match = delimiter_pattern_element.parse many_node
-          break unless delimiter_match
-          many_node.add_match delimiter_match
+        while (parent_node.attempt_match do
+            parent_node.match_delimiter &&
+            parent_node.match(many_delimiter_pattern_element).tap{|md|md&&md.many_delimiter=true} &&
+            parent_node.match_delimiter &&
+            parent_node.match(pattern_element)
+          end)
         end
-        many_node.separate_delimiter_matches
       else
         # not delimited matching
-        while true
-          match = single_parser.call many_node
-          break unless match
-          many_node.add_match match
+        while (parent_node.attempt_match do
+            parent_node.match_delimiter &&
+            parent_node.match(pattern_element)
+          end)
         end
       end
-
-      # success only if we have at least one match
-      many_node.length>0 && many_node
+      parent_node
     end
   end
 end

data/lib/rule.rb

@@ -11,7 +11,7 @@ class Rule
   end
 
   # creates a new sub_class of the node_class for a variant
-  def create_next_node_variant_class
+  def new_variant_node_class
     rule_variant_class_name = "#{name}_node#{self.variants.length+1}".camelize
     parser.const_set rule_variant_class_name, Class.new(node_class)
   end
@@ -24,11 +24,17 @@ class Rule
     @node_class = create_node_class
   end
 
-  def add_variant(pattern, &block)
-    rule_variant_class = create_next_node_variant_class
-    variants << RuleVariant.new(pattern, self, rule_variant_class)
-    rule_variant_class.class_eval &block if block
-    rule_variant_class
+  def root_rule?
+    parser.root_rule == name
+  end
+
+  def add_variant(options={}, &block)
+    new_variant_node_class.tap do |variant_node_class|
+      options[:variant_node_class] = variant_node_class
+      options[:rule] = self
+      variants << RuleVariant.new(options)
+      variant_node_class.class_eval &block if block
+    end
   end
 
   def parse(node)

data/lib/rule_variant.rb

@@ -3,35 +3,59 @@ module BabelBridge
 # Each Rule has one or more RuleVariant
 # Rules attempt to match each of their Variants in order. The first one to succeed returns true and the Rule succeeds.
 class RuleVariant
-  attr_accessor :pattern, :rule, :variant_node_class
+  attr_accessor :pattern, :rule, :variant_node_class, :delimiter_pattern, :match_delimiter_prepost
 
-  def initialize(pattern, rule, variant_node_class=nil)
-    @pattern = pattern
-    @rule = rule
-    @variant_node_class = variant_node_class
+  # pattern: Array - the pattern to match
+  # rule: Rule instance
+  # variant_node_class: RuleVariant class
+  def initialize(options = {})
+    @pattern = options[:pattern]
+    @rule = options[:rule]
+    @variant_node_class = options[:variant_node_class]
+    raise "variant_node_class required" unless variant_node_class
+    @delimiter = options[:delimiter]
+  end
+
+  def parser
+    @rule.parser
+  end
+
+  def root_rule?
+    rule.root_rule?
+  end
+
+  def delimiter_pattern
+    @delimiter_pattern ||= if @delimiter
+      PatternElement.new(@delimiter, :rule_variant => self, :delimiter => true) unless @delimiter==// || @delimiter==""
+    else
+      parser.delimiter_pattern
+    end
   end
 
   # convert the pattern into a set of lamba functions
   def pattern_elements
-    @pattern_elements||=pattern.collect { |match| PatternElement.new match, self }
+    @pattern_elements||=pattern.collect { |match| [PatternElement.new(match, :rule_variant => self, :pattern_element => true), delimiter_pattern] }.flatten[0..-2]
+  end
+
+  def parse_element(element_parser, node)
+    node.add_match element_parser.parse(node), element_parser.name
   end
 
   # returns a Node object if it matches, nil otherwise
   def parse(parent_node)
     #return parse_nongreedy_optional(src,offset,parent_node) # nongreedy optionals break standard PEG
-    node = variant_node_class.new(parent_node)
+    node = variant_node_class.new(parent_node, delimiter_pattern)
+
+    node.match parser.delimiter_pattern if root_rule?
 
     pattern_elements.each do |pe|
-      match=pe.parse(node)
+      return unless node.match(pe)
+    end
+    node.pop_match if node.last_match && node.last_match.delimiter
 
-      # if parse failed
-      return if !match
-      match.matched
+    node.match parser.delimiter_pattern if root_rule?
 
-      # parse succeeded, add to node and continue
-      node.add_match(match,pe.name)
-    end
-    node.post_match
+    node && node.post_match_processing
   end
 
   def inspect; pattern.collect {|a| a.inspect}.join(', '); end

data/lib/string.rb

@@ -14,16 +14,9 @@ module BabelBridge
       lines.length<=n ? self : lines[-n..-1].join("\n")
     end
 
-    # return the line and column of a given offset into this string
-    # line and column are 1-based
-    def line_col(offset)
-      return 1,1 if length==0 || offset==0
-      lines=(self[0..offset-1]+" ").split("\n")
-      return lines.length, lines[-1].length
-    end
   end
 end
- 
+
 class String
   include BabelBridge::StringExtensions
-end
+end

data/lib/tools.rb

@@ -2,8 +2,29 @@ module BabelBridge
 class Tools
   class << self
 
-    def indent(string,indent="  ")
-      indent + string.gsub("\n", "\n#{indent}")
+    def indent(string, first_indent = "  ", rest_indent = first_indent)
+      first_indent + string.gsub("\n", "\n#{rest_indent}")
+    end
+
+    def uniform_tabs(string)
+      lines = string.split("\n").collect{|line|line.split("\t")}
+      max_fields = lines.collect {|line| line.length}.max
+      max_fields.times do |field|
+        max_field_length = lines.collect {|line| (line[field]||"").length}.max
+        formatter = "%-#{max_field_length}s "
+        lines.each_with_index do |line,i|
+          lines[i][field] = formatter%line[field] if line[field]
+        end
+      end
+      lines.collect {|line|line.join}.join("\n")
+    end
+
+    # return the line and column of a given offset into this string
+    # line and column are 1-based
+    def line_column(string, offset)
+      return 1,1 if string.length==0 || offset==0
+      lines = (string[0..offset-1] + " ").split("\n")
+      return lines.length, lines[-1].length
     end
 
     def symbols_to_strings(array)
@@ -21,14 +42,14 @@ class Tools
       array.sort_by {|a| a.kind_of?(Regexp) ? 0 : -a.length}
     end
 
-    # Takes an array of Strings and Regexp and generates a new Regexp 
+    # Takes an array of Strings and Regexp and generates a new Regexp
     # that matches the or ("|") of all strings and Regexp
     def array_to_or_regexp_string(array)
       array = symbols_to_strings array.flatten
       array = sort_operator_patterns array
       array = regexp_and_strings_to_regexpstrings array
 
-      array.collect {|op| "(#{op})"}.join('|') #.tap {|a| puts "array_to_or_regexp_string(#{array.inspect}) -> /#{a}/"}
+      array.collect {|op| "(#{op})"}.join('|')
     end
 
     def array_to_anchored_or_regexp(array)
@@ -96,7 +117,6 @@ class BinaryOperatorProcessor
     return operands[0] if operands.length==1
 
     i = index_of_lowest_precedence(operators)
-
     operator = operators[i]
     new_operand = node_class.new(parent_node)
     new_operand.add_match generate_tree(operands[0..i], operators[0..i-1],new_operand), :left
@@ -106,4 +126,4 @@ class BinaryOperatorProcessor
   end
 
 end
-end
+end

data/lib/version.rb

@@ -1,3 +1,4 @@
 module BabelBridge
-  VERSION = "0.4.1"
+  # last release: 0.4.1
+  VERSION = "0.5.0"
 end

data/spec/advanced_parsers_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe "advanced parsing" do
+  include TestParserGenerator
+
+  it "test_custom_parser" do
+    new_parser do
+      rule :foo, (custom_parser do |parent_node|
+        offset=parent_node.next
+        src=parent_node.src
+
+        # Note, the \A anchors the search at the beginning of the string
+        if src[offset..-1].index(/\A[A-Z]+/)==0
+          endpattern=$~.to_s
+          if i=src.index(endpattern,offset+endpattern.length)
+            range = offset..(i+endpattern.length)
+            BabelBridge::TerminalNode.new(parent_node,range,"endpattern")
+          end
+        end
+      end)
+    end
+
+    test_parse("END this is in the middle END")
+    test_parse("END this is in END the middle END",:partial_match => true).text.should == "END this is in END"
+    test_parse "END this is in the middle EN", :should_fail_at => 0
+    test_parse "    END this is in the middle END", :should_fail_at => 0
+  end
+
+  it "test_binary_operator_rule" do
+    new_parser do
+      binary_operators_rule :bin_op, :int, ["**", [:/, :*], [:+, "-"]], :right_operators => ["**"] do
+        def evaluate
+          "(#{left.evaluate}#{operator}#{right.evaluate})"
+        end
+      end
+
+      rule :int, /[-]?[0-9]+/ do
+        def evaluate; to_s; end
+      end
+    end
+    test_parse("1+2").evaluate          .should == "(1+2)"
+    test_parse("1+2+3").evaluate        .should == "((1+2)+3)"
+    test_parse("1+2*3").evaluate        .should == "(1+(2*3))"
+    test_parse("1*2+3").evaluate        .should == "((1*2)+3)"
+    test_parse("5**6").evaluate         .should == "(5**6)"
+    test_parse("1-2+3*4/5**6").evaluate .should == "((1-2)+((3*4)/(5**6)))"
+    test_parse("5**6**7").evaluate      .should == "(5**(6**7))"
+  end
+end