babel_bridge 0.2.0 → 0.3.0

data/lib/rule.rb

@@ -0,0 +1,62 @@
+module BabelBridge
+# Rules define one or more patterns (RuleVariants)  to match for a given non-terminal
+class Rule
+  attr_accessor :name, :variants, :parser, :node_class
+
+  private
+  # creates a subclass of the NonTerminalNode 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)
+  end
+
+  # creates a new sub_class of the node_class for a variant
+  def create_next_node_variant_class
+    rule_variant_class_name = "#{name}_node#{self.variants.length+1}".camelize
+    parser.const_set rule_variant_class_name, Class.new(node_class)
+  end
+
+  public
+  def initialize(name,parser)
+    @name = name
+    @variants = []
+    @parser = parser
+    @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
+  end
+
+  def parse(node)
+    if cached = node.parser.cached(name,node.next)
+      return cached == :no_match ? nil : cached # return nil if cached==:no_matched
+    end
+
+    variants.each do |v|
+      if match = v.parse(node)
+        node.parser.cache_match(name,match)
+        return match
+      end
+    end
+    node.parser.cache_no_match(name,node.next)
+    nil
+  end
+
+  # inspect returns a string which approximates the syntax for generating the rule and all its variants
+  def inspect
+    variants.collect do |v|
+      "rule #{name.inspect}, #{v.inspect}"
+    end.join("\n")
+  end
+
+  # returns a more human-readable explanation of the rule
+  def to_s
+    "rule #{name.inspect}, node_class: #{node_class}\n\t"+
+    "#{variants.collect {|v|v.to_s}.join("\n\t")}"
+  end
+end
+end

data/lib/rule_variant.rb

@@ -0,0 +1,45 @@
+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
+
+  def initialize(pattern, rule, variant_node_class=nil)
+    @pattern = pattern
+    @rule = rule
+    @variant_node_class = variant_node_class
+  end
+
+  # convert the pattern into a set of lamba functions
+  def pattern_elements
+    @pattern_elements||=pattern.collect { |match| PatternElement.new match, self }
+  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)
+
+    pattern_elements.each do |pe|
+      match=pe.parse(node)
+
+      # if parse failed
+      if !match
+        if pe.terminal
+          # log failures on Terminal patterns for debug output if overall parse fails
+          node.parser.log_parsing_failure(node.next,:pattern=>pe.match,:node=>node)
+        end
+        return nil
+      end
+
+      # parse succeeded, add to node and continue
+      node.add_match(match,pe.name)
+    end
+    node.post_match
+  end
+
+  def inspect; pattern.collect {|a| a.inspect}.join(', '); end
+  def to_s; "variant_class: #{variant_node_class}, pattern: #{inspect}"; end  
+end
+end

data/lib/shell.rb

@@ -0,0 +1,36 @@
+require "readline"
+
+module BabelBridge
+class Shell
+  attr_accessor :parser
+  def initialize(parser)
+    @parser = parser
+  end
+
+  def evaluate(parse_tree_node)
+    parse_tree_node.evaluate
+  rescue Exception => e
+    @stderr.puts "Error evaluating parse tree: #{e}\n  "+e.backtrace.join("\n  ")
+  end
+
+  # if block is provided, successful parsers are yield to block
+  # Otherwise, succuessful parsers are sent the "eval" method
+  def start(options={},&block)
+    @stdout = options[:stdout] || $stdout
+    @stderr = options[:stdout] || @stdout
+    @stdin = options[:stdin] || $stdin
+    while line = @stdin == $stdin ? Readline.readline("> ", true) : @stdin.gets
+      ret = parser.parse line.strip
+      if ret
+        if block
+          yield ret
+        else
+          @stdout.puts " => #{evaluate(ret).inspect}"
+        end
+      else
+        @stderr.puts parser.parser_failure_info
+      end
+    end
+  end
+end
+end

data/lib/string.rb

@@ -0,0 +1,26 @@
+module BabelBridge
+  module StringExtensions
+    def camelize
+      self.split("_").collect {|a| a.capitalize}.join
+    end
+
+    def first_lines(n)
+      lines=self.split("\n",-1)
+      lines.length<=n ? self : lines[0..n-1].join("\n")
+    end
+
+    def last_lines(n)
+      lines=self.split("\n",-1)
+      lines.length<=n ? self : lines[-n..-1].join("\n")
+    end
+
+    def line_col(offset)
+      lines=self[0..offset-1].split("\n")
+      return lines.length, lines[-1].length
+    end
+  end
+end
+ 
+class String
+  include BabelBridge::StringExtensions
+end

data/lib/tools.rb

@@ -0,0 +1,90 @@
+module BabelBridge
+class Tools
+  class << self
+
+    # 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)
+      new_re=array.flatten.collect do |op|
+        "("+case op
+        when Regexp then op.source
+        when String, Symbol then Regexp.escape(op.to_s)
+        end+")"
+      end.sort{|a|a.length}.join('|')
+    end
+
+    def array_to_anchored_or_regexp(array)
+      Regexp.new "^"+array_to_or_regexp_string(array)+"$"
+    end
+
+    def array_to_or_regexp(array)
+      Regexp.new array_to_or_regexp_string(array)
+    end
+  end
+end
+
+class BinaryOperatorProcessor
+  attr_accessor :node_class, :exact_operator_precedence, :regexp_operator_precedence, :right_operators
+  def initialize(operator_precedence,node_class,right_operators)
+    @right_operators_regexp= right_operators && Tools::array_to_anchored_or_regexp(right_operators)
+    @node_class=node_class
+    @exact_operator_precedence={}
+    @regexp_operator_precedence=[]
+
+    operator_precedence.each_with_index do |op_level,i|
+      (op_level.kind_of?(Array) ? op_level : [op_level]).each do |op|
+        case op
+        when String, Symbol then @exact_operator_precedence[op.to_s] = i
+        when Regexp then @regexp_operator_precedence << [op,i]
+        end
+      end
+    end
+  end
+
+  def operator_precedence(operator_string)
+    p = @exact_operator_precedence[operator_string]
+    return p if p
+    @regexp_operator_precedence.each do |regexp,p|
+      return p if operator_string[regexp]
+    end
+    raise "operator #{operator_string.inspect} didn't match #{@exact_operator_precedence} or #{@regexp_operator_precedence}"
+  end
+
+  # associativity =
+  #    :left => operators of the same precidence execut from left to right
+  #    :right => operators of the same precidence execut from right to left
+  def index_of_lowest_precedence(operators,associativity=:left)
+    lowest = lowest_precedence = nil
+    operators.each_with_index do |operator,i|
+      operator_string = operator.to_s
+      precedence = operator_precedence(operator_string)
+      right_associative = @right_operators_regexp && operator_string[@right_operators_regexp]
+      if !lowest || (right_associative ? precedence < lowest_precedence : precedence <= lowest_precedence)
+        lowest = i
+        lowest_precedence = precedence
+      end
+    end
+    lowest
+  end
+
+  # generates a tree of nodes of the specified node_class
+  # The nodes have access to the following useful methods:
+  #    self.left -> return the left operand parse-tree-node
+  #    self.right -> return the right operand parse-tree-node
+  #    self.operator_node -> return the operator parse-tree-node
+  #    self.operator -> return the operator as a ruby symbol
+  def generate_tree(operands, operators, parent_node)
+    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
+    new_operand.add_match operators[i], :operator_node
+    new_operand.add_match generate_tree(operands[i+1..-1], operators[i+1..-1],new_operand), :right
+    new_operand
+  end
+
+end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module BabelBridge
+  VERSION = "0.3.0"
+end

data/test/test_bb.rb

@@ -1,5 +1,5 @@
-require File.dirname(__FILE__) + "/../lib/babel_bridge"
-require File.dirname(__FILE__) + "/test_helper"
+require File.expand_path(File.join(File.dirname(__FILE__),"..","lib","babel_bridge"))
+require File.expand_path(File.join(File.dirname(__FILE__),"test_helper"))
 
 class BBTests < TestHelper
 
@@ -287,7 +287,9 @@ class BBTests < TestHelper
       rule :foo, {:parser=>lambda do |parent_node|
         offset=parent_node.next
         src=parent_node.src
-        if src.index(/[A-Z]+/,offset)==offset
+
+        # 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)
             BabelBridge::TerminalNode.new(parent_node,i+endpattern.length-offset,"endpattern")
@@ -299,6 +301,7 @@ class BBTests < TestHelper
     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")
+    assert_nil parser.parse("    END this is in the middle END")
   end
 
   def test_poly
@@ -378,6 +381,38 @@ class BBTests < TestHelper
     assert_equal({:match=>";",:could=>true}, BabelBridge::Parser.could.match(";"))
   end
 
+  def test_ignore_whitespace
+    parser=new_parser do
+      ignore_whitespace
+      rule :pair, "foo", "bar"
+    end
+    assert parser.parse("foobar")
+    assert parser.parse("foo   bar")
+    assert parser.parse("foobar   ")
+    assert parser.parse("foo bar     ")
+  end
+
+  def test_binary_operator_rule
+    parser=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
+    assert_equal "(1+2)",     parser.parse("1+2").evaluate
+    assert_equal "((1+2)+3)", parser.parse("1+2+3").evaluate
+    assert_equal "(1+(2*3))", parser.parse("1+2*3").evaluate
+    assert_equal "((1*2)+3)", parser.parse("1*2+3").evaluate
+    assert_equal "(5**6)", parser.parse("5**6").evaluate
+    assert_equal "((1-2)+((3*4)/(5**6)))", parser.parse("1-2+3*4/5**6").evaluate
+    assert_equal "(5**(6**7))", parser.parse("5**6**7").evaluate
+  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.
@@ -391,6 +426,7 @@ class BBTests < TestHelper
   end
 
 
+
   def regex_performance
     parser=new_parser do
       rule :foo, many(:element)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: babel_bridge
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2010-11-28 00:00:00.000000000Z
+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
@@ -24,8 +24,24 @@ files:
 - test/test_bb.rb
 - test/test_helper.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/terminal_node.rb
 - lib/nodes.rb
+- lib/parser.rb
 - lib/pattern_element.rb
+- lib/rule.rb
+- lib/rule_variant.rb
+- lib/shell.rb
+- lib/string.rb
+- lib/tools.rb
+- lib/version.rb
+- examples/indention_grouping.rb
+- examples/indention_grouping_test.txt
+- examples/turing/test.rb
+- examples/turing/turing.rb
 homepage: http://babel-bridge.rubyforge.org
 licenses: []
 post_install_message: 
@@ -46,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: babel-bridge
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A Ruby-based parser-generator based on Parsing Expression Grammars.