ParseTree 3.0.3 → 3.0.4

data/History.txt

@@ -1,3 +1,17 @@
+=== 3.0.4 / 2009-06-23
+
+* 4 minor enhancements:
+
+  * Pulled unique.rb from ParseTree to sexp_processor.
+  * Switched to minitest
+  * UnifiedRuby strips flip2 back down to expected values
+  * Updated Rakefile for new hoe
+
+* 2 bug fixes:
+
+  * 1.8.6p287 & 1.8.7 changed flip2 with fixnum start. fixed
+  * 1.8.6p287 & 1.8.7 removed the begin node. fixed.
+
 === 3.0.3 / 2009-01-20
 
 * 4 bug fixes:

data/Manifest.txt

@@ -12,10 +12,8 @@ lib/gauntlet_parsetree.rb
 lib/parse_tree.rb
 lib/parse_tree_extensions.rb
 lib/unified_ruby.rb
-lib/unique.rb
 test/pt_testcase.rb
 test/something.rb
-test/test_all.rb
 test/test_parse_tree.rb
 test/test_parse_tree_extensions.rb
 test/test_unified_ruby.rb

data/Rakefile

@@ -8,21 +8,22 @@ Hoe.add_include_dirs("../../RubyInline/dev/lib",
                      "../../ZenTest/dev/lib",
                      "lib")
 
-require './lib/parse_tree.rb'
+Hoe.plugin :seattlerb
 
-Hoe.new("ParseTree", ParseTree::VERSION) do |pt|
-  pt.rubyforge_name = "parsetree"
+Hoe.spec "ParseTree" do
+  developer 'Ryan Davis', 'ryand-ruby@zenspider.com'
 
-  pt.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
+  clean_globs << File.expand_path("~/.ruby_inline")
+  extra_deps  << ['RubyInline',     '>= 3.7.0']
+  extra_deps  << ['sexp_processor', '>= 3.0.0']
 
-  pt.clean_globs << File.expand_path("~/.ruby_inline")
-  pt.extra_deps << ['RubyInline',     '>= 3.7.0']
-  pt.extra_deps << ['sexp_processor', '>= 3.0.0']
-  pt.spec_extras[:require_paths] = proc { |paths| paths << 'test' }
+  spec_extras[:require_paths] = proc { |paths| paths << 'test' }
 
-  pt.multiruby_skip << "mri_rel_1_9" << "rubinius" << "mri_trunk"
+  multiruby_skip << "1.9"
 end
 
+task :test => :clean
+
 desc 'Run in gdb'
 task :debug do
   puts "RUN: r -d #{Hoe::RUBY_FLAGS} test/test_all.rb #{Hoe::FILTER}"

data/lib/parse_tree.rb

@@ -43,7 +43,7 @@ end
 
 class RawParseTree
 
-  VERSION = '3.0.3'
+  VERSION = '3.0.4'
 
   ##
   # Front end translation method.
@@ -570,10 +570,31 @@ again:
     add_to_parse_tree(self, current, node->nd_2nd, locals);
     break;
 
-  case NODE_DOT2:
-  case NODE_DOT3:
   case NODE_FLIP2:
   case NODE_FLIP3:
+    if (nd_type(node->nd_beg) == NODE_LIT) {
+      /*
+       new somewhere between 1.8.6 p287 to p368 and 1.8.7 p72 to p160.
+       [:flip2, [:call, [:lit, 1], :==, [:array, [:gvar, :$.]]],
+      */
+      VALUE result = rb_ary_new3(1, _sym("call"));
+      add_to_parse_tree(self, result, node->nd_beg, locals);
+      rb_ary_push(result, _sym("=="));
+      rb_ary_push(result, rb_ary_new3(2, _sym("array"),
+                                      rb_ary_new3(2, _sym("gvar"),
+                                                     _sym("$."))));
+      rb_ary_push(current, result);
+    } else {
+      add_to_parse_tree(self, current, node->nd_beg, locals);
+    }
+
+
+    // add_to_parse_tree(self, current, node->nd_beg, locals);
+    add_to_parse_tree(self, current, node->nd_end, locals);
+    break;
+
+  case NODE_DOT2:
+  case NODE_DOT3:
     add_to_parse_tree(self, current, node->nd_beg, locals);
     add_to_parse_tree(self, current, node->nd_end, locals);
     break;
@@ -939,15 +960,10 @@ again:
   case NODE_STR:              /* u1 */
   case NODE_LIT:
     rb_ary_push(current, node->nd_lit);
-    if (node->nd_cflag) {
-      rb_ary_push(current, INT2FIX(node->nd_cflag));
-    }
     break;
 
   case NODE_MATCH:            /* u1 -> [:lit, u1] */
-    {
-      rb_ary_push(current, wrap_into_node("lit", node->nd_lit));
-    }
+    rb_ary_push(current, wrap_into_node("lit", node->nd_lit));
     break;
 
   case NODE_NEWLINE:

data/lib/unified_ruby.rb

@@ -218,6 +218,21 @@ module UnifiedRuby
     rewrite_call(exp)
   end
 
+  def rewrite_flip2(exp)
+    # from:
+    # s(:flip2,
+    #   s(:call, s(:lit, 1), :==, s(:arglist, s(:gvar, :$.))),
+    #   s(:call, s(:lit, 2), :a?, s(:arglist, s(:call, nil, :b, s(:arglist)))))
+    # to:
+    # s(:flip2,
+    #   s(:lit, 1),
+    #   s(:call, s(:lit, 2), :a?, s(:arglist, s(:call, nil, :b, s(:arglist)))))
+    exp[1] = exp[1][1] if exp[1][0] == :call && exp[1][1][0] == :lit
+    exp
+  end
+
+  alias :rewrite_flip3 :rewrite_flip2
+
   def rewrite_masgn(exp)
     raise "wtf: #{exp}" unless exp.size == 4 # TODO: remove 2009-01-29
     t, lhs, lhs_splat, rhs = exp

data/test/pt_testcase.rb

@@ -1,6 +1,6 @@
 $TESTING = true
 
-require 'test/unit/testcase'
+require 'minitest/unit'
 require 'sexp_processor' # for deep_clone
 
 # key:
@@ -32,12 +32,7 @@ class Examples
     RUBY_VERSION < "1.9"
 end
 
-class ParseTreeTestCase < Test::Unit::TestCase
-  unless defined? Mini then
-    undef_method :default_test rescue nil
-    alias :refute_nil :assert_not_nil
-  end
-
+class ParseTreeTestCase < MiniTest::Unit::TestCase
   attr_accessor :processor # to be defined by subclass
 
   def setup
@@ -370,8 +365,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
   add_tests("begin",
             "Ruby"         => "begin\n  (1 + 1)\nend",
-            "RawParseTree" => [:begin,
-                               [:call, [:lit, 1], :+, [:array, [:lit, 1]]]],
+            "RawParseTree" => [:call, [:lit, 1], :+, [:array, [:lit, 1]]],
             "ParseTree"    => s(:call, s(:lit, 1), :+,
                                 s(:arglist, s(:lit, 1))),
             "Ruby2Ruby"    => "(1 + 1)")
@@ -385,12 +379,11 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
   add_tests("begin_rescue_ensure",
             "Ruby"         => "begin\n  a\nrescue\n  # do nothing\nensure\n  # do nothing\nend",
-            "RawParseTree" => [:begin,
-                               [:ensure,
-                                [:rescue,
-                                 [:vcall, :a],
-                                 [:resbody, nil]],
-                                [:nil]]],
+            "RawParseTree" => [:ensure,
+                               [:rescue,
+                                [:vcall, :a],
+                                [:resbody, nil]],
+                               [:nil]],
             "ParseTree"    => s(:ensure,
                                 s(:rescue,
                                   s(:call, nil, :a, s(:arglist)),
@@ -399,11 +392,10 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
   add_tests("begin_rescue_ensure_all_empty",
             "Ruby"         => "begin\n  # do nothing\nrescue\n  # do nothing\nensure\n  # do nothing\nend",
-            "RawParseTree" => [:begin,
-                               [:ensure,
-                                [:rescue,
-                                 [:resbody, nil]],
-                                [:nil]]],
+            "RawParseTree" => [:ensure,
+                               [:rescue,
+                                [:resbody, nil]],
+                               [:nil]],
             "ParseTree"    => s(:ensure,
                                 s(:rescue,
                                   s(:resbody, s(:array), nil)),
@@ -412,16 +404,14 @@ class ParseTreeTestCase < Test::Unit::TestCase
   add_tests("begin_rescue_twice",
             "Ruby"         => "begin\n  a\nrescue => mes\n  # do nothing\nend\nbegin\n  b\nrescue => mes\n  # do nothing\nend\n",
             "RawParseTree" => [:block,
-                               [:begin,
-                                [:rescue,
-                                 [:vcall, :a],
-                                 [:resbody, nil,
-                                  [:lasgn, :mes, [:gvar, :$!]]]]],
-                               [:begin,
-                                [:rescue,
-                                 [:vcall, :b],
-                                 [:resbody, nil,
-                                  [:lasgn, :mes, [:gvar, :$!]]]]]],
+                               [:rescue,
+                                [:vcall, :a],
+                                [:resbody, nil,
+                                 [:lasgn, :mes, [:gvar, :$!]]]],
+                               [:rescue,
+                                [:vcall, :b],
+                                [:resbody, nil,
+                                 [:lasgn, :mes, [:gvar, :$!]]]]],
             "ParseTree"    => s(:block,
                                 s(:rescue,
                                   s(:call, nil, :a, s(:arglist)),
@@ -441,11 +431,10 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                 [:vcall, :a],
                                 [:resbody, nil,
                                  [:lasgn, :mes, [:gvar, :$!]]]],
-                               [:begin,
-                                [:rescue,
-                                 [:vcall, :b],
-                                 [:resbody, nil,
-                                  [:lasgn, :mes, [:gvar, :$!]]]]]])
+                               [:rescue,
+                                [:vcall, :b],
+                                [:resbody, nil,
+                                 [:lasgn, :mes, [:gvar, :$!]]]]])
 
   copy_test_case "begin_rescue_twice", "Ruby"
   copy_test_case "begin_rescue_twice", "ParseTree"
@@ -665,10 +654,9 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                [:scope,
                                 [:block,
                                  [:args],
-                                 [:begin,
-                                  [:rescue,
-                                   [:vcall, :b],
-                                   [:resbody, nil, [:vcall, :c]]]],
+                                 [:rescue,
+                                  [:vcall, :b],
+                                  [:resbody, nil, [:vcall, :c]]],
                                  [:vcall, :d]]]],
             "ParseTree"    => s(:defn, :f,
                                 s(:args),
@@ -703,9 +691,8 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                 [:block,
                                  [:args],
                                  [:vcall, :a],
-                                 [:begin,
-                                  [:rescue, [:vcall, :b],
-                                   [:resbody, nil, [:vcall, :c]]]]]]],
+                                 [:rescue, [:vcall, :b],
+                                  [:resbody, nil, [:vcall, :c]]]]]],
             "ParseTree"    => s(:defn, :f,
                                 s(:args),
                                 s(:scope,
@@ -730,12 +717,11 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                 [:block,
                                  [:args],
                                  [:vcall, :a],
-                                 [:begin,
-                                  [:rescue,
-                                   [:vcall, :b],
-                                   [:resbody,
-                                    nil,
-                                    [:vcall, :c]]]],
+                                 [:rescue,
+                                  [:vcall, :b],
+                                  [:resbody,
+                                   nil,
+                                   [:vcall, :c]]],
                                  [:vcall, :d]]]],
             "ParseTree"    => s(:defn, :f, s(:args),
                                 s(:scope,
@@ -1422,14 +1408,13 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                  [:fcall, :assert_block,
                                   [:array, [:vcall, :full_message]]],
                                  nil,
-                                 [:begin,
-                                  [:rescue,
-                                   [:yield],
-                                   [:resbody,
-                                    [:array, [:const, :Exception]],
-                                    [:block,
-                                     [:dasgn, :v,
-                                      [:gvar, :$!]], [:break]]]]]]]],
+                                 [:rescue,
+                                  [:yield],
+                                  [:resbody,
+                                   [:array, [:const, :Exception]],
+                                   [:block,
+                                    [:dasgn, :v,
+                                     [:gvar, :$!]], [:break]]]]]]],
             "ParseTree"    => s(:iter,
                                 s(:call, nil, :a, s(:arglist)),
                                 nil,
@@ -2170,20 +2155,19 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
   add_tests("ensure",
             "Ruby"         => "begin\n  (1 + 1)\nrescue SyntaxError => e1\n  2\nrescue Exception => e2\n  3\nelse\n  4\nensure\n  5\nend",
-            "RawParseTree" => [:begin,
-                               [:ensure,
-                                [:rescue,
-                                 [:call, [:lit, 1], :+, [:array, [:lit, 1]]],
+            "RawParseTree" => [:ensure,
+                               [:rescue,
+                                [:call, [:lit, 1], :+, [:array, [:lit, 1]]],
+                                [:resbody,
+                                 [:array, [:const, :SyntaxError]],
+                                 [:block,
+                                  [:lasgn, :e1, [:gvar, :$!]], [:lit, 2]],
                                  [:resbody,
-                                  [:array, [:const, :SyntaxError]],
+                                  [:array, [:const, :Exception]],
                                   [:block,
-                                   [:lasgn, :e1, [:gvar, :$!]], [:lit, 2]],
-                                  [:resbody,
-                                   [:array, [:const, :Exception]],
-                                   [:block,
-                                    [:lasgn, :e2, [:gvar, :$!]], [:lit, 3]]]],
-                                 [:lit, 4]],
-                                [:lit, 5]]],
+                                   [:lasgn, :e2, [:gvar, :$!]], [:lit, 3]]]],
+                                [:lit, 4]],
+                               [:lit, 5]],
             "ParseTree"    => s(:ensure,
                                 s(:rescue,
                                   s(:call, s(:lit, 1), :+,
@@ -2339,7 +2323,8 @@ class ParseTreeTestCase < Test::Unit::TestCase
             "Ruby"         => "if 1..2.a?(b) then\n  nil\nend",
             "RawParseTree" => [:if,
                                [:flip2,
-                                [:lit, 1],
+                                [:call, [:lit, 1], :==,
+                                 [:array, [:gvar, :$.]]],
                                 [:call, [:lit, 2], :a?,
                                  [:array, [:vcall, :b]]]],
                                [:nil],
@@ -2910,15 +2895,14 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                   [:iter,
                                    [:fcall, :c],
                                    nil,
-                                   [:begin,
-                                    [:rescue,
-                                     [:vcall, :do_stuff],
-                                     [:resbody,
-                                      [:array, [:const, :RuntimeError]],
-                                      [:block,
-                                       [:dasgn_curr, :b, [:gvar, :$!]],
-                                       [:fcall, :puts,
-                                        [:array, [:dvar, :b]]]]]]]]]]]],
+                                   [:rescue,
+                                    [:vcall, :do_stuff],
+                                    [:resbody,
+                                     [:array, [:const, :RuntimeError]],
+                                     [:block,
+                                      [:dasgn_curr, :b, [:gvar, :$!]],
+                                      [:fcall, :puts,
+                                       [:array, [:dvar, :b]]]]]]]]]]],
             "ParseTree"    => s(:block,
                                 s(:lasgn, :b, s(:lit, 42)),
                                 s(:defn, :a,
@@ -3590,14 +3574,13 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
   add_tests("rescue_block_body",
             "Ruby"         => "begin\n  a\nrescue => e\n  c\n  d\nend",
-            "RawParseTree" => [:begin,
-                               [:rescue,
-                                [:vcall, :a],
-                                [:resbody, nil,
-                                 [:block,
-                                  [:lasgn, :e, [:gvar, :$!]],
-                                  [:vcall, :c],
-                                  [:vcall, :d]]]]],
+            "RawParseTree" => [:rescue,
+                               [:vcall, :a],
+                               [:resbody, nil,
+                                [:block,
+                                 [:lasgn, :e, [:gvar, :$!]],
+                                 [:vcall, :c],
+                                 [:vcall, :d]]]],
             "ParseTree"    => s(:rescue,
                                 s(:call, nil, :a, s(:arglist)),
                                 s(:resbody,
@@ -3608,15 +3591,14 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
   add_tests("rescue_block_body_3",
             "Ruby"         => "begin\n  a\nrescue A\n  b\nrescue B\n  c\nrescue C\n  d\nend",
-            "RawParseTree" => [:begin,
-                               [:rescue,
-                                [:vcall, :a],
-                                [:resbody, [:array, [:const, :A]],
-                                 [:vcall, :b],
-                                 [:resbody, [:array, [:const, :B]],
-                                  [:vcall, :c],
-                                  [:resbody, [:array, [:const, :C]],
-                                   [:vcall, :d]]]]]],
+            "RawParseTree" => [:rescue,
+                               [:vcall, :a],
+                               [:resbody, [:array, [:const, :A]],
+                                [:vcall, :b],
+                                [:resbody, [:array, [:const, :B]],
+                                 [:vcall, :c],
+                                 [:resbody, [:array, [:const, :C]],
+                                  [:vcall, :d]]]]],
             "ParseTree"    => s(:rescue,
                                 s(:call, nil, :a, s(:arglist)),
                                 s(:resbody, s(:array, s(:const, :A)),
@@ -3628,14 +3610,13 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
   add_tests("rescue_block_body_ivar",
             "Ruby"         => "begin\n  a\nrescue => @e\n  c\n  d\nend",
-            "RawParseTree" => [:begin,
-                               [:rescue,
-                                [:vcall, :a],
-                                [:resbody, nil,
-                                 [:block,
-                                  [:iasgn, :@e, [:gvar, :$!]],
-                                  [:vcall, :c],
-                                  [:vcall, :d]]]]],
+            "RawParseTree" => [:rescue,
+                               [:vcall, :a],
+                               [:resbody, nil,
+                                [:block,
+                                 [:iasgn, :@e, [:gvar, :$!]],
+                                 [:vcall, :c],
+                                 [:vcall, :d]]]],
             "ParseTree"    => s(:rescue,
                                 s(:call, nil, :a, s(:arglist)),
                                 s(:resbody,
@@ -3646,20 +3627,18 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
   add_tests("rescue_block_nada",
             "Ruby"         => "begin\n  blah\nrescue\n  # do nothing\nend",
-            "RawParseTree" => [:begin,
-                               [:rescue, [:vcall, :blah], [:resbody, nil]]],
+            "RawParseTree" => [:rescue, [:vcall, :blah], [:resbody, nil]],
             "ParseTree"    => s(:rescue,
                                 s(:call, nil, :blah, s(:arglist)),
                                 s(:resbody, s(:array), nil)))
 
   add_tests("rescue_exceptions",
             "Ruby"         => "begin\n  blah\nrescue RuntimeError => r\n  # do nothing\nend",
-            "RawParseTree" => [:begin,
-                               [:rescue,
-                                [:vcall, :blah],
-                                [:resbody,
-                                 [:array, [:const, :RuntimeError]],
-                                 [:lasgn, :r, [:gvar, :$!]]]]],
+            "RawParseTree" => [:rescue,
+                               [:vcall, :blah],
+                               [:resbody,
+                                [:array, [:const, :RuntimeError]],
+                                [:lasgn, :r, [:gvar, :$!]]]],
             "ParseTree"    => s(:rescue,
                                 s(:call, nil, :blah, s(:arglist)),
                                 s(:resbody,
@@ -3671,10 +3650,9 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
   add_tests("rescue_iasgn_var_empty",
             "Ruby"         => "begin\n  1\nrescue => @e\n  # do nothing\nend",
-            "RawParseTree" => [:begin,
-                               [:rescue,
-                                [:lit, 1],
-                                [:resbody, nil, [:iasgn, :@e, [:gvar, :$!]]]]],
+            "RawParseTree" => [:rescue,
+                               [:lit, 1],
+                               [:resbody, nil, [:iasgn, :@e, [:gvar, :$!]]]],
             "ParseTree"    => s(:rescue,
                                 s(:lit, 1),
                                 s(:resbody,
@@ -3683,10 +3661,9 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
   add_tests("rescue_lasgn",
             "Ruby"         => "begin\n  1\nrescue\n  var = 2\nend",
-            "RawParseTree" => [:begin,
-                               [:rescue,
-                                [:lit, 1],
-                                [:resbody, nil, [:lasgn, :var, [:lit, 2]]]]],
+            "RawParseTree" => [:rescue,
+                               [:lit, 1],
+                               [:resbody, nil, [:lasgn, :var, [:lit, 2]]]],
             "ParseTree"    => s(:rescue,
                                 s(:lit, 1),
                                 s(:resbody,
@@ -3696,13 +3673,12 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
   add_tests("rescue_lasgn_var",
             "Ruby"         => "begin\n  1\nrescue => e\n  var = 2\nend",
-            "RawParseTree" => [:begin,
-                               [:rescue,
-                                [:lit, 1],
-                                [:resbody, nil,
-                                 [:block,
-                                  [:lasgn, :e, [:gvar, :$!]],
-                                  [:lasgn, :var, [:lit, 2]]]]]],
+            "RawParseTree" => [:rescue,
+                               [:lit, 1],
+                               [:resbody, nil,
+                                [:block,
+                                 [:lasgn, :e, [:gvar, :$!]],
+                                 [:lasgn, :var, [:lit, 2]]]]],
             "ParseTree"    => s(:rescue,
                                 s(:lit, 1),
                                 s(:resbody,
@@ -3711,10 +3687,9 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
   add_tests("rescue_lasgn_var_empty",
             "Ruby"         => "begin\n  1\nrescue => e\n  # do nothing\nend",
-            "RawParseTree" => [:begin,
-                               [:rescue,
-                                [:lit, 1],
-                                [:resbody, nil, [:lasgn, :e, [:gvar, :$!]]]]],
+            "RawParseTree" => [:rescue,
+                               [:lit, 1],
+                               [:resbody, nil, [:lasgn, :e, [:gvar, :$!]]]],
             "ParseTree"    => s(:rescue,
                                 s(:lit, 1),
                                 s(:resbody,

data/test/test_parse_tree.rb

@@ -8,7 +8,7 @@ if test ?d, dir then
   FileUtils.rm_r dir, :force => true
 end
 
-require 'test/unit'
+require 'minitest/autorun'
 require 'parse_tree'
 require 'pt_testcase'
 require 'test/something'
@@ -105,90 +105,90 @@ class TestRawParseTree < ParseTreeTestCase
   @@missing = [nil]
 
   @@opt_args = [:defn, :opt_args,
-    [:scope,
-      [:block,
-        [:args, :arg1, :arg2, :"*args", [:block, [:lasgn, :arg2, [:lit, 42]]]],
-        [:lasgn, :arg3,
-          [:call,
-            [:call,
-              [:lvar, :arg1],
-              :*,
-              [:array, [:lvar, :arg2]]],
-            :*,
-            [:array, [:lit, 7]]]],
-        [:fcall, :puts, [:array, [:call, [:lvar, :arg3], :to_s]]],
-        [:return,
-          [:str, "foo"]]]]]
+                [:scope,
+                 [:block,
+                  [:args, :arg1, :arg2, :"*args",
+                   [:block, [:lasgn, :arg2, [:lit, 42]]]],
+                  [:lasgn, :arg3,
+                   [:call,
+                    [:call,
+                     [:lvar, :arg1],
+                     :*,
+                     [:array, [:lvar, :arg2]]],
+                    :*,
+                    [:array, [:lit, 7]]]],
+                  [:fcall, :puts, [:array, [:call, [:lvar, :arg3], :to_s]]],
+                  [:return,
+                   [:str, "foo"]]]]]
 
   @@multi_args = [:defn, :multi_args,
-    [:scope,
-      [:block,
-        [:args, :arg1, :arg2],
-        [:lasgn, :arg3,
-          [:call,
-            [:call,
-              [:lvar, :arg1],
-              :*,
-              [:array, [:lvar, :arg2]]],
-            :*,
-            [:array, [:lit, 7]]]],
-        [:fcall, :puts, [:array, [:call, [:lvar, :arg3], :to_s]]],
-        [:return,
-          [:str, "foo"]]]]]
+                  [:scope,
+                   [:block,
+                    [:args, :arg1, :arg2],
+                    [:lasgn, :arg3,
+                     [:call,
+                      [:call,
+                       [:lvar, :arg1],
+                       :*,
+                       [:array, [:lvar, :arg2]]],
+                      :*,
+                      [:array, [:lit, 7]]]],
+                    [:fcall, :puts, [:array, [:call, [:lvar, :arg3], :to_s]]],
+                    [:return,
+                     [:str, "foo"]]]]]
 
   @@unknown_args = [:defn, :unknown_args,
-    [:scope,
-      [:block,
-        [:args, :arg1, :arg2],
-        [:return, [:lvar, :arg1]]]]]
+                    [:scope,
+                     [:block,
+                      [:args, :arg1, :arg2],
+                      [:return, [:lvar, :arg1]]]]]
 
   @@bbegin = [:defn, :bbegin,
-    [:scope,
-      [:block,
-        [:args],
-        [:begin,
-          [:ensure,
-            [:rescue,
-              [:lit, 1],
-              [:resbody,
-                [:array, [:const, :SyntaxError]],
-                [:block, [:lasgn, :e1, [:gvar, :$!]], [:lit, 2]],
-                [:resbody,
-                  [:array, [:const, :Exception]],
-                  [:block, [:lasgn, :e2, [:gvar, :$!]], [:lit, 3]]]],
-              [:lit, 4]],
-            [:lit, 5]]]]]]
+              [:scope,
+               [:block,
+                [:args],
+                [:ensure,
+                 [:rescue,
+                  [:lit, 1],
+                  [:resbody,
+                   [:array, [:const, :SyntaxError]],
+                   [:block, [:lasgn, :e1, [:gvar, :$!]], [:lit, 2]],
+                   [:resbody,
+                    [:array, [:const, :Exception]],
+                    [:block, [:lasgn, :e2, [:gvar, :$!]], [:lit, 3]]]],
+                  [:lit, 4]],
+                 [:lit, 5]]]]]
+
   @@bbegin_no_exception = [:defn, :bbegin_no_exception,
-    [:scope,
-      [:block,
-        [:args],
-        [:begin,
-          [:rescue,
-            [:lit, 5],
-            [:resbody, nil, [:lit, 6]]]]]]]
+                           [:scope,
+                            [:block,
+                             [:args],
+                             [:rescue,
+                              [:lit, 5],
+                              [:resbody, nil, [:lit, 6]]]]]]
 
   @@determine_args = [:defn, :determine_args,
-    [:scope,
-      [:block,
-        [:args],
-          [:call,
-            [:lit, 5],
-            :==,
-            [:array,
-              [:fcall,
-                :unknown_args,
-                [:array, [:lit, 4], [:str, "known"]]]]]]]]
+                      [:scope,
+                       [:block,
+                        [:args],
+                        [:call,
+                         [:lit, 5],
+                         :==,
+                         [:array,
+                          [:fcall,
+                           :unknown_args,
+                           [:array, [:lit, 4], [:str, "known"]]]]]]]]
 
   @@attrasgn = [:defn,
-    :attrasgn,
-    [:scope,
-      [:block,
-        [:args],
-        [:attrasgn, [:lit, 42], :method=, [:array, [:vcall, :y]]],
-        [:attrasgn,
-          [:self],
-          :type=,
-          [:array, [:call, [:vcall, :other], :type]]]]]]
+                :attrasgn,
+                [:scope,
+                 [:block,
+                  [:args],
+                  [:attrasgn, [:lit, 42], :method=, [:array, [:vcall, :y]]],
+                  [:attrasgn,
+                   [:self],
+                   :type=,
+                   [:array, [:call, [:vcall, :other], :type]]]]]]
 
   @@__all = [:class, :Something, [:const, :Object]]
 

data/test/test_parse_tree_extensions.rb

@@ -1,4 +1,4 @@
-require 'test/unit'
+require 'minitest/autorun'
 require 'parse_tree'
 require 'parse_tree_extensions'
 require 'tmpdir'
@@ -6,7 +6,7 @@ require 'tmpdir'
 $: << "../../ruby2ruby/dev/lib" # unoffical dependency - user responsibility
 require 'ruby2ruby'
 
-class R2RTestCase < Test::Unit::TestCase
+class R2RTestCase < MiniTest::Unit::TestCase
   def test_proc_to_ruby
     util_setup_inline
     block = proc { puts "something" }

data/test/test_unified_ruby.rb

@@ -2,13 +2,13 @@
 
 $TESTING = true
 
-require 'test/unit' if $0 == __FILE__ unless defined? $ZENTEST and $ZENTEST
+require 'minitest/autorun' if $0 == __FILE__ unless defined? $ZENTEST and $ZENTEST
 require 'test/unit/testcase'
 require 'sexp'
 require 'sexp_processor'
 require 'unified_ruby'
 
-class TestUnifier < Test::Unit::TestCase
+class TestUnifier < MiniTest::Unit::TestCase
   def test_pre_fcall
     u = PreUnifier.new
 

metadata

@@ -1,15 +1,36 @@
 --- !ruby/object:Gem::Specification 
 name: ParseTree
 version: !ruby/object:Gem::Version 
-  version: 3.0.3
+  version: 3.0.4
 platform: ruby
 authors: 
 - Ryan Davis
 autorequire: 
 bindir: bin
-cert_chain: []
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDPjCCAiagAwIBAgIBADANBgkqhkiG9w0BAQUFADBFMRMwEQYDVQQDDApyeWFu
+  ZC1ydWJ5MRkwFwYKCZImiZPyLGQBGRYJemVuc3BpZGVyMRMwEQYKCZImiZPyLGQB
+  GRYDY29tMB4XDTA5MDMwNjE4NTMxNVoXDTEwMDMwNjE4NTMxNVowRTETMBEGA1UE
+  AwwKcnlhbmQtcnVieTEZMBcGCgmSJomT8ixkARkWCXplbnNwaWRlcjETMBEGCgmS
+  JomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALda
+  b9DCgK+627gPJkB6XfjZ1itoOQvpqH1EXScSaba9/S2VF22VYQbXU1xQXL/WzCkx
+  taCPaLmfYIaFcHHCSY4hYDJijRQkLxPeB3xbOfzfLoBDbjvx5JxgJxUjmGa7xhcT
+  oOvjtt5P8+GSK9zLzxQP0gVLS/D0FmoE44XuDr3iQkVS2ujU5zZL84mMNqNB1znh
+  GiadM9GHRaDiaxuX0cIUBj19T01mVE2iymf9I6bEsiayK/n6QujtyCbTWsAS9Rqt
+  qhtV7HJxNKuPj/JFH0D2cswvzznE/a5FOYO68g+YCuFi5L8wZuuM8zzdwjrWHqSV
+  gBEfoTEGr7Zii72cx+sCAwEAAaM5MDcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAw
+  HQYDVR0OBBYEFEfFe9md/r/tj/Wmwpy+MI8d9k/hMA0GCSqGSIb3DQEBBQUAA4IB
+  AQAY59gYvDxqSqgC92nAP9P8dnGgfZgLxP237xS6XxFGJSghdz/nI6pusfCWKM8m
+  vzjjH2wUMSSf3tNudQ3rCGLf2epkcU13/rguI88wO6MrE0wi4ZqLQX+eZQFskJb/
+  w6x9W1ur8eR01s397LSMexySDBrJOh34cm2AlfKr/jokKCTwcM0OvVZnAutaovC0
+  l1SVZ0ecg88bsWHA0Yhh7NFxK1utWoIhtB6AFC/+trM0FQEB/jZkIS8SaNzn96Rl
+  n0sZEf77FLf5peR8TP/PtmIg7Cyqz23sLM4mCOoTGIy5OcZ8TdyiyINUHtb5ej/T
+  FBHgymkyj/AOSqKRIpXPhjC6
+  -----END CERTIFICATE-----
 
-date: 2009-01-20 00:00:00 -08:00
+date: 2009-06-23 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,9 +61,35 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.8.2
+        version: 2.3.0
     version: 
-description: "ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]"
+description: |-
+  ParseTree is a C extension (using RubyInline) that extracts the parse
+  tree for an entire class or a specific method and returns it as a
+  s-expression (aka sexp) using ruby's arrays, strings, symbols, and
+  integers.
+  
+  As an example:
+  
+    def conditional1(arg1)
+      if arg1 == 0 then
+        return 1
+      end
+      return 0
+    end
+  
+  becomes:
+  
+    [:defn,
+      :conditional1,
+      [:scope,
+       [:block,
+        [:args, :arg1],
+        [:if,
+         [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]],
+         [:return, [:lit, 1]],
+         nil],
+        [:return, [:lit, 0]]]]]
 email: 
 - ryand-ruby@zenspider.com
 executables: 
@@ -71,16 +118,16 @@ files:
 - lib/parse_tree.rb
 - lib/parse_tree_extensions.rb
 - lib/unified_ruby.rb
-- lib/unique.rb
 - test/pt_testcase.rb
 - test/something.rb
-- test/test_all.rb
 - test/test_parse_tree.rb
 - test/test_parse_tree_extensions.rb
 - test/test_unified_ruby.rb
 - validate.sh
 has_rdoc: true
 homepage: http://rubyforge.org/projects/parsetree/
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
@@ -103,9 +150,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: parsetree
-rubygems_version: 1.3.1
+rubygems_version: 1.3.4
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers
 test_files: 
-- test/test_all.rb
+- test/test_parse_tree.rb
+- test/test_parse_tree_extensions.rb
+- test/test_unified_ruby.rb

metadata.gz.sig

@@ -0,0 +1 @@
+=p���J����F[��Ć+��6*���?ڴu�"����O��C8	�f	�*�Y�!�;]��Ԍ=��H�1��m��+ǫм�8B�wR�r;�TV|*'�����\ˮ����1���B���c�o-֤Λ���x]�_�s)z�@)H�tk��mz��%��{o�H���asƲ�cĚH6j~r3���)���R"��:��ZnZ

data/lib/unique.rb

@@ -1,15 +0,0 @@
-##
-# Unique creates unique variable names.
-
-class Unique
-  def self.reset # mostly for testing
-    @@curr = 0
-  end
-
-  def self.next
-    @@curr += 1
-    "temp_#{@@curr}".intern
-  end
-
-  reset
-end

data/test/test_all.rb

@@ -1,13 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-pat = "test_*.rb"
-if File.basename(Dir.pwd) != "test" then
-  $: << "test"
-  pat = File.join("test", pat)
-end
-
-Dir.glob(pat).each do |f|
-  require f
-end
-
-require 'test/unit'