ruby2ruby 2.4.4 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0a68c49fb78276f0904646fd04f48042d124b765d63cca627967c5f36d232ad
-  data.tar.gz: 397b684e0d7a1d64b0ec2cc9a9c6419340021d7000302f72524d1af075cc63ea
+  metadata.gz: 81af7fc05fec7a9e31a0e7e0e707526277c4535d0b7a5b12f67ab524989bc355
+  data.tar.gz: df311f1adf30683d68b615494249bd903dfb962b52936031c02b1c3fe147e1eb
 SHA512:
-  metadata.gz: a39d237921b8aa506673f3efb48c4c0cf570ad36eca10399eef3e0a89261eb6cc65f87f4023793f61a64b3db1b73c935ba24b0cbb0a9c5d6aa394a5c6ee94863
-  data.tar.gz: 8a3fd4b2479cc4bdb89e420f6a4173c1e30719456bc3f3b53b9828bbc243fcc65d8fbd922ac5a9516a862d2059e16c19517020fca925b730b3bbccec4eb6e1cf
+  metadata.gz: 60363a4606501b46962382d2343a49e1687a85f608b039936b516619209f407292052da552b1328ae02c872d7972d7b839b2de4d28ca6c2945e2a77746046417
+  data.tar.gz: cb1f7cf0373c3f2f8ed7adfdd2688ad2cf9b262db3f058cf7f6bb43b195ba7a1e270b168039396a26923d0d21aa2a23233f4b0c8f2e2f5e49ce3ff87efcfd30b

data/History.rdoc

@@ -1,3 +1,19 @@
+=== 2.5.0 / 2022-10-04
+
+* 5 minor enhancements:
+
+  * Added support for (most?) pattern matching.
+  * Added support for **kwrest.
+  * Added support for forward args (...), defn and call.
+  * Added support for preexe (BEGIN { ... }).
+  * Support ruby 3.1 hash shorthand syntax. (presidentbeef)
+
+* 3 bug fixes:
+
+  * Fix generation of case w/ no else.
+  * Fixed a bug block shadow vars (they're grouped)
+  * Fixed find_pat up (after fixing a find_pat bug in ruby_parser).
+
 === 2.4.4 / 2019-09-24
 
 * 1 bug fix:

data/Rakefile

@@ -79,6 +79,24 @@ task :debug => :isolate do
   puts process(ruby, file)
 end
 
+task :parse => :isolate do
+  require "ruby_parser"
+  require "pp"
+
+  parser = RubyParser.for_current_ruby
+
+  file = ENV["F"]
+  ruby = ENV["R"]
+
+  if ruby then
+    file = "env"
+  else
+    ruby = File.read file
+  end
+
+  pp parser.process(ruby, file)
+end
+
 task :bugs do
   sh "for f in bug*.rb ; do #{Gem.ruby} -S rake debug F=$f && rm $f ; done"
 end

data/lib/ruby2ruby.rb

@@ -31,7 +31,7 @@ end
 # Generate ruby code from a sexp.
 
 class Ruby2Ruby < SexpProcessor
-  VERSION = "2.4.4" # :nodoc:
+  VERSION = "2.5.0" # :nodoc:
 
   # cutoff for one-liners
   LINE_LENGTH = 78
@@ -134,8 +134,10 @@ class Ruby2Ruby < SexpProcessor
           _, k, v = arg
           "#{k}: #{process v}"
         when :shadow then
-          shadow << arg[1]
+          shadow << arg.sexp_body
           next
+        when :forward_args then
+          "..."
         else
           raise "unknown arg type #{arg.first.inspect}"
         end
@@ -322,9 +324,10 @@ class Ruby2Ruby < SexpProcessor
               end
 
     result.concat rest.map { |pt|
-      if pt and pt.sexp_type == :when
+      if pt and %i[when in].include? pt.sexp_type
         "#{process pt}"
       else
+        next unless pt
         code = indent process pt
         code = indent("# do nothing") if code =~ /^\s*$/
         "else\n#{code}"
@@ -333,7 +336,7 @@ class Ruby2Ruby < SexpProcessor
 
     result << "end"
 
-    result.join "\n"
+    result.compact.join "\n"
   end
 
   def process_cdecl exp # :nodoc:
@@ -366,13 +369,26 @@ class Ruby2Ruby < SexpProcessor
   def process_const exp # :nodoc:
     _, name = exp
 
+    name = process name if Sexp === name
+
     name.to_s
   end
 
+  def __var name
+    case context[1]
+    when /_pat$/ then
+      "^#{name}"
+    when :in then
+      "^#{name}"
+    else
+      name.to_s
+    end
+  end
+
   def process_cvar exp # :nodoc:
     _, name = exp
 
-    name.to_s
+    __var name
   end
 
   def process_cvasgn exp # :nodoc:
@@ -528,6 +544,10 @@ class Ruby2Ruby < SexpProcessor
     result.join "\n"
   end
 
+  def process_forward_args exp
+    "..."
+  end
+
   def process_gasgn exp # :nodoc:
     process_iasgn exp
   end
@@ -535,7 +555,7 @@ class Ruby2Ruby < SexpProcessor
   def process_gvar exp # :nodoc:
     _, name = exp
 
-    name.to_s
+    __var name
   end
 
   def process_hash(exp) # :nodoc:
@@ -544,6 +564,13 @@ class Ruby2Ruby < SexpProcessor
     result = pairs.each_slice(2).map { |k, v|
       if k.sexp_type == :kwsplat then
         "%s" % process(k)
+      elsif v.nil?
+        # Shorthand hash syntax
+        unless k.sexp_type == :lit and k.value.is_a? Symbol
+          raise "Expected symbol for hash key, but got #{k.inspect}"
+        end
+
+        "#{k.value}:"
       else
         t = v.sexp_type
 
@@ -568,6 +595,89 @@ class Ruby2Ruby < SexpProcessor
     end
   end
 
+  def process_in exp # :nodoc:
+    _, lhs, *rhs = exp
+
+    cond = process lhs
+    body = rhs.compact.map { |sexp| indent process sexp }
+
+    body << indent("# do nothing") if body.empty?
+    body = body.join "\n"
+
+    "in #{cond} then\n#{body.chomp}"
+  end
+
+  def process_find_pat exp # :nodoc:
+    _, a, b, *c, d = exp
+
+      a = process a               # might be nil
+      b = process b if Sexp === b
+      c = c.map { |sexp| process sexp }.join(", ")
+      d = process d if Sexp === d
+
+      "%s[%s, %s, %s]" % [a, b, c, d]
+  end
+
+  def process_array_pat exp # :nodoc:
+    _, const, *rest = exp
+
+    const = process const if const
+
+    rest = rest.map { |sexp|
+      case sexp
+      when Sexp
+        process sexp
+      else
+        sexp
+      end
+    }
+
+    "%s[%s]" % [const, rest.join(", ")]
+  end
+
+  def process_kwrest exp # :nodoc:
+    _, name = exp
+
+    name.to_s
+  end
+
+  def process_hash_pat exp # :nodoc:
+    _, const, *rest = exp
+
+    if const then
+      const = process const
+      kwrest = process rest.pop if rest.last && rest.last.sexp_type == :kwrest
+
+      rest = rest.each_slice(2).map { |k, v|
+        k = process(k).delete_prefix ":"
+        v = process v
+
+        "#{k}: #{v}".strip
+      }
+
+      rest << kwrest if kwrest
+
+      rest.empty? ? "%s[]" % const : "%s[%s]" % [const, rest.join(", ")]
+    else
+      kwrest = process rest.pop if rest.last && rest.last.sexp_type == :kwrest
+
+      rest = rest.each_slice(2).map { |k, v|
+        k = process(k).delete_prefix ":"
+        v = process v
+
+        "#{k}: #{v}".strip
+      }
+
+      rest << kwrest if kwrest
+
+      rest.empty? ? "{}" : "{ %s }" % [rest.join(", ")]
+    end
+  end
+
+  def process_preexe exp # :nodoc:
+    "BEGIN"
+  end
+
   def process_if(exp) # :nodoc:
     _, c, t, f = exp
 
@@ -610,6 +720,8 @@ class Ruby2Ruby < SexpProcessor
     "->"
   end
 
+  MUST_BE_CURLY = %w[ BEGIN END ]
+
   def process_iter(exp) # :nodoc:
     _, iter, args, body = exp
 
@@ -627,7 +739,7 @@ class Ruby2Ruby < SexpProcessor
              " |#{process(args)[1..-2]}|"
            end
 
-    b, e = if iter == "END" then
+    b, e = if MUST_BE_CURLY.include? iter then
              %w[ { } ]
            else
              %w[ do end ]
@@ -676,7 +788,8 @@ class Ruby2Ruby < SexpProcessor
 
   def process_ivar(exp) # :nodoc:
     _, name = exp
-    name.to_s
+
+    __var name
   end
 
   def process_kwsplat(exp)
@@ -687,9 +800,18 @@ class Ruby2Ruby < SexpProcessor
   def process_lasgn(exp) # :nodoc:
     _, name, value = exp
 
-    s = "#{name}"
-    s += " = #{process value}" if value
-    s
+    value = process value
+
+    if value then
+      "%s %s %s" % case context[1]
+                   when /_pat$/ then
+                     [value, "=>", name]
+                   else
+                     [name, "=", value]
+                   end
+    else
+      "%s" % [name]
+    end
   end
 
   def process_lit exp # :nodoc:
@@ -704,7 +826,8 @@ class Ruby2Ruby < SexpProcessor
 
   def process_lvar(exp) # :nodoc:
     _, name = exp
-    name.to_s
+
+    __var name
   end
 
   def process_masgn(exp) # :nodoc:
@@ -793,12 +916,20 @@ class Ruby2Ruby < SexpProcessor
 
   def process_op_asgn exp # :nodoc:
     # [[:lvar, :x], [:call, nil, :z, [:lit, 1]], :y, :"||"]
-    _, lhs, rhs, index, op = exp
 
-    lhs = process lhs
-    rhs = process rhs
+    case exp.length
+    when 4
+      raise "NOT YET: op_asgn 4"
+    when 5
+      _, lhs, rhs, index, op = exp
+
+      lhs = process lhs
+      rhs = process rhs
 
-    "#{lhs}.#{index} #{op}= #{rhs}"
+      "#{lhs}.#{index} #{op}= #{rhs}"
+    else
+      raise ArgumentError, "Don't know how to process this length: %p" % [exp]
+    end
   end
 
   def process_op_asgn1(exp) # :nodoc:
@@ -840,7 +971,15 @@ class Ruby2Ruby < SexpProcessor
   def process_or(exp) # :nodoc:
     _, lhs, rhs = exp
 
-    "(#{process lhs} or #{process rhs})"
+    lhs = process lhs
+    rhs = process rhs
+
+    case context[1]
+    when :in then
+      "(#{lhs} | #{rhs})"
+    else
+      "(#{lhs} or #{rhs})"
+    end
   end
 
   def process_postexe(exp) # :nodoc:
@@ -1029,10 +1168,6 @@ class Ruby2Ruby < SexpProcessor
   end
 
   def process_when exp # :nodoc:
-    s(:when, s(:array, s(:lit, 1)),
-      s(:call, nil, :puts, s(:str, "something")),
-      s(:lasgn, :result, s(:str, "red")))
-
     _, lhs, *rhs = exp
 
     cond = process(lhs)[1..-2]

data/test/test_ruby2ruby.rb

@@ -100,8 +100,8 @@ class TestRuby2Ruby < R2RTestCase
   end
 
   def test_hash_parens_lvar
-    inn = s(:hash, s(:lit, :k), s(:lvar, :x))
-    out = "{ :k => x }"
+    inn = s(:hash, s(:lit, :k), s(:lvar, :a))
+    out = "{ :k => a }"
     assert_parse inn, out
   end
 
@@ -118,6 +118,23 @@ class TestRuby2Ruby < R2RTestCase
     assert_parse inn, out
   end
 
+  def test_hash_shorthand
+    inn = s(:hash, s(:lit, :k), nil)
+    out = '{ k: }'
+
+    assert_parse inn, out
+  end
+
+  def test_hash_shorthand_invalid_key_type
+    do_not_check_sexp!
+
+    inn = s(:hash, s(:str, 'k'), nil)
+    out = '{ k: }'
+    assert_raises do
+      assert_parse inn, out
+    end
+  end
+
   def test_and_alias
     inn = s(:and, s(:true), s(:alias, s(:lit, :a), s(:lit, :b)))
     out = "true and (alias :a :b)"
@@ -351,15 +368,6 @@ class TestRuby2Ruby < R2RTestCase
     assert_parse inn, out
   end
 
-  def test_defn_kwargs
-    inn = s(:defn, :initialize,
-            s(:args, :arg, s(:kwarg, :keyword, s(:nil)), :"**args"),
-            s(:nil))
-    out = "def initialize(arg, keyword: nil, **args)\n  # do nothing\nend"
-
-    assert_parse inn, out
-  end
-
   def test_defn_kwargs2
     inn = s(:defn, :initialize,
             s(:args, :arg,
@@ -373,55 +381,34 @@ class TestRuby2Ruby < R2RTestCase
   end
 
   def test_call_self_index
-    assert_parse s(:call, nil, :[], s(:lit, 42)), "self[42]"
+    assert_parse s(:call, s(:self), :[], s(:lit, 42)), "self[42]"
   end
 
   def test_call_self_index_equals
     assert_parse(s(:attrasgn, s(:self), :[]=, s(:lit, 42), s(:lit, 24)),
                  "self[42] = 24")
-  end
-
-  def test_call_self_index_equals_array
     assert_parse(s(:attrasgn, s(:self), :[]=, s(:lit, 1), s(:lit, 2), s(:lit, 3)),
                  "self[1, 2] = 3")
   end
 
-  def test_call_arglist_hash_first
-    inn = s(:call, nil, :method,
-            s(:hash, s(:lit, :a), s(:lit, 1)),
-            s(:call, nil, :b))
-    out = "method({ :a => 1 }, b)"
-
-    assert_parse inn, out
-  end
-
   def test_call_arglist_hash_first_last
     inn = s(:call, nil, :method,
             s(:hash, s(:lit, :a), s(:lit, 1)),
-            s(:call, nil, :b),
+            s(:lvar, :b),
             s(:hash, s(:lit, :c), s(:lit, 1)))
     out = "method({ :a => 1 }, b, :c => 1)"
 
     assert_parse inn, out
   end
 
-  def test_call_arglist_hash_last
-    inn = s(:call, nil, :method,
-            s(:call, nil, :b),
-            s(:hash, s(:lit, :a), s(:lit, 1)))
-    out = "method(b, :a => 1)"
-
-    assert_parse inn, out
-  end
-
   def test_call_arglist_if
     inn = s(:call,
-            s(:call, nil, :a),
+            s(:lvar, :a),
             :+,
             s(:if,
-              s(:call, nil, :b),
-              s(:call, nil, :c),
-              s(:call, nil, :d)))
+              s(:lvar, :b),
+              s(:lvar, :c),
+              s(:lvar, :d)))
 
     out = "(a + (b ? (c) : (d)))"
     assert_parse inn, out
@@ -443,12 +430,25 @@ class TestRuby2Ruby < R2RTestCase
     assert_parse inn, out
   end
 
+  def test_forward_args__defn
+    inn = s(:defn, :x, s(:args, :a, s(:forward_args)), s(:nil))
+    out = "def x(a, ...)\n  # do nothing\nend"
+
+    assert_parse inn, out
+  end
+
+  def test_forward_args__call
+    inn = s(:call, nil, :y, s(:forward_args))
+    out = "y(...)"
+
+    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)))
+              s(:shadow, :b, :c)))
     out = 'a { |; b, c| }'
 
     assert_parse inn, out
@@ -481,19 +481,6 @@ class TestRuby2Ruby < R2RTestCase
     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,
@@ -544,6 +531,13 @@ class TestRuby2Ruby < R2RTestCase
     assert_parse inn, out
   end
 
+  def test_preexe
+    inn = s(:iter, s(:preexe), 0, s(:block, s(:lit, 1), s(:lit, 2), s(:lit, 3)))
+    out = "BEGIN {\n  1\n  2\n  3\n}"
+
+    assert_parse inn, out
+  end
+
   def test_safe_attrasgn
     inn = s(:safe_attrasgn,
             s(:call, nil, :x),
@@ -578,6 +572,8 @@ class TestRuby2Ruby < R2RTestCase
   end
 
   def test_safe_op_asgn
+    do_not_check_sexp! # TODO: fix!
+
     inn = s(:safe_op_asgn,
             s(:call, nil, :x),
             s(:call, nil, :z, s(:lit, 1)),
@@ -611,38 +607,6 @@ class TestRuby2Ruby < R2RTestCase
     assert_parse inn, out
   end
 
-  def test_resbody_block
-    inn = s(:rescue,
-            s(:call, nil, :x1),
-            s(:resbody,
-              s(:array),
-              s(:call, nil, :x2),
-              s(:call, nil, :x3)))
-
-    out = "begin\n  x1\nrescue\n  x2\n  x3\nend"
-    assert_parse inn, out
-  end
-
-  def test_resbody_short_with_begin_end
-    # "begin; blah; rescue; []; end"
-    inn = s(:rescue,
-            s(:call, nil, :blah),
-            s(:resbody, s(:array), s(:array)))
-    out = "blah rescue []"
-    assert_parse inn, out
-  end
-
-  def test_resbody_short_with_begin_end_multiple
-    # "begin; blah; rescue; []; end"
-    inn = s(:rescue,
-            s(:call, nil, :blah),
-            s(:resbody, s(:array),
-              s(:call, nil, :log),
-              s(:call, nil, :raise)))
-    out = "begin\n  blah\nrescue\n  log\n  raise\nend"
-    assert_parse inn, out
-  end
-
   def test_resbody_short_with_defn_multiple
     inn = s(:defn,
             :foo,
@@ -678,9 +642,7 @@ class TestRuby2Ruby < R2RTestCase
   end
 
   def test_call_binary_call_with_hash_arg
-    # if 42
-    #   args << {:key => 24}
-    # end
+    # args << {:key => 24} if 42
 
     inn = s(:if, s(:lit, 42),
             s(:call, s(:call, nil, :args),
@@ -704,8 +666,8 @@ class TestRuby2Ruby < R2RTestCase
 
   def test_binary_operators_with_multiple_arguments
     Ruby2Ruby::BINARY.each do |op|
-      inn = s(:call, s(:lvar, :x), op, s(:lit, 2), s(:lit, 3))
-      out = "x.#{op}(2, 3)"
+      inn = s(:call, s(:lvar, :a), op, s(:lit, 2), s(:lit, 3))
+      out = "a.#{op}(2, 3)"
       assert_parse inn, out
     end
   end
@@ -722,6 +684,297 @@ class TestRuby2Ruby < R2RTestCase
     assert_parse inn, out
   end
 
+  def test_case_in_normal_01
+    assert_case_in "var", s(:lasgn, :var)
+  end
+
+  def test_case_in_normal_02
+    assert_case_in "^var", s(:lvar, :var)
+  end
+
+  def test_case_in_normal_04
+    assert_case_in "A if true", s(:if, s(:true), s(:const, :A), nil)
+  end
+
+  def test_case_in_normal_05
+    assert_case_in "A unless true", s(:if, s(:true), nil, s(:const, :A))
+  end
+
+  def test_case_in_normal_06
+    assert_case_in "A::B",   s(:const, s(:colon2, s(:const, :A), :B))
+  end
+
+  def test_case_in_normal_07
+    assert_case_in "A | B", s(:or, s(:const, :A), s(:const, :B)), "(A | B)"
+
+    # TODO: assert_case_in "(A or B)", s(:const, s(:colon2, s(:colon3, :A), :B))
+  end
+
+  def test_case_in_normal_08
+    assert_case_in "::A::B", s(:const, s(:colon2, s(:colon3, :A), :B))
+  end
+
+  def test_case_in_normal_09
+    assert_case_in "A", s(:const, :A)
+  end
+
+  def test_case_in__array_pat_00
+    assert_case_in "Object[]", s(:array_pat, s(:const, :Object))
+  end
+
+  def test_case_in__array_pat_01
+    assert_case_in "[]", s(:array_pat)
+  end
+
+  def test_case_in__array_pat_02
+    assert_case_in "[*, ::NilClass]", s(:array_pat, nil, :*, s(:colon3, :NilClass))
+  end
+
+  def test_case_in__array_pat_03
+    assert_case_in "[*, :b, :c]", s(:array_pat, nil, :*, s(:lit, :b), s(:lit, :c))
+  end
+
+  def test_case_in__array_pat_04
+    assert_case_in "[[:b, ^c], [:d, ^e]]", s(:array_pat, nil, s(:array_pat, nil, s(:lit, :b), s(:lvar, :c)), s(:array_pat, nil, s(:lit, :d), s(:lvar, :e)))
+  end
+
+  def test_case_in__array_pat_06
+    assert_case_in "[A, *, B]", s(:array_pat, nil, s(:const, :A), :*, s(:const, :B))
+  end
+
+  def test_case_in__array_pat_07
+    assert_case_in "[-> (b) { true }, ^c]", s(:array_pat, nil, s(:iter, s(:lambda), s(:args, :b), s(:true)), s(:lvar, :c))
+  end
+
+  def test_case_in__array_pat_09
+    assert_case_in "[:a, ^b, ^c, [:d, *e, nil]]", s(:array_pat, nil, s(:lit, :a), s(:lvar, :b), s(:lvar, :c), s(:array_pat, nil, s(:lit, :d), :"*e", s(:nil)))
+  end
+
+  def test_case_in__array_pat_14
+    assert_case_in "A[*list]", s(:array_pat, s(:const, :A), :"*list")
+  end
+
+  def test_case_in__array_pat_15
+    assert_case_in "B[C => d]", s(:array_pat, s(:const, :B), s(:lasgn, :d, s(:const, :C)))
+  end
+
+  def test_case_in__array_pat_16
+    assert_case_in "B[^c]", s(:array_pat, s(:const, :B), s(:lvar, :c))
+  end
+
+  def test_case_in__array_pat_19
+    assert_case_in "[^@a, ^$b, ^@@c]", s(:array_pat, nil, s(:ivar, :@a), s(:gvar, :$b), s(:cvar, :@@c)) # HACK: really not sure about this one
+  end
+
+  def test_case_in__find_pat_1
+    assert_case_in "[*a, :+, *b]", s(:find_pat, nil, :"*a",
+                                     s(:lit, :+),
+                                     :"*b")
+  end
+
+  def test_case_in__find_pat_2
+    assert_case_in "[*, :b, ^c, *]", s(:find_pat, nil,
+                                       :*,
+                                       s(:lit, :b), s(:lvar, :c),
+                                       :*)
+  end
+
+  def test_case_in__find_pat_3
+    assert_case_in("Array(*b, n, { a: }, m, *a)",
+                   s(:find_pat,
+                     s(:const, :Array),
+                     :"*b",
+                     s(:lasgn, :n),
+                     s(:hash_pat, nil, s(:lit, :a), nil),
+                     s(:lasgn, :m),
+                     :"*a"),
+                   "Array[*b, n, { a: }, m, *a]")
+  end
+
+  def test_case_in__find_pat_4
+    assert_case_in("*b, n, { a: }, m, *a", s(:find_pat,
+                                             nil,
+                                             :"*b",
+                                             s(:lasgn, :n),
+                                             s(:hash_pat, nil, s(:lit, :a), nil),
+                                             s(:lasgn, :m),
+                                             :"*a"),
+                   "[*b, n, { a: }, m, *a]")
+  end
+
+  def test_case_in__find_pat_5
+    assert_case_in("Array(*lhs, ^b, *rhs)", s(:find_pat,
+                                              s(:const, :Array),
+                                              :"*lhs",
+                                              s(:lvar, :b),
+                                              :"*rhs"),
+                   "Array[*lhs, ^b, *rhs]")
+  end
+
+  def test_case_in__find_pat_6
+    assert_case_in("Array[*lhs, b, *rhs]", s(:find_pat,
+                                             s(:const, :Array),
+                                             :"*lhs",
+                                             s(:lasgn, :b),
+                                             :"*rhs"))
+  end
+
+  def test_case_in__find_pat_7
+    assert_case_in("Array[*lhs, :b, *rhs]", s(:find_pat,
+                                              s(:const, :Array),
+                                              :"*lhs",
+                                              s(:lit, :b),
+                                              :"*rhs"))
+  end
+
+  def test_case_in_10
+    assert_case_in("[nil, nil, nil]",
+                   s(:array_pat,
+                     nil,
+                     s(:nil),
+                     s(:nil),
+                     s(:nil)))
+  end
+
+  def test_case_in_32_2
+    assert_case_in "1..3", s(:dot2, s(:lit, 1), s(:lit, 3)), "(1..3)"
+  end
+
+  def test_case_in_32_3
+    assert_case_in "1...3", s(:dot3, s(:lit, 1), s(:lit, 3)), "(1...3)"
+  end
+
+  def test_case_in_36
+    pt = s(:array_pat, nil,
+           s(:lit, :a), s(:lasgn, :b), s(:lvar, :d), :"*e", s(:nil))
+
+    assert_case_in "[:a, b, ^d, *e, nil]", pt
+  end
+
+  def test_case_in_42
+    rb = "case :a\nin [:b, *_] then\n  nil\nend"
+    pt = s(:case, s(:lit, :a),
+           s(:in,
+             s(:array_pat,
+               nil,
+               s(:lit, :b),
+               :"*_",
+              ),
+             s(:nil)),
+           nil)
+
+    assert_parse pt, rb
+    assert_variant pt, "case :a\nin :b, *_ then\n  nil\nend"
+  end
+
+  def test_case_in_42_2
+    rb = "case :a\nin A[*list] then\n  nil\nend"
+    pt = s(:case, s(:lit, :a),
+           s(:in,
+             s(:array_pat,
+               s(:const, :A),
+               :"*list"),
+             s(:nil)),
+           nil)
+
+    assert_parse pt, rb
+    assert_variant pt, "case :a\nin A(*list) then\n  nil\nend"
+  end
+
+  def test_case_in_67
+    rb = "case :a\nin 1.. then nil\nend"
+    rb = "case :a\nin (1..) then\n  nil\nend"
+    pt = s(:case,
+           s(:lit, :a),
+           s(:in, s(:dot2, s(:lit, 1), nil),
+             s(:nil)),
+           nil)
+
+    assert_parse pt, rb
+  end
+
+  def test_case_in_76
+    assert_case_in "`echo hi`", s(:xstr, "echo hi")
+  end
+
+  def test_case_in_77
+    assert_case_in "/regexp/", s(:lit, /regexp/)
+  end
+
+  def test_case_in_79
+    assert_case_in "%w[a b]", s(:array_pat, nil, s(:str, "a"), s(:str, "b")), "[\"a\", \"b\"]"
+  end
+
+  def test_case_in_80
+    assert_case_in "%I[a b]", s(:array_pat, nil, s(:lit, :a), s(:lit, :b)), "[:a, :b]"
+  end
+
+  def test_case_in_83
+    pt = s(:array_pat, nil,
+           s(:iter, s(:lambda), s(:args, :b),
+             s(:true)),
+           s(:lasgn, :c))
+
+    assert_case_in "[-> (b) { true }, c]", pt
+  end
+
+  def test_case_in_85
+    pt = s(:array_pat, nil,
+           s(:array_pat, nil,
+             s(:lit, :b),
+             s(:lasgn, :c)),
+           s(:array_pat,
+             nil,
+             s(:lit, :d),
+             s(:lvar, :e)),
+          )
+
+    assert_case_in "[[:b, c], [:d, ^e]]", pt
+  end
+
+  def test_case_in__hash_pat_00
+    assert_case_in "{}", s(:hash_pat, nil)
+  end
+
+  def test_case_in__hash_pat_01
+    assert_case_in "**nil",   s(:hash_pat, nil, s(:kwrest, :"**nil")), "{ **nil }"
+  end
+
+  def test_case_in__hash_pat_03
+    assert_case_in "a:", s(:hash_pat, nil, s(:lit, :a), nil), "{ a: }"
+  end
+
+  def test_case_in__hash_pat_06
+    assert_case_in "a:1, **r",s(:hash_pat, nil, s(:lit, :a), s(:lit, 1), s(:kwrest, :"**r")), "{ a: 1, **r }"
+  end
+
+  def test_case_in__hash_pat_08
+    assert_case_in "{ b: [Hash, *] }", s(:hash_pat, nil, s(:lit, :b), s(:array_pat, nil, s(:const, :Hash), :*))
+  end
+
+  def test_case_in__hash_pat_09
+    assert_case_in("{ b: Integer => x, d: \"e\", f: }",
+                   s(:hash_pat, nil,
+                     s(:lit, :b), s(:lasgn, :x, s(:const, :Integer)),
+                     s(:lit, :d), s(:str, "e"), s(:lit, :f), nil))
+  end
+
+  def test_case_in__hash_pat_10
+    assert_case_in "{ b: ^c, **r }", s(:hash_pat, nil, s(:lit, :b), s(:lvar, :c), s(:kwrest, :"**r"))
+  end
+
+  def test_case_in__hash_pat_11
+    assert_case_in "{ b: \"c\", d: \"e\" }", s(:hash_pat, nil, s(:lit, :b), s(:str, "c"), s(:lit, :d), s(:str, "e"))
+  end
+
+  def test_case_in__hash_pat_12
+    assert_case_in "{ b: true }", s(:hash_pat, nil, s(:lit, :b), s(:true))
+  end
+
+  def test_case_in__hash_pat_14
+    assert_case_in "Object[b: 1]", s(:hash_pat, s(:const, :Object), s(:lit, :b), s(:lit, 1))
+  end
+
   def test_interpolation_and_escapes
     # log_entry = "  \e[#{message_color}m#{message}\e[0m   "
     inn = s(:lasgn, :log_entry,
@@ -756,12 +1009,6 @@ class TestRuby2Ruby < R2RTestCase
     assert_parse inn, out
   end
 
-  def test_basic_ensure
-    inn = s(:ensure, s(:lit, 1), s(:lit, 2))
-    out = "begin\n  1\nensure\n  2\nend"
-    assert_parse 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"
@@ -775,18 +1022,18 @@ class TestRuby2Ruby < R2RTestCase
   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))))
+    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"
     assert_parse 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"
-    assert_parse inn, out
-  end
-
   def test_op_asgn
+    do_not_check_sexp! # TODO: fix!
+
     inn = s(:op_asgn,
             s(:call, nil, :x),
             s(:call, nil, :z, s(:lit, 1)),
@@ -809,42 +1056,80 @@ class TestRuby2Ruby < R2RTestCase
 
   def test_array_adds_parens_around_rescue
     inn = s(:array,
-            s(:call, nil, :a),
-            s(:rescue, s(:call, nil, :b), s(:resbody, s(:array), s(:call, nil, :c))))
+            s(:lvar, :a),
+            s(:rescue, s(:lvar, :b), s(:resbody, s(:array), s(:lvar, :c))))
     out = "[a, (b rescue c)]"
 
     assert_parse inn, out
   end
 
   def test_call_arglist_rescue
-    inn = s(:call,
-            nil,
-            :method,
+    inn = s(:call, nil, :method,
             s(:rescue,
-              s(:call, nil, :a),
-              s(:resbody, s(:array), s(:call, nil, :b))))
+              s(:lvar, :a),
+              s(:resbody, s(:array), s(:lvar, :b))))
     out = "method((a rescue b))"
     assert_parse inn, out
   end
 
   def test_unless_vs_if_not
+    do_not_check_sexp! # TODO: remove? dunno if that's possible w/ this one
+
     rb1 = "a unless b"
     rb2 = "a if (not b)"
     rb3 = "a if ! b"
 
-    assert_parse RubyParser.new.parse(rb1), rb1
+    assert_parse ruby_parser.parse(rb1), rb1
 
-    assert_parse RubyParser.new.parse(rb2), rb1
+    assert_parse ruby_parser.parse(rb2), rb1
 
-    assert_parse RubyParser.new.parse(rb3), rb1
+    assert_parse ruby_parser.parse(rb3), rb1
   end
 
-  def assert_parse sexp, expected_ruby, expected_eval = nil
-    assert_equal sexp, RubyParser.new.process(expected_ruby), "ruby -> sexp" if
-      @check_sexp
+  def ruby_parser
+    parser = RubyParser.for_current_ruby
+
+    %i[a b c d].each do |v|
+      parser.env[v] = :lvar
+    end
 
+    parser
+  end
+
+  def assert_parse sexp, expected_ruby, expected_eval = nil
     assert_equal expected_ruby, @processor.process(sexp), "sexp -> ruby"
     assert_equal expected_eval, eval(expected_ruby) if expected_eval
+    assert_variant sexp, expected_ruby if @check_sexp
+  end
+
+  def assert_variant sexp, expected_ruby
+    assert_equal sexp, ruby_parser.process(expected_ruby), "ruby -> sexp"
+  end
+
+  def assert_case_in lit, exp_pt, normal_lit = nil
+    rb = "case :a\nin #{normal_lit || lit} then\n  # do nothing\nend"
+
+    exp_pt.deep_each { |s| s.line ||= 2 }
+    exp_pt.line ||= 2
+
+    # flunk "redundant: #{lit.inspect}" if normal_lit == lit
+    # flunk "redundant: #{lit.inspect}" if normal_lit && normal_lit[1..-2] == lit
+    normal_lit, lit = lit, lit[1..-2] if lit =~ /^\[.+\]$/ && !normal_lit
+
+    if ENV["VERBOSE_TEST"] then
+      puts
+      puts rb
+    end
+
+    pt = s(:case, s(:lit, :a).line(1),
+           s(:in, exp_pt, nil).line(2),
+           nil).line(1)
+
+    if normal_lit then
+      assert_variant pt, "case :a\nin #{lit} then\n  # do nothing\nend"
+    end
+
+    assert_parse pt, rb
   end
 
   def util_thingy(type)
@@ -864,22 +1149,17 @@ end
 # s
 # t  new    2    3
 
-tr2r = File.read(__FILE__).split(/\n/)[start + 1..__LINE__ - 2].join("\n")
+tr2r = File.read(__FILE__).lines[start + 1..__LINE__ - 2].join
 ir2r = File.read("lib/ruby2ruby.rb")
 
 require "ruby_parser"
 
-def silent_eval ruby
-  old, $-w = $-w, nil
-  eval ruby
-  $-w = old
-end
-
 def morph_and_eval src, from, to, processor
   parser = RubyParser.for_current_ruby rescue RubyParser.new
   new_src = processor.new.process(parser.process(src.sub(from, to)))
 
-  silent_eval new_src
+  eval new_src
+
   new_src
 end
 

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: ruby2ruby
 version: !ruby/object:Gem::Version
-  version: 2.4.4
+  version: 2.5.0
 platform: ruby
 authors:
 - Ryan Davis
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain:
 - |
   -----BEGIN CERTIFICATE-----
-  MIIDPjCCAiagAwIBAgIBAzANBgkqhkiG9w0BAQsFADBFMRMwEQYDVQQDDApyeWFu
+  MIIDPjCCAiagAwIBAgIBBjANBgkqhkiG9w0BAQsFADBFMRMwEQYDVQQDDApyeWFu
   ZC1ydWJ5MRkwFwYKCZImiZPyLGQBGRYJemVuc3BpZGVyMRMwEQYKCZImiZPyLGQB
-  GRYDY29tMB4XDTE4MTIwNDIxMzAxNFoXDTE5MTIwNDIxMzAxNFowRTETMBEGA1UE
+  GRYDY29tMB4XDTIxMTIyMzIzMTkwNFoXDTIyMTIyMzIzMTkwNFowRTETMBEGA1UE
   AwwKcnlhbmQtcnVieTEZMBcGCgmSJomT8ixkARkWCXplbnNwaWRlcjETMBEGCgmS
   JomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALda
   b9DCgK+627gPJkB6XfjZ1itoOQvpqH1EXScSaba9/S2VF22VYQbXU1xQXL/WzCkx
@@ -22,14 +22,14 @@ cert_chain:
   qhtV7HJxNKuPj/JFH0D2cswvzznE/a5FOYO68g+YCuFi5L8wZuuM8zzdwjrWHqSV
   gBEfoTEGr7Zii72cx+sCAwEAAaM5MDcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAw
   HQYDVR0OBBYEFEfFe9md/r/tj/Wmwpy+MI8d9k/hMA0GCSqGSIb3DQEBCwUAA4IB
-  AQCbJwLmpJR2PomLU+Zzw3KRzH/hbyUWc/ftru71AopZ1fy4iY9J/BW5QYKVYwbP
-  V0FSBWtvfI/RdwfKGtuGhPKECZgmLieGuZ3XCc09qPu1bdg7i/tu1p0t0c6163ku
-  nDMDIC/t/DAFK0TY9I3HswuyZGbLW7rgF0DmiuZdN/RPhHq2pOLMLXJmFclCb/im
-  9yToml/06TJdUJ5p64mkBs0TzaK66DIB1Smd3PdtfZqoRV+EwaXMdx0Hb3zdR1JR
-  Em82dBUFsipwMLCYj39kcyHWAxyl6Ae1Cn9r/ItVBCxoeFdrHjfavnrIEoXUt4bU
-  UfBugfLD19bu3nvL+zTAGx/U
+  AQCKB5jfsuSnKb+t/Wrh3UpdkmX7TrEsjVmERC0pPqzQ5GQJgmEXDD7oMgaKXaAq
+  x2m+KSZDrqk7c8uho5OX6YMqg4KdxehfSLqqTZGoeV78qwf/jpPQZKTf+W9gUSJh
+  zsWpo4K50MP+QtdSbKXZwjAafpQ8hK0MnnZ/aeCsW9ov5vdXpYbf3dpg6ADXRGE7
+  lQY2y1tJ5/chqu6h7dQmnm2ABUqx9O+JcN9hbCYoA5i/EeubUEtFIh2w3SpO6YfB
+  JFmxn4h9YO/pVdB962BdBNNDia0kgIjI3ENnkLq0dKpYU3+F3KhEuTksLO0L6X/V
+  YsuyUzsMz6GQA4khyaMgKNSD
   -----END CERTIFICATE-----
-date: 2019-09-25 00:00:00.000000000 Z
+date: 2022-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sexp_processor
@@ -85,14 +85,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.18'
+        version: '3.25'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.18'
+        version: '3.25'
 description: |-
   ruby2ruby provides a means of generating pure ruby code easily from
   RubyParser compatible Sexps. This makes making dynamic language
@@ -118,8 +118,9 @@ files:
 homepage: https://github.com/seattlerb/ruby2ruby
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  homepage_uri: https://github.com/seattlerb/ruby2ruby
+post_install_message:
 rdoc_options:
 - "--main"
 - README.rdoc
@@ -136,8 +137,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.3.12
+signing_key:
 specification_version: 4
 summary: ruby2ruby provides a means of generating pure ruby code easily from RubyParser
   compatible Sexps