brakeman 6.0.0 → 7.1.0

data/bundle/ruby/{3.0.0/gems/ruby2ruby-2.4.4 → 3.2.0/gems/ruby2ruby-2.5.2}/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.2" # :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:
@@ -459,7 +475,7 @@ class Ruby2Ruby < SexpProcessor
 
     options = re_opt rest.pop if Integer === rest.last
 
-    "/" << util_dthing(:dregx, s(:dregx, str, *rest)) << "/#{options}"
+    "/" + util_dthing(:dregx, s(:dregx, str, *rest)) << "/#{options}"
   end
 
   def process_dregx_once(exp) # :nodoc:
@@ -486,7 +502,7 @@ 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 = body.sub(/\n\s*end\z/, "")
     body = indent(body) unless body =~ /(^|\n)rescue/
 
     "#{body}\nensure\n#{indent ens}"
@@ -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
 
@@ -589,11 +699,12 @@ class Ruby2Ruby < SexpProcessor
         return r if r and (@indent + r).size < LINE_LENGTH and r !~ /\n/
       end
 
-      r = "if #{c} then\n#{indent(t)}\n"
+      r = []
+      r << "if #{c} then\n#{indent(t)}\n"
       r << "else\n#{indent(f)}\n" if f
       r << "end"
 
-      r
+      r.join
     elsif f
       unless expand then
         r = "#{f} unless #{c}"
@@ -610,6 +721,8 @@ class Ruby2Ruby < SexpProcessor
     "->"
   end
 
+  MUST_BE_CURLY = %w[ BEGIN END ]
+
   def process_iter(exp) # :nodoc:
     _, iter, args, body = exp
 
@@ -627,13 +740,13 @@ 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 ]
            end
 
-    iter.sub!(/\(\)$/, "")
+    iter = iter.sub(/\(\)$/, "")
 
     # REFACTOR: ugh
     result = []
@@ -676,7 +789,8 @@ class Ruby2Ruby < SexpProcessor
 
   def process_ivar(exp) # :nodoc:
     _, name = exp
-    name.to_s
+
+    __var name
   end
 
   def process_kwsplat(exp)
@@ -687,9 +801,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 +827,8 @@ class Ruby2Ruby < SexpProcessor
 
   def process_lvar(exp) # :nodoc:
     _, name = exp
-    name.to_s
+
+    __var name
   end
 
   def process_masgn(exp) # :nodoc:
@@ -792,13 +916,24 @@ class Ruby2Ruby < SexpProcessor
   end
 
   def process_op_asgn exp # :nodoc:
-    # [[:lvar, :x], [:call, nil, :z, [:lit, 1]], :y, :"||"]
-    _, lhs, rhs, index, op = exp
+    case exp.length
+    when 4
+      _, lhs, op, rhs = exp
 
-    lhs = process lhs
-    rhs = process rhs
+      lhs = process lhs
+      rhs = process rhs
+
+      "#{lhs} #{op}= #{rhs}"
+    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 +975,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 +1172,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/bundle/ruby/{3.0.0/gems/ruby_parser-3.20.1 → 3.2.0/gems/ruby_parser-3.20.3}/History.rdoc

@@ -1,3 +1,21 @@
+=== 3.20.3 / 2023-07-11
+
+* 2 minor enhancements:
+
+  * Added Parser#in_argdef and integrated into 3.x parsers.
+  * Improved tools/munge.rb to handler MRI 3.2 output
+
+* 2 bug fixes:
+
+  * Fixed process_dots to properly deal with paren-less forward_args. (eric1234)
+  * Fixed tools/ripper.rb to properly print ripper sexp at the end
+
+=== 3.20.2 / 2023-06-06
+
+* 1 bug fix:
+
+  * 3.2: fixed parsing of f(*) and f(**). (agrobbin)
+
 === 3.20.1 / 2023-05-16
 
 * 1 minor enhancement:

data/bundle/ruby/{3.0.0/gems/ruby_parser-3.20.1 → 3.2.0/gems/ruby_parser-3.20.3}/compare/normalize.rb

@@ -84,6 +84,7 @@ def munge s
 
              "' '",             "tSPACE", # needs to be later to avoid bad hits
 
+             "ε",               "none", # bison 3+
              "%empty",          "none", # newer bison
              "/* empty */",     "none",
              /^\s*$/,           "none",