ruby2ruby 1.1.9 → 1.2.0

data/.autotest

@@ -1,15 +1,21 @@
 # -*- ruby -*-
 
+require 'autotest/restart'
+
 Autotest.add_hook :initialize do |at|
   at.extra_files << "../../ParseTree/dev/test/pt_testcase.rb"
   at.extra_files << "../../ParseTree/dev/lib/unified_ruby.rb"
-  at.libs << ":../../ParseTree/dev/lib:../../ParseTree/dev/test"
+  at.libs << ":../../sexp_processor/dev/lib:../../ParseTree/dev/lib:../../ParseTree/dev/test"
 
   (1..4).each do |n|
     at.extra_class_map["TestRuby2Ruby#{n}"] = "test/test_ruby2ruby.rb"
   end
 
   at.add_mapping(/unified|pt_testcase/) do |f, _|
-    at.files_matching(/^test.*rb$/)
+    at.files_matching(/test.*rb$/)
   end
 end
+
+require 'autotest/rcov'
+Autotest::RCov.command = 'rcov_info'
+Autotest::RCov.pattern = 'test/test_ruby2ruby.rb'

data/History.txt

@@ -1,3 +1,10 @@
+=== 1.2.0 / 2008-10-22
+
+* 2 minor enhancements:
+
+  * Removed all PT dependent code to PT project (see parse_tree_extensions.rb).
+  * Revamped. Got working with new unified ruby output. Much much cleaner.
+
 === 1.1.9 / 2008-06-09
 
 * 5 minor enhancements:

data/Rakefile

@@ -1,24 +1,39 @@
 # -*- ruby -*-
 
-dirs = (%w(lib ../../ParseTree/dev/test) +
-        %w(ParseTree RubyInline ruby_parser).map { |p| "../../#{p}/dev/lib" })
-$:.push(*dirs)
-ENV['RUBY_FLAGS'] = "-I" + dirs.join(":")
-
 require 'rubygems'
 require 'hoe'
+
+Hoe.add_include_dirs("lib",
+                     "../../ZenTest/dev/lib",
+                     "../../ParseTree/dev/test",
+                     "../../ParseTree/dev/lib",
+                     "../../RubyInline/dev/lib",
+                     "../../ruby_parser/dev/lib",
+                     "../../sexp_processor/dev/lib")
+
 require './lib/ruby2ruby.rb'
 
-Hoe.new('ruby2ruby', RubyToRuby::VERSION) do |r2r|
+Hoe.new('ruby2ruby', Ruby2Ruby::VERSION) do |r2r|
   r2r.rubyforge_name = 'seattlerb'
   r2r.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
 
   r2r.clean_globs << File.expand_path("~/.ruby_inline")
-  r2r.extra_deps << "ParseTree"
-
-  r2r.multiruby_skip << "rubinius"
+  r2r.extra_deps << ["ParseTree", "~> 3.0"]
 end
 
 task :test => :clean
 
+task :rcov_info do
+  pat = ENV['PATTERN'] || "test/test_*.rb"
+  ruby "#{Hoe::RUBY_FLAGS} -S rcov --text-report --save coverage.info #{pat}"
+end
+
+task :rcov_overlay do
+  rcov, eol = Marshal.load(File.read("coverage.info")).last[ENV["FILE"]], 1
+  puts rcov[:lines].zip(rcov[:coverage]).map { |line, coverage|
+    bol, eol = eol, eol + line.length
+    [bol, eol, "#ffcccc"] unless coverage
+  }.compact.inspect
+end
+
 # vim: syntax=Ruby

data/lib/ruby2ruby.rb

@@ -5,9 +5,7 @@ require 'sexp_processor'
 require 'unified_ruby'
 
 class Ruby2Ruby < SexpProcessor
-  include UnifiedRuby
-
-  VERSION = '1.1.9'
+  VERSION = '1.2.0'
   LINE_LENGTH = 78
 
   ##
@@ -19,6 +17,7 @@ class Ruby2Ruby < SexpProcessor
                   :flip3,
                   :lasgn,
                   :masgn,
+                  :attrasgn,
                   :op_asgn1,
                   :op_asgn2,
                   :op_asgn_and,
@@ -28,7 +27,9 @@ class Ruby2Ruby < SexpProcessor
 
   def self.translate(klass_or_str, method = nil)
     require 'parse_tree'
-    self.new.process(ParseTree.translate(klass_or_str, method))
+    sexp = ParseTree.translate(klass_or_str, method)
+    sexp = Unifier.new.process(sexp)
+    self.new.process(sexp)
   end
 
   def initialize
@@ -41,11 +42,6 @@ class Ruby2Ruby < SexpProcessor
     # self.debug[:defn] = /zsuper/
   end
 
-  def process exp
-    exp = Sexp.from_array(exp) if Array === exp unless Sexp === exp
-    super exp
-  end
-
   ############################################################
   # Processors
 
@@ -57,6 +53,14 @@ class Ruby2Ruby < SexpProcessor
     "(#{process exp.shift} and #{process exp.shift})"
   end
 
+  def process_arglist(exp) # custom made node
+    code = []
+    until exp.empty? do
+      code << process(exp.shift)
+    end
+    code.join ', '
+  end
+
   def process_args(exp)
     args = []
 
@@ -76,8 +80,6 @@ class Ruby2Ruby < SexpProcessor
           args.each_with_index do |name, index|
             args[index] = asgns[name] if asgns.has_key? name
           end
-        when :block_arg then
-          args << "&#{arg.last}"
         else
           raise "unknown arg type #{arg.first.inspect}"
         end
@@ -89,33 +91,6 @@ class Ruby2Ruby < SexpProcessor
     return "(#{args.join ', '})"
   end
 
-  def process_arglist(exp) # custom made node
-    code = []
-    until exp.empty? do
-      code << process(exp.shift)
-    end
-    code.join ', '
-  end
-
-  def process_argscat(exp)
-    args = []
-
-    ary = exp.shift
-    ary.shift # :array
-    until ary.empty? do
-      args << process(ary.shift)
-    end
-
-    args << "*#{process(exp.shift)}"
-    args << process(exp.shift) unless exp.empty? # optional block arg
-
-    args.join ', '
-  end
-
-  def process_argspush(exp)
-    process_arglist(exp)
-  end
-
   def process_array(exp)
     "[#{process_arglist(exp)}]"
   end
@@ -128,13 +103,11 @@ class Ruby2Ruby < SexpProcessor
     case name
     when :[]= then
       rhs = process args.pop
-      args[0] = :arglist if args[0] == :array
       "#{receiver}[#{process(args)}] = #{rhs}"
     else
-      if args then
-        "#{receiver}.#{name.to_s[0..-2]} = #{process(args)[1..-2]}"
-      else
-        "#{receiver}.#{name.to_s[0..-2]}"
+      name = name.to_s.sub(/=$/, '')
+      if args && args != s(:arglist) then
+        "#{receiver}.#{name} = #{process(args)}"
       end
     end
   end
@@ -143,16 +116,16 @@ class Ruby2Ruby < SexpProcessor
     "$#{exp.shift}"
   end
 
+  # TODO: figure out how to do rescue and ensure ENTIRELY w/o begin
   def process_begin(exp)
-    is_rescue = exp.first.first == :rescue rescue false
     code = []
     code << "begin"
     until exp.empty?
       src = process(exp.shift)
-      src = indent(src) unless src =~ /(^|\n)rescue/ # ensures no level 0 rescues
+      src = indent(src) unless src =~ /(^|\n)rescue/ # ensure no level 0 rescues
       code << src
     end
-    code << "end" unless is_rescue
+    code << "end"
     return code.join("\n")
   end
 
@@ -181,30 +154,10 @@ class Ruby2Ruby < SexpProcessor
     return result
   end
 
-  def process_block_arg(exp)
-    "&#{exp.shift}"
-  end
-
-  def process_block_pass(exp)
-    bname = s(:block_arg, process(exp.shift)) # FIX
-    call = exp.shift
-
-    if Array === call.last then # HACK - I _really_ need rewrites to happen first
-      case call.last.first
-      when :splat then
-        call << [:array, call.pop]
-      when :array then
-        # do nothing
-      else
-        has_args = Array === call.last and call.last.first == :array
-        call << [:array] unless has_args
-      end
-      call.last << bname
-    else
-      call << [:array, bname]
-    end
+  def process_block_pass exp
+    raise "huh?: #{exp.inspect}" if exp.size > 1
 
-    process(call)
+    "&#{process exp.shift}"
   end
 
   def process_break(exp)
@@ -276,8 +229,12 @@ class Ruby2Ruby < SexpProcessor
   def process_cdecl(exp)
     lhs = exp.shift
     lhs = process lhs if Sexp === lhs
-    rhs = process exp.shift
-    "#{lhs} = #{rhs}"
+    unless exp.empty? then
+      rhs = process(exp.shift)
+      "#{lhs} = #{rhs}"
+    else
+      lhs.to_s
+    end
   end
 
   def process_class(exp)
@@ -308,34 +265,6 @@ class Ruby2Ruby < SexpProcessor
     "#{exp.shift} = #{process(exp.shift)}"
   end
 
-  # (a, lit1)      => "a = 1"
-  # (a, (b, lit2)) => "a = b = 2"
-  # (a, (b))       => ""
-
-  def process_dasgn_curr(exp)
-    lhs = exp.shift.to_s
-    rhs = (exp.empty? ? nil : exp.shift)
-    if rhs.nil? then
-      if self.context[1] == :block then
-        return ''
-      end
-
-      return lhs
-    end
-    return "#{lhs} = #{process rhs}" unless rhs.first == :dasgn_curr
-
-    # keep recursing. ensure that the leaf node assigns to _something_
-    "#{lhs} = #{process rhs}"
-  end
-
-  def process_dasgn(exp)
-    if exp.size == 1 then
-      exp.shift.to_s
-    else
-      "#{exp.shift} = #{process(exp.shift)}"
-    end
-  end
-
   def process_defined(exp)
     "defined? #{process(exp.shift)}"
   end
@@ -371,7 +300,14 @@ class Ruby2Ruby < SexpProcessor
   end
 
   def process_defs(exp)
-    exp.unshift "#{process(exp.shift)}.#{exp.shift}"
+    lhs  = exp.shift
+    var = [:self, :cvar, :dvar, :ivar, :gvar, :lvar].include? lhs.first
+    name = exp.shift
+
+    lhs = process(lhs)
+    lhs = "(#{lhs})" unless var
+
+    exp.unshift "#{lhs}.#{name}"
     process_defn(exp)
   end
 
@@ -399,41 +335,29 @@ class Ruby2Ruby < SexpProcessor
     ":#{process_dstr(exp)}"
   end
 
-  def process_dvar(exp)
-    exp.shift.to_s
-  end
-
   def process_dxstr(exp)
     "`#{process_dstr(exp)[1..-2]}`"
   end
 
   def process_ensure(exp)
     body = process exp.shift
-    ens  = process exp.shift
+    ens  = exp.shift
+    ens  = nil if ens == s(:nil)
+    ens  = process(ens) || "# do nothing"
+
+    body.sub!(/\n\s*end\z/, '')
+
     return "#{body}\nensure\n#{indent ens}"
   end
 
   def process_evstr(exp)
-    process exp.shift
+    exp.empty? ? '' : process(exp.shift)
   end
 
   def process_false(exp)
     "false"
   end
 
-  # TODO: remove for unified
-  def process_fcall(exp)
-    recv = exp.shift unless Symbol === exp.first # HACK conditional - some not getting rewritten?
-    name = exp.shift.to_s
-    args = exp.shift
-    code = []
-    unless args.nil? then
-      args[0] = :arglist if args.first == :array
-      code << process(args)
-    end
-    return code.empty? ? name : "#{name}(#{code.join(', ')})"
-  end
-
   def process_flip2(exp)
     "#{process(exp.shift)}..#{process(exp.shift)}"
   end
@@ -465,7 +389,13 @@ class Ruby2Ruby < SexpProcessor
   def process_hash(exp)
     result = []
     until exp.empty?
-      result << "#{process(exp.shift)} => #{process(exp.shift)}"
+      lhs = process(exp.shift)
+      rhs = exp.shift
+      t = rhs.first
+      rhs = process rhs
+      rhs = "(#{rhs})" unless [:lit, :str].include? t # TODO: verify better!
+
+      result << "#{lhs} => #{rhs}"
     end
 
     case self.context[1]
@@ -588,7 +518,7 @@ class Ruby2Ruby < SexpProcessor
     rhs = exp.empty? ? nil : exp.shift
 
     unless exp.empty? then
-      rhs[-1] = splat(rhs[-1]) unless rhs == s(:splat)
+      rhs[1] = splat(rhs[1]) unless rhs == s(:splat)
       lhs << rhs
       rhs = exp.shift
     end
@@ -604,7 +534,7 @@ class Ruby2Ruby < SexpProcessor
           process(l)
         end
       end
-    when :dasgn_curr then
+    when :lasgn then
       lhs = [ splat(lhs.last) ]
     when :splat then
       lhs = [ :"*" ]
@@ -613,20 +543,14 @@ class Ruby2Ruby < SexpProcessor
     end
 
     if context[1] == :iter and rhs then
-      lhs << splat(rhs.last)
+      lhs << splat(rhs[1])
       rhs = nil
     end
 
     unless rhs.nil? then
       t = rhs.first
-      rhs = if t == :argscat then
-              rhs.shift
-              process_argscat(rhs)
-            else
-              r = process(rhs)
-              r = r[1..-2] if t != :to_ary
-              r
-            end
+      rhs = process rhs
+      rhs = rhs[1..-2] if t != :to_ary
       return "#{lhs.join(", ")} = #{rhs}"
     else
       return lhs.join(", ")
@@ -676,13 +600,13 @@ class Ruby2Ruby < SexpProcessor
   end
 
   def process_op_asgn1(exp)
-    # [[:lvar, :b], [:array, [:lit, 1]], :"||", [:lit, 10]]
+    # [[:lvar, :b], [:arglist, [:lit, 1]], :"||", [:lit, 10]]
     lhs = process(exp.shift)
     index = process(exp.shift)
     msg = exp.shift
     rhs = process(exp.shift)
 
-    "#{lhs}#{index} #{msg}= #{rhs}"
+    "#{lhs}[#{index}] #{msg}= #{rhs}"
   end
 
   def process_op_asgn2(exp)
@@ -696,18 +620,18 @@ class Ruby2Ruby < SexpProcessor
     "#{lhs}.#{index} #{msg}= #{rhs}"
   end
 
-  def process_op_asgn_or(exp)
-    # a ||= 1
+  def process_op_asgn_and(exp)
+    # a &&= 1
     # [[:lvar, :a], [:lasgn, :a, [:lit, 1]]]
     exp.shift
-    process(exp.shift).sub(/=/, '||=')
+    process(exp.shift).sub(/\=/, '&&=')
   end
 
-  def process_op_asgn_and(exp)
-    # a &&= 1
+  def process_op_asgn_or(exp)
+    # a ||= 1
     # [[:lvar, :a], [:lasgn, :a, [:lit, 1]]]
     exp.shift
-    process(exp.shift).sub(/=/, '&&=')
+    process(exp.shift).sub(/\=/, '||=')
   end
 
   def process_or(exp)
@@ -722,97 +646,40 @@ class Ruby2Ruby < SexpProcessor
     "redo"
   end
 
-  def process_resbody(exp) # TODO: rewrite this fucker
-    code = []
-
-    sexp = exp
-    until exp.empty? and (sexp.nil? or sexp.empty?)
-      list = sexp.shift
-      body = sexp.shift
-
-      var = if list and
-                list.size > 1 and
-                [:lasgn, :dasgn, :dasgn_curr].include? list.last.first then
-              list.pop[1]
-            else
-              nil
-            end
-
-      # FIX: omg this is horrid. I should be punished
-      var = body.delete_at(1)[1] if
-        [:dasgn_curr, :dasgn].include? body[1][0] unless
-        var or body.nil? rescue nil
-
-      if list and list.size > 1 then
-        list[0] = :arglist
-        code << "rescue #{process(list)}"
-      else
-        code << "rescue"
-      end
-
-      code.last << " => #{var}" if var
-
-      if body then
-        code << indent(process(body)).chomp
-      else
-        code << indent("# do nothing")
-      end
+  def process_resbody exp
+    args = exp.shift
+    body = process(exp.shift) || "# do nothing"
 
-      unless exp.empty? then
-        sexp = exp.shift
-        assert_type sexp, :resbody
-        sexp.shift
-      end
-    end
+    name =   args.lasgn true
+    name ||= args.iasgn true
+    args = process(args)[1..-2]
+    args = " #{args}" unless args.empty?
+    args += " => #{name[1]}" if name
 
-    code.join("\n")
+    "rescue#{args}\n#{indent body}"
   end
 
-  def process_rescue(exp)
-    # TODO: rewrite this
-    #
-    # a = b rescue c            =>                [lasgn a [rescue b c]]
-    # begin; a = b; rescue c    => [begin [rescue [lasgn a b] c]]
-
-    current = self.context[1]
-    case current
-    when :begin, :ensure, :block then
-      body = (exp.first.first == :resbody) ? nil : process(exp.shift)
-      resbody = exp.empty? ? '' : process(exp.shift)
-      els = exp.empty? ? nil : process(exp.shift)
-
-      code = []
-      code << indent(body) if body
-      code << resbody
-      if els then
-        code << "else"
-        code << indent(els)
-      else
-        unless [:block].include? current then
-          code << "end\n" unless current == :ensure
-        else
-          r = [body, resbody.gsub(/rescue\n\s+/, 'rescue ')].compact.join(' ')
-          code = [r] if (@indent+r).size < LINE_LENGTH and r !~ /\n/
-        end
-      end
+  def process_rescue exp
+    body = process(exp.shift) unless exp.first.first == :resbody
+    els  = process(exp.pop)   unless exp.last.first  == :resbody
+
+    body ||= "# do nothing"
+    simple = exp.size == 1
 
-      code.join("\n").chomp
-    else # a rescue b and others
-      body = process exp.shift
-      assert_type exp.first, :resbody
+    resbodies = []
+    until exp.empty? do
       resbody = exp.shift
-      resbody.shift # resbody
-      resbody.shift # nil (no types for expression form)
-      resbody = resbody.shift # actual code
-
-      resbody = process resbody
-      code = "#{body} rescue #{resbody}"
-      case current
-      when :hash then # HACK move to process_hash
-        "(#{code})"
-      else
-        code
-      end
+      simple &&= resbody[1] == s(:array) && resbody[2] != nil
+      resbodies << process(resbody)
+    end
+
+    if els then
+      "#{indent body}\n#{resbodies.join("\n")}\nelse\n#{indent els}"
+    elsif simple then
+      resbody = resbodies.first.sub(/\n\s*/, ' ')
+      "#{body} #{resbody}"
+    else
+      "#{indent body}\n#{resbodies.join("\n")}"
     end
   end
 
@@ -855,13 +722,20 @@ class Ruby2Ruby < SexpProcessor
   end
 
   def process_super(exp)
-    args = exp.shift
-    args[0] = :arglist if args[0] == :array
-    "super(#{process(args)})"
+    args = []
+    until exp.empty? do
+      args << process(exp.shift)
+    end
+
+    "super(#{args.join(', ')})"
   end
 
   def process_svalue(exp)
-    process(exp.shift)
+    code = []
+    until exp.empty? do
+      code << process(exp.shift)
+    end
+    code.join(", ")
   end
 
   def process_to_ary(exp)
@@ -912,24 +786,18 @@ class Ruby2Ruby < SexpProcessor
   end
 
   def process_yield(exp)
-    args = exp.empty? ? nil : exp.shift
-    if args then
-      args[0] = :arglist if args.first == :array
-      args = process(args)
+    args = []
+    until exp.empty? do
+      args << process(exp.shift)
     end
 
-    # "yield" + (args ? "(#{args})" : "")
-    if args then
-      "yield(#{args})"
+    unless args.empty? then
+      "yield(#{args.join(', ')})"
     else
       "yield"
     end
   end
 
-  def process_zarray(exp)
-    "[]"
-  end
-
   def process_zsuper(exp)
     "super"
   end
@@ -957,24 +825,52 @@ class Ruby2Ruby < SexpProcessor
   ############################################################
   # Rewriters:
 
+  def rewrite_attrasgn exp
+    if context.first(2) == [:array, :masgn] then
+      exp[0] = :call
+      exp[2] = exp[2].to_s.sub(/=$/, '').to_sym
+    end
+
+    exp
+  end
+
+  def rewrite_ensure exp
+    exp = s(:begin, exp) unless context.first == :begin
+    exp
+  end
+
   def rewrite_rescue exp
-    exp = s(:begin, exp) if
-      context[1] == :block unless
-      context[2] == :scope and [:defn, :defs].include? context[3]
+    complex = false
+    complex ||= exp.size > 3
+    complex ||= exp.block
+    complex ||= exp.find_nodes(:resbody).any? { |n| n.array != s(:array) }
+    complex ||= exp.find_nodes(:resbody).any? { |n| n.last.nil? }
+
+    handled = context.first == :ensure
+
+    exp = s(:begin, exp) if complex unless handled
+
     exp
   end
 
+  def rewrite_svalue(exp)
+    case exp.last.first
+    when :array
+      s(:svalue, *exp[1][1..-1])
+    when :splat
+      exp
+    else
+      raise "huh: #{exp.inspect}"
+    end
+  end
+
   ############################################################
   # Utility Methods:
 
   def util_dthing(exp, regx = false)
     s = []
     suck = true
-    if suck then
-      x = exp.shift.gsub(/"/, '\"').gsub(/\n/, '\n')
-    else
-      x = exp.shift.dump[1..-2]
-    end
+    x = exp.shift.gsub(/"/, '\"').gsub(/\n/, '\n')
     x.gsub!(/\//, '\/') if regx
 
     s << x
@@ -984,18 +880,15 @@ class Ruby2Ruby < SexpProcessor
       when Sexp then
         case pt.first
         when :str then
-          if suck then
-            x = pt.last.gsub(/"/, '\"').gsub(/\n/, '\n')
-          else
-            x = pt.last.dump[1..-2]
-          end
+          x = pt.last.gsub(/"/, '\"').gsub(/\n/, '\n')
           x.gsub!(/\//, '\/') if regx
           s << x
         else
           s << '#{' << process(pt) << '}' # do not use interpolation here
         end
       else
-        # do nothing - yet
+        # HACK: raise "huh?: #{pt.inspect}"
+        # do nothing for now
       end
     end
 
@@ -1038,71 +931,3 @@ class Ruby2Ruby < SexpProcessor
     s.to_s.split(/\n/).map{|line| @indent + line}.join("\n")
   end
 end
-
-RubyToRuby = Ruby2Ruby # For backwards compatibilty... TODO: remove 2008-03-28
-
-class Method
-  def with_class_and_method_name
-    if self.inspect =~ /<Method: (.*)\#(.*)>/ then
-      klass = eval $1
-      method  = $2.intern
-      raise "Couldn't determine class from #{self.inspect}" if klass.nil?
-      return yield(klass, method)
-    else
-      raise "Can't parse signature: #{self.inspect}"
-    end
-  end
-
-  def to_sexp
-    require 'parse_tree'
-    parser = ParseTree.new(false)
-    with_class_and_method_name do |klass, method|
-      parser.parse_tree_for_method(klass, method)
-    end
-  end
-
-  def to_ruby
-    Ruby2Ruby.new.process(self.to_sexp)
-  end
-end
-
-class ProcStoreTmp
-  @@n = 0
-  def self.new_name
-    @@n += 1
-    return :"myproc#{@@n}"
-  end
-end
-
-class UnboundMethod
-  def to_ruby
-    name = ProcStoreTmp.new_name
-    ProcStoreTmp.send(:define_method, name, self)
-    m = ProcStoreTmp.new.method(name)
-    result = m.to_ruby.sub(/def #{name}(?:\(([^\)]*)\))?/,
-                           'proc { |\1|').sub(/end\Z/, '}')
-    return result
-  end
-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[2]
-    body[0] = :block
-    args = body.delete_at 1
-    body = body[1] if body.size == 2
-
-    [:iter, [:fcall, :proc], args, body]
-  end
-
-  def to_ruby
-    Ruby2Ruby.new.process(self.to_sexp).sub(/^\Aproc do/, 'proc {').sub(/end\Z/, '}')
-  end
-end

data/test/test_ruby2ruby.rb

@@ -14,8 +14,29 @@ require 'tmpdir'
 
 FileUtils.rm_rf File.expand_path("~/.ruby_inline") # for self-translation
 
-class TestRuby2Ruby < Test::Unit::TestCase
+class R2RTestCase < ParseTreeTestCase
+  def self.previous key
+    "ParseTree"
+  end
+
+  def self.generate_test klass, node, data, input_name, output_name
+    output_name = data.has_key?('Ruby2Ruby') ? 'Ruby2Ruby' : 'Ruby'
+
+    klass.class_eval <<-EOM
+      def test_#{node}
+        pt = #{data[input_name].inspect}
+        rb = #{data[output_name].inspect}
+
+        refute_nil pt, \"ParseTree for #{node} undefined\"
+        refute_nil rb, \"Ruby for #{node} undefined\"
+
+        assert_equal rb, @processor.process(pt)
+      end
+    EOM
+  end
+end
 
+class TestRuby2Ruby < R2RTestCase
   alias :refute_nil :assert_not_nil unless defined? Mini
 
   def setup
@@ -30,35 +51,6 @@ class TestRuby2Ruby < Test::Unit::TestCase
     end if defined?(@rootdir) && @rootdir
   end
 
-  def util_setup_inline
-    @rootdir = File.join(Dir.tmpdir, "test_ruby_to_ruby.#{$$}")
-    Dir.mkdir @rootdir, 0700 unless test ?d, @rootdir
-    ENV['INLINEDIR'] = @rootdir
-  end
-
-  def test_proc_to_ruby
-    util_setup_inline
-    block = proc { puts "something" }
-    assert_equal 'proc { puts("something") }', block.to_ruby
-  end unless SKIP_PROCS
-
-  def test_lit_regexp_slash
-    inn = s(:lit, /blah\/blah/)
-    out = '/blah\/blah/'
-
-    assert_equal out, @processor.process(inn)
-
-    r = eval(out)
-    assert_equal(/blah\/blah/, r)
-  end
-
-  def util_thingy(type)
-    s(type,
-      'blah"blah',
-      s(:call, s(:lit, 1), :+, s(:array, s(:lit, 1))),
-      s(:str, 'blah"blah/blah'))
-  end
-
   def test_dregx_slash
     inn = util_thingy(:dregx)
     out = "/blah\\\"blah#\{(1 + 1)}blah\\\"blah\\/blah/"
@@ -89,58 +81,59 @@ class TestRuby2Ruby < Test::Unit::TestCase
     assert_equal :"blah\"blah2blah\"blah/blah", r
   end
 
-  def test_proc_to_sexp
-    util_setup_inline
-    p = proc { 1 + 1 }
-    s = [:iter, [:fcall, :proc], nil, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]]
-    assert_equal s, p.to_sexp
-  end unless SKIP_PROCS
-
-  def test_unbound_method_to_ruby
-    util_setup_inline
-    r = "proc { ||\n  util_setup_inline\n  p = proc { (1 + 1) }\n  s = [:iter, [:fcall, :proc], nil, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]]\n  assert_equal(s, p.to_sexp)\n}"
-    m = self.class.instance_method(:test_proc_to_sexp)
-
-    assert_equal r, m.to_ruby
-  end unless SKIP_PROCS
+  def test_lit_regexp_slash
+    inn = s(:lit, /blah\/blah/)
+    out = '/blah\/blah/'
 
-  eval ParseTreeTestCase.testcases.map { |node, data|
-    next if node == "vcall" # HACK
+    assert_equal out, @processor.process(inn)
 
-    "def test_#{node}
-       pt = #{data['ParseTree'].inspect}
-       rb = #{(data['Ruby2Ruby'] || data['Ruby']).inspect}
+    r = eval(out)
+    assert_equal(/blah\/blah/, r)
+  end
 
-       refute_nil pt, \"ParseTree for #{node} undefined\"
-       refute_nil rb, \"Ruby for #{node} undefined\"
+  def util_setup_inline
+    @rootdir = File.join(Dir.tmpdir, "test_ruby_to_ruby.#{$$}")
+    Dir.mkdir @rootdir, 0700 unless test ?d, @rootdir
+    ENV['INLINEDIR'] = @rootdir
+  end
 
-       assert_equal rb, @processor.process(pt)
-     end"
-  }.join("\n")
+  def util_thingy(type)
+    s(type,
+      'blah"blah',
+      s(:call, s(:lit, 1), :+, s(:array, s(:lit, 1))),
+      s(:str, 'blah"blah/blah'))
+  end
 end
 
 ##
 # Converts a +target+ using a +processor+ and converts +target+ name
 # in the source adding +gen+ to allow easy renaming.
 
+$broken = false
 def morph_and_eval(processor, target, gen, n)
+  return if $broken
   begin
     processor = Object.const_get processor if Symbol === processor
     target    = Object.const_get target    if Symbol === target
     old_name  = target.name
     new_name  = target.name.sub(/\d*$/, gen.to_s)
-    ruby = processor.translate(target).sub(old_name, new_name)
+    ruby      = processor.translate(target).sub(old_name, new_name)
 
+    old, $-w = $-w, nil
     eval ruby
+    $-w = old
+
     target.constants.each do |constant|
       eval "#{new_name}::#{constant} = #{old_name}::#{constant}"
     end
   rescue Exception => e
     warn "Self-Translation Generation #{n} failed:"
     warn "#{e.class}: #{e.message}"
+    warn e.backtrace.join("\n  ")
     warn ""
     warn ruby
     warn ""
+    $broken = true
   else
     begin
       yield if block_given?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby2ruby
 version: !ruby/object:Gem::Version 
-  version: 1.1.9
+  version: 1.2.0
 platform: ruby
 authors: 
 - Ryan Davis
@@ -9,26 +9,28 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-09 00:00:00 -07:00
+date: 2008-10-22 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: ParseTree
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: "3.0"
     version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
+  type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.5.3
+        version: 1.8.0
     version: 
 description: ruby2ruby provides a means of generating pure ruby code easily from ParseTree's Sexps. This makes making dynamic language processors much easier in ruby than ever before.
 email: 
@@ -73,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: seattlerb
-rubygems_version: 1.1.1
+rubygems_version: 1.3.0
 signing_key: 
 specification_version: 2
 summary: ruby2ruby provides a means of generating pure ruby code easily from ParseTree's Sexps