ruby2ruby 1.3.0 → 1.3.1

data/History.txt

@@ -1,3 +1,22 @@
+=== 1.3.1 / 2011-09-22
+
+* 1 minor enhancement:
+
+  * Added parenthesize to add parens in certain contexts.
+
+* 10 bug fixes:
+
+  * Add newline to 'do nothing' comment in a block... seems contrived. (andreacampi)
+  * Binary operations not work properly with some complex statements. (smorss)
+  * Fixed if statements with no body (smorss)
+  * Fixed logic for call with hash args in various locations (smorss)
+  * Fixed match3 on an assignment. (smorss)
+  * Fixed multiple nested rescue/ensure exprs (larsch)
+  * Fixed process_alias to parenthesize (smorss)
+  * Fixed process_and to parenthenize only when it makes sense.
+  * Fixed rescue with 2+ statements in resbody (smorss)
+  * Regexps with options other than /o were not showing flags. (smorss)
+
 === 1.3.0 / 2011-09-01
 
 * 1 minor enhancement:

data/lib/ruby2ruby.rb

@@ -3,14 +3,36 @@
 require 'rubygems'
 require 'sexp_processor'
 
+# REFACTOR: stolen from ruby_parser
+class Regexp
+  unless defined? ENC_NONE then
+    ENC_NONE = /x/n.options
+    ENC_EUC  = /x/e.options
+    ENC_SJIS = /x/s.options
+    ENC_UTF8 = /x/u.options
+
+    CODES = {
+      EXTENDED   => 'x',
+      IGNORECASE => 'i',
+      MULTILINE  => 'm',
+      ENC_NONE   => 'n',
+      ENC_EUC    => 'e',
+      ENC_SJIS   => 's',
+      ENC_UTF8   => 'u',
+    }
+  end
+end
+
 class Ruby2Ruby < SexpProcessor
-  VERSION = '1.3.0'
+  VERSION = '1.3.1'
   LINE_LENGTH = 78
 
   BINARY = [:<=>, :==, :<, :>, :<=, :>=, :-, :+, :*, :/, :%, :<<, :>>, :**]
 
   ##
   # Nodes that represent assignment and probably need () around them.
+  #
+  # TODO: this should be replaced with full precedence support :/
 
   ASSIGN_NODES = [
                   :dasgn,
@@ -24,6 +46,7 @@ class Ruby2Ruby < SexpProcessor
                   :op_asgn_and,
                   :op_asgn_or,
                   :return,
+                  :if, # HACK
                  ]
 
   def initialize
@@ -42,11 +65,11 @@ class Ruby2Ruby < SexpProcessor
   # Processors
 
   def process_alias(exp)
-    "alias #{process(exp.shift)} #{process(exp.shift)}"
+    parenthesize "alias #{process(exp.shift)} #{process(exp.shift)}"
   end
 
   def process_and(exp)
-    "(#{process exp.shift} and #{process exp.shift})"
+    parenthesize "#{process exp.shift} and #{process exp.shift}"
   end
 
   def process_arglist(exp) # custom made node
@@ -118,7 +141,7 @@ class Ruby2Ruby < SexpProcessor
     code << "begin"
     until exp.empty?
       src = process(exp.shift)
-      src = indent(src) unless src =~ /(^|\n)rescue/ # ensure no level 0 rescues
+      src = indent(src) unless src =~ /(^|\n)(rescue|ensure)/ # ensure no level 0 rescues
       code << src
     end
     code << "end"
@@ -132,24 +155,27 @@ class Ruby2Ruby < SexpProcessor
     until exp.empty? do
       code = exp.shift
       if code.nil? or code.first == :nil then
-        result << "# do nothing"
+        result << "# do nothing\n"
       else
         result << process(code)
       end
     end
 
-    result = result.join "\n"
-
-    result = case self.context[1]
-             when nil, :scope, :if, :iter, :resbody, :when, :while then
-               result + "\n"
-             else
-               "(#{result})"
-             end
+    result = parenthesize result.join "\n"
+    result += "\n" unless result.start_with? "("
 
     return result
   end
 
+  def parenthesize exp
+    case self.context[1]
+    when nil, :scope, :if, :iter, :resbody, :when, :while then
+      exp
+    else
+      "(#{exp})"
+    end
+  end
+
   def process_block_pass exp
     raise "huh?: #{exp.inspect}" if exp.size > 1
 
@@ -169,9 +195,7 @@ class Ruby2Ruby < SexpProcessor
   def process_call(exp)
     receiver_node_type = exp.first.nil? ? nil : exp.first.first
     receiver = process exp.shift
-
-    receiver = "(#{receiver})" if
-      Ruby2Ruby::ASSIGN_NODES.include? receiver_node_type
+    receiver = "(#{receiver})" if ASSIGN_NODES.include? receiver_node_type
 
     name = exp.shift
     args = []
@@ -183,8 +207,20 @@ class Ruby2Ruby < SexpProcessor
 
     in_context :arglist do
       until exp.empty? do
+        arg_type = exp.first.sexp_type
         arg = process exp.shift
-        args << arg unless arg.empty?
+
+        next if arg.empty?
+
+        strip_hash = (arg_type == :hash and
+                      not BINARY.include? name and
+                      (exp.empty? or exp.first.sexp_type == :splat))
+        wrap_arg = Ruby2Ruby::ASSIGN_NODES.include? arg_type
+
+        arg = arg[2..-3] if strip_hash
+        arg = "(#{arg})" if wrap_arg
+
+        args << arg
       end
     end
 
@@ -332,8 +368,15 @@ class Ruby2Ruby < SexpProcessor
     "(#{process exp.shift}...#{process exp.shift})"
   end
 
+  def re_opt options
+    bits = (0..8).map { |n| options[n] * 2**n }
+    bits.delete 0
+    bits.map { |n| Regexp::CODES[n] }.join
+  end
+
   def process_dregx(exp)
-    "/" << util_dthing(:dregx, exp) << "/"
+    options = re_opt exp.pop if Fixnum === exp.last
+    "/" << util_dthing(:dregx, exp) << "/#{options}"
   end
 
   def process_dregx_once(exp)
@@ -357,8 +400,10 @@ class Ruby2Ruby < SexpProcessor
     ens  = exp.shift
     ens  = nil if ens == s(:nil)
     ens  = process(ens) || "# do nothing"
+    ens = "begin\n#{ens}\nend\n" if ens =~ /(^|\n)rescue/
 
     body.sub!(/\n\s*end\z/, '')
+    body = indent(body) unless body =~ /(^|\n)rescue/
 
     return "#{body}\nensure\n#{indent ens}"
   end
@@ -401,6 +446,7 @@ class Ruby2Ruby < SexpProcessor
 
   def process_hash(exp)
     result = []
+
     until exp.empty?
       lhs = process(exp.shift)
       rhs = exp.shift
@@ -411,21 +457,7 @@ class Ruby2Ruby < SexpProcessor
       result << "#{lhs} => #{rhs}"
     end
 
-    case self.context[1]
-    when :arglist, :argscat then
-      unless result.empty? then
-        # HACK - this will break w/ 2 hashes as args
-        if BINARY.include? @calls.last then
-          return "{ #{result.join(', ')} }"
-        else
-          return "#{result.join(', ')}"
-        end
-      else
-        return "{}"
-      end
-    else
-      return "{ #{result.join(', ')} }"
-    end
+    return "{ #{result.join(', ')} }"
   end
 
   def process_iasgn(exp)
@@ -461,12 +493,15 @@ class Ruby2Ruby < SexpProcessor
       r << "end"
 
       r
-    else
+    elsif f
       unless expand then
         r = "#{f} unless #{c}"
         return r if (@indent+r).size < LINE_LENGTH and r !~ /\n/
       end
       "unless #{c} then\n#{indent(f)}\nend"
+    else
+      # empty if statement, just do it in case of side effects from condition
+      "if #{c} then\n#{indent '# do nothing'}\nend"
     end
   end
 
@@ -587,8 +622,14 @@ class Ruby2Ruby < SexpProcessor
 
   def process_match3(exp)
     rhs = process(exp.shift)
+    left_type = exp.first.sexp_type
     lhs = process(exp.shift)
-    "#{lhs} =~ #{rhs}"
+
+    if ASSIGN_NODES.include? left_type then
+      "(#{lhs}) =~ #{rhs}"
+    else
+      "#{lhs} =~ #{rhs}"
+    end
   end
 
   def process_module(exp)
@@ -681,12 +722,14 @@ class Ruby2Ruby < SexpProcessor
     els  = process(exp.pop)   unless exp.last.first  == :resbody
 
     body ||= "# do nothing"
-    simple = exp.size == 1
+    simple = exp.size == 1 && !exp.resbody.block
+
 
     resbodies = []
     until exp.empty? do
       resbody = exp.shift
-      simple &&= resbody[1] == s(:array) && resbody[2] != nil
+      simple &&= resbody[1] == s(:array)
+      simple &&= resbody[2] != nil && resbody[2].node_type != :block
       resbodies << process(resbody)
     end
 
@@ -866,9 +909,10 @@ class Ruby2Ruby < SexpProcessor
   def rewrite_rescue exp
     complex = false
     complex ||= exp.size > 3
-    complex ||= exp.block
+    complex ||= exp.resbody.block
     complex ||= exp.find_nodes(:resbody).any? { |n| n[1] != s(:array) }
     complex ||= exp.find_nodes(:resbody).any? { |n| n.last.nil? }
+    complex ||= exp.find_nodes(:resbody).any? { |n| n[2] and n[2].node_type == :block }
 
     handled = context.first == :ensure
 
@@ -924,8 +968,7 @@ class Ruby2Ruby < SexpProcessor
           raise "unknown type: #{pt.inspect}"
         end
       else
-        # HACK: raise "huh?: #{pt.inspect}" -- hitting # constants in regexps
-        # do nothing for now
+        raise "unhandled value in d-thing: #{pt.inspect}"
       end
     end
 

data/test/test_ruby2ruby.rb

@@ -72,6 +72,12 @@ class TestRuby2Ruby < R2RTestCase
     assert_equal exp, eval(out)
   end
 
+  def test_and_alias
+    inn = s(:and, s(:true), s(:alias, s(:lit, :a), s(:lit, :b)))
+    out = "true and (alias :a :b)"
+    util_compare inn, out
+  end
+
   def test_dregx_slash
     inn = util_thingy(:dregx)
     out = '/a"b#{(1 + 1)}c"d\/e/'
@@ -103,6 +109,51 @@ class TestRuby2Ruby < R2RTestCase
                  "self[42] = 24")
   end
 
+  def test_call_arglist_hash_first
+    inn = s(:call, nil, :method,
+            s(:arglist,
+              s(:hash, s(:lit, :a), s(:lit, 1)),
+              s(:call, nil, :b, s(:arglist))))
+    out = "method({ :a => 1 }, b)"
+
+    util_compare inn, out
+  end
+
+  def test_call_arglist_hash_first_last
+    inn = s(:call, nil, :method,
+            s(:arglist,
+              s(:hash, s(:lit, :a), s(:lit, 1)),
+              s(:call, nil, :b, s(:arglist)),
+              s(:hash, s(:lit, :c), s(:lit, 1))))
+    out = "method({ :a => 1 }, b, :c => 1)"
+
+    util_compare inn, out
+  end
+
+  def test_call_arglist_hash_last
+    inn = s(:call, nil, :method,
+            s(:arglist,
+              s(:call, nil, :b, s(:arglist)),
+              s(:hash, s(:lit, :a), s(:lit, 1))))
+    out = "method(b, :a => 1)"
+
+    util_compare inn, out
+  end
+
+  def test_call_arglist_if
+    inn = s(:call,
+            s(:call, nil, :a, s(:arglist)),
+            :+,
+            s(:arglist,
+              s(:if,
+                s(:call, nil, :b, s(:arglist)),
+                s(:call, nil, :c, s(:arglist)),
+                s(:call, nil, :d, s(:arglist)))))
+
+    out = "(a + (b ? (c) : (d)))"
+    util_compare inn, out
+  end
+
   def test_masgn_wtf
     inn = s(:block,
             s(:masgn,
@@ -124,7 +175,6 @@ class TestRuby2Ruby < R2RTestCase
     util_compare inn, out
   end
 
-
   def test_masgn_splat_wtf
     inn = s(:masgn,
             s(:array, s(:lasgn, :k), s(:lasgn, :v)),
@@ -138,6 +188,13 @@ class TestRuby2Ruby < R2RTestCase
     util_compare inn, out
   end
 
+  def test_match3_asgn
+    inn = s(:match3, s(:lit, //), s(:lasgn, :y, s(:call, nil, :x, s(:arglist))))
+    out = "(y = x) =~ //"
+    # "y = x =~ //", which matches on x and assigns to y (not what sexp says).
+    util_compare inn, out
+  end
+
   def test_splat_call
     inn = s(:call, nil, :x,
             s(:arglist,
@@ -151,6 +208,19 @@ class TestRuby2Ruby < R2RTestCase
     util_compare inn, out
   end
 
+  def test_resbody_block
+    inn = s(:rescue,
+            s(:call, nil, :x1, s(:arglist)),
+            s(:resbody,
+              s(:array),
+              s(:block,
+                s(:call, nil, :x2, s(:arglist)),
+                s(:call, nil, :x3, s(:arglist)))))
+
+    out = "begin\n  x1\nrescue\n  x2\n  x3\nend"
+    util_compare inn, out
+  end
+
   def test_resbody_short_with_begin_end
     # "begin; blah; rescue; []; end"
     inn = s(:rescue,
@@ -160,6 +230,18 @@ class TestRuby2Ruby < R2RTestCase
     util_compare inn, out
   end
 
+  def test_regexp_options
+    inn = s(:match3,
+            s(:dregx,
+              "abc",
+              s(:evstr, s(:call, nil, :x, s(:arglist))),
+              s(:str, "def"),
+              4),
+            s(:str, "a"))
+    out = '"a" =~ /abc#{x}def/m'
+    util_compare inn, out
+  end
+
   def test_resbody_short_with_rescue_args
     inn = s(:rescue,
             s(:call, nil, :blah, s(:arglist)),
@@ -184,6 +266,12 @@ class TestRuby2Ruby < R2RTestCase
     util_compare inn, out
   end
 
+  def test_if_empty
+    inn = s(:if, s(:call, nil, :x, s(:arglist)), nil, nil)
+    out = "if x then\n  # do nothing\nend"
+    util_compare inn, out
+  end
+
   def test_interpolation_and_escapes
     # log_entry = "  \e[#{message_color}m#{message}\e[0m   "
     inn = s(:lasgn, :log_entry,
@@ -218,6 +306,47 @@ class TestRuby2Ruby < R2RTestCase
     util_compare inn, out
   end
 
+  def test_basic_ensure
+    inn = s(:ensure, s(:lit, 1), s(:lit, 2))
+    out = "begin\n  1\nensure\n  2\nend"
+    util_compare inn, out
+  end
+  
+  def test_nested_ensure
+    inn = s(:ensure, s(:lit, 1), s(:ensure, s(:lit, 2), s(:lit, 3)))
+    out = "begin\n  1\nensure\n  begin\n    2\n  ensure\n    3\n  end\nend"
+    util_compare inn, out
+  end
+  
+  def test_nested_rescue
+    inn = s(:ensure, s(:lit, 1), s(:rescue, s(:lit, 2), s(:resbody, s(:array), s(:lit, 3))))
+    out = "begin\n  1\nensure\n  2 rescue 3\nend"
+    util_compare inn, out
+  end
+  
+  def test_nested_rescue_exception
+    inn = s(:ensure, s(:lit, 1), s(:rescue, s(:lit, 2), s(:resbody, s(:array, s(:const, :Exception)), s(:lit, 3))))
+    out = "begin\n  1\nensure\n  begin\n    2\n  rescue Exception\n    3\n  end\nend"
+    util_compare inn, out
+  end
+
+  def test_nested_rescue_exception2
+    inn = s(:ensure, s(:rescue, s(:lit, 2), s(:resbody, s(:array, s(:const, :Exception)), s(:lit, 3))), s(:lit, 1))
+    out = "begin\n  2\nrescue Exception\n  3\nensure\n  1\nend"
+    util_compare inn, out
+  end
+
+  def test_rescue_block
+    inn = s(:rescue,
+            s(:call, nil, :alpha, s(:arglist)),
+            s(:resbody, s(:array), 
+              s(:block,
+                s(:call, nil, :beta, s(:arglist)),
+                s(:call, nil, :gamma, s(:arglist)))))
+    out = "begin\n  alpha\nrescue\n  beta\n  gamma\nend"
+    util_compare inn, out
+  end
+  
   def util_compare sexp, expected_ruby, expected_eval = nil
     assert_equal expected_ruby, @processor.process(sexp)
     assert_equal expected_eval, eval(expected_ruby) if expected_eval

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ruby2ruby
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 1
   - 3
-  - 0
-  version: 1.3.0
+  - 1
+  version: 1.3.1
 platform: ruby
 authors: 
 - Ryan Davis
@@ -36,7 +36,7 @@ cert_chain:
   FBHgymkyj/AOSqKRIpXPhjC6
   -----END CERTIFICATE-----
 
-date: 2011-09-01 00:00:00 Z
+date: 2011-09-22 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sexp_processor