ParseTree 1.6.4 → 1.7.0

data/History.txt

@@ -1,15 +1,25 @@
+*** 1.7.0 / 2007-02-13
+
++ 2 major enhancements:
+	+ rewrite extracted and intended to be run before (or in front of) process.
+	+ rewrite is now recursive as well, so children rewritings should be done independently of their parents. This should make complex rewriting layers much cleaner and allow me to eventually collect and publish a single "standard" rewriting layer.
++ 1 minor enhancement:
+	+ Iters are now {} if short and one line. YAY!
++ 1 bug fix:
+	+ Added test cases brought out by ruby2ruby/heckle.
+
 *** 1.6.4 / 2007-01-15
 
 + 1 minor enhancement:
-	Switched short if/unless to 1 line expressions.
+	+ Switched short if/unless to 1 line expressions.
 + 2 bug fixes:
- 	Fixed the nested case/when bug. YAY!
-	Added dasgn_curr and defn_rescue test cases.
+ 	+ Fixed the nested case/when bug. YAY!
+	+ Added dasgn_curr and defn_rescue test cases.
 
 *** 1.6.3 / 2006-12-20
 
 + 1 bug fix:
-        + ParseTree::translate was trying to translate inherited class methods.
+    + ParseTree::translate was trying to translate inherited class methods.
 
 *** 1.6.2 / 2006-12-19
 

data/lib/parse_tree.rb

@@ -25,7 +25,7 @@ require 'inline'
 
 class ParseTree
 
-  VERSION = '1.6.4'
+  VERSION = '1.7.0'
 
   ##
   # Front end translation method.
@@ -590,10 +590,8 @@ again_no_block:
 
   case NODE_MASGN:
     add_to_parse_tree(current, node->nd_head, newlines, locals);
-    if (node->nd_args) {
-      if (node->nd_args != (NODE *)-1) {
-        add_to_parse_tree(current, node->nd_args, newlines, locals);
-      }
+    if (node->nd_args && node->nd_args != (NODE *)-1) {
+      add_to_parse_tree(current, node->nd_args, newlines, locals);
     }
     add_to_parse_tree(current, node->nd_value, newlines, locals);
     break;

data/lib/sexp_processor.rb

@@ -65,7 +65,7 @@ class SexpTypeError < SexpProcessorError; end
 #       super
 #       self.strict = false
 #     end
-#   
+#
 #     def process_lit(exp)
 #       val = exp.shift
 #       return val
@@ -73,7 +73,7 @@ class SexpTypeError < SexpProcessorError; end
 #   end
 
 class SexpProcessor
-  
+
   ##
   # A default method to call if a process_<type> method is not found
   # for the Sexp type.
@@ -138,6 +138,7 @@ class SexpProcessor
     @expected = Sexp
     @require_empty = true
     @exceptions = {}
+    @process_level = 0
 
     # we do this on an instance basis so we can subclass it for
     # different processors.
@@ -154,6 +155,36 @@ class SexpProcessor
     end
   end
 
+  def assert_empty(meth, exp, exp_orig)
+    unless exp.empty? then
+      msg = "exp not empty after #{self.class}.#{meth} on #{exp.inspect}"
+      msg += " from #{exp_orig.inspect}" if $DEBUG
+      raise NotEmptyError, msg
+    end
+  end
+
+  def rewrite(exp)
+    meth = @rewriters[exp.first]
+    if meth then
+      r = self.send(meth, exp)
+      self.assert_empty(meth, exp, nil) if @require_empty
+      r
+    else
+      result = exp.class.new
+      until exp.empty? do
+        sub_exp = exp.shift
+        sub_result = nil
+
+        if Array === sub_exp then
+          result << rewrite(sub_exp)
+        else
+          result << sub_exp
+        end
+      end
+      result
+    end
+  end
+
   ##
   # Default Sexp processor.  Invokes process_<type> methods matching
   # the Sexp type given.  Performs additional checks as specified by
@@ -162,6 +193,8 @@ class SexpProcessor
   def process(exp)
     return nil if exp.nil?
 
+    @process_level += 1
+
     unless @unsupported_checked then
       m = public_methods.grep(/^process_/) { |o| o.sub(/^process_/, '').intern }
       supported = m - (m - @unsupported)
@@ -180,28 +213,13 @@ class SexpProcessor
       puts "// DEBUG: #{str}" if str =~ @debug[type]
     end
 
+    exp_orig = nil
     exp_orig = exp.deep_clone if $DEBUG or
       @debug.has_key? type or @exceptions.has_key?(type)
 
     raise UnsupportedNodeError, "'#{type}' is not a supported node type" if @unsupported.include? type
 
-    # do a pass through the rewriter first, if any, reassign back to exp
-    # TODO: maybe the whole rewriting thing needs to be nuked
-    meth = @rewriters[type]
-    if meth then
-      new_exp = error_handler(type, exp_orig) do
-        self.send(meth, exp)
-      end
-      # REFACTOR: duplicated from below
-      if @require_empty and not exp.empty? then
-        msg = "exp not empty after #{self.class}.#{meth} on #{exp.inspect}"
-        if $DEBUG then
-          msg += " from #{exp_orig.inspect}" 
-        end
-        raise NotEmptyError, msg
-      end
-      exp = new_exp
-    end
+    exp = self.rewrite(exp) if @process_level == 1
 
     # now do a pass with the real processor (or generic)
     meth = @processors[type] || @default_method
@@ -219,11 +237,7 @@ class SexpProcessor
 
       raise SexpTypeError, "Result must be a #{@expected}, was #{result.class}:#{result.inspect}" unless @expected === result
 
-      if @require_empty and not exp.empty? then
-        msg = "exp not empty after #{self.class}.#{meth} on #{exp.inspect}"
-        msg += " from #{exp_orig.inspect}" if $DEBUG
-        raise NotEmptyError, msg
-      end
+      self.assert_empty(meth, exp, exp_orig) if @require_empty
     else
       unless @strict then
         until exp.empty? do
@@ -255,6 +269,9 @@ class SexpProcessor
         raise UnknownNodeError, msg
       end
     end
+
+    @process_level -= 1
+
     result
   end
 

data/test/pt_testcase.rb

@@ -129,13 +129,36 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:block_pass, [:vcall, :b], [:fcall, :a]],
     },
 
+    "block_pass_omgwtf" => {
+      "Ruby" => "define_attr_method(:x, :sequence_name, &Proc.new { |*args| nil })",
+      "ParseTree" => [:block_pass,
+                      [:iter,
+                       [:call, [:const, :Proc], :new],
+                       [:masgn, [:dasgn_curr, :args]],
+                       [:nil]],
+                      [:fcall, :define_attr_method,
+                       [:array, [:lit, :x], [:lit, :sequence_name]]]],
+    },
+
+    "block_pass_splat" => {
+      "Ruby" => "def blah(*args, &block)\n  other(*args, &block)\nend",
+      "ParseTree" => [:defn, :blah,
+                      [:scope,
+                       [:block,
+                        [:args, "*args".intern],
+                        [:block_arg, :block],
+                        [:block_pass,
+                         [:lvar, :block],
+                         [:fcall, :other, [:splat, [:lvar, :args]]]]]]],
+    },
+
     "bmethod"  => {
       "Ruby"        => [Examples, :unsplatted],
       "ParseTree"   => [:defn,
                         :unsplatted,
                         [:bmethod,
                          [:dasgn_curr, :x],
-                         [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]],
+                         [:call, [:dvar, :x], "+".intern, [:array, [:lit, 1]]]]],
       "Ruby2Ruby"   => "def unsplatted(x)\n  (x + 1)\nend"
     },
 
@@ -152,13 +175,13 @@ class ParseTreeTestCase < Test::Unit::TestCase
     },
 
     "break"  => {
-      "Ruby"        => "loop do\n  break if true\nend",
+      "Ruby"        => "loop { break if true }",
       "ParseTree"   => [:iter,
                         [:fcall, :loop], nil, [:if, [:true], [:break], nil]],
     },
 
     "break_arg"  => {
-      "Ruby"        => "loop do\n  break 42 if true\nend",
+      "Ruby"        => "loop { break 42 if true }",
       "ParseTree"   => [:iter,
                         [:fcall, :loop], nil,
                         [:if, [:true], [:break, [:lit, 42]], nil]],
@@ -364,7 +387,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
     },
 
     "dasgn"  => {
-      "Ruby"        => "a.each do |x|\n  b.each do |y|\n    x = (x + 1)\n  end\nend",
+      "Ruby"        => "a.each { |x| b.each { |y| x = (x + 1) } }",
       "ParseTree"   => [:iter,
                         [:call, [:vcall, :a], :each],
                         [:dasgn_curr, :x],
@@ -626,12 +649,12 @@ end",
     },
 
     "iteration1" => {
-      "Ruby"        => "loop do end",
+      "Ruby"        => "loop { }",
       "ParseTree"   => [:iter, [:fcall, :loop], nil],
     },
 
     "iteration2" => {
-      "Ruby" => "array = [1, 2, 3]\narray.each do |x|\n  puts(x.to_s)\nend\n",
+      "Ruby" => "array = [1, 2, 3]\narray.each { |x| puts(x.to_s) }\n",
       "ParseTree"   => [:block,
                         [:lasgn, :array,
                          [:array, [:lit, 1], [:lit, 2], [:lit, 3]]],
@@ -642,7 +665,7 @@ end",
     },
 
     "iteration3" => {
-      "Ruby"        => "1.upto(3) do |n|\n  puts(n.to_s)\nend",
+      "Ruby"        => "1.upto(3) { |n| puts(n.to_s) }",
       "ParseTree"   => [:iter,
                         [:call, [:lit, 1], :upto, [:array, [:lit, 3]]],
                         [:dasgn_curr, :n],
@@ -650,7 +673,7 @@ end",
     },
 
     "iteration4" => {
-      "Ruby"        => "3.downto(1) do |n|\n  puts(n.to_s)\nend",
+      "Ruby"        => "3.downto(1) { |n| puts(n.to_s) }",
       "ParseTree"   => [:iter,
                         [:call, [:lit, 3], :downto, [:array, [:lit, 1]]],
                         [:dasgn_curr, :n],
@@ -662,13 +685,13 @@ end",
       "ParseTree"   => [:block,
                         [:lasgn, :argl, [:lit, 10]],
                         [:while,
-                         [:call, [:lvar, :argl], :>=, [:array, [:lit, 1]]],
+                         [:call, [:lvar, :argl], ">=".intern, [:array, [:lit, 1]]],
                          [:block,
                           [:fcall, :puts, [:array, [:str, "hello"]]],
                           [:lasgn,
                            :argl,
                            [:call, [:lvar, :argl],
-                            :-, [:array, [:lit, 1]]]]], true]],
+                            "-".intern, [:array, [:lit, 1]]]]], true]],
     },
 
     "iteration6" => {
@@ -766,9 +789,28 @@ end",
     "masgn_iasgn"  => {
       "Ruby"        => "a, @b = c, d",
       "ParseTree"   => [:masgn,
-                        [:array, [:lasgn, :a], [:iasgn, :@b]],
+                        [:array, [:lasgn, :a], [:iasgn, "@b".intern]],
                         [:array,  [:vcall, :c], [:vcall, :d]]],
     },
+
+    "masgn_attrasgn"  => {
+      "Ruby"        => "a, b.c = d, e",
+      "ParseTree"   => [:masgn,
+                         [:array, [:lasgn, :a], [:attrasgn, [:vcall, :b], :c=]],
+                         [:array, [:vcall, :d], [:vcall, :e]]],
+    },
+
+    "masgn_splat"  => {
+      "Ruby"        => "a, b, *c = d, e, f, g",
+      "ParseTree"   => [:masgn,
+                        [:array, [:lasgn, :a], [:lasgn, :b]],
+                        [:lasgn, :c],
+                        [:array,
+                         [:vcall, :d], [:vcall, :e],
+                         [:vcall, :f], [:vcall, :g]]]
+    },
+
+
     "match"  => {
       "Ruby"        => "1 if /x/",
       "ParseTree"   => [:if, [:match, [:lit, /x/]], [:lit, 1], nil],
@@ -792,7 +834,7 @@ end",
     },
 
     "next"  => {
-      "Ruby"        => "loop do\n  next if false\nend",
+      "Ruby"        => "loop { next if false }",
       "ParseTree"   => [:iter,
                         [:fcall, :loop],
                         nil,
@@ -862,28 +904,28 @@ end",
     },
 
     "postexe"  => {
-      "Ruby"        => "END {\n  1\n}",
+      "Ruby"        => "END { 1 }",
       "ParseTree"   => [:iter, [:postexe], nil, [:lit, 1]],
     },
 
-    "proc_no_args" => {
-      "Ruby" => "proc do\n  (x + 1)\nend",
+    "proc_args" => {
+      "Ruby" => "proc { |x| (x + 1) }",
       "ParseTree" => [:iter,
                       [:fcall, :proc],
-                      nil,
-                      [:call, [:vcall, :x], :+, [:array, [:lit, 1]]]],
+                      [:dasgn_curr, :x],
+                      [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]],
     },
 
-    "proc_args" => {
-      "Ruby" => "proc do |x|\n  (x + 1)\nend",
+    "proc_no_args" => {
+      "Ruby" => "proc { (x + 1) }",
       "ParseTree" => [:iter,
                       [:fcall, :proc],
-                      [:dasgn_curr, :x],
-                      [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]],
+                      nil,
+                      [:call, [:vcall, :x], :+, [:array, [:lit, 1]]]],
     },
 
     "redo"  => {
-      "Ruby"        => "loop do\n  redo if false\nend",
+      "Ruby"        => "loop { redo if false }",
       "ParseTree"   => [:iter,
                         [:fcall, :loop], nil, [:if, [:false], [:redo], nil]],
     },
@@ -893,16 +935,16 @@ end",
       "ParseTree"   => [:rescue, [:vcall, :blah], [:resbody, nil, [:nil]]],
     },
 
-    "rescue_block_nada"  => {
-      "Ruby"        => "begin\n  blah\nrescue\n  # do nothing\nend\n",
-      "ParseTree"   => [:begin, [:rescue, [:vcall, :blah], [:resbody, nil]]]
-    },
-
     "rescue_block_body"  => {
       "Ruby"        => "begin\n  blah\nrescue\n  nil\nend\n",
       "ParseTree"   => [:begin, [:rescue, [:vcall, :blah], [:resbody, nil, [:nil]]]],
     },
 
+    "rescue_block_nada"  => {
+      "Ruby"        => "begin\n  blah\nrescue\n  # do nothing\nend\n",
+      "ParseTree"   => [:begin, [:rescue, [:vcall, :blah], [:resbody, nil]]]
+    },
+
     "rescue_exceptions"  => {
       "Ruby"        => "begin\n  blah\nrescue RuntimeError => r\n  # do nothing\nend\n",
       "ParseTree"   => [:begin,
@@ -978,18 +1020,18 @@ end",
       "Ruby2Ruby"   => "undef :x\nundef :y\nundef :z\n",
     },
 
-    "until_pre"  => {
-      "Ruby"        => "until false do\n  (1 + 1)\nend",
-      "ParseTree"   => [:until, [:false],
-                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], true],
-    },
-
     "until_post"  => {
       "Ruby"        => "begin\n  (1 + 1)\nend until false",
       "ParseTree"   => [:until, [:false],
                         [:call, [:lit, 1], :+, [:array, [:lit, 1]]], false],
     },
 
+    "until_pre"  => {
+      "Ruby"        => "until false do\n  (1 + 1)\nend",
+      "ParseTree"   => [:until, [:false],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], true],
+    },
+
     "valias"  => {
       "Ruby"        => "alias $y $x",
       "ParseTree"   => [:valias, :$y, :$x],
@@ -1114,7 +1156,7 @@ end",
         unless data.has_key?(output_name) then
           $stderr.puts "add_test(#{node.inspect}, :same)"
         end
-        assert data.has_key?(output_name), "Unknown expected data"
+        assert data.has_key?(output_name), "Missing test data: #{self.class} #{node}"
         input = data[input_name].deep_clone
 
         expected = if data[output_name] == :same then

data/test/test_sexp_processor.rb

@@ -52,16 +52,15 @@ class TestProcessor < SexpProcessor # ZenTest SKIP
 
   def process_string(exp)
     return exp.shift
-  end 
+  end
 
-  def rewrite_rewritable(exp)
+  def rewrite_rewritable(exp) # (a b c) => (a c b)
     return s(exp.shift, exp.pop, exp.shift)
   end
 
   def process_rewritable(exp)
     return s(exp.shift, exp.shift == 2, exp.shift == 1)
   end
-
 end
 
 class TestProcessorDefault < SexpProcessor # ZenTest SKIP
@@ -140,7 +139,6 @@ class TestSexpProcessor < Test::Unit::TestCase
 
   def test_require_empty_false
     @processor.require_empty = false
-    @processor.expected = Object
 
     assert_nothing_raised do
       @processor.process([:nonempty, 1, 2, 3])
@@ -159,11 +157,26 @@ class TestSexpProcessor < Test::Unit::TestCase
     assert_equal([1, 2, 3], @processor.process(s(:strip, 1, 2, 3)))
   end
 
+  def test_rewrite
+    assert_equal(s(:rewritable, :b, :a),
+                 @processor.rewrite(s(:rewritable, :a, :b)))
+  end
+
+  def test_rewrite_deep
+    assert_equal(s(:specific, s(:rewritable, :b, :a)),
+                 @processor.rewrite(s(:specific, s(:rewritable, :a, :b))))
+  end
+
   def test_process_rewrite
     assert_equal(s(:rewritable, true, true),
                  @processor.process(s(:rewritable, 1, 2)))
   end
 
+  def test_process_rewrite_deep
+    assert_equal(s(s(:rewritable, :b, :a)),
+                 @processor.process(s(:specific, s(:rewritable, :a, :b))))
+  end
+
   def test_process_rewrite_not_empty
     assert_raise(NotEmptyError) do
       @processor.process(s(:rewritable, 1, 2, 2))

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0.9
 specification_version: 1
 name: ParseTree
 version: !ruby/object:Gem::Version 
-  version: 1.6.4
-date: 2007-01-15 00:00:00 -08:00
+  version: 1.7.0
+date: 2007-02-13 00:00:00 -08:00
 summary: Extract and enumerate ruby parse trees.
 require_paths: 
 - lib
@@ -84,5 +84,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.1.7
+        version: 1.2.0
     version: