ParseTree 3.0.1-x86-mswin32-60 → 3.0.2-x86-mswin32-60

data/.autotest

@@ -6,9 +6,8 @@ Autotest.add_hook :initialize do |at|
   at.libs << ":../../sexp_processor/dev/lib"
   at.extra_files << "test/pt_testcase.rb"
 
-  %w(TestRawParseTree).each do |klass|
-    at.extra_class_map[klass] = "test/test_parse_tree.rb"
-  end
+  at.extra_class_map["TestRawParseTree"] = "test/test_parse_tree.rb"
+  at.extra_class_map["R2RTestCase"] = "test/test_parse_tree_extensions.rb"
 
   at.add_mapping(/pt_testcase/) do |f, _|
     at.files_matching(/test_.*rb$/)

data/History.txt

@@ -1,6 +1,19 @@
+=== 3.0.2 / 2008-11-04
+
+* 1 minor enhancement:
+
+  * parse_tree_show now defaults to unified, added -U to UNunify output.
+
+* 4 bug fixes:
+
+  * UnifiedRuby#rewrite_defn kinda sorta deals with cfunc now. Stupid rails.
+  * Fixed ambiguities in splatted nodes in a bunch of contexts.
+  * Fixed 1 arg form of parse_tree_for_proc
+  * KNOWN ISSUE: 0 arg form (||) of parse_tree_for_proc segfaults.
+
 === 3.0.1 / 2008-10-23
 
-* 1 bug fix
+* 1 bug fix:
 
   * Fixed the dependency on sexp_processor (accidentally camelcased). thanks ez!
 

data/README.txt

@@ -36,9 +36,7 @@ becomes:
 == FEATURES/PROBLEMS:
 
 * Uses RubyInline, so it just drops in.
-* Includes SexpProcessor and CompositeSexpProcessor.
-  * Allows you to write very clean filters.
-* Includes UnifiedRuby, allowing you to automatically rewrite ruby quirks.
+* Uses UnifiedRuby by default, automatically rewriting ruby quirks.
 * ParseTree#parse_tree_for_string lets you parse arbitrary strings of ruby.
 * Includes parse_tree_show, which lets you quickly snoop code.
   * echo "1+1" | parse_tree_show -f for quick snippet output.
@@ -54,19 +52,6 @@ becomes:
   sexp_array = ParseTree.translate(klass, :method)
   sexp_array = ParseTree.translate("1+1")
 
-or:
-
-  class MyProcessor < SexpProcessor
-    def initialize
-      super
-      self.strict = false
-    end
-    def process_lit(exp)
-      val = exp.shift
-      return val
-    end
-  end
-
 or:
 
   % ./parse_tree_show myfile.rb
@@ -85,8 +70,6 @@ or:
 
 == INSTALL:
 
-* rake install_gem
-* sudo rake install
 * sudo gem install ParseTree
 
 == LICENSE:

data/bin/parse_tree_show

@@ -10,9 +10,11 @@ $h ||= false
 $n ||= false
 $r ||= false
 $s ||= false
-$u ||= false
+$U ||= false
 $n = $n.intern if $n
 
+$u ||= ! $U
+
 if $h then
   puts "usage: #{File.basename $0} [options] [file...]"
   puts "options:"
@@ -21,7 +23,8 @@ if $h then
   puts "-n=node : only display matching nodes"
   puts "-r      : raw arrays, no sexps"
   puts "-s      : structural sexps, strip all content and show bare tree"
-  puts "-u      : unified sexps"
+  puts "-u      : unified sexps (now the default)"
+  puts "-U      : UNunified sexps"
 
   exit 1
 end
@@ -32,7 +35,7 @@ if $u then
   require 'sexp_processor'
   require 'unified_ruby'
 
-  class Unifier < SexpProcessor
+  class Unifier
     include UnifiedRuby
   end
 end

data/lib/parse_tree.rb

@@ -43,7 +43,7 @@ end
 
 class RawParseTree
 
-  VERSION = '3.0.1'
+  VERSION = '3.0.2'
 
   ##
   # Front end translation method.
@@ -258,6 +258,8 @@ class RawParseTree
     builder.include '"st.h"'
     builder.include '"env.h"'
 
+    builder.prefix '#define _sym(s) ID2SYM(rb_intern((s)))'
+
     if RUBY_VERSION < "1.8.6" then
       builder.prefix '#define RARRAY_PTR(s) (RARRAY(s)->ptr)'
       builder.prefix '#define RARRAY_LEN(s) (RARRAY(s)->len)'
@@ -274,7 +276,8 @@ class RawParseTree
       builder.add_compile_flags "-Wno-long-long"
 
       # NOTE: this flag doesn't work w/ gcc 2.95.x - the FreeBSD default
-      # builder.add_compile_flags "-Wno-strict-aliasing"
+      builder.add_compile_flags "-Wno-strict-aliasing"
+
       # ruby.h screws these up hardcore:
       # builder.add_compile_flags "-Wundef"
       # builder.add_compile_flags "-Wconversion"
@@ -296,12 +299,13 @@ class RawParseTree
         static unsigned case_level = 0;
         static unsigned when_level = 0;
         static unsigned inside_case_args = 0;
+        static int masgn_level = 0;
     }
 
     builder.prefix %{
       static VALUE wrap_into_node(const char * name, VALUE val) {
         VALUE n = rb_ary_new();
-        rb_ary_push(n, ID2SYM(rb_intern(name)));
+        rb_ary_push(n, _sym(name));
         if (val) rb_ary_push(n, val);
         return n;
       }
@@ -348,7 +352,6 @@ void add_to_parse_tree(VALUE self, VALUE ary, NODE * n, ID * locals) {
   VALUE current;
   VALUE node_name;
   static VALUE node_names = Qnil;
-  static int masgn_level = 0;
 
   if (NIL_P(node_names)) {
     node_names = rb_const_get_at(rb_path2class("RawParseTree"),rb_intern("NODE_NAMES"));
@@ -368,7 +371,7 @@ again:
         (RNODE(node)->u3.node != NULL ? "u3 " : "   "));
     }
   } else {
-    node_name = ID2SYM(rb_intern("ICKY"));
+    node_name = _sym("ICKY");
   }
 
   current = rb_ary_new();
@@ -518,6 +521,11 @@ again:
     if (node->nd_stts)
       add_to_parse_tree(self, current, node->nd_stts, locals);
 
+    // if node is newline, it is aref_args w/ a splat, eg: yield([*[1]])
+    if (node->nd_stts && nd_type(node->nd_stts) == NODE_NEWLINE)
+      rb_ary_push(current, Qtrue);
+
+    // array is an array, not list of args
     if (node->nd_stts
         && (nd_type(node->nd_stts) == NODE_ARRAY
             || nd_type(node->nd_stts) == NODE_ZARRAY)
@@ -639,10 +647,10 @@ again:
 #endif
     switch (node->nd_mid) {
     case 0:
-      rb_ary_push(current, ID2SYM(rb_intern("||")));
+      rb_ary_push(current, _sym("||"));
       break;
     case 1:
-      rb_ary_push(current, ID2SYM(rb_intern("&&")));
+      rb_ary_push(current, _sym("&&"));
       break;
     default:
       rb_ary_push(current, ID2SYM(node->nd_mid));
@@ -657,10 +665,10 @@ again:
 
     switch (node->nd_next->nd_mid) {
     case 0:
-      rb_ary_push(current, ID2SYM(rb_intern("||")));
+      rb_ary_push(current, _sym("||"));
       break;
     case 1:
-      rb_ary_push(current, ID2SYM(rb_intern("&&")));
+      rb_ary_push(current, _sym("&&"));
       break;
     default:
       rb_ary_push(current, ID2SYM(node->nd_next->nd_mid));
@@ -1005,8 +1013,8 @@ again:
     /* Nothing to do here... we are in an iter block */
     break;
 
-  case NODE_CFUNC:
   case NODE_IFUNC:
+  case NODE_CFUNC:
     rb_ary_push(current, INT2NUM((long)node->nd_cfnc));
     rb_ary_push(current, INT2NUM(node->nd_argc));
     break;
@@ -1040,6 +1048,28 @@ again:
 }
 @ # end of add_to_parse_tree block
 
+    builder.c %Q{
+  static VALUE parse_tree_for_proc(VALUE proc) {
+    VALUE result = rb_ary_new();
+    struct BLOCK *data;
+    Data_Get_Struct(proc, struct BLOCK, data);
+
+    rb_ary_push(result, _sym("iter"));
+    rb_ary_push(result, rb_ary_new3(4, _sym("call"), Qnil, _sym("proc"),
+                                    rb_ary_new3(1, _sym("arglist"))));
+    masgn_level++;
+    if (data->var) {
+      add_to_parse_tree(self, result, data->var, NULL);
+    } else {
+      rb_ary_push(result, Qnil);
+    }
+    add_to_parse_tree(self, result, data->body, NULL);
+    masgn_level--;
+
+    return result;
+  }
+}
+
     builder.c %Q{
 static VALUE parse_tree_for_meth(VALUE klass, VALUE method, VALUE is_cls_meth) {
   VALUE n;
@@ -1060,9 +1090,9 @@ static VALUE parse_tree_for_meth(VALUE klass, VALUE method, VALUE is_cls_meth) {
   }
   if (st_lookup(RCLASS(klass)->m_tbl, id, &n)) {
     node = (NODE*)n;
-    rb_ary_push(result, ID2SYM(rb_intern(is_cls_meth ? "defs": "defn")));
+    rb_ary_push(result, _sym(is_cls_meth ? "defs": "defn"));
     if (is_cls_meth) {
-      rb_ary_push(result, rb_ary_new3(1, ID2SYM(rb_intern("self"))));
+      rb_ary_push(result, rb_ary_new3(1, _sym("self")));
     }
     rb_ary_push(result, ID2SYM(id));
     add_to_parse_tree(self, result, node->nd_body, NULL);

data/lib/parse_tree_extensions.rb

@@ -17,7 +17,7 @@ class Method
     unifier = Unifier.new
     with_class_and_method_name do |klass, method|
       old_sexp = parser.parse_tree_for_method(klass, method)
-      unifier.process(old_sexp) # HACK
+      unifier.process(old_sexp)
     end
   end
 
@@ -47,20 +47,10 @@ class UnboundMethod
 end
 
 class Proc
-  def to_method
-    name = ProcStoreTmp.new_name
-    ProcStoreTmp.send(:define_method, name, self)
-    ProcStoreTmp.new.method(name)
-  end
-
   def to_sexp
-    sexp = self.to_method.to_sexp
-    body = sexp.scope.block
-    args = sexp.args
-    args = nil if args.size == 1
-    body = body[1] if body.size == 2
-
-    s(:iter, s(:call, nil, :proc, s(:arglist)), args, body)
+    pt = ParseTree.new(false)
+    sexp = pt.parse_tree_for_proc(self)
+    Unifier.new.process(sexp)
   end
 
   def to_ruby

data/lib/unified_ruby.rb

@@ -1,4 +1,5 @@
 require 'sexp_processor'
+require 'composite_sexp_processor'
 
 $TESTING ||= false
 
@@ -8,6 +9,17 @@ module UnifiedRuby
     super
   end
 
+  def rewrite_argscat exp
+    _, ary, val = exp
+    ary = s(:array, ary) unless ary.first == :array
+    ary << s(:splat, val)
+  end
+
+  def rewrite_argspush exp
+    exp[0] = :arglist
+    exp
+  end
+
   def rewrite_attrasgn(exp)
     last = exp.last
 
@@ -20,42 +32,9 @@ module UnifiedRuby
     exp
   end
 
-  def rewrite_bmethod(exp)
-    exp[0] = :scope
-
-    has_splat = exp.masgn.array.splat.lasgn rescue false
-
-    args =
-      if has_splat then
-        arg = exp.masgn(true).array.splat.lasgn.sexp_body
-        raise "nope: #{arg.size}" unless arg.size == 1
-        s(:args, :"*#{arg.last}")
-      else
-        args = exp.lasgn(true)
-        if args then
-          s(:args, *args.sexp_body)
-        else
-          exp.delete_at 1 # nil
-          s(:args)
-        end
-      end
-
-    exp = s(:scope, s(:block, *exp.sexp_body)) unless exp.block
-    exp.block.insert 1, args
-    exp.find_and_replace_all(:dvar, :lvar)
-
-    exp
-  end
-
-  def rewrite_argscat exp
-    _, ary, val = exp
-    ary = s(:array, ary) unless ary.first == :array
-    ary << s(:splat, val)
-  end
-
-  def rewrite_argspush exp
-    exp[0] = :arglist
-    exp
+  def rewrite_begin(exp)
+    raise "wtf: #{exp.inspect}" if exp.size > 2
+    exp.last
   end
 
   def rewrite_block_pass exp
@@ -76,6 +55,41 @@ module UnifiedRuby
     exp
   end
 
+  def rewrite_bmethod(exp)
+    _, args, body = exp
+
+    args ||= s(:array)
+    body ||= s(:block)
+
+    args = s(:args, args) unless args[0] == :array
+
+    args = args[1] if args[1] && args[1][0] == :masgn # TODO: clean up
+    args = args[1] if args[1] && args[1][0] == :array
+    args[0] = :args
+
+    # this is ugly because rewriters are depth first.
+    # TODO: maybe we could come up with some way to do both forms of rewriting.
+    args.map! { |s|
+      if Sexp === s
+        case s[0]
+        when :lasgn then
+          s[1]
+        when :splat then
+          :"*#{s[1][1]}"
+        else
+          raise "huh?: #{s.inspect}"
+        end
+      else
+        s
+      end
+    }
+
+    body = s(:block, body) unless body[0] == :block
+    body.insert 1, args
+
+    s(:scope, body)
+  end
+
   def rewrite_call(exp)
     args = exp.last
     case args
@@ -138,9 +152,11 @@ module UnifiedRuby
 
   def rewrite_defn(exp)
     weirdo = exp.ivar || exp.attrset
+    fbody  = exp.fbody(true)
+
+    weirdo ||= fbody.cfunc if fbody
 
-    fbody = exp.fbody(true)
-    exp.push(fbody.scope) if fbody
+    exp.push(fbody.scope) if fbody unless weirdo
 
     args = exp.scope.block.args(true) unless weirdo
     exp.insert 2, args if args
@@ -156,6 +172,8 @@ module UnifiedRuby
     # patch up attr_accessor methods
     if weirdo then
       case
+      when fbody && fbody.cfunc then
+        exp.insert 2, s(:args, :"*args")
       when exp.ivar then
         exp.insert 2, s(:args)
       when exp.attrset then
@@ -174,7 +192,7 @@ module UnifiedRuby
     # TODO: I think this would be better as rewrite_scope, but that breaks others
     exp = s(exp.shift, exp.shift,
             s(:scope,
-              s(:block, exp.scope.args))) if exp.scope.args
+              s(:block, exp.scope.args))) if exp.scope && exp.scope.args
 
     result = rewrite_defn(exp)
     result.insert 1, receiver
@@ -196,20 +214,25 @@ module UnifiedRuby
   def rewrite_fcall(exp)
     exp[0] = :call
     exp.insert 1, nil
-    exp.push nil if exp.size <= 3
 
     rewrite_call(exp)
   end
 
   def rewrite_masgn(exp)
-    raise "wtf: #{exp}" unless exp.size == 4
-
+    raise "wtf: #{exp}" unless exp.size == 4 # TODO: remove 2009-01-29
     t, lhs, lhs_splat, rhs = exp
 
     lhs ||= s(:array)
 
     if lhs_splat then
-      lhs_splat = s(:splat, lhs_splat) unless lhs_splat[0] == :splat
+      case lhs_splat.first
+      when :array then
+        lhs_splat = lhs_splat.last if lhs_splat.last.first == :splat
+      when :splat then
+        # do nothing
+      else
+        lhs_splat = s(:splat, lhs_splat)
+      end
       lhs << lhs_splat
     end
 
@@ -221,6 +244,25 @@ module UnifiedRuby
     exp
   end
 
+  def rewrite_resbody(exp)
+    exp[1] ||= s(:array)        # no args
+
+    body = exp[2]
+    if body then
+      case body.first
+      when :lasgn, :iasgn then
+        exp[1] << exp.delete_at(2) if body[-1] == s(:gvar, :$!)
+      when :block then
+        exp[1] << body.delete_at(1) if [:lasgn, :iasgn].include?(body[1][0]) &&
+          body[1][-1] == s(:gvar, :$!)
+      end
+    end
+
+    exp << nil if exp.size == 2 # no body
+
+    exp
+  end
+
   def rewrite_rescue(exp)
     # SKETCHY HACK return exp if exp.size > 4
     ignored = exp.shift
@@ -251,28 +293,16 @@ module UnifiedRuby
     s(:rescue, body, *resbodies).compact
   end
 
-  def rewrite_resbody(exp)
-    exp[1] ||= s(:array)        # no args
-
-    body = exp[2]
-    if body then
-      case body.first
-      when :lasgn, :iasgn then
-        exp[1] << exp.delete_at(2) if body[-1] == s(:gvar, :$!)
-      when :block then
-        exp[1] << body.delete_at(1) if [:lasgn, :iasgn].include?(body[1][0]) &&
-          body[1][-1] == s(:gvar, :$!)
-      end
-    end
-
-    exp << nil if exp.size == 2 # no body
-
+  def rewrite_splat(exp)
+    good = [:arglist, :argspush, :array, :svalue, :yield, :super].include? context.first
+    exp = s(:array, exp) unless good
     exp
   end
 
-  def rewrite_begin(exp)
-    raise "wtf: #{exp.inspect}" if exp.size > 2
-    exp.last
+  def rewrite_super(exp)
+    return exp if exp.structure.flatten.first(3) == [:super, :array, :splat]
+    exp.push(*exp.pop[1..-1]) if exp.size == 2 && exp.last.first == :array
+    exp
   end
 
   def rewrite_vcall(exp)
@@ -281,18 +311,16 @@ module UnifiedRuby
   end
 
   def rewrite_yield(exp)
-    # Literal array in yield, not args.
-    if exp.size == 3 and exp.pop == true then
-      # exp[1] = s(:arglist, exp[1])
-    elsif exp.size == 2 && exp.last.first == :array then
-      exp.push(*exp.pop[1..-1])
-    end
+    real_array = exp.pop if exp.size == 3
 
-    exp
-  end
+    if exp.size == 2 then
+      if real_array then
+        exp[-1] = s(:array, exp[-1]) if exp[-1][0] != :array
+      else
+        exp.push(*exp.pop[1..-1]) if exp.last.first == :array
+      end
+    end
 
-  def rewrite_super(exp)
-    exp.push(*exp.pop[1..-1]) if exp.size == 2 && exp.last.first == :array
     exp
   end
 
@@ -302,10 +330,30 @@ module UnifiedRuby
   end
 end
 
-##
-# Quick and easy SexpProcessor that unified the sexp structure.
+class PreUnifier < SexpProcessor
+  def initialize
+    super
+    @unsupported.delete :newline
+  end
 
-class Unifier < SexpProcessor
+  def rewrite_call exp
+    exp << s(:arglist) if exp.size < 4
+    exp.last[0] = :arglist if exp.last.first == :array
+    exp
+  end
+
+  def rewrite_fcall exp
+    exp << s(:arglist) if exp.size < 3
+    if exp[-1][0] == :array then
+      has_splat = exp[-1].find { |s| Array === s && s.first == :splat }
+      exp[-1] = s(:arglist, exp[-1]) if has_splat
+      exp[-1][0] = :arglist
+    end
+    exp
+  end
+end
+
+class PostUnifier < SexpProcessor
   include UnifiedRuby
 
   def initialize
@@ -313,3 +361,14 @@ class Unifier < SexpProcessor
     @unsupported.delete :newline
   end
 end
+
+##
+# Quick and easy SexpProcessor that unified the sexp structure.
+
+class Unifier < CompositeSexpProcessor
+  def initialize
+    super
+    self << PreUnifier.new
+    self << PostUnifier.new
+  end
+end

data/test/pt_testcase.rb

@@ -3578,24 +3578,6 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                     s(:call, nil, :c, s(:arglist)),
                                     s(:call, nil, :d, s(:arglist))))))
 
-  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]]]]],
-            "ParseTree"    => s(:rescue,
-                                s(:call, nil, :a, s(:arglist)),
-                                s(:resbody,
-                                  s(:array, s(:iasgn, :@e, s(:gvar, :$!))),
-                                  s(:block,
-                                    s(:call, nil, :c, s(:arglist)),
-                                    s(:call, nil, :d, s(:arglist))))))
-
   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,
@@ -3616,6 +3598,24 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                 s(:resbody, s(:array, s(:const, :C)),
                                   s(:call, nil, :d, s(:arglist)))))
 
+  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]]]]],
+            "ParseTree"    => s(:rescue,
+                                s(:call, nil, :a, s(:arglist)),
+                                s(:resbody,
+                                  s(:array, s(:iasgn, :@e, s(:gvar, :$!))),
+                                  s(:block,
+                                    s(:call, nil, :c, s(:arglist)),
+                                    s(:call, nil, :d, s(:arglist))))))
+
   add_tests("rescue_block_nada",
             "Ruby"         => "begin\n  blah\nrescue\n  # do nothing\nend",
             "RawParseTree" => [:begin,
@@ -3641,6 +3641,18 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                   nil)))
 
 
+  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, :$!]]]]],
+            "ParseTree"    => s(:rescue,
+                                s(:lit, 1),
+                                s(:resbody,
+                                  s(:array, s(:iasgn, :@e, s(:gvar, :$!))),
+                                  nil)))
+
   add_tests("rescue_lasgn",
             "Ruby"         => "begin\n  1\nrescue\n  var = 2\nend",
             "RawParseTree" => [:begin,
@@ -3681,17 +3693,6 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                   s(:array, s(:lasgn, :e, s(:gvar, :$!))),
                                   nil)))
 
-  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, :$!]]]]],
-            "ParseTree"    => s(:rescue,
-                                s(:lit, 1),
-                                s(:resbody,
-                                  s(:array, s(:iasgn, :@e, s(:gvar, :$!))),
-                                  nil)))
   add_tests("retry",
             "Ruby"         => "retry",
             "RawParseTree" => [:retry],
@@ -3707,6 +3708,11 @@ class ParseTreeTestCase < Test::Unit::TestCase
             "RawParseTree" => [:return, [:lit, 1]],
             "ParseTree"    => s(:return, s(:lit, 1)))
 
+  add_tests("return_1_splatted",
+            "Ruby"         => "return *1",
+            "RawParseTree" => [:return, [:svalue, [:splat, [:lit, 1]]]],
+            "ParseTree"    => s(:return, s(:svalue, s(:splat, s(:lit, 1)))))
+
   add_tests("return_n",
             "Ruby"         => "return 1, 2, 3",
             "RawParseTree" => [:return, [:array,
@@ -3749,6 +3755,96 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                     s(:call, nil, :a,
                                       s(:arglist, s(:splat, s(:lvar, :b))))))))
 
+  add_tests("splat_array",
+            "Ruby"         => "[*[1]]",
+            "RawParseTree" => [:splat, [:array, [:lit, 1]]],
+            "ParseTree"    => s(:array, s(:splat, s(:array, s(:lit, 1)))))
+
+  add_tests("splat_break",
+            "Ruby"         => "break *[1]",
+            "RawParseTree" => [:break, [:svalue, [:splat, [:array, [:lit, 1]]]]],
+            "ParseTree"    => s(:break, s(:svalue, s(:splat, s(:array, s(:lit, 1))))))
+
+  add_tests("splat_break_array",
+            "Ruby"         => "break [*[1]]",
+            "RawParseTree" => [:break, [:splat, [:array, [:lit, 1]]]],
+            "ParseTree"    => s(:break, s(:array, s(:splat, s(:array, s(:lit, 1))))))
+
+  add_tests("splat_fcall",
+            "Ruby"         => "meth(*[1])",
+            "RawParseTree" => [:fcall, :meth,
+                               [:splat, [:array, [:lit, 1]]]],
+            "ParseTree"    => s(:call, nil, :meth,
+                             s(:arglist, s(:splat, s(:array, s(:lit, 1))))))
+
+  add_tests("splat_fcall_array",
+            "Ruby"         => "meth([*[1]])",
+            "RawParseTree" => [:fcall, :meth,
+                               [:array, [:splat, [:array, [:lit, 1]]]]],
+            "ParseTree"    => s(:call, nil, :meth,
+                             s(:arglist,
+                               s(:array, s(:splat, s(:array, s(:lit, 1)))))))
+
+  add_tests("splat_lasgn",
+            "Ruby"         => "x = *[1]",
+            "RawParseTree" => [:lasgn, :x, [:svalue, [:splat, [:array, [:lit, 1]]]]],
+            "ParseTree"    => s(:lasgn, :x, s(:svalue, s(:splat, s(:array, s(:lit, 1))))))
+
+  add_tests("splat_lasgn_array",
+            "Ruby"         => "x = [*[1]]",
+            "RawParseTree" => [:lasgn, :x, [:splat, [:array, [:lit, 1]]]],
+            "ParseTree"    => s(:lasgn, :x, s(:array, s(:splat, s(:array, s(:lit, 1))))))
+
+  add_tests("splat_lit_1",
+            "Ruby"         => "[*1]",
+            "RawParseTree" => [:splat, [:lit, 1]], # UGH - damn MRI
+            "ParseTree"    => s(:array, s(:splat, s(:lit, 1))))
+
+  add_tests("splat_lit_n",
+            "Ruby"         => "[1, *2]",
+            "RawParseTree" => [:argscat, [:array, [:lit, 1]], [:lit, 2]],
+            "ParseTree"    => s(:array, s(:lit, 1), s(:splat, s(:lit, 2))))
+
+  add_tests("splat_next",
+            "Ruby"         => "next *[1]",
+            "RawParseTree" => [:next, [:svalue, [:splat, [:array, [:lit, 1]]]]],
+            "ParseTree"    => s(:next, s(:svalue, s(:splat, s(:array, s(:lit, 1))))))
+
+  add_tests("splat_next_array",
+            "Ruby"         => "next [*[1]]",
+            "RawParseTree" => [:next, [:splat, [:array, [:lit, 1]]]],
+            "ParseTree"    => s(:next, s(:array, s(:splat, s(:array, s(:lit, 1))))))
+
+  add_tests("splat_return",
+            "Ruby"         => "return *[1]",
+            "RawParseTree" => [:return, [:svalue, [:splat, [:array, [:lit, 1]]]]],
+            "ParseTree"    => s(:return, s(:svalue, s(:splat, s(:array, s(:lit, 1))))))
+
+  add_tests("splat_return_array",
+            "Ruby"         => "return [*[1]]",
+            "RawParseTree" => [:return, [:splat, [:array, [:lit, 1]]]],
+            "ParseTree"    => s(:return, s(:array, s(:splat, s(:array, s(:lit, 1))))))
+
+  add_tests("splat_super",
+            "Ruby"         => "super(*[1])",
+            "RawParseTree" => [:super, [:splat, [:array, [:lit, 1]]]],
+            "ParseTree"    => s(:super, s(:splat, s(:array, s(:lit, 1)))))
+
+  add_tests("splat_super_array",
+            "Ruby"         => "super([*[1]])",
+            "RawParseTree" => [:super, [:array, [:splat, [:array, [:lit, 1]]]]],
+            "ParseTree"    => s(:super, s(:array, s(:splat, s(:array, s(:lit, 1))))))
+
+  add_tests("splat_yield",
+            "Ruby"         => "yield(*[1])",
+            "RawParseTree" => [:yield, [:splat, [:array, [:lit, 1]]]],
+            "ParseTree"    => s(:yield, s(:splat, s(:array, s(:lit, 1)))))
+
+  add_tests("splat_yield_array",
+            "Ruby"         => "yield([*[1]])",
+            "RawParseTree" => [:yield, [:splat, [:array, [:lit, 1]]], true],
+            "ParseTree"    => s(:yield, s(:array, s(:splat, s(:array, s(:lit, 1))))))
+
   add_tests("str",
             "Ruby"         => '"x"',
             "RawParseTree" => [:str, "x"],
@@ -3936,19 +4032,6 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                                 s(:lit, 24),
                                                 s(:lit, 42)))))))
 
-  add_tests("super_n",
-            "Ruby"         => "def x\n  super(24, 42)\nend",
-            "RawParseTree" => [:defn, :x,
-                               [:scope,
-                                [:block,
-                                 [:args],
-                                 [:super, [:array, [:lit, 24], [:lit, 42]]]]]],
-            "ParseTree"    => s(:defn, :x,
-                                s(:args),
-                                s(:scope,
-                                  s(:block,
-                                    s(:super, s(:lit, 24), s(:lit, 42))))))
-
   add_tests("super_block_pass",
             "Ruby"         => "super(a, &b)",
             "RawParseTree" => [:block_pass,
@@ -3968,6 +4051,19 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                 s(:call, nil, :a, s(:arglist)),
                                 s(:splat, s(:call, nil, :b, s(:arglist)))))
 
+  add_tests("super_n",
+            "Ruby"         => "def x\n  super(24, 42)\nend",
+            "RawParseTree" => [:defn, :x,
+                               [:scope,
+                                [:block,
+                                 [:args],
+                                 [:super, [:array, [:lit, 24], [:lit, 42]]]]]],
+            "ParseTree"    => s(:defn, :x,
+                                s(:args),
+                                s(:scope,
+                                  s(:block,
+                                    s(:super, s(:lit, 24), s(:lit, 42))))))
+
   add_tests("svalue",
             "Ruby"         => "a = *b",
             "RawParseTree" => [:lasgn, :a, [:svalue, [:splat, [:vcall, :b]]]],
@@ -4278,25 +4374,25 @@ class ParseTreeTestCase < Test::Unit::TestCase
             "RawParseTree" => [:yield, [:lit, 42]],
             "ParseTree"    => s(:yield, s(:lit, 42)))
 
-  add_tests("yield_n",
-            "Ruby"         => "yield(42, 24)",
-            "RawParseTree" => [:yield, [:array, [:lit, 42], [:lit, 24]]],
-            "ParseTree"    => s(:yield, s(:lit, 42), s(:lit, 24)))
+  add_tests("yield_array_0",
+            "Ruby"         => "yield([])",
+            "RawParseTree" => [:yield, [:zarray], true],
+            "ParseTree"    => s(:yield, s(:array)))
 
-  add_tests("yield_splat",
-            "Ruby"         => "yield(*ary)",
-            "RawParseTree" => [:yield, [:splat, [:vcall, :ary]]],
-            "ParseTree"    => s(:yield, s(:splat, s(:call, nil, :ary, s(:arglist)))))
+  add_tests("yield_array_1",
+            "Ruby"         => "yield([42])",
+            "RawParseTree" => [:yield, [:array, [:lit, 42]], true],
+            "ParseTree"    => s(:yield, s(:array, s(:lit, 42))))
 
-  add_tests("yield_array",
+  add_tests("yield_array_n",
             "Ruby"         => "yield([42, 24])",
             "RawParseTree" => [:yield, [:array, [:lit, 42], [:lit, 24]], true],
             "ParseTree"    => s(:yield, s(:array, s(:lit, 42), s(:lit, 24))))
 
-  add_tests("yield_zarray",
-            "Ruby"         => "yield([])",
-            "RawParseTree" => [:yield, [:zarray], true],
-            "ParseTree"    => s(:yield, s(:array)))
+  add_tests("yield_n",
+            "Ruby"         => "yield(42, 24)",
+            "RawParseTree" => [:yield, [:array, [:lit, 42], [:lit, 24]]],
+            "ParseTree"    => s(:yield, s(:lit, 42), s(:lit, 24)))
 
   add_tests("zarray",
             "Ruby"         => "a = []",

data/test/test_parse_tree_extensions.rb

@@ -13,6 +13,25 @@ class R2RTestCase < Test::Unit::TestCase
     assert_equal 'proc { puts("something") }', block.to_ruby
   end
 
+  # TODO: bus error
+#   def test_proc_to_ruby_args_0
+#     util_setup_inline
+#     block = proc { || puts 42 }
+#     assert_equal 'proc { || puts(42) }', block.to_ruby
+#   end
+
+  def test_proc_to_ruby_args_1
+    util_setup_inline
+    block = proc { |x| puts x }
+    assert_equal 'proc { |x| puts(x) }', block.to_ruby
+  end
+
+  def test_proc_to_ruby_args_n
+    util_setup_inline
+    block = proc { |x| puts x }
+    assert_equal 'proc { |x| puts(x) }', block.to_ruby
+  end
+
   def test_proc_to_sexp
     util_setup_inline
     p = proc { 1 + 1 }
@@ -23,6 +42,55 @@ class R2RTestCase < Test::Unit::TestCase
     assert_equal s, p.to_sexp
   end
 
+  # TODO: bus error
+#   def test_proc_to_sexp_args_0
+#     util_setup_inline
+#     p = proc { || 1 + 1 }
+#     s = s(:iter,
+#           s(:call, nil, :proc, s(:arglist)),
+#           nil,
+#           s(:call, s(:lit, 1), :+, s(:arglist, s(:lit, 1))))
+#     assert_equal s, p.to_sexp
+#   end
+
+  def test_proc_to_sexp_args_1
+    util_setup_inline
+    p = proc {|x| puts x }
+    s = s(:iter,
+          s(:call, nil, :proc, s(:arglist)),
+          s(:lasgn, :x),
+          s(:call, nil, :puts, s(:arglist, s(:lvar, :x))))
+
+    assert_equal s, p.to_sexp
+  end
+
+  def test_proc_to_sexp_args_n
+    util_setup_inline
+    p = proc {|x, y| puts x + y }
+    s = s(:iter,
+          s(:call, nil, :proc, s(:arglist)),
+          s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
+          s(:call, nil, :puts,
+            s(:arglist, s(:call, s(:lvar, :x), :+, s(:arglist, s(:lvar, :y))))))
+
+    assert_equal s, p.to_sexp
+  end
+
+  def test_parse_tree_for_proc # TODO: move?
+    p = proc {|a, b, c|}
+    s = s(:iter,
+          s(:call, nil, :proc, s(:arglist)),
+          s(:masgn, s(:array, s(:lasgn, :a), s(:lasgn, :b), s(:lasgn, :c))))
+
+    pt = ParseTree.new(false)
+    u = Unifier.new
+    sexp = pt.parse_tree_for_proc p
+
+    sexp = u.process(sexp)
+
+    assert_equal s, sexp
+  end
+
   def test_unbound_method_to_ruby
     util_setup_inline
     r = "proc { ||\n  util_setup_inline\n  p = proc { (1 + 1) }\n  s = s(:iter, s(:call, nil, :proc, s(:arglist)), nil, s(:call, s(:lit, 1), :+, s(:arglist, s(:lit, 1))))\n  assert_equal(s, p.to_sexp)\n}"

data/test/test_unified_ruby.rb

@@ -7,309 +7,51 @@ require 'test/unit/testcase'
 require 'sexp'
 require 'sexp_processor'
 require 'unified_ruby'
-require 'pt_testcase'
 
-class TestUnifier < SexpProcessor
-  include UnifiedRuby
-end
+class TestUnifier < Test::Unit::TestCase
+  def test_pre_fcall
+    u = PreUnifier.new
+
+    input  = [:fcall, :block_given?]
+    expect = s(:fcall, :block_given?, s(:arglist))
+
+    assert_equal expect, u.process(input)
+
+    input  = [:fcall, :m, [:array, [:lit, 42]]]
+    expect = s(:fcall, :m, s(:arglist, s(:lit, 42)))
+
+    assert_equal expect, u.process(input)
+  end
+
+  def test_pre_call
+    u = PreUnifier.new
 
-# (old) TODO:
-#
-# 1) DONE [vf]call => call
-# 2) DONE defn scope block args -> defn args scope block
-# 3) DONE [bd]method/fbody => defn
-# 4) rescue cleanup
-# 5) defs x -> defn self.x # ON HOLD
-# 6) ? :block_arg into args list?
+    input  = [:call, [:self], :method]
+    expect = s(:call, s(:self), :method, s(:arglist))
 
-# ParseTreeTestCase.testcase_order << "UnifiedRuby"
-# class TestUnifiedRuby < ParseTreeTestCase
-#   def setup
-#     super
-#     @processor = TestUnifier.new
-#   end
-# end
+    assert_equal expect, u.process(input)
 
-#   add_test("alias", :skip)
-#   add_test("alias_ugh", :skip)
-#   add_test("and", :skip)
-#   add_test("argscat_inside", :skip)
-#   add_test("argscat_svalue", :skip)
-#   add_test("argspush", :skip)
-#   add_test("array", :skip)
-#   add_test("array_pct_W", :skip)
-#   add_test("attrasgn", :skip)
-#   add_test("attrasgn_index_equals", :skip)
-#   add_test("attrasgn_index_equals_space", :skip)
-#   add_test("attrset", :skip)
-#   add_test("back_ref", :skip)
-#   add_test("begin", :skip)
-#   add_test("begin_def", :skip)
-#   add_test("begin_rescue_ensure", :skip)
-#   add_test("begin_rescue_twice", :skip)
-#   add_test("block_lasgn", :skip)
-#   add_test("block_mystery_block", :skip)
-#   add_test("block_pass_args_and_splat", :skip)
-#   add_test("block_pass_call_0", :skip)
-#   add_test("block_pass_call_1", :skip)
-#   add_test("block_pass_call_n", :skip)
-#   add_test("block_pass_fcall_0", :skip)
-#   add_test("block_pass_fcall_1", :skip)
-#   add_test("block_pass_fcall_n", :skip)
-#   add_test("block_pass_omgwtf", :skip)
-#   add_test("block_pass_splat", :skip)
-#   add_test("block_pass_thingy", :skip)
-#   add_test("block_stmt_after", :skip)
-#   add_test("block_stmt_before", :skip)
-#   add_test("block_stmt_both", :skip)
-#   add_test("bmethod", :skip)
-#   add_test("bmethod_noargs", :skip)
-#   add_test("bmethod_splat", :skip)
-#   add_test("break", :skip)
-#   add_test("break_arg", :skip)
-#   add_test("call", :skip)
-#   add_test("call_arglist", :skip)
-#   add_test("call_arglist_hash", :skip)
-#   add_test("call_arglist_norm_hash", :skip)
-#   add_test("call_arglist_norm_hash_splat", :skip)
-#   add_test("call_command", :skip)
-#   add_test("call_expr", :skip)
-#   add_test("call_index", :skip)
-#   add_test("call_index_no_args", :skip)
-#   add_test("call_index_space", :skip)
-#   add_test("call_unary_neg", :skip)
-#   add_test("case", :skip)
-#   add_test("case_nested", :skip)
-#   add_test("case_nested_inner_no_expr", :skip)
-#   add_test("case_no_expr", :skip)
-#   add_test("case_splat", :skip)
-#   add_test("cdecl", :skip)
-#   add_test("class_plain", :skip)
-#   add_test("class_scoped", :skip)
-#   add_test("class_scoped3", :skip)
-#   add_test("class_super_array", :skip)
-#   add_test("class_super_expr", :skip)
-#   add_test("class_super_object", :skip)
-#   add_test("colon2", :skip)
-#   add_test("colon3", :skip)
-#   add_test("conditional1", :skip)
-#   add_test("conditional2", :skip)
-#   add_test("conditional3", :skip)
-#   add_test("conditional4", :skip)
-#   add_test("conditional5", :skip)
-#   add_test("conditional_post_if", :skip)
-#   add_test("conditional_post_if_not", :skip)
-#   add_test("conditional_post_unless", :skip)
-#   add_test("conditional_post_unless_not", :skip)
-#   add_test("conditional_pre_if", :skip)
-#   add_test("conditional_pre_if_not", :skip)
-#   add_test("conditional_pre_unless", :skip)
-#   add_test("conditional_pre_unless_not", :skip)
-#   add_test("const", :skip)
-#   add_test("constX", :skip)
-#   add_test("constY", :skip)
-#   add_test("constZ", :skip)
-#   add_test("cvar", :skip)
-#   add_test("cvasgn", :skip)
-#   add_test("cvasgn_cls_method", :skip)
-#   add_test("cvdecl", :skip)
-#   add_test("dasgn_0", :skip)
-#   add_test("dasgn_1", :skip)
-#   add_test("dasgn_2", :skip)
-#   add_test("dasgn_curr", :skip)
-#   add_test("dasgn_icky", :skip)
-#   add_test("dasgn_mixed", :skip)
-#   add_test("defined", :skip)
-#   add_test("defn_args_mand_opt_block", :skip)
-#   add_test("defn_args_mand_opt_splat", :skip)
-#   add_test("defn_args_mand_opt_splat_block", :skip)
-#   add_test("defn_args_mand_opt_splat_no_name", :skip)
-#   add_test("defn_args_opt_block", :skip)
-#   add_test("defn_args_opt_splat_no_name", :skip)
-#   add_test("defn_empty", :skip)
-#   add_test("defn_empty_args", :skip)
-#   add_test("defn_lvar_boundary", :skip)
-#   add_test("defn_optargs", :skip)
-#   add_test("defn_or", :skip)
-#   add_test("defn_rescue", :skip)
-#   add_test("defn_something_eh", :skip)
-#   add_test("defn_splat_no_name", :skip)
-#   add_test("defn_zarray", :skip)
-#   add_test("defs", :skip)
-#   add_test("defs_args_mand_opt_splat_block", :skip)
-#   add_test("defs_empty", :skip)
-#   add_test("defs_empty_args", :skip)
-#   add_test("dmethod", :skip)
-#   add_test("dot2", :skip)
-#   add_test("dot3", :skip)
-#   add_test("dregx", :skip)
-#   add_test("dregx_interp", :skip)
-#   add_test("dregx_n", :skip)
-#   add_test("dregx_once", :skip)
-#   add_test("dregx_once_n_interp", :skip)
-#   add_test("dstr", :skip)
-#   add_test("dstr_2", :skip)
-#   add_test("dstr_3", :skip)
-#   add_test("dstr_concat", :skip)
-#   add_test("dstr_heredoc_expand", :skip)
-#   add_test("dstr_heredoc_windoze_sucks", :skip)
-#   add_test("dstr_heredoc_yet_again", :skip)
-#   add_test("dstr_nest", :skip)
-#   add_test("dstr_str_lit_start", :skip)
-#   add_test("dstr_the_revenge", :skip)
-#   add_test("dsym", :skip)
-#   add_test("dxstr", :skip)
-#   add_test("ensure", :skip)
-#   add_test("false", :skip)
-#   add_test("fbody", :skip)
-#   add_test("fcall_arglist", :skip)
-#   add_test("fcall_arglist_hash", :skip)
-#   add_test("fcall_arglist_norm_hash", :skip)
-#   add_test("fcall_arglist_norm_hash_splat", :skip)
-#   add_test("fcall_block", :skip)
-#   add_test("fcall_index_space", :skip)
-#   add_test("fcall_keyword", :skip)
-#   add_test("flip2", :skip)
-#   add_test("flip2_method", :skip)
-#   add_test("flip3", :skip)
-#   add_test("for", :skip)
-#   add_test("for_no_body", :skip)
-#   add_test("gasgn", :skip)
-#   add_test("global", :skip)
-#   add_test("gvar", :skip)
-#   add_test("gvar_underscore", :skip)
-#   add_test("gvar_underscore_blah", :skip)
-#   add_test("hash", :skip)
-#   add_test("hash_rescue", :skip)
-#   add_test("iasgn", :skip)
-#   add_test("if_block_condition", :skip)
-#   add_test("if_lasgn_short", :skip)
-#   add_test("iteration1", :skip)
-#   add_test("iteration2", :skip)
-#   add_test("iteration3", :skip)
-#   add_test("iteration4", :skip)
-#   add_test("iteration5", :skip)
-#   add_test("iteration6", :skip)
-#   add_test("iteration7", :skip)
-#   add_test("iteration8", :skip)
-#   add_test("iteration9", :skip)
-#   add_test("iteration_dasgn_curr_dasgn_madness", :skip)
-#   add_test("iteration_double_var", :skip)
-#   add_test("iteration_masgn", :skip)
-#   add_test("ivar", :skip)
-#   add_test("lasgn_array", :skip)
-#   add_test("lasgn_call", :skip)
-#   add_test("lit_bool_false", :skip)
-#   add_test("lit_bool_true", :skip)
-#   add_test("lit_float", :skip)
-#   add_test("lit_long", :skip)
-#   add_test("lit_long_negative", :skip)
-#   add_test("lit_range2", :skip)
-#   add_test("lit_range3", :skip)
-#   add_test("lit_regexp", :skip)
-#   add_test("lit_regexp_i_wwtt", :skip)
-#   add_test("lit_regexp_n", :skip)
-#   add_test("lit_regexp_once", :skip)
-#   add_test("lit_sym", :skip)
-#   add_test("lit_sym_splat", :skip)
-#   add_test("lvar_def_boundary", :skip)
-#   add_test("masgn", :skip)
-#   add_test("masgn_argscat", :skip)
-#   add_test("masgn_attrasgn", :skip)
-#   add_test("masgn_iasgn", :skip)
-#   add_test("masgn_masgn", :skip)
-#   add_test("masgn_splat", :skip)
-#   add_test("masgn_splat_no_name_to_ary", :skip)
-#   add_test("masgn_splat_no_name_trailing", :skip)
-#   add_test("masgn_splat_to_ary", :skip)
-#   add_test("masgn_splat_to_ary2", :skip)
-#   add_test("match", :skip)
-#   add_test("match2", :skip)
-#   add_test("match3", :skip)
-#   add_test("module", :skip)
-#   add_test("module_scoped", :skip)
-#   add_test("module_scoped3", :skip)
-#   add_test("next", :skip)
-#   add_test("next_arg", :skip)
-#   add_test("not", :skip)
-#   add_test("nth_ref", :skip)
-#   add_test("op_asgn1", :skip)
-#   add_test("op_asgn2", :skip)
-#   add_test("op_asgn2_self", :skip)
-#   add_test("op_asgn_and", :skip)
-#   add_test("op_asgn_and_ivar2", :skip)
-#   add_test("op_asgn_or", :skip)
-#   add_test("op_asgn_or_block", :skip)
-#   add_test("op_asgn_or_ivar", :skip)
-#   add_test("op_asgn_or_ivar2", :skip)
-#   add_test("or", :skip)
-#   add_test("or_big", :skip)
-#   add_test("or_big2", :skip)
-#   add_test("parse_floats_as_args", :skip)
-#   add_test("postexe", :skip)
-#   add_test("proc_args_0", :skip)
-#   add_test("proc_args_1", :skip)
-#   add_test("proc_args_2", :skip)
-#   add_test("proc_args_no", :skip)
-#   add_test("redo", :skip)
-#   add_test("rescue", :skip)
-#   add_test("rescue_block_body", :skip)
-#   add_test("rescue_block_nada", :skip)
-#   add_test("rescue_exceptions", :skip)
-#   add_test("retry", :skip)
-#   add_test("return_0", :skip)
-#   add_test("return_1", :skip)
-#   add_test("return_n", :skip)
-#   add_test("sclass", :skip)
-#   add_test("sclass_trailing_class", :skip)
-#   add_test("splat", :skip)
-#   add_test("str", :skip)
-#   add_test("str_concat_newline", :skip)
-#   add_test("str_concat_space", :skip)
-#   add_test("str_heredoc", :skip)
-#   add_test("str_heredoc_call", :skip)
-#   add_test("str_heredoc_double", :skip)
-#   add_test("str_heredoc_indent", :skip)
-#   add_test("str_interp_file", :skip)
-#   add_test("structure_extra_block_for_dvar_scoping", :skip)
-#   add_test("structure_remove_begin_1", :skip)
-#   add_test("structure_remove_begin_2", :skip)
-#   add_test("structure_unused_literal_wwtt", :skip)
-#   add_test("super", :skip)
-#   add_test("super_block_pass", :skip)
-#   add_test("super_block_splat", :skip)
-#   add_test("super_multi", :skip)
-#   add_test("svalue", :skip)
-#   add_test("to_ary", :skip)
-#   add_test("true", :skip)
-#   add_test("undef", :skip)
-#   add_test("undef_2", :skip)
-#   add_test("undef_3", :skip)
-#   add_test("undef_block_1", :skip)
-#   add_test("undef_block_2", :skip)
-#   add_test("undef_block_3", :skip)
-#   add_test("undef_block_3_post", :skip)
-#   add_test("undef_block_wtf", :skip)
-#   add_test("until_post", :skip)
-#   add_test("until_post_not", :skip)
-#   add_test("until_pre", :skip)
-#   add_test("until_pre_mod", :skip)
-#   add_test("until_pre_not", :skip)
-#   add_test("until_pre_not_mod", :skip)
-#   add_test("valias", :skip)
-#   add_test("vcall", :skip)
-#   add_test("while_post", :skip)
-#   add_test("while_post_not", :skip)
-#   add_test("while_pre", :skip)
-#   add_test("while_pre_mod", :skip)
-#   add_test("while_pre_nil", :skip)
-#   add_test("while_pre_not", :skip)
-#   add_test("while_pre_not_mod", :skip)
-#   add_test("xstr", :skip)
-#   add_test("yield", :skip)
-#   add_test("yield_arg", :skip)  # TODO: make it always have an argslist
-#   add_test("yield_args", :skip) # TODO: array -> argslist
-#   add_test("zarray", :skip)
-#   add_test("zsuper", :skip)
-# end
+    input  = [:fcall, :m, [:array, [:lit, 42]]]
+    expect = s(:fcall, :m, s(:arglist, s(:lit, 42)))
 
+    assert_equal expect, u.process(input)
+  end
+
+  def test_process_bmethod
+    u = Unifier.new
+
+    raw = [:defn, :myproc3,
+           [:bmethod,
+            [:masgn, [:array,
+                      [:dasgn_curr, :a],
+                      [:dasgn_curr, :b],
+                      [:dasgn_curr, :c]],
+             nil, nil]]]
+
+    s = s(:defn, :myproc3,
+          s(:args, :a, :b, :c),
+          s(:scope, s(:block)))
+
+    assert_equal s, u.process(raw)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ParseTree
 version: !ruby/object:Gem::Version 
-  version: 3.0.1
+  version: 3.0.2
 platform: x86-mswin32-60
 authors: 
 - Ryan Davis
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-24 00:00:00 -03:00
+date: 2008-11-05 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -78,7 +78,7 @@ files:
 - test/test_parse_tree_extensions.rb
 - test/test_unified_ruby.rb
 - validate.sh
-- lib/inline/Inline_RawParseTree_fa12.so
+- lib/inline/Inline_RawParseTree_ab80.so
 has_rdoc: true
 homepage: http://rubyforge.org/projects/parsetree/
 post_install_message: 
@@ -103,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: parsetree
-rubygems_version: 1.3.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 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