ruby2ruby 1.1.1 → 1.1.2

data/History.txt

@@ -1,3 +1,13 @@
+== 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
+
 == 1.1.1 / 2006-11-13
 
 * 3 bug fixes

data/lib/ruby2ruby.rb

@@ -11,7 +11,7 @@ class NilClass # Objective-C trick
 end
 
 class RubyToRuby < SexpProcessor
-  VERSION = '1.1.1'
+  VERSION = '1.1.2'
 
   def self.translate(klass_or_str, method=nil)
     self.new.process(ParseTree.translate(klass_or_str, method))
@@ -24,7 +24,7 @@ class RubyToRuby < SexpProcessor
     self.strict = true
     self.expected = String
   end
-  
+
   ############################################################
   # Processors (rewriters at bottom)
 
@@ -35,7 +35,7 @@ class RubyToRuby < SexpProcessor
   def process_and(exp)
     "(#{process exp.shift} and #{process exp.shift})"
   end
-  
+
   def process_args(exp)
     args = []
 
@@ -67,7 +67,7 @@ class RubyToRuby < SexpProcessor
           args << process(names.shift) until names.size == v_size
           names.zip(vals) do |name, val|
             args << "#{process name} = #{process val}"
-          end            
+          end
         else
           raise "unknown arg type #{arg.first.inspect}"
         end
@@ -78,7 +78,7 @@ class RubyToRuby < SexpProcessor
 
     return "(#{args.join ', '})"
   end
-  
+
   def process_arglist(exp) # custom made node
     code = []
     until exp.empty? do
@@ -86,7 +86,7 @@ class RubyToRuby < SexpProcessor
     end
     code.join ', '
   end
-  
+
   def process_argscat(exp)
     args = []
     ary = exp.shift
@@ -113,7 +113,18 @@ class RubyToRuby < SexpProcessor
   end
 
   def process_attrasgn(exp)
-    process_call(exp)
+    receiver = process exp.shift
+    name = exp.shift
+    args = exp.shift
+
+    case name
+    when :[]= then
+      lhs = process args.delete_at(1)
+      args[0] = :arglist
+      "#{receiver}[#{lhs}] = #{process(args)}"
+    else
+      "#{receiver}.#{name.to_s[0..-2]} = #{process(args)[1..-2]}"
+    end
   end
 
   def process_back_ref(exp)
@@ -158,7 +169,7 @@ class RubyToRuby < SexpProcessor
   def process_block_arg(exp)
     "&#{exp.shift}"
   end
-  
+
   def process_block_pass(exp)
     bname = [:lvar, "&" + process(exp.shift)]
     call = exp.shift
@@ -168,7 +179,7 @@ class RubyToRuby < SexpProcessor
 
     process(call)
   end
-  
+
   def process_break(exp)
     val = process(exp.shift)
     "break" + (val ? " #{val}" : "")
@@ -177,7 +188,7 @@ class RubyToRuby < SexpProcessor
   def process_call(exp)
     receiver = process exp.shift
     name = exp.shift
-    args_exp = exp.shift
+    args_exp = exp.shift rescue nil
     if args_exp && args_exp.first == :array
       args = "#{process(args_exp)[1..-2]}"
     else
@@ -197,10 +208,15 @@ class RubyToRuby < SexpProcessor
       end
     end
   end
-  
+
   def process_case(exp)
     result = []
-    result << "case #{process exp.shift}"
+    expr = process exp.shift
+    if expr then
+      result << "case #{expr}"
+    else
+      result << "case"
+    end
     until exp.empty?
       pt = exp.shift
       if pt and pt.first == :when
@@ -214,7 +230,7 @@ class RubyToRuby < SexpProcessor
     result << "end"
     result.join("\n")
   end
-  
+
   def process_cdecl(exp)
     "#{exp.shift} = #{process(exp.shift)}"
   end
@@ -238,19 +254,19 @@ class RubyToRuby < SexpProcessor
     end
     s + body + "end"
   end
-  
+
   def process_colon2(exp)
     "#{process(exp.shift)}::#{exp.shift}"
   end
-  
+
   def process_colon3(exp)
     "::#{exp.shift}"
   end
-  
+
   def process_const(exp)
     exp.shift.to_s
   end
-  
+
   def process_cvar(exp)
     "#{exp.shift}"
   end
@@ -264,7 +280,7 @@ class RubyToRuby < SexpProcessor
   end
 
   def process_dasgn_curr(exp)
-    s = exp.shift.to_s 
+    s = exp.shift.to_s
     s += "=" + process(exp.shift) unless exp.empty?
     s
   end
@@ -320,14 +336,14 @@ class RubyToRuby < SexpProcessor
       raise "Unknown defn type: #{t} 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")
   end
-  
+
   def process_dot2(exp)
     "(#{process exp.shift}..#{process exp.shift})"
   end
@@ -335,7 +351,7 @@ class RubyToRuby < SexpProcessor
   def process_dot3(exp)
     "(#{process exp.shift}...#{process exp.shift})"
   end
-  
+
   def process_dregx(exp)
     "/#{process_dstr(exp)[1..-2]}/"
   end
@@ -387,7 +403,7 @@ class RubyToRuby < SexpProcessor
   def process_false(exp)
     "false"
   end
-  
+
   def process_fcall(exp)
     exp_orig = exp.deep_clone
     name = exp.shift.to_s
@@ -399,7 +415,7 @@ class RubyToRuby < SexpProcessor
     end
     return "#{name}(#{code.join(', ')})"
   end
-  
+
   def process_flip2(exp)
     "#{process(exp.shift)}..#{process(exp.shift)}"
   end
@@ -414,7 +430,7 @@ class RubyToRuby < SexpProcessor
     body = process exp.shift
     return "for #{iter} in #{recv}\n#{indent body}\nend\n"
   end
-  
+
   def process_gasgn(exp)
     process_iasgn(exp)
   end
@@ -434,11 +450,11 @@ class RubyToRuby < SexpProcessor
   def process_iasgn(exp)
     "#{exp.shift} = #{process exp.shift}"
   end
-  
+
   def cond_indent_process(pt)
     (pt and pt.first == :block) ? process(pt) : indent(process(pt))
   end
-  
+
   def process_if(exp)
     c = process exp.shift
     t = process exp.shift
@@ -453,7 +469,7 @@ class RubyToRuby < SexpProcessor
       "unless #{c} then\n#{indent(f)}\nend"
     end
   end
-  
+
   def process_iter(exp)
     iter = process exp.shift
     args = process exp.shift
@@ -480,17 +496,17 @@ class RubyToRuby < SexpProcessor
     result << e
     result.join
   end
-  
+
   def process_ivar(exp)
     exp.shift.to_s
   end
-  
+
   def process_lasgn(exp)
-    s = "#{exp.shift}" 
+    s = "#{exp.shift}"
     s += " = #{process exp.shift}" unless exp.empty?
     s
   end
-  
+
   def process_lit(exp)
     obj = exp.shift
     if obj.is_a? Range # to get around how parsed ranges turn into lits and lose parens
@@ -499,11 +515,11 @@ class RubyToRuby < SexpProcessor
       obj.inspect
     end
   end
-  
+
   def process_lvar(exp)
     exp.shift.to_s
   end
-  
+
   def process_masgn(exp)
     lhs = exp.shift
     rhs = exp.shift
@@ -553,7 +569,7 @@ class RubyToRuby < SexpProcessor
     end
     s + body + "end"
   end
-  
+
   def process_next(exp)
     "next"
   end
@@ -561,11 +577,11 @@ class RubyToRuby < SexpProcessor
   def process_nil(exp)
     "nil"
   end
-  
+
   def process_not(exp)
     "(not #{process exp.shift})"
   end
-  
+
   def process_nth_ref(exp)
     "$#{exp.shift}"
   end
@@ -585,7 +601,7 @@ class RubyToRuby < SexpProcessor
     lhs = process(exp.shift)
     index = exp.shift.to_s[0..-2]
     msg = exp.shift
-    
+
     rhs = process(exp.shift)
 
     "#{lhs}.#{index} #{msg}= #{rhs}"
@@ -608,7 +624,7 @@ class RubyToRuby < SexpProcessor
   def process_or(exp)
     "(#{process exp.shift} or #{process exp.shift})"
   end
-  
+
   def process_postexe(exp)
     "END"
   end
@@ -624,7 +640,7 @@ class RubyToRuby < SexpProcessor
     until exp.empty? and (sexp.nil? or sexp.empty?)
       list = sexp.shift
       body = sexp.shift
-      
+
       var = if list.last.first == :lasgn then
               list.pop[1]
             else
@@ -686,16 +702,16 @@ class RubyToRuby < SexpProcessor
       resbody.shift # resbody
       resbody.shift # nil (no types for expression form)
       resbody = resbody.shift # actual code
-      
+
       resbody = process resbody
       "#{body} rescue #{resbody}"
     end
   end
-  
+
   def process_retry(exp)
     "retry"
   end
-  
+
   def process_return(exp)
     return "return" + (exp.empty? ? "" : " #{process exp.shift}")
   end
@@ -725,7 +741,7 @@ class RubyToRuby < SexpProcessor
     args[0] = :arglist
     "super(#{process(args)})"
   end
-  
+
   def process_svalue(exp)
     process(exp.shift)
   end
@@ -745,7 +761,7 @@ class RubyToRuby < SexpProcessor
   def process_until(exp)
     cond_loop(exp, 'until')
   end
-  
+
   def process_valias(exp)
     "alias #{exp.shift} #{exp.shift}"
   end
@@ -753,18 +769,23 @@ class RubyToRuby < SexpProcessor
   def process_vcall(exp)
     return exp.shift.to_s
   end
-  
+
   def process_when(exp)
-    cond = process(exp.shift).to_s[1..-2]
-    code = indent(process(exp.shift))
-    code = indent "# do nothing" if code =~ /\A\s*\Z/
-    "when #{cond} then\n#{code.chomp}"
+    src = []
+
+    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
 
   def process_while(exp)
     cond_loop(exp, 'while')
   end
-  
+
   def process_xstr(exp)
     "`#{process_str(exp)[1..-2]}`"
   end
@@ -778,7 +799,7 @@ class RubyToRuby < SexpProcessor
 
     "yield" + (args ? "(#{args})" : "")
   end
-  
+
   def process_zarray(exp)
     "[]"
   end
@@ -786,7 +807,7 @@ class RubyToRuby < SexpProcessor
   def process_zsuper(exp)
     "super"
   end
-  
+
   def cond_loop(exp, name)
     cond = process(exp.shift)
     body = process(exp.shift)
@@ -807,7 +828,7 @@ class RubyToRuby < SexpProcessor
     code.join("\n")
   end
 
-  ############################################################  
+  ############################################################
   # Rewriters
 
   ##
@@ -875,7 +896,7 @@ class RubyToRuby < SexpProcessor
     else
       raise "Unknown :defn format: #{name.inspect} #{args.inspect} #{body.inspect}"
     end
-    
+
     return s(:defn, name, args, body)
   end
 
@@ -899,7 +920,7 @@ class RubyToRuby < SexpProcessor
         body = nil
       when :block then
         # TODO: check that it is assigning $!
-        list << body.delete_at(1) if body[1].first == :lasgn 
+        list << body.delete_at(1) if body[1].first == :lasgn
       else
         # do nothing (expression form)
       end

data/test/test_ruby2ruby.rb

@@ -49,8 +49,8 @@ class TestRubyToRuby < Test::Unit::TestCase
 
   ParseTreeTestCase.testcases.each do |node, data|
     define_method :"test_#{node}" do
-      pt = data['ParseTree']
-      rb = data['Ruby2Ruby'] || data['Ruby']
+      pt = data['ParseTree'].deep_clone
+      rb = (data['Ruby2Ruby'] || data['Ruby']).deep_clone
 
       result = @processor.process(pt)
 
@@ -60,11 +60,6 @@ class TestRubyToRuby < Test::Unit::TestCase
     end
   end
 
-
-end
-
-class R2RTest < Test::Unit::TestCase
-
   def test_self_translation
     r2r2r = RubyToRuby.translate(RubyToRuby).sub("RubyToRuby","RubyToRubyToRuby")
 
@@ -80,7 +75,7 @@ class R2RTest < Test::Unit::TestCase
     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
@@ -92,7 +87,7 @@ class R2RTest < Test::Unit::TestCase
       raise n
     rescue RuntimeError => e
       raise if n != e.message
-      n = lambda do |i| 
+      n = lambda do |i|
         lambda do |j|
           "#{i} #{z+2*2} #{j.message.reverse}"
         end
@@ -102,7 +97,7 @@ class R2RTest < Test::Unit::TestCase
         retry
       end
     rescue ArgumentError => e
-      e.message  
+      e.message
     rescue
     end
   ensure
@@ -111,18 +106,18 @@ class R2RTest < Test::Unit::TestCase
 
   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")
 
     eval src
-    
-    blk = lambda{|x,y,z,arr| 
+
+    blk = lambda{|x,y,z,arr|
       unless y
         x.to_i*2
       else
@@ -137,3 +132,17 @@ class R2RTest < Test::Unit::TestCase
     assert_equal("ensure a-working", x1)
   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

metadata

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