ruby2ruby 1.1.3 → 1.1.4

data/History.txt

@@ -1,3 +1,16 @@
+== 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.
+  * Fixed improper end in method rescues (bug 7396).
+
 == 1.1.3 / 2006-12-20
 
 * 1 minor enhancement

data/Rakefile

@@ -1,5 +1,9 @@
 # -*- ruby -*-
 
+dirs = %w(../../ParseTree/dev/lib ../../ParseTree/dev/test:lib)
+$:.push(*dirs)
+ENV['RUBY_FLAGS'] = "-I" + dirs.join(":")
+
 require 'rubygems'
 require 'hoe'
 require './lib/ruby2ruby.rb'
@@ -10,6 +14,7 @@ Hoe.new('ruby2ruby', RubyToRuby::VERSION) do |p|
   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.clean_globs << File.expand_path("~/.ruby_inline")
   p.extra_deps << "ParseTree"
 end
 

data/lib/ruby2ruby.rb

@@ -11,7 +11,7 @@ class NilClass # Objective-C trick
 end
 
 class RubyToRuby < SexpProcessor
-  VERSION = '1.1.3'
+  VERSION = '1.1.4'
 
   def self.translate(klass_or_str, method = nil)
     self.new.process(ParseTree.translate(klass_or_str, method))
@@ -148,18 +148,11 @@ class RubyToRuby < SexpProcessor
     result = []
 
     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)})"
+      code = exp.shift
+      if code.nil? or code.first == :nil then
+        result << "# do nothing"
       else
-        code = exp.shift
-        if code.nil? or code.first == :nil then
-          result << "# do nothing"
-        else
-          result << process(code)
-        end
+        result << process(code)
       end
     end
 
@@ -236,23 +229,7 @@ class RubyToRuby < SexpProcessor
   end
 
   def process_class(exp)
-    s = "class #{exp.shift}"
-    superk = process(exp.shift)
-
-    s << " < #{superk}" if superk
-    s << "\n"
-
-    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"
+    "class #{util_module_or_class(exp, true)}"
   end
 
   def process_colon2(exp)
@@ -279,10 +256,23 @@ class RubyToRuby < SexpProcessor
     "#{exp.shift} = #{process(exp.shift)}"
   end
 
+  # (a, lit1)      => "a = 1"
+  # (a, (b, lit2)) => "a = b = 2"
+  # (a, (b))       => ""
+
   def process_dasgn_curr(exp)
-    s = exp.shift.to_s
-    s += "=" + process(exp.shift) unless exp.empty?
-    s
+    lhs = exp.shift.to_s
+    rhs = exp.shift
+    return lhs if rhs.nil?
+    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
   end
 
   def process_dasgn(exp)
@@ -374,16 +364,7 @@ class RubyToRuby < SexpProcessor
   end
 
   def process_dsym(exp)
-    s = ":" + exp.shift.dump[0..-2]
-    until exp.empty?
-      pt = exp.shift
-      if pt.first == :str
-        s << process(pt)[1..-2]
-      else
-        s << '#{' + process(pt) + '}'
-      end
-    end
-    s + '"'
+    ":" + process_dstr(exp)
   end
 
   def process_dvar(exp)
@@ -466,11 +447,17 @@ class RubyToRuby < SexpProcessor
     f = process exp.shift
 
     if t then
+      unless f then
+        r = "#{t} if #{c}"
+        return r if (@indent+r).size < 78 and r !~ /\n/
+      end
       r = "if #{c} then\n#{indent(t)}\n"
       r << "else\n#{indent(f)}\n" if f
       r << "end"
       r
     else
+      r = "#{f} unless #{c}"
+      return r if (@indent+r).size < 78 and r !~ /\n/
       "unless #{c} then\n#{indent(f)}\nend"
     end
   end
@@ -493,7 +480,7 @@ class RubyToRuby < SexpProcessor
     result << " |#{args}|" if args
     if body then
       result << "\n"
-      result << indent(body).chomp
+      result << indent(body.strip)
       result << "\n"
     else
       result << ' '
@@ -561,18 +548,7 @@ class RubyToRuby < SexpProcessor
   end
 
   def process_module(exp)
-    s = "module #{exp.shift}\n"
-    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"
+    "module #{util_module_or_class(exp)}"
   end
 
   def process_next(exp)
@@ -697,7 +673,7 @@ class RubyToRuby < SexpProcessor
         code << "else"
         code << indent(els)
       else
-        code << "end\n"
+        code << "end\n" unless stack.first == "process_block"
       end
       code.join("\n")
     else # a rescue b and others
@@ -845,6 +821,12 @@ class RubyToRuby < SexpProcessor
     rewrite_defn(exp)
   end
 
+  # s(:defn, :name, s(:scope, s(:block, s(:args, ...), ...)))
+  # s(:defn, :name, s(:bmethod, s(:masgn, s(:dasgn_curr, :args)), s(:block, ...)))
+  # s(:defn, :name, s(:fbody, s(:bmethod, s(:masgn, s(:dasgn_curr, :params)), s(:block, ...))))
+  # =>
+  # s(:defn, :name, s(:args, ...), s(:scope, s:(block, ...)))
+
   def rewrite_defn(exp)
     # REFACTOR this needs help now
     exp.shift # :defn
@@ -861,18 +843,38 @@ class RubyToRuby < SexpProcessor
       assert_type body[1], :block
     when :scope, :fbody then
       body = body[1] if body.first == :fbody
-      args = body.last.delete_at 1
-      assert_type args, :args
-      assert_type body, :scope
-      assert_type body[1], :block
-
-      if body[1][1].first == :block_arg then
-        block_arg = body[1].delete_at 1
-        args << block_arg
+      case body.first
+      when :scope then
+        args = body.block.args(true)
+        assert_type body, :scope
+        assert_type body[1], :block
+
+        if body[1][1].first == :block_arg then
+          block_arg = body[1].delete_at 1
+          args << block_arg
+        end
+      when :bmethod then
+        body[0] = :scope
+        body.block.delete_at(1) # nuke the decl # REFACTOR
+        masgn = body.masgn(true)
+        if masgn then
+          splat = :"*#{masgn[-1][-1]}"
+          args.push(splat)
+        else
+          dasgn_curr = body.dasgn_curr(true)
+          if dasgn_curr then
+            arg = :"*#{dasgn_curr[-1]}"
+            args.push(arg)
+          end
+        end
+        body.find_and_replace_all(:dvar, :lvar)
+      else
+        raise "no: #{body.first} / #{body.inspect}"
       end
     when :bmethod then
       body.shift # :bmethod
-      if body.first.first == :dasgn_curr then
+      case body.first.first
+      when :dasgn_curr then
         # WARN: there are some implications here of having an empty
         # :args below namely, "proc { || " does not allow extra args
         # passed in.
@@ -881,7 +883,15 @@ class RubyToRuby < SexpProcessor
         dasgn.shift # type
         args.push(*dasgn)
         body.find_and_replace_all(:dvar, :lvar)
+      when :masgn then
+        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]}"
+        args.push(splat)
+        body.find_and_replace_all(:dvar, :lvar)
       end
+
       if body.first.first == :block then
         body = s(:scope, body.shift)
       else
@@ -890,12 +900,9 @@ class RubyToRuby < SexpProcessor
     when :dmethod
       # BEFORE: [:defn, :dmethod_added, [:dmethod, :bmethod_maker, ...]]
       # AFTER:  [:defn, :dmethod_added, ...]
-      iter = body[2][1][2] # UGH! FIX
-      iter.delete_at 1 # fcall define_method
-      args = iter[1].find_and_replace_all(:dasgn_curr, :args)
-      iter.delete_at 1 # args
-      iter[0] = :block
-      body = s(:scope, iter.find_and_replace_all(:dvar, :lvar))
+      body[0] = :scope
+      body.delete_at 1 # method name
+      args = body.scope.block.args(true)
     when :ivar, :attrset then
       # do nothing
     else
@@ -943,6 +950,29 @@ class RubyToRuby < SexpProcessor
   ############################################################
   # Utility Methods:
 
+  def util_module_or_class(exp, is_class=false)
+    s = "#{exp.shift}"
+
+    if is_class then
+      superk = process(exp.shift)
+      s << " < #{superk}" if superk
+    end
+
+    s << "\n"
+
+    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 indent(s)
     s.to_s.map{|line| @indent + line}.join
   end
@@ -1003,8 +1033,11 @@ class Proc
   end
 
   def to_ruby
-    name = ProcStoreTmp.name
-    self.to_method.to_ruby.sub(/def [^\(]+\(([^\)]*)\)/,
-                               'proc { |\1|').sub(/end\Z/, '}')
+    ruby = self.to_method.to_ruby
+    ruby.sub!(/\A(def \S+)\(([^\)]*)\)/, '\1 |\2|')     # move args
+    ruby.sub!(/\Adef[^\n\|]+/, 'proc { ')               # strip def name
+    ruby.sub!(/end\Z/, '}')                             # strip end
+    ruby.gsub!(/\s+$/, '')                              # trailing WS bugs me
+    ruby
   end
 end

data/test/test_ruby2ruby.rb

@@ -10,6 +10,40 @@ class TestRubyToRuby < Test::Unit::TestCase
     @processor = RubyToRuby.new
   end
 
+  def test_rewrite_defn_define_method
+    inn = s(:defn, :splatted,
+            s(:bmethod,
+              s(:masgn, s(:dasgn_curr, :args)),
+              s(:block,
+                s(:dasgn_curr, :y),
+                s(:dasgn_curr, :y, s(:call, s(:dvar, :args), :first)),
+                s(:call, s(:dvar, :y), :+, s(:array, s(:lit, 42))))))
+    out = s(:defn, :splatted,
+            s(:args, :"*args"),
+            s(:scope,
+              s(:block,
+                s(:dasgn_curr, :y, s(:call, s(:lvar, :args), :first)),
+                s(:call, s(:lvar, :y), :+, s(:array, s(:lit, 42))))))
+
+    assert_equal out, @processor.rewrite_defn(inn)
+  end
+
+  def test_rewrite_defn_bmethod
+    inn = s(:defn, :group,
+            s(:fbody,
+              s(:bmethod,
+                s(:masgn, s(:dasgn_curr, :params)),
+                s(:block,
+                  s(:dasgn_curr, :force_reload, s(:dasgn_curr, :association, s(:dasgn_curr, :retval))),
+                  s(:lit, 42)))))
+    out = s(:defn, :group,
+            s(:args, :"*params"),
+            s(:scope,
+              s(:block, s(:lit, 42))))
+
+    assert_equal out, @processor.rewrite_defn(inn)
+  end
+
   def test_rewrite_resbody
     inn = [:resbody,
            [:array, [:const, :SyntaxError]],
@@ -60,7 +94,15 @@ class TestRubyToRuby < Test::Unit::TestCase
 end
 
 # Self-Translation: 1st Generation
-eval RubyToRuby.translate(RubyToRuby).sub("RubyToRuby", "RubyToRuby2")
+ruby = RubyToRuby.translate(RubyToRuby).sub("RubyToRuby", "RubyToRuby2")
+begin
+  eval ruby
+rescue SyntaxError => e
+  puts "SyntaxError: #{e.message}"
+  puts
+  puts ruby
+  exit 1
+end
 
 class TestRubyToRuby2 < TestRubyToRuby
   def setup

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
+rubygems_version: 0.9.0.9
 specification_version: 1
 name: ruby2ruby
 version: !ruby/object:Gem::Version 
-  version: 1.1.3
-date: 2006-12-20 00:00:00 -08:00
+  version: 1.1.4
+date: 2007-01-15 00:00:00 -08:00
 summary: ruby2ruby provides a means of generating pure ruby code easily from ParseTree's Sexps.
 require_paths: 
 - lib
@@ -49,20 +49,20 @@ requirements: []
 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: hoe
+  name: ParseTree
   version_requirement: 
   version_requirements: !ruby/object:Gem::Version::Requirement 
     requirements: 
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version 
-        version: 1.1.4
+        version: 0.0.0
     version: 
 - !ruby/object:Gem::Dependency 
-  name: ParseTree
+  name: hoe
   version_requirement: 
   version_requirements: !ruby/object:Gem::Version::Requirement 
     requirements: 
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.0.0
+        version: 1.1.7
     version: