ruby2ruby 1.1.7 → 1.1.8

data/.autotest

@@ -0,0 +1,15 @@
+# -*- ruby -*-
+
+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"
+
+  (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$/)
+  end
+end

data/History.txt

@@ -1,15 +1,36 @@
+=== 1.1.8 / 2007-08-21
+
+* 6 minor enhancements:
+
+  * Added super awesome .autotest file. YAY!
+  * Removed nil.method_missing... too many ppl bitching about it.
+  * Renamed RubyToRuby (the class name) to Ruby2Ruby.
+  * Restructured self-translation tests so they were friendlier when dying.
+  * Strings are now always one line long only.
+  * Fully in sync with ParseTree and ruby_parser.
+
+* 2 bug fixes:
+
+  * Fixed a number of issues/bugs discovered via ruby_parser.
+  * Cleaned out some dead code and hacks we don't need anymore.
+
 === 1.1.7 / 2007-08-21
 
 * 2 major enhancements:
+
   * Switched to ParseTree's UnifiedRuby... much much cleaner now!
   * Made test_ruby2ruby MUCH more rigorous with circular testing.
+
 * 5 minor enhancements:
+
   * Add r2r_show command like parse_tree_show.
   * Add parens for :block nodes as appropriate. May be overzealous.
   * Make SexpAny work with #==.
   * Removed calls to processor_stack / caller in favor of self.context.
   * Some style differences, eschew rescue.
+
 * 6 bug fixes:
+
   * Fix R2R bug with masgn/argscat.
   * Fixed a bug with new resbody unification.
   * Fixes for changes to pt_testcase.
@@ -20,19 +41,25 @@
 === 1.1.6 / 2007-06-05
 
 * 2 minor enhancements:
+
   * Extended tests for dstr/dsym/drgx to test against embedded slashes and quotes.
   * Updated for dasgn_curr changes to PT.
+
 * 2 bug fixes:
+
   * Fixed a bug with begin/rescue/ensure.
   * Fixed argscat and blockpass bug. blah(42, *args, &block) handled.
 
 === 1.1.5 / 2007-02-13
 
 * 3 minor enhancements:
+
   * Can now heckle ActiveRecord::Base in full.
   * Cleaned up 1-liner generating code.
   * Made clean/simple rescues 1-liners.
+
 * 7 bug fixes:
+
   * Finally got the rest of block_pass working.
   * Fixed block_pass on procs in iters. UGH!
   * Fixed attrasgn in masgn.
@@ -44,11 +71,14 @@
 === 1.1.4 / 2007-01-15
 
 * 4 minor enhancements:
+
   * Added some extra rewriting code and tests for various bmethods. Ugh.
   * Added support for splatted block args.
   * Refactored class/module and dsym/dstr.
   * Short if/unless statements are now post-conditional expressions.
+
 * 4 bug fixes:
+
   * Finally fixed eric's nebulous proc code-in-goalposts bug.
   * Fixed dasgn_curr so block's dasgn vars decl goes away (bug 7420).
   * Fixed dmethod. I think the tests were bogus before.
@@ -57,16 +87,22 @@
 === 1.1.3 / 2006-12-20
 
 * 1 minor enhancement
+
   * Unit tests do self-translation and retesting for 3 generations! Solid. BAM!
+
 * 1 bug fixes
+
   * iasgn inside masgn was totally borked in ruby2ruby.
 
 === 1.1.2 / 2006-12-19
 
 * 2 minor enhancements
+
   * Improved []= and [] to be more idiomatic.
   * Support for nested whens (from when case has no expression).
+
 * 3 bug fixes
+
   * Fixed case output when there is no case expression.
   * NEARLY have RubyToRuby self-cloning and passing tests again.
   * Minor cleanup
@@ -74,6 +110,7 @@
 === 1.1.1 / 2006-11-13
 
 * 3 bug fixes
+
   * Fixed procs
   * Cleaned return when no return values.
   * Rewrote process_if. No more elsif but no more bugs. :)
@@ -81,7 +118,6 @@
 === 1.1.0 / 2006-10-11
 
 * 2 major enhancements
+
   * Released separately from ZenHacks.
   * Major overhaul/audit from the new ParseTree test infrastructure. Very complete now.
-
-

data/Manifest.txt

@@ -1,3 +1,4 @@
+.autotest
 History.txt
 Manifest.txt
 README.txt

data/README.txt

@@ -28,7 +28,7 @@ easier in ruby than ever before.
 
 (The MIT License)
 
-Copyright (c) 2006 Ryan Davis
+Copyright (c) 2006-2007 Ryan Davis
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -13,7 +13,7 @@ Hoe.new('ruby2ruby', RubyToRuby::VERSION) do |p|
   p.summary = 'ruby2ruby provides a means of generating pure ruby code easily from ParseTree\'s Sexps.'
   p.description = p.paragraphs_of('README.txt', 2).join
   p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1].map {|u| u.strip }
-  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.changes = p.paragraphs_of('History.txt', 0..4).join("\n\n")
   p.clean_globs << File.expand_path("~/.ruby_inline")
   p.extra_deps << "ParseTree"
 end

data/lib/ruby2ruby.rb

@@ -5,16 +5,10 @@ require 'parse_tree'
 require 'sexp_processor'
 require 'unified_ruby'
 
-class NilClass # Objective-C trick
-  def method_missing(msg, *args, &block)
-    nil
-  end
-end
-
-class RubyToRuby < SexpProcessor
+class Ruby2Ruby < SexpProcessor
   include UnifiedRuby
 
-  VERSION = '1.1.7'
+  VERSION = '1.1.8'
   LINE_LENGTH = 78
 
   ##
@@ -84,17 +78,6 @@ class RubyToRuby < SexpProcessor
           end
         when :block_arg then
           args << "&#{arg.last}"
-        when :array then
-          names = arg
-          vals  = exp.shift
-          names.shift
-          vals.shift
-          v_size = vals.size
-
-          args << process(names.shift) until names.size == v_size
-          names.zip(vals) do |name, val|
-            args << "#{process name} = #{process val}"
-          end
         else
           raise "unknown arg type #{arg.first.inspect}"
         end
@@ -130,13 +113,7 @@ class RubyToRuby < SexpProcessor
   end
 
   def process_argspush(exp)
-    args = []
-
-    until exp.empty? do
-      args << process(exp.shift)
-    end
-
-    "#{args.join ', '}"
+    process_arglist(exp)
   end
 
   def process_array(exp)
@@ -151,7 +128,7 @@ class RubyToRuby < SexpProcessor
     case name
     when :[]= then
       rhs = process args.pop
-      args[0] = :arglist
+      args[0] = :arglist if args[0] == :array
       "#{receiver}[#{process(args)}] = #{rhs}"
     else
       if args then
@@ -172,7 +149,7 @@ class RubyToRuby < SexpProcessor
     code << "begin"
     until exp.empty?
       src = process(exp.shift)
-      src = indent(src) unless src =~ /\nrescue/ # ensures no level 0 rescues
+      src = indent(src) unless src =~ /(^|\n)rescue/ # ensures no level 0 rescues
       code << src
     end
     code << "end" unless is_rescue
@@ -182,6 +159,7 @@ class RubyToRuby < SexpProcessor
   def process_block(exp)
     result = []
 
+    exp << nil if exp.empty?
     until exp.empty? do
       code = exp.shift
       if code.nil? or code.first == :nil then
@@ -240,11 +218,11 @@ class RubyToRuby < SexpProcessor
   end
 
   def process_call(exp)
-    receiver_node_type = exp.first.first
+    receiver_node_type = exp.first.nil? ? nil : exp.first.first
     receiver = process exp.shift
 
     receiver = "(#{receiver})" if
-      RubyToRuby::ASSIGN_NODES.include? receiver_node_type
+      Ruby2Ruby::ASSIGN_NODES.include? receiver_node_type
 
     name = exp.shift
     args_exp = exp.shift rescue nil
@@ -256,7 +234,7 @@ class RubyToRuby < SexpProcessor
     end
 
     case name
-    when :<=>, :==, :<, :>, :<=, :>=, :-, :+, :*, :/, :%, :<<, :>> then #
+    when :<=>, :==, :<, :>, :<=, :>=, :-, :+, :*, :/, :%, :<<, :>>, :** then
       "(#{receiver} #{name} #{args})"
     when :[] then
       "#{receiver}[#{args}]"
@@ -333,34 +311,32 @@ class RubyToRuby < SexpProcessor
 
   def process_dasgn_curr(exp)
     lhs = exp.shift.to_s
-    rhs = exp.shift rescue nil
-    return lhs if rhs.nil?
+    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_
-    rhs = process rhs
-    if rhs =~ /=/ then
-      "#{lhs} = #{rhs}"
-    else
-      ""
-    end
+    "#{lhs} = #{process rhs}"
   end
 
   def process_dasgn(exp)
-    "#{exp.shift.to_s} = #{process(exp.shift)}"
+    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
 
-  def process_defs(exp)
-    receiver = process(exp.shift)
-    name = exp.shift
-    exp.unshift "#{receiver}.#{name}"
-    process_defn(exp)
-  end
-
   def process_defn(exp)
     type1 = exp[1].first
     type2 = exp[2].first rescue nil
@@ -380,32 +356,20 @@ class RubyToRuby < SexpProcessor
     end
 
     case type1
-    when :cfunc then
-      s = "# method '#{exp.shift}' defined in a C function"
-      exp.shift
-      return s
     when :scope, :args then
       name = exp.shift
       args = process(exp.shift)
       args = "" if args == "()"
       body = indent(process(exp.shift))
       return "def #{name}#{args}\n#{body}\nend".gsub(/\n\s*\n+/, "\n")
-    when :fcall then
-      # skip the fcall (to define_method and such) and grab the body
-      name = exp.shift
-      exp.shift # :fcall to define_method
-      body = process(exp.shift)
-      raise "no"
     else
       raise "Unknown defn type: #{type1} for #{exp.inspect}"
     end
   end
 
-  def process_defx(exp) # custom node type - TODO why in r2r?
-    name = exp.shift
-    args = process(exp.shift)
-    body = indent(process(exp.shift))
-    return "defx #{name}#{args}\n#{body}end".gsub(/\n\s*\n+/, "\n")
+  def process_defs(exp)
+    exp.unshift "#{process(exp.shift)}.#{exp.shift}"
+    process_defn(exp)
   end
 
   def process_dot2(exp)
@@ -416,27 +380,8 @@ class RubyToRuby < SexpProcessor
     "(#{process exp.shift}...#{process exp.shift})"
   end
 
-  def util_dthing(exp, dump=false)
-    s = []
-    s << exp.shift.dump[1..-2]
-    until exp.empty?
-      pt = exp.shift
-      s << case pt.first
-           when :str then
-             if dump then
-               pt.last.dump[1..-2]
-             else
-               pt.last.gsub(%r%/%, '\/')
-             end
-           else
-             "#\{#{process(pt)}}"
-           end
-    end
-    s
-  end
-
   def process_dregx(exp)
-    "/#{util_dthing(exp).join}/"
+    "/" << util_dthing(exp, true) << "/"
   end
 
   def process_dregx_once(exp)
@@ -444,11 +389,11 @@ class RubyToRuby < SexpProcessor
   end
 
   def process_dstr(exp)
-    "\"#{util_dthing(exp, true).join}\""
+    "\"#{util_dthing(exp)}\""
   end
 
   def process_dsym(exp)
-    ":" + process_dstr(exp)
+    ":#{process_dstr(exp)}"
   end
 
   def process_dvar(exp)
@@ -465,6 +410,10 @@ class RubyToRuby < SexpProcessor
     return "#{body}\nensure\n#{indent ens}"
   end
 
+  def process_evstr(exp)
+    process exp.shift
+  end
+
   def process_false(exp)
     "false"
   end
@@ -493,8 +442,13 @@ class RubyToRuby < SexpProcessor
   def process_for(exp)
     recv = process exp.shift
     iter = process exp.shift
-    body = process exp.shift
-    return "for #{iter} in #{recv}\n#{indent body}\nend\n"
+    body = exp.empty? ? nil : process(exp.shift)
+
+    result = ["for #{iter} in #{recv} do"]
+    result << indent(body ? body : "# do nothing")
+    result << "end"
+
+    result.join("\n")
   end
 
   def process_gasgn(exp)
@@ -510,7 +464,13 @@ class RubyToRuby < SexpProcessor
     until exp.empty?
       result << "#{process(exp.shift)} => #{process(exp.shift)}"
     end
-    return "{ #{result.join(', ')} }"
+
+    case self.context[1]
+    when :arglist, :argscat then
+      return "#{result.join(', ')}" # HACK - this will break w/ 2 hashes as args
+    else
+      return "{ #{result.join(', ')} }"
+    end
   end
 
   def process_iasgn(exp)
@@ -522,15 +482,11 @@ class RubyToRuby < SexpProcessor
     end
   end
 
-  def cond_indent_process(pt)
-    (pt and pt.first == :block) ? process(pt) : indent(process(pt))
-  end
-
   def process_if(exp)
-      expand = RubyToRuby::ASSIGN_NODES.include? exp.first.first
-      c = process exp.shift
-      t = process exp.shift
-      f = process exp.shift
+    expand = Ruby2Ruby::ASSIGN_NODES.include? exp.first.first
+    c = process exp.shift
+    t = process exp.shift
+    f = process exp.shift
 
     c = "(#{c.chomp})" if c =~ /\n/
 
@@ -561,7 +517,8 @@ class RubyToRuby < SexpProcessor
 
   def process_iter(exp)
     iter = process exp.shift
-    args = process exp.shift
+    args = exp.shift
+    args = (args == 0) ? '' : process(args)
     body = exp.empty? ? nil : process(exp.shift)
 
     b, e = if iter == "END" then
@@ -588,13 +545,9 @@ class RubyToRuby < SexpProcessor
     result = []
     result << "#{iter} #{b}"
     result << " |#{args}|" if args
-    if body then
-      result << "\n"
-      result << indent(body.strip)
-      result << "\n"
-    else
-      result << ' '
-    end
+    result << "\n"
+    result << indent(body.strip)
+    result << "\n"
     result << e
     result.join
   end
@@ -632,7 +585,7 @@ class RubyToRuby < SexpProcessor
     rhs = exp.empty? ? nil : exp.shift
 
     unless exp.empty? then
-      rhs[-1] = splat(rhs[-1])
+      rhs[-1] = splat(rhs[-1]) unless rhs == s(:splat)
       lhs << rhs
       rhs = exp.shift
     end
@@ -650,18 +603,28 @@ class RubyToRuby < SexpProcessor
       end
     when :dasgn_curr then
       lhs = [ splat(lhs.last) ]
+    when :splat then
+      lhs = [ :"*" ]
     else
       raise "no clue: #{lhs.inspect}"
     end
 
+    if context[1] == :iter and rhs then
+      lhs << splat(rhs.last)
+      rhs = nil
+    end
+
     unless rhs.nil? then
-      # HACK - but seems to work (see to_ary test)      assert_type rhs, :array
-      rhs = if rhs.shift == :argscat then
-              [process_argscat(rhs)]
+      t = rhs.first
+      rhs = if t == :argscat then
+              rhs.shift
+              process_argscat(rhs)
             else
-              rhs.map { |r| process(r) }
+              r = process(rhs)
+              r = r[1..-2] if t != :to_ary
+              r
             end
-      return "#{lhs.join(", ")} = #{rhs.join(", ")}"
+      return "#{lhs.join(", ")} = #{rhs}"
     else
       return lhs.join(", ")
     end
@@ -689,7 +652,12 @@ class RubyToRuby < SexpProcessor
   end
 
   def process_next(exp)
-    "next"
+    val = exp.empty? ? nil : process(exp.shift)
+    if val then
+      "next #{val}"
+    else
+      "next"
+    end
   end
 
   def process_nil(exp)
@@ -759,12 +727,19 @@ class RubyToRuby < SexpProcessor
       list = sexp.shift
       body = sexp.shift
 
-      var = if list and list.size > 1 and list.last.first == :lasgn then
+      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)}"
@@ -799,24 +774,25 @@ class RubyToRuby < SexpProcessor
     current = self.context[1]
     case current
     when :begin, :ensure, :block then
-      body = process exp.shift
-      resbody = exp.empty? ? nil : process(exp.shift)
+      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)
+      code << indent(body) if body
       code << resbody
       if els then
         code << "else"
         code << indent(els)
       else
-        unless [:block, :ensure].include? current then
-          code << "end\n"
+        unless [:block].include? current then
+          code << "end\n" unless current == :ensure
         else
-          r = [body, resbody.gsub(/rescue\n\s+/, 'rescue ')].join(' ')
+          r = [body, resbody.gsub(/rescue\n\s+/, 'rescue ')].compact.join(' ')
           code = [r] if (@indent+r).size < LINE_LENGTH and r !~ /\n/
         end
       end
+
       code.join("\n").chomp
     else # a rescue b and others
       body = process exp.shift
@@ -864,7 +840,11 @@ class RubyToRuby < SexpProcessor
   end
 
   def process_splat(exp)
-    "*#{process(exp.shift)}"
+    if exp.empty? then
+      "*"
+    else
+      "*#{process(exp.shift)}"
+    end
   end
 
   def process_str(exp)
@@ -873,7 +853,7 @@ class RubyToRuby < SexpProcessor
 
   def process_super(exp)
     args = exp.shift
-    args[0] = :arglist
+    args[0] = :arglist if args[0] == :array
     "super(#{process(args)})"
   end
 
@@ -901,22 +881,22 @@ class RubyToRuby < SexpProcessor
     "alias #{exp.shift} #{exp.shift}"
   end
 
-#   def process_vcall(exp)
-#     recv = exp.shift # nil
-#     name = exp.shift
-#     args = exp.shift # nil
-#     return name.to_s
-#   end
-
   def process_when(exp)
     src = []
 
+    if self.context[1] == :array then # ugh. matz! why not an argscat?!?
+      val = process(exp.shift)
+      exp.shift # empty body
+      return "*#{val}"
+    end
+
     until exp.empty?
       cond = process(exp.shift).to_s[1..-2]
       code = indent(process(exp.shift))
       code = indent "# do nothing" if code =~ /\A\s*\Z/
       src << "when #{cond} then\n#{code.chomp}"
     end
+
     src.join("\n")
   end
 
@@ -972,18 +952,53 @@ class RubyToRuby < SexpProcessor
   end
 
   ############################################################
-  # Rewriters
+  # Rewriters:
 
-  def rewrite_defs(exp)
-    receiver = exp.shift
-    result = rewrite_defn(exp)
-    result.unshift receiver
-    result
+  def rewrite_rescue exp
+    exp = s(:begin, exp) if
+      context[1] == :block unless
+      context[2] == :scope and [:defn, :defs].include? context[3]
+    exp
   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.gsub!(/\//, '\/') if regx
+
+    s << x
+    until exp.empty?
+      pt = exp.shift
+      case pt
+      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.gsub!(/\//, '\/') if regx
+          s << x
+        else
+          s << '#{' << process(pt) << '}' # do not use interpolation here
+        end
+      else
+        # do nothing - yet
+      end
+    end
+
+    s.join
+  end
+
   def util_module_or_class(exp, is_class=false)
     s = "#{exp.shift}"
 
@@ -1012,6 +1027,8 @@ class RubyToRuby < SexpProcessor
   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
@@ -1031,7 +1048,7 @@ class Method
   end
 
   def to_ruby
-    RubyToRuby.new.process(self.to_sexp)
+    Ruby2Ruby.new.process(self.to_sexp)
   end
 end
 
@@ -1048,7 +1065,7 @@ class UnboundMethod
     name = ProcStoreTmp.name
     ProcStoreTmp.send(:define_method, name, self)
     m = ProcStoreTmp.new.method(name)
-    result = m.to_ruby.sub(/def #{name}\(([^\)]*)\)/,
+    result = m.to_ruby.sub(/def #{name}(?:\(([^\)]*)\))?/,
                            'proc { |\1|').sub(/end\Z/, '}')
     return result
   end

data/test/test_ruby2ruby.rb

@@ -2,16 +2,15 @@
 
 $TESTING = true
 
+$: << 'lib'
+
 require 'test/unit'
-begin require 'rubygems'; rescue LoadError; end
 require 'ruby2ruby'
 require 'pt_testcase'
 
-# TODO: rename file so autotest stops bitching
-
-class TestRubyToRuby < Test::Unit::TestCase
+class TestRuby2Ruby < Test::Unit::TestCase
   def setup
-    @processor = RubyToRuby.new
+    @processor = Ruby2Ruby.new
   end
 
   def test_proc_to_ruby
@@ -31,39 +30,52 @@ class TestRubyToRuby < Test::Unit::TestCase
 
   def util_thingy(type)
     s(type,
-      "blah",
+      '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#{(1 + 1)}blah"blah\/blah/'
+    out = "/blah\\\"blah#\{(1 + 1)}blah\\\"blah\\/blah/"
 
     assert_equal out, @processor.process(inn)
 
     r = eval(out)
-    assert_equal(/blah2blah"blah\/blah/, r)
+    assert_equal(/blah\"blah2blah\"blah\/blah/, r)
   end
 
   def test_dstr_quote
     inn = util_thingy(:dstr)
-    out = '"blah#{(1 + 1)}blah\"blah/blah"'
+    out = "\"blah\\\"blah#\{(1 + 1)}blah\\\"blah/blah\""
 
     assert_equal out, @processor.process(inn)
 
     r = eval(out)
-    assert_equal "blah2blah\"blah/blah", r
+    assert_equal "blah\"blah2blah\"blah/blah", r
   end
 
   def test_dsym_quote
     inn = util_thingy(:dsym)
-    out = ':"blah#{(1 + 1)}blah\"blah/blah"'
+    out = ":\"blah\\\"blah#\{(1 + 1)}blah\\\"blah/blah\""
 
     assert_equal out, @processor.process(inn)
 
     r = eval(out)
-    assert_equal :"blah2blah\"blah/blah", r
+    assert_equal :"blah\"blah2blah\"blah/blah", r
+  end
+
+  def test_proc_to_sexp
+    p = proc { 1 + 1 }
+    s = [:proc, nil, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]]
+    assert_equal s, p.to_sexp
+  end
+
+  def test_unbound_method_to_ruby
+    r = "proc { ||\n  p = proc { (1 + 1) }\n  s = [: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
 
   eval ParseTreeTestCase.testcases.map { |node, data|
@@ -85,25 +97,34 @@ end
 # Converts a +target+ using a +processor+ and converts +target+ name
 # in the source adding +gen+ to allow easy renaming.
 
-def morph_and_eval(processor, target, gen)
+def morph_and_eval(processor, target, gen, n)
   begin
     old_name = target.name
     new_name = target.name.sub(/\d*$/, gen.to_s)
     ruby = processor.translate(target).sub(old_name, new_name)
+
     eval ruby
     target.constants.each do |constant|
       eval "#{new_name}::#{constant} = #{old_name}::#{constant}"
     end
   rescue SyntaxError => e
-    puts
-    puts ruby
-    puts
-    raise e
+    warn "Self-Translation Generation #{n} failed:"
+    warn "#{e.class}: #{e.message}"
+    warn ""
+    warn ruby
+    warn ""
   rescue => e
-    puts
-    puts ruby
-    puts
-    raise e
+    warn "Self-Translation Generation #{n} failed:"
+    warn "#{e.class}: #{e.message}"
+    warn ""
+    warn ruby
+    warn ""
+  else
+    begin
+      yield if block_given?
+    rescue
+      # probably already handled
+    end
   end
 end
 
@@ -116,28 +137,30 @@ end
 # s
 # t  new    2    3
 
-# Self-Translation: 1st Generation - morph RubyToRuby using RubyToRuby
-morph_and_eval RubyToRuby, RubyToRuby, 2
-class TestRubyToRuby1 < TestRubyToRuby
-  def setup
-    @processor = RubyToRuby2.new
+# Self-Translation: 1st Generation - morph Ruby2Ruby using Ruby2Ruby
+morph_and_eval Ruby2Ruby, Ruby2Ruby, 2, 1 do
+  class TestRuby2Ruby1 < TestRuby2Ruby
+    def setup
+      @processor = Ruby2Ruby2.new
+    end
   end
 end
 
-# Self-Translation: 2nd Generation - morph TestRubyToRuby using RubyToRuby
-morph_and_eval RubyToRuby, TestRubyToRuby, 2
-
-# Self-Translation: 3rd Generation - test RubyToRuby2 with TestRubyToRuby1
-class TestRubyToRuby3 < TestRubyToRuby2
-  def setup
-    @processor = RubyToRuby2.new
+# Self-Translation: 2nd Generation - morph TestRuby2Ruby using Ruby2Ruby
+morph_and_eval Ruby2Ruby, TestRuby2Ruby, 2, 2 do
+  # Self-Translation: 3rd Generation - test Ruby2Ruby2 with TestRuby2Ruby1
+  class TestRuby2Ruby3 < TestRuby2Ruby2
+    def setup
+      @processor = Ruby2Ruby2.new
+    end
   end
 end
 
 # Self-Translation: 4th (and final) Generation - fully circular
-morph_and_eval RubyToRuby2, RubyToRuby2, 3
-class TestRubyToRuby4 < TestRubyToRuby3
-  def setup
-    @processor = RubyToRuby3.new
+morph_and_eval(Ruby2Ruby2, Ruby2Ruby2, 3, 4) do
+  class TestRuby2Ruby4 < TestRuby2Ruby3
+    def setup
+      @processor = Ruby2Ruby3.new
+    end
   end
-end
+end rescue nil # for Ruby2Ruby2 at the top

metadata

@@ -1,72 +1,80 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: ruby2ruby
 version: !ruby/object:Gem::Version 
-  version: 1.1.7
-date: 2007-08-21 00:00:00 -07:00
-summary: ruby2ruby provides a means of generating pure ruby code easily from ParseTree's Sexps.
-require_paths: 
-- lib
-email: ryand-ruby@zenspider.com
-homepage: http://seattlerb.rubyforge.org/
-rubyforge_project: seattlerb
-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.
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 1.1.8
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Ryan Davis
-files: 
-- History.txt
-- Manifest.txt
-- README.txt
-- Rakefile
-- bin/r2r_show
-- lib/ruby2ruby.rb
-- test/test_ruby2ruby.rb
-test_files: 
-- test/test_ruby2ruby.rb
-rdoc_options: 
-- --main
-- README.txt
-extra_rdoc_files: 
-- History.txt
-- Manifest.txt
-- README.txt
-executables: 
-- r2r_show
-extensions: []
-
-requirements: []
+autorequire: 
+bindir: bin
+cert_chain: []
 
+date: 2007-12-22 00:00:00 -08:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: ParseTree
   version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.0.0
+        version: "0"
     version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
   version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.3.0
+        version: 1.4.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: ryand-ruby@zenspider.com
+executables: 
+- r2r_show
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/r2r_show
+- lib/ruby2ruby.rb
+- test/test_ruby2ruby.rb
+has_rdoc: true
+homepage: http://seattlerb.rubyforge.org/
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: seattlerb
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: ruby2ruby provides a means of generating pure ruby code easily from ParseTree's Sexps.
+test_files: 
+- test/test_ruby2ruby.rb