ruby2ruby 2.4.2 → 2.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 831b366b64498b5f2783288fbccbf4feac9c87b80ab472f1d7561fb3c1a9a807
-  data.tar.gz: a0a44de2c917acb356f92b0fb81c9bb97b68f255810b91218fb4ef4a57f7bd8a
+  metadata.gz: 3f72338e1430e938dcc3c0934ecef41cd7a1a589d8c67cde7419f05b9eb8b247
+  data.tar.gz: 2be6fc2a82fe2ca73fe59d9025ba6c3734d7571dcc867f2e3da800537cf71758
 SHA512:
-  metadata.gz: 766278dc4ca1886b5a9e5dca83f2d025d21d16ec100423d784ad7992dee41f0fd1573a82c2535ddd592e278b109099dcc44d9663a4e33d5a7116c6f7e9f4df04
-  data.tar.gz: 44875a9e97d38517f51adc6f16015d50f94d4daf854286f6ebc73b8f7dfb9fc446fb98408ac76680abfafe8746961177e47b1f16b794e59586d097ce137ef465
+  metadata.gz: fe9fe4523da05005533346ba4ba1806e3f1ba22c7d36faff48623d7827b108d4dc195ae77bf3124369fed874b28229cefcbfcc00d9c2596b7a638b2931d8f5c9
+  data.tar.gz: 314e0287a424263e3f05e013d06bde2e8f9c9b9dd3b69ce1d9c9358c820f23571c5a66cdd621200ff0315c25082886ef124f870f9fb9d38d403d607b2b77d747

data/History.rdoc

@@ -1,10 +1,18 @@
-=== 4.12.0 / 2019-03-12
+=== 2.4.3 / 2019-06-03
 
-* 3 bug fixes:
+* 4 bug fixes:
+
+  * Added shadow block args. (jaynetics)
+  * Fixed generation for block args w/ trailing commas.
+  * Fixed nested masgn block args and arrays. (jaynetics)
+  * Fixes for stabby proc / lambda changes.
+
+=== 2.4.2 / 2019-03-12
+
+* 2 bug fixes:
 
-  * Fixed sexp_body to return empty sexp instead of nil when using STRICT_SEXP.
-  * STRICT_SEXP=4+ fails w/ current use of concat. Removed concat from strictness for now.
-  * Use concat internally instead of splat. Some people have 20000 node sexps! (presidentbeef)
+  * Rewrote process_masgn to fix problems with nesting masgn in block args.
+  * Use RubyParser directly instead of versioned parsers.
 
 === 2.4.1 / 2018-02-15
 

data/lib/ruby2ruby.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby -w
 
-require 'rubygems'
-require 'sexp_processor'
+require "rubygems"
+require "sexp_processor"
 
 # :stopdoc:
 # REFACTOR: stolen from ruby_parser
@@ -15,13 +15,13 @@ class Regexp
 
   unless defined? CODES then
     CODES = {
-      EXTENDED   => 'x',
-      IGNORECASE => 'i',
-      MULTILINE  => 'm',
-      ENC_NONE   => 'n',
-      ENC_EUC    => 'e',
-      ENC_SJIS   => 's',
-      ENC_UTF8   => 'u',
+      EXTENDED   => "x",
+      IGNORECASE => "i",
+      MULTILINE  => "m",
+      ENC_NONE   => "n",
+      ENC_EUC    => "e",
+      ENC_SJIS   => "s",
+      ENC_UTF8   => "u",
     }
   end
 end
@@ -31,13 +31,13 @@ end
 # Generate ruby code from a sexp.
 
 class Ruby2Ruby < SexpProcessor
-  VERSION = "2.4.2" # :nodoc:
+  VERSION = "2.4.3" # :nodoc:
 
   # cutoff for one-liners
   LINE_LENGTH = 78
 
   # binary operation messages
-  BINARY = [:<=>, :==, :<, :>, :<=, :>=, :-, :+, :*, :/, :%, :<<, :>>, :**, :'!=', :^, :|, :&]
+  BINARY = [:<=>, :==, :<, :>, :<=, :>=, :-, :+, :*, :/, :%, :<<, :>>, :**, :"!=", :^, :|, :&]
 
   ##
   # Nodes that represent assignment and probably need () around them.
@@ -76,7 +76,7 @@ class Ruby2Ruby < SexpProcessor
     :lvar,
     :nil,
     :str,
-    :true
+    :true,
   ]
 
   def initialize # :nodoc:
@@ -118,6 +118,8 @@ class Ruby2Ruby < SexpProcessor
   def process_args exp # :nodoc:
     _, *args = exp
 
+    shadow = []
+
     args = args.map { |arg|
       case arg
       when Symbol then
@@ -131,15 +133,24 @@ class Ruby2Ruby < SexpProcessor
         when :kwarg then
           _, k, v = arg
           "#{k}: #{process v}"
+        when :shadow then
+          shadow << arg[1]
+          next
         else
           raise "unknown arg type #{arg.first.inspect}"
         end
+      when nil then
+        ""
       else
         raise "unknown arg type #{arg.inspect}"
       end
-    }
+    }.compact
+
+    args   = args.join(", ").strip
+    shadow = shadow.join(", ").strip
+    shadow = "; #{shadow}" unless shadow.empty?
 
-    "(#{args.join ', '})"
+    "(%s%s)" % [args, shadow]
   end
 
   def process_array exp # :nodoc:
@@ -180,7 +191,7 @@ class Ruby2Ruby < SexpProcessor
 
     code = rest.map { |sexp|
       src = process sexp
-      src = indent src unless src =~  /(^|\n)(rescue|ensure)/ # ensure no level 0 rescues
+      src = indent src unless src =~ /(^|\n)(rescue|ensure)/ # ensure no level 0 rescues
       src
     }
     code.unshift "begin"
@@ -238,7 +249,7 @@ class Ruby2Ruby < SexpProcessor
     @calls.push name
 
     in_context :arglist do
-      max = args.size-1
+      max = args.size - 1
       args = args.map.with_index { |arg, i|
         arg_type = arg.sexp_type
         is_empty_hash = arg == s(:hash)
@@ -249,7 +260,7 @@ class Ruby2Ruby < SexpProcessor
         strip_hash = (arg_type == :hash and
                       not BINARY.include? name and
                       not is_empty_hash and
-                      (i == max or args[i+1].sexp_type == :splat))
+                      (i == max or args[i + 1].sexp_type == :splat))
         wrap_arg = Ruby2Ruby::ASSIGN_NODES.include? arg_type
 
         arg = arg[2..-3] if strip_hash
@@ -262,19 +273,19 @@ class Ruby2Ruby < SexpProcessor
     case name
     when *BINARY then
       if safe_call
-        "#{receiver}&.#{name}(#{args.join(', ')})"
+        "#{receiver}&.#{name}(#{args.join(", ")})"
       elsif args.length > 1
-        "#{receiver}.#{name}(#{args.join(', ')})"
+        "#{receiver}.#{name}(#{args.join(", ")})"
       else
-        "(#{receiver} #{name} #{args.join(', ')})"
+        "(#{receiver} #{name} #{args.join(", ")})"
       end
     when :[] then
       receiver ||= "self"
-      "#{receiver}[#{args.join(', ')}]"
+      "#{receiver}[#{args.join(", ")}]"
     when :[]= then
       receiver ||= "self"
       rhs = args.pop
-      "#{receiver}[#{args.join(', ')}] = #{rhs}"
+      "#{receiver}[#{args.join(", ")}] = #{rhs}"
     when :"!" then
       "(not #{receiver})"
     when :"-@" then
@@ -283,7 +294,7 @@ class Ruby2Ruby < SexpProcessor
       "+#{receiver}"
     else
       args     = nil                    if args.empty?
-      args     = "(#{args.join(', ')})" if args
+      args     = "(#{args.join(", ")})" if args
       receiver = "#{receiver}."         if receiver and not safe_call
       receiver = "#{receiver}&."        if receiver and safe_call
 
@@ -304,11 +315,11 @@ class Ruby2Ruby < SexpProcessor
 
     expr = process expr
 
-    if expr then
-      result << "case #{expr}"
-    else
-      result << "case"
-    end
+    result << if expr then
+                "case #{expr}"
+              else
+                "case"
+              end
 
     result.concat rest.map { |pt|
       if pt and pt.sexp_type == :when
@@ -416,7 +427,7 @@ class Ruby2Ruby < SexpProcessor
       simple && body =~ /^\Abegin/ && body =~ /^end\z/
     body = indent(body) unless simple && body =~ /(^|\n)rescue/
 
-    return "#{comm}def #{name}#{args}\n#{body}\nend".gsub(/\n\s*\n+/, "\n")
+    "#{comm}def #{name}#{args}\n#{body}\nend".gsub(/\n\s*\n+/, "\n")
   end
 
   def process_defs exp # :nodoc:
@@ -475,10 +486,10 @@ class Ruby2Ruby < SexpProcessor
     ens  = process(ens) || "# do nothing"
     ens = "begin\n#{ens}\nend\n" if ens =~ /(^|\n)rescue/
 
-    body.sub!(/\n\s*end\z/, '')
+    body.sub!(/\n\s*end\z/, "")
     body = indent(body) unless body =~ /(^|\n)rescue/
 
-    return "#{body}\nensure\n#{indent ens}"
+    "#{body}\nensure\n#{indent ens}"
   end
 
   def process_evstr exp # :nodoc:
@@ -530,8 +541,6 @@ class Ruby2Ruby < SexpProcessor
   def process_hash(exp) # :nodoc:
     _, *pairs = exp
 
-    result = []
-
     result = pairs.each_slice(2).map { |k, v|
       if k.sexp_type == :kwsplat then
         "%s" % process(k)
@@ -546,7 +555,7 @@ class Ruby2Ruby < SexpProcessor
       end
     }
 
-    return result.empty? ? "{}" : "{ #{result.join(', ')} }"
+    result.empty? ? "{}" : "{ #{result.join(", ")} }"
   end
 
   def process_iasgn(exp) # :nodoc:
@@ -577,7 +586,7 @@ class Ruby2Ruby < SexpProcessor
         else
           r = "#{t} if #{c}"
         end
-        return r if r and (@indent+r).size < LINE_LENGTH and r !~ /\n/
+        return r if r and (@indent + r).size < LINE_LENGTH and r !~ /\n/
       end
 
       r = "if #{c} then\n#{indent(t)}\n"
@@ -588,52 +597,74 @@ class Ruby2Ruby < SexpProcessor
     elsif f
       unless expand then
         r = "#{f} unless #{c}"
-        return r if (@indent+r).size < LINE_LENGTH and r !~ /\n/
+        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"
+      "if #{c} then\n#{indent "# do nothing"}\nend"
     end
   end
 
+  def process_lambda exp # :nodoc:
+    "->"
+  end
+
   def process_iter(exp) # :nodoc:
     _, iter, args, body = exp
 
+    is_lambda = iter.sexp_type == :lambda
+
     iter = process iter
     body = process body if body
 
-    args = case args
-           when 0 then
+    args = case
+           when args == 0 then
              ""
+           when is_lambda then
+             " (#{process(args)[1..-2]})"
            else
              " |#{process(args)[1..-2]}|"
            end
 
     b, e = if iter == "END" then
-             [ "{", "}" ]
+             %w[ { } ]
            else
-             [ "do", "end" ]
+             %w[ do end ]
            end
 
-    iter.sub!(/\(\)$/, '')
+    iter.sub!(/\(\)$/, "")
 
     # REFACTOR: ugh
     result = []
-    result << "#{iter} {"
-    result << args
-    if body then
-      result << " #{body.strip} "
+    if is_lambda then
+      result << iter
+      result << args
+      result << " {"
     else
-      result << ' '
+      result << "#{iter} {"
+      result << args
     end
+    result << if body then
+                " #{body.strip} "
+              else
+                " "
+              end
     result << "}"
     result = result.join
     return result if result !~ /\n/ and result.size < LINE_LENGTH
 
     result = []
-    result << "#{iter} #{b}"
-    result << args
+
+    if is_lambda then
+      result << iter
+      result << args
+      result << " #{b}"
+    else
+      result << "#{iter} #{b}"
+      result << args
+    end
+
     result << "\n"
     if body then
       result << indent(body.strip)
@@ -677,43 +708,28 @@ class Ruby2Ruby < SexpProcessor
   end
 
   def process_masgn(exp) # :nodoc:
-    _, (type, *), * = exp # ugly, but STRICT_SEXP=1+ requires this
-
-    if type == :array then
-      _, lhs, rhs = exp
-
-      case exp.length
-      when 3 then               # a, b = c, d
-        lhs = lhs.sexp_body.map { |e|
-          process e
-        }
-
-        rhs = case rhs && rhs.sexp_type
-              when :array then  # a, b = [c, d]
-                process(rhs)[1..-2]
-              else              # a, b = c
-                process rhs
-              end
-        "%s = %s" % [lhs.join(", "), rhs]
-      when 2 then               # a, (b, c) = ...
-        "(%s)" % [process(lhs)[1..-2]]
-      else
-        raise "unknown masgn length: %p" % [exp]
-      end
-    else                        # a { |(b, c)| ... }
-      lhs = exp.sexp_body.map { |e|
-        case e
-        when Symbol then
-          e
-        when Sexp then
-          process e
+    # s(:masgn, s(:array, s(:lasgn, :var), ...), s(:to_ary, <val>, ...))
+    # s(:iter, <call>, s(:args, s(:masgn, :a, :b)), <body>)
+    parenthesize = true
+
+    result = exp.sexp_body.map { |sexp|
+      case sexp
+      when Sexp then
+        if sexp.sexp_type == :array then
+          parenthesize = context.grep(:masgn).size > 1
+          res = process sexp
+
+          res[1..-2]
         else
-          raise "unknown masgn type: %p" % [e]
+          process sexp
         end
-      }
-
-      "(%s)" % [lhs.join(", ")]
-    end
+      when Symbol then
+        sexp
+      else
+        raise "unknown masgn: #{sexp.inspect}"
+      end
+    }
+    parenthesize ? "(#{result.join ", "})" : result.join(" = ")
   end
 
   def process_match exp # :nodoc:
@@ -811,14 +827,14 @@ class Ruby2Ruby < SexpProcessor
     # a &&= 1
     # [[:lvar, :a], [:lasgn, :a, [:lit, 1]]]
     _, _lhs, rhs = exp
-    process(rhs).sub(/\=/, '&&=')
+    process(rhs).sub(/\=/, "&&=")
   end
 
   def process_op_asgn_or(exp) # :nodoc:
     # a ||= 1
     # [[:lvar, :a], [:lasgn, :a, [:lit, 1]]]
     _, _lhs, rhs = exp
-    process(rhs).sub(/\=/, '||=')
+    process(rhs).sub(/\=/, "||=")
   end
 
   def process_or(exp) # :nodoc:
@@ -856,10 +872,9 @@ class Ruby2Ruby < SexpProcessor
 
   def process_rescue exp # :nodoc:
     _, *rest = exp
-    exp = nil
 
     body = process rest.shift unless rest.first.sexp_type == :resbody
-    els  = process rest.pop   unless rest.last && rest.last.sexp_type  == :resbody
+    els  = process rest.pop   unless rest.last && rest.last.sexp_type == :resbody
 
     body ||= "# do nothing"
 
@@ -878,7 +893,7 @@ class Ruby2Ruby < SexpProcessor
     if els then
       "#{indent body}\n#{resbodies.join("\n")}\nelse\n#{indent els}"
     elsif simple then
-      resbody = resbodies.first.sub(/\n\s*/, ' ')
+      resbody = resbodies.first.sub(/\n\s*/, " ")
       "#{body} #{resbody}"
     else
       "#{indent body}\n#{resbodies.join("\n")}"
@@ -911,7 +926,7 @@ class Ruby2Ruby < SexpProcessor
 
     raise "dunno what to do: #{args.inspect}" if args
 
-    name = name.to_s.sub(/=$/, '')
+    name = name.to_s.sub(/=$/, "")
 
     if rhs && rhs != s(:arglist) then
       "#{receiver}&.#{name} = #{process rhs}"
@@ -1004,7 +1019,7 @@ class Ruby2Ruby < SexpProcessor
   end
 
   def process_until(exp) # :nodoc:
-    cond_loop(exp, 'until')
+    cond_loop(exp, "until")
   end
 
   def process_valias exp # :nodoc:
@@ -1048,7 +1063,7 @@ class Ruby2Ruby < SexpProcessor
     }
 
     unless args.empty? then
-      "yield(#{args.join(', ')})"
+      "yield(#{args.join(", ")})"
     else
       "yield"
     end
@@ -1209,7 +1224,7 @@ class Ruby2Ruby < SexpProcessor
   # Wrap appropriate expressions in matching parens.
 
   def parenthesize exp
-    case self.context[1]
+    case context[1]
     when nil, :defn, :defs, :class, :sclass, :if, :iter, :resbody, :when, :while then
       exp
     else
@@ -1243,18 +1258,13 @@ class Ruby2Ruby < SexpProcessor
     str = dthing_escape(type, str)
 
     rest = rest.map { |pt|
-      case pt
-      when Sexp then # TODO: what the fuck? why??
-        case pt.sexp_type
-        when :str then
-          dthing_escape(type, pt.last)
-        when :evstr then
-          '#{%s}' % [process(pt)]
-        else
-          raise "unknown type: #{pt.inspect}"
-        end
+      case pt.sexp_type
+      when :str then
+        dthing_escape(type, pt.last)
+      when :evstr then
+        '#{%s}' % [process(pt)]
       else
-        raise "unhandled value in d-thing: #{pt.inspect}"
+        raise "unknown type: #{pt.inspect}"
       end
     }
 
@@ -1264,7 +1274,7 @@ class Ruby2Ruby < SexpProcessor
   ##
   # Utility method to generate ether a module or class.
 
-  def util_module_or_class(exp, is_class=false)
+  def util_module_or_class exp, is_class = false
     result = []
 
     _, name, *body = exp
@@ -1285,11 +1295,11 @@ class Ruby2Ruby < SexpProcessor
       process(sexp).chomp
     }
 
-    unless body.empty? then
-      body = indent(body.join("\n\n")) + "\n"
-    else
-      body = ""
-    end
+    body = unless body.empty? then
+             indent(body.join("\n\n")) + "\n"
+           else
+             ""
+           end
 
     result << body
     result << "end"

data/test/test_ruby2ruby.rb

@@ -2,22 +2,22 @@
 
 $TESTING = true
 
-$: << 'lib'
+$: << "lib"
 
-require 'minitest/autorun'
-require 'ruby2ruby'
-require 'pt_testcase'
-require 'fileutils'
-require 'tmpdir'
-require 'ruby_parser' if ENV["CHECK_SEXPS"]
+require "minitest/autorun"
+require "ruby2ruby"
+require "pt_testcase"
+require "fileutils"
+require "tmpdir"
+require "ruby_parser" if ENV["CHECK_SEXPS"]
 
 class R2RTestCase < ParseTreeTestCase
   def self.previous key
     "ParseTree"
   end
 
-  def self.generate_test klass, node, data, input_name, output_name
-    output_name = data.has_key?('Ruby2Ruby') ? 'Ruby2Ruby' : 'Ruby'
+  def self.generate_test klass, node, data, input_name, _output_name
+    output_name = data.key?("Ruby2Ruby") ? "Ruby2Ruby" : "Ruby"
 
     klass.class_eval <<-EOM
       def test_#{node}
@@ -170,7 +170,7 @@ class TestRuby2Ruby < R2RTestCase
     assert_equal exp, Ruby2Ruby.new.process(sexp)
   end
 
-  def assert_rt src, exp=src.dup
+  def assert_rt src, exp = src.dup
     assert_equal exp, Ruby2Ruby.new.process(RubyParser.new.parse(src))
   end
 
@@ -297,7 +297,7 @@ class TestRuby2Ruby < R2RTestCase
   def test_attr_writer_same
     do_not_check_sexp!
 
-    inn = s(:defn, :same=, s(:args, :o), s(:iasgn, :@same , s(:lvar, :o)))
+    inn = s(:defn, :same=, s(:args, :o), s(:iasgn, :@same, s(:lvar, :o)))
     out = "attr_writer :same"
     assert_parse inn, out
   end
@@ -443,6 +443,17 @@ class TestRuby2Ruby < R2RTestCase
     assert_parse inn, out
   end
 
+  def test_shadow_block_args
+    inn = s(:iter,
+            s(:call, nil, :a),
+            s(:args,
+              s(:shadow, :b),
+              s(:shadow, :c)))
+    out = 'a { |; b, c| }'
+
+    assert_parse inn, out
+  end
+
   def test_masgn_block_arg
     inn = s(:iter,
             s(:call,
@@ -458,6 +469,42 @@ class TestRuby2Ruby < R2RTestCase
     assert_parse inn, out
   end
 
+  def test_single_nested_masgn_block_arg
+    inn = s(:iter,
+            s(:call, nil, :a),
+            s(:args,
+              s(:masgn,
+                s(:masgn,
+                  s(:masgn, :b)))))
+    out = "a { |(((b)))| }"
+
+    assert_parse inn, out
+  end
+
+  def test_multiple_nested_masgn_block_arg
+    inn = s(:iter,
+            s(:call, nil, :a),
+            s(:args, :b,
+              s(:masgn,
+                s(:masgn, :c, :d),
+                :e,
+                s(:masgn, :f, :g))))
+    out = "a { |b, ((c, d), e, (f, g))| }"
+
+    assert_parse inn, out
+  end
+
+  def test_multiple_nested_masgn_array
+    inn = s(:masgn,
+            s(:array,
+              s(:masgn, s(:array, s(:lasgn, :a), s(:lasgn, :b))),
+              s(:lasgn, :c)),
+            s(:to_ary, s(:call, nil, :fn)))
+    out = "(a, b), c = fn"
+
+    assert_parse inn, out
+  end
+
   def test_masgn_wtf
     inn = s(:block,
             s(:masgn,
@@ -516,7 +563,7 @@ class TestRuby2Ruby < R2RTestCase
               :z,
               s(:lit, 1))
 
-    out ="x&.y&.z(1)"
+    out = "x&.y&.z(1)"
     assert_parse inn, out
   end
 
@@ -817,10 +864,10 @@ end
 # s
 # t  new    2    3
 
-tr2r = File.read(__FILE__).split(/\n/)[start+1..__LINE__-2].join("\n")
+tr2r = File.read(__FILE__).split(/\n/)[start + 1..__LINE__ - 2].join("\n")
 ir2r = File.read("lib/ruby2ruby.rb")
 
-require 'ruby_parser'
+require "ruby_parser"
 
 def silent_eval ruby
   old, $-w = $-w, nil
@@ -837,9 +884,9 @@ def morph_and_eval src, from, to, processor
 end
 
 unless ENV["SIMPLE"] then
-  ____ = morph_and_eval tr2r, /TestRuby2Ruby/, 'TestRuby2Ruby2', Ruby2Ruby
-  ruby = morph_and_eval ir2r, /Ruby2Ruby/,     'Ruby2Ruby2',     Ruby2Ruby
-  ____ = morph_and_eval ruby, /Ruby2Ruby2/,    'Ruby2Ruby3',     Ruby2Ruby2
+  ____ = morph_and_eval tr2r, /TestRuby2Ruby/, "TestRuby2Ruby2", Ruby2Ruby
+  ruby = morph_and_eval ir2r, /Ruby2Ruby/,     "Ruby2Ruby2",     Ruby2Ruby
+  ____ = morph_and_eval ruby, /Ruby2Ruby2/,    "Ruby2Ruby3",     Ruby2Ruby2
 
   class TestRuby2Ruby1 < TestRuby2Ruby
     def setup

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby2ruby
 version: !ruby/object:Gem::Version
-  version: 2.4.2
+  version: 2.4.3
 platform: ruby
 authors:
 - Ryan Davis
@@ -29,7 +29,7 @@ cert_chain:
   Em82dBUFsipwMLCYj39kcyHWAxyl6Ae1Cn9r/ItVBCxoeFdrHjfavnrIEoXUt4bU
   UfBugfLD19bu3nvL+zTAGx/U
   -----END CERTIFICATE-----
-date: 2019-03-13 00:00:00.000000000 Z
+date: 2019-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sexp_processor