ruby2ruby 1.1.0 → 1.1.1

data/History.txt

@@ -1,3 +1,10 @@
+== 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. :)
+
 == 1.1.0 / 2006-10-11
 
 * 2 major enhancements

data/lib/ruby2ruby.rb

@@ -1,15 +1,17 @@
-# begin require 'rubygems'; rescue LoadError; end
+#!/usr/bin/env ruby -w
+
+begin require 'rubygems'; rescue LoadError; end
 require 'parse_tree'
 require 'sexp_processor'
 
-class NilClass
+class NilClass # Objective-C trick
   def method_missing(msg, *args, &block)
     nil
   end
 end
 
 class RubyToRuby < SexpProcessor
-  VERSION = '1.1.0'
+  VERSION = '1.1.1'
 
   def self.translate(klass_or_str, method=nil)
     self.new.process(ParseTree.translate(klass_or_str, method))
@@ -136,6 +138,7 @@ class RubyToRuby < SexpProcessor
 
     until exp.empty? do
       found = exp.first.first == :block_arg rescue false
+
       if found then
         raise "wtf"
         result[-1] = result[-1][0..-2] + ", #{process(exp.shift)})"
@@ -223,9 +226,17 @@ class RubyToRuby < SexpProcessor
     s << " < #{superk}" if superk
     s << "\n"
 
-    body = ""
-    body << "#{process exp.shift}\n\n" until exp.empty?
-    s + indent(body) + "end"
+    body = []
+    begin
+      code = process(exp.shift).chomp
+      body << code unless code.nil? or code.empty?
+    end until exp.empty?
+    unless body.empty? then
+      body = indent(body.join("\n\n")) + "\n"
+    else
+      body = ""
+    end
+    s + body + "end"
   end
   
   def process_colon2(exp)
@@ -273,6 +284,7 @@ class RubyToRuby < SexpProcessor
   def process_defn(exp)
     t = exp[1].first
     t2 = exp[2].first rescue nil
+
     if t == :args and [:ivar, :attrset].include? t2 then
       name = exp.shift
       case t2
@@ -303,7 +315,6 @@ class RubyToRuby < SexpProcessor
       name = exp.shift
       exp.shift # :fcall to define_method
       body = process(exp.shift)
-p name, body
       raise "no"
     else
       raise "Unknown defn type: #{t} for #{exp.inspect}"
@@ -429,33 +440,18 @@ p name, body
   end
   
   def process_if(exp)
-    cond = process exp.shift
+    c = process exp.shift
     t = process exp.shift
+    f = process exp.shift
 
-    type = t ? "if" : "unless"
-
-    s = ["#{type} #{cond} then"]
-    s << indent(t) if t
-
-    until exp.empty?
-      code = exp.shift
-      case code.first
-      when nil
-        # do nothing
-      when :if then
-        s << "els#{process(code).sub(/\nend\Z/, '')}"
-      else
-        s << "else\n#{cond_indent_process(code)}"
-      end
-
-      if t.nil? then
-        s[-1] = s[-1][5..-1] # remove else\n
-        t = true
-      end
+    if t then
+      r = "if #{c} then\n#{indent(t)}\n"
+      r << "else\n#{indent(f)}\n" if f
+      r << "end"
+      r
+    else
+      "unless #{c} then\n#{indent(f)}\nend"
     end
-    s << "end"
-
-    s.join("\n")
   end
   
   def process_iter(exp)
@@ -545,9 +541,17 @@ p name, body
 
   def process_module(exp)
     s = "module #{exp.shift}\n"
-    body = ""
-    body << "#{process exp.shift}\n\n" until exp.empty?
-    s + indent(body) + "end"
+    body = []
+    begin
+      code = process exp.shift
+      body << code unless code.nil? or code.empty?
+    end until exp.empty?
+    unless body.empty? then
+      body = indent(body.join("\n\n")) + "\n"
+    else
+      body = ""
+    end
+    s + body + "end"
   end
   
   def process_next(exp)
@@ -616,9 +620,10 @@ p name, body
   def process_resbody(exp) # TODO: rewrite this fucker
     code = []
 
-    until exp.nil? or exp.empty?
-      list = exp.shift
-      body = exp.shift
+    sexp = exp
+    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]
@@ -636,13 +641,16 @@ p name, body
       code.last << " => #{var}" if var
 
       if body then
-        code << indent(process(body))
+        code << indent(process(body)).chomp
       else
         code << indent("# do nothing")
       end
 
-      exp = exp.shift
-      exp.shift if exp
+      sexp = exp.shift
+      if sexp then
+        assert_type sexp, :resbody
+        sexp.shift
+      end
     end
 
     code.join("\n")
@@ -653,20 +661,35 @@ p name, body
     #
     # a = b rescue c            =>                [lasgn a [rescue b c]]
     # begin; a = b; rescue c    => [begin [rescue [lasgn a b] c]]
-    body = process exp.shift
-    resbody = process exp.shift
-    els = process exp.shift
-
-    code = []
-    code << indent(body)
-    code << resbody
-    if els then
-      code << "else"
-      code << indent(els)
-    else
-      code << "end\n"
+    stack = caller.map { |s| s[/process_\w+/] }.compact
+
+    case stack.first
+    when "process_begin", "process_ensure", "process_block" then
+      body = process exp.shift
+      resbody = process exp.shift
+      els = process exp.shift
+
+      code = []
+      code << indent(body)
+      code << resbody
+      if els then
+        code << "else"
+        code << indent(els)
+      else
+        code << "end\n"
+      end
+      code.join("\n")
+    else # a rescue b and others
+      body = process exp.shift
+      assert_type exp.first, :resbody
+      resbody = exp.shift
+      resbody.shift # resbody
+      resbody.shift # nil (no types for expression form)
+      resbody = resbody.shift # actual code
+      
+      resbody = process resbody
+      "#{body} rescue #{resbody}"
     end
-    code.join("\n")
   end
   
   def process_retry(exp)
@@ -674,7 +697,7 @@ p name, body
   end
   
   def process_return(exp)
-    return "return #{process exp.shift}"
+    return "return" + (exp.empty? ? "" : " #{process exp.shift}")
   end
 
   def process_sclass(exp)
@@ -682,7 +705,7 @@ p name, body
   end
 
   def process_scope(exp)
-    return process(exp.shift)
+    return process(exp.shift) || ""
   end
 
   def process_self(exp)
@@ -766,17 +789,19 @@ p name, body
   
   def cond_loop(exp, name)
     cond = process(exp.shift)
-    body = indent(process(exp.shift)).chomp
-    head_controlled = exp.empty? ? false : exp.shift
+    body = process(exp.shift)
+    head_controlled = exp.shift
+
+    body = indent(body).chomp if body
 
     code = []
     if head_controlled then
       code << "#{name} #{cond} do"
-      code << body
+      code << body if body
       code << "end"
     else
       code << "begin"
-      code << body
+      code << body if body
       code << "end #{name} #{cond}"
     end
     code.join("\n")
@@ -858,7 +883,7 @@ p name, body
     result = []
 
     code = result
-    while exp.first == :resbody do
+    while exp and exp.first == :resbody do
       code << exp.shift
       list = exp.shift
       body = exp.shift
@@ -876,7 +901,7 @@ p name, body
         # TODO: check that it is assigning $!
         list << body.delete_at(1) if body[1].first == :lasgn 
       else
-        raise "unknown: #{code.inspect}"
+        # do nothing (expression form)
       end
 
       code << list << body
@@ -914,6 +939,10 @@ class Method
       ParseTree.new(false).parse_tree_for_method(klass, method)
     end
   end
+
+  def to_ruby
+    RubyToRuby.new.process(self.to_sexp)
+  end
 end
 
 class ProcStoreTmp
@@ -948,7 +977,8 @@ class Proc
   end
 
   def to_ruby
-    self.to_method.to_ruby.sub(/def #{name}\(([^\)]*)\)/,
+    name = ProcStoreTmp.name
+    self.to_method.to_ruby.sub(/def [^\(]+\(([^\)]*)\)/,
                                'proc { |\1|').sub(/end\Z/, '}')
   end
 end

data/test/test_ruby2ruby.rb

@@ -65,10 +65,15 @@ end
 
 class R2RTest < Test::Unit::TestCase
 
-  def xtest_self_translation
+  def test_self_translation
     r2r2r = RubyToRuby.translate(RubyToRuby).sub("RubyToRuby","RubyToRubyToRuby")
 
-    Object.class_eval r2r2r
+    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)
@@ -112,7 +117,7 @@ class R2RTest < Test::Unit::TestCase
     assert_equal(k, l)
   end
   
-  def HACK_test_hairy_method
+  def test_hairy_method
     src = RubyToRuby.translate(self.class, :hairy_method).sub(" h", " f")
 
     eval src

metadata

@@ -3,12 +3,11 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: ruby2ruby
 version: !ruby/object:Gem::Version 
-  version: 1.1.0
-date: 2006-10-11 00:00:00 -07:00
+  version: 1.1.1
+date: 2006-11-13 00:00:00 -05:00
 summary: ruby2ruby provides a means of generating pure ruby code easily from ParseTree's Sexps.
 require_paths: 
 - lib
-- test
 email: ryand-ruby@zenspider.com
 homepage: http://seattlerb.rubyforge.org/
 rubyforge_project: seattlerb
@@ -36,8 +35,8 @@ files:
 - Rakefile
 - lib/ruby2ruby.rb
 - test/test_ruby2ruby.rb
-test_files: []
-
+test_files: 
+- test/test_ruby2ruby.rb
 rdoc_options: []
 
 extra_rdoc_files: []
@@ -56,7 +55,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.1.1
+        version: 1.1.4
     version: 
 - !ruby/object:Gem::Dependency 
   name: ParseTree