ruby2ruby 1.1.2 → 1.1.3

data/History.txt

@@ -1,3 +1,10 @@
+== 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

data/lib/ruby2ruby.rb

@@ -11,9 +11,9 @@ class NilClass # Objective-C trick
 end
 
 class RubyToRuby < SexpProcessor
-  VERSION = '1.1.2'
+  VERSION = '1.1.3'
 
-  def self.translate(klass_or_str, method=nil)
+  def self.translate(klass_or_str, method = nil)
     self.new.process(ParseTree.translate(klass_or_str, method))
   end
 
@@ -448,7 +448,12 @@ class RubyToRuby < SexpProcessor
   end
 
   def process_iasgn(exp)
-    "#{exp.shift} = #{process exp.shift}"
+    lhs = exp.shift
+    if exp.empty? then # part of an masgn
+      lhs.to_s
+    else
+      "#{lhs} = #{process exp.shift}"
+    end
   end
 
   def cond_indent_process(pt)
@@ -522,7 +527,7 @@ class RubyToRuby < SexpProcessor
 
   def process_masgn(exp)
     lhs = exp.shift
-    rhs = exp.shift
+    rhs = exp.shift rescue nil
 
     assert_type lhs, :array
     lhs.shift

data/test/test_ruby2ruby.rb

@@ -46,103 +46,27 @@ class TestRubyToRuby < Test::Unit::TestCase
     assert_equal out, @processor.rewrite_resbody(inn)
   end
 
+  eval ParseTreeTestCase.testcases.map { |node, data|
+    "def test_#{node}
+       pt = #{data['ParseTree'].inspect}
+       rb = #{(data['Ruby2Ruby'] || data['Ruby']).inspect}
 
-  ParseTreeTestCase.testcases.each do |node, data|
-    define_method :"test_#{node}" do
-      pt = data['ParseTree'].deep_clone
-      rb = (data['Ruby2Ruby'] || data['Ruby']).deep_clone
+       assert_not_nil pt, \"ParseTree for #{node} undefined\"
+       assert_not_nil rb, \"Ruby for #{node} undefined\"
 
-      result = @processor.process(pt)
-
-      assert_not_nil pt, "ParseTree for #{node} undefined"
-      assert_not_nil rb, "Ruby for #{node} undefined"
-      assert_equal rb, result
-    end
-  end
-
-  def test_self_translation
-    r2r2r = RubyToRuby.translate(RubyToRuby).sub("RubyToRuby","RubyToRubyToRuby")
-
-    begin
-      Object.class_eval r2r2r
-    rescue SyntaxError => e
-      $stderr.puts r2r2r
-      flunk "syntax error, see above (#{e.inspect})"
-    end
-
-    r2r2r2 = RubyToRubyToRuby.translate(RubyToRuby).sub("RubyToRuby","RubyToRubyToRuby")
-    r2r2r2r = RubyToRubyToRuby.translate(RubyToRubyToRuby)
-    assert_equal(r2r2r, r2r2r2, "first generation must equal second generation")
-    assert_equal(r2r2r, r2r2r2r, "first generation must equal third generation")
-  end
-
-  def hairy_method(z,x=10,y=20*z.abs,&blok)
-    n = 1 + 2 * 40.0 / (z - 2)
-    retried = false
-    begin
-      raise ArgumentError, n if retried
-      n -= yield x,y,z,[z,x,y].map(&blok)
-      n = n / 1.1 until n < 500 # TODO: translated isn't respecting post iter
-      n = "hop hop #{"%.4f" % n}"
-      raise n
-    rescue RuntimeError => e
-      raise if n != e.message
-      n = lambda do |i|
-        lambda do |j|
-          "#{i} #{z+2*2} #{j.message.reverse}"
-        end
-      end[n].call(e)
-      unless retried
-        retried = true
-        retry
-      end
-    rescue ArgumentError => e
-      e.message
-    rescue
-    end
-  ensure
-    x << "ensure a-working"
-  end
-
-  def foobar a, &block; block.call(a) end
-  def k; foobar [1,2,3].each { |x| x*2 } do |x| x*2 end end
-
-  def test_block_precedence_escape
-    eval RubyToRuby.translate(self.class, :k).sub(" k"," l")
-    assert_equal(k, l)
-  end
-
-  def test_hairy_method
-    src = RubyToRuby.translate(self.class, :hairy_method).sub(" h", " f")
+       assert_equal rb, @processor.process(pt)
+     end"
+  }.join("\n")
+end
 
-    eval src
+# Self-Translation: 1st Generation
+eval RubyToRuby.translate(RubyToRuby).sub("RubyToRuby", "RubyToRuby2")
 
-    blk = lambda{|x,y,z,arr|
-      unless y
-        x.to_i*2
-      else
-        x.to_i*y*z*arr.inject(1){|s,i| s+i}
-      end
-    }
-    x1 = ""
-    x2 = ""
-    res = [hairy_method(-5,x1,&blk), fairy_method(-5,x2,&blk)]
-    assert_equal(res.first, res.last)
-    assert_equal(x1, x2)
-    assert_equal("ensure a-working", x1)
+class TestRubyToRuby2 < TestRubyToRuby
+  def setup
+    @processor = RubyToRuby2.new
   end
 end
 
-# TODO: pass your tests through yourself and run them again
-# r2r2 = RubyToRuby.translate(RubyToRuby).sub("RubyToRuby","RubyToRuby2")
-# begin
-#   Object.class_eval r2r2
-# rescue SyntaxError => e
-#   $stderr.puts r2r2
-#   flunk "syntax error, see above (#{e.inspect})"
-# end
-# class TestRubyToRubyToRuby < TestRubyToRuby
-#   def setup
-#     @processor = RubyToRuby2.new
-#   end
-# end
+# Self-Translation: 2nd Generation - against the tests this time
+eval RubyToRuby2.translate(TestRubyToRuby).sub("TestRubyToRuby", "TestRubyToRuby3")

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: ruby2ruby
 version: !ruby/object:Gem::Version 
-  version: 1.1.2
-date: 2006-12-19 00:00:00 -08:00
+  version: 1.1.3
+date: 2006-12-20 00:00:00 -08:00
 summary: ruby2ruby provides a means of generating pure ruby code easily from ParseTree's Sexps.
 require_paths: 
 - lib