ruby2ruby 1.1.4 → 1.1.5

data/History.txt

@@ -1,3 +1,18 @@
+== 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.
+	* Fixed splat in masgn.
+	* Fixed unary/prefix methods.
+	* Fixed attrasgn for []= where there were multiple args inside [].
+	* Fixed a couple resbody bugs.
+
 == 1.1.4 / 2007-01-15
 
 * 4 minor enhancements:

data/lib/ruby2ruby.rb

@@ -11,7 +11,8 @@ class NilClass # Objective-C trick
 end
 
 class RubyToRuby < SexpProcessor
-  VERSION = '1.1.4'
+  VERSION = '1.1.5'
+  LINE_LENGTH = 78
 
   def self.translate(klass_or_str, method = nil)
     self.new.process(ParseTree.translate(klass_or_str, method))
@@ -119,11 +120,15 @@ class RubyToRuby < SexpProcessor
 
     case name
     when :[]= then
-      lhs = process args.delete_at(1)
+      rhs = process args.pop
       args[0] = :arglist
-      "#{receiver}[#{lhs}] = #{process(args)}"
+      "#{receiver}[#{process(args)}] = #{rhs}"
     else
-      "#{receiver}.#{name.to_s[0..-2]} = #{process(args)[1..-2]}"
+      if args then
+        "#{receiver}.#{name.to_s[0..-2]} = #{process(args)[1..-2]}"
+      else
+        "#{receiver}.#{name.to_s[0..-2]}"
+      end
     end
   end
 
@@ -164,11 +169,22 @@ class RubyToRuby < SexpProcessor
   end
 
   def process_block_pass(exp)
-    bname = [:lvar, "&" + process(exp.shift)]
+    bname = [:block_arg, process(exp.shift)]
     call = exp.shift
-    has_args = Array === call.last and call.last.first == :array
-    call << [:array] unless has_args
-    call.last << bname
+
+    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
+        call << [:array] unless has_args
+      end
+      call.last << bname
+    else
+      call << [:array, bname]
+    end
 
     process(call)
   end
@@ -193,6 +209,10 @@ class RubyToRuby < SexpProcessor
       "(#{receiver} #{name} #{args})"
     when :[] then
       "#{receiver}[#{args}]"
+    when :"-@" then
+      "-#{receiver}"
+    when :"+@" then
+      "+#{receiver}"
     else
       unless receiver.nil? then
         "#{receiver}.#{name}#{args ? "(#{args})" : args}"
@@ -449,7 +469,7 @@ class RubyToRuby < SexpProcessor
     if t then
       unless f then
         r = "#{t} if #{c}"
-        return r if (@indent+r).size < 78 and r !~ /\n/
+        return r if (@indent+r).size < LINE_LENGTH and r !~ /\n/
       end
       r = "if #{c} then\n#{indent(t)}\n"
       r << "else\n#{indent(f)}\n" if f
@@ -457,7 +477,7 @@ class RubyToRuby < SexpProcessor
       r
     else
       r = "#{f} unless #{c}"
-      return r if (@indent+r).size < 78 and r !~ /\n/
+      return r if (@indent+r).size < LINE_LENGTH and r !~ /\n/
       "unless #{c} then\n#{indent(f)}\nend"
     end
   end
@@ -475,6 +495,19 @@ class RubyToRuby < SexpProcessor
 
     iter.sub!(/\(\)$/, '')
 
+    # REFACTOR: ugh
+    result = []
+    result << "#{iter} {"
+    result << " |#{args}|" if args
+    if body then
+      result << " #{body.strip} "
+    else
+      result << ' '
+    end
+    result << "}"
+    result = result.join
+    return result if result !~ /\n/ and result.size < LINE_LENGTH
+
     result = []
     result << "#{iter} #{b}"
     result << " |#{args}|" if args
@@ -512,13 +545,29 @@ class RubyToRuby < SexpProcessor
     exp.shift.to_s
   end
 
+  def splat(sym)
+    :"*#{sym}"
+  end
+
   def process_masgn(exp)
     lhs = exp.shift
-    rhs = exp.shift rescue nil
+    rhs = exp.empty? ? nil : exp.shift
+
+    unless exp.empty? then
+      rhs[-1] = splat(rhs[-1])
+      lhs << rhs
+      rhs = exp.shift
+    end
 
-    assert_type lhs, :array
-    lhs.shift
-    lhs = lhs.map { |l| process(l) }
+    case lhs.first
+    when :array then
+      lhs.shift
+      lhs = lhs.map { |l| process(l) }
+    when :dasgn_curr then
+      lhs = [ splat(lhs.last) ]
+    else
+      raise "no clue: #{lhs.inspect}"
+    end
 
     unless rhs.nil? then
       # HACK - but seems to work (see to_ary test)      assert_type rhs, :array
@@ -622,15 +671,14 @@ class RubyToRuby < SexpProcessor
       list = sexp.shift
       body = sexp.shift
 
-      var = if list.last.first == :lasgn then
+      var = if list and list.last.first == :lasgn then
               list.pop[1]
             else
               nil
             end
 
-      list[0] = :arglist
-
       if list then
+        list[0] = :arglist
         code << "rescue #{process(list)}"
       else
         code << "rescue"
@@ -654,6 +702,7 @@ class RubyToRuby < SexpProcessor
   end
 
   def process_rescue(exp)
+    # TODO: rewrite this
     # TODO: proper formatting depends on knowing the context
     #
     # a = b rescue c            =>                [lasgn a [rescue b c]]
@@ -673,9 +722,14 @@ class RubyToRuby < SexpProcessor
         code << "else"
         code << indent(els)
       else
-        code << "end\n" unless stack.first == "process_block"
+        unless stack.first == "process_block" then
+          code << "end\n"
+        else
+          r = [body, resbody.gsub(/rescue\n\s+/, 'rescue ')].join(' ')
+          code = [r] if (@indent+r).size < LINE_LENGTH and r !~ /\n/
+        end
       end
-      code.join("\n")
+      code.join("\n").chomp
     else # a rescue b and others
       body = process exp.shift
       assert_type exp.first, :resbody
@@ -842,7 +896,7 @@ class RubyToRuby < SexpProcessor
       assert_type body, :scope
       assert_type body[1], :block
     when :scope, :fbody then
-      body = body[1] if body.first == :fbody
+      body = body.pop if body.first == :fbody
       case body.first
       when :scope then
         args = body.block.args(true)
@@ -858,12 +912,12 @@ class RubyToRuby < SexpProcessor
         body.block.delete_at(1) # nuke the decl # REFACTOR
         masgn = body.masgn(true)
         if masgn then
-          splat = :"*#{masgn[-1][-1]}"
+          splat = self.splat(masgn[-1][-1])
           args.push(splat)
         else
           dasgn_curr = body.dasgn_curr(true)
           if dasgn_curr then
-            arg = :"*#{dasgn_curr[-1]}"
+            arg = self.splat(dasgn_curr[-1])
             args.push(arg)
           end
         end
@@ -887,7 +941,7 @@ class RubyToRuby < SexpProcessor
         dasgn = body.masgn(true)
         # DAMNIT body.block.dasgn_curr(true) - multiple values so can't use
         body.block.delete_at(1) # nuke the decl
-        splat = :"*#{dasgn[-1][-1]}"
+        splat = self.splat(dasgn[-1][-1])
         args.push(splat)
         body.find_and_replace_all(:dvar, :lvar)
       end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0.9
 specification_version: 1
 name: ruby2ruby
 version: !ruby/object:Gem::Version 
-  version: 1.1.4
-date: 2007-01-15 00:00:00 -08:00
+  version: 1.1.5
+date: 2007-02-13 00:00:00 -08:00
 summary: ruby2ruby provides a means of generating pure ruby code easily from ParseTree's Sexps.
 require_paths: 
 - lib
@@ -64,5 +64,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.1.7
+        version: 1.2.0
     version: