brakeman 4.5.1 → 4.10.1

data/bundle/ruby/2.7.0/gems/rexml-3.2.4/rexml.gemspec

@@ -0,0 +1,84 @@
+begin
+  require_relative "lib/rexml/rexml"
+rescue LoadError
+  # for Ruby core repository
+  require_relative "rexml"
+end
+
+Gem::Specification.new do |spec|
+  spec.name          = "rexml"
+  spec.version       = REXML::VERSION
+  spec.authors       = ["Kouhei Sutou"]
+  spec.email         = ["kou@cozmixng.org"]
+
+  spec.summary       = %q{An XML toolkit for Ruby}
+  spec.description   = %q{An XML toolkit for Ruby}
+  spec.homepage      = "https://github.com/ruby/rexml"
+  spec.license       = "BSD-2-Clause"
+
+  spec.files         = [
+    ".gitignore",
+    ".travis.yml",
+    "Gemfile",
+    "LICENSE.txt",
+    "NEWS.md",
+    "README.md",
+    "Rakefile",
+    "lib/rexml/attlistdecl.rb",
+    "lib/rexml/attribute.rb",
+    "lib/rexml/cdata.rb",
+    "lib/rexml/child.rb",
+    "lib/rexml/comment.rb",
+    "lib/rexml/doctype.rb",
+    "lib/rexml/document.rb",
+    "lib/rexml/dtd/attlistdecl.rb",
+    "lib/rexml/dtd/dtd.rb",
+    "lib/rexml/dtd/elementdecl.rb",
+    "lib/rexml/dtd/entitydecl.rb",
+    "lib/rexml/dtd/notationdecl.rb",
+    "lib/rexml/element.rb",
+    "lib/rexml/encoding.rb",
+    "lib/rexml/entity.rb",
+    "lib/rexml/formatters/default.rb",
+    "lib/rexml/formatters/pretty.rb",
+    "lib/rexml/formatters/transitive.rb",
+    "lib/rexml/functions.rb",
+    "lib/rexml/instruction.rb",
+    "lib/rexml/light/node.rb",
+    "lib/rexml/namespace.rb",
+    "lib/rexml/node.rb",
+    "lib/rexml/output.rb",
+    "lib/rexml/parent.rb",
+    "lib/rexml/parseexception.rb",
+    "lib/rexml/parsers/baseparser.rb",
+    "lib/rexml/parsers/lightparser.rb",
+    "lib/rexml/parsers/pullparser.rb",
+    "lib/rexml/parsers/sax2parser.rb",
+    "lib/rexml/parsers/streamparser.rb",
+    "lib/rexml/parsers/treeparser.rb",
+    "lib/rexml/parsers/ultralightparser.rb",
+    "lib/rexml/parsers/xpathparser.rb",
+    "lib/rexml/quickpath.rb",
+    "lib/rexml/rexml.rb",
+    "lib/rexml/sax2listener.rb",
+    "lib/rexml/security.rb",
+    "lib/rexml/source.rb",
+    "lib/rexml/streamlistener.rb",
+    "lib/rexml/text.rb",
+    "lib/rexml/undefinednamespaceexception.rb",
+    "lib/rexml/validation/relaxng.rb",
+    "lib/rexml/validation/validation.rb",
+    "lib/rexml/validation/validationexception.rb",
+    "lib/rexml/xmldecl.rb",
+    "lib/rexml/xmltokens.rb",
+    "lib/rexml/xpath.rb",
+    "lib/rexml/xpath_parser.rb",
+    "rexml.gemspec",
+  ]
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+end

data/bundle/ruby/{2.5.0/gems/ruby2ruby-2.4.2 → 2.7.0/gems/ruby2ruby-2.4.4}/History.rdoc

@@ -1,10 +1,24 @@
-=== 4.12.0 / 2019-03-12
+=== 2.4.4 / 2019-09-24
 
-* 3 bug fixes:
+* 1 bug fix:
+
+  * Fixed deprecation warnings from patterns change in sexp_processor.
+
+=== 2.4.3 / 2019-06-03
+
+* 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/bundle/ruby/{2.5.0/gems/ruby2ruby-2.4.2 → 2.7.0/gems/ruby2ruby-2.4.4}/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.4" # :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
@@ -392,12 +403,12 @@ class Ruby2Ruby < SexpProcessor
 
     # s(:defn, name, args, ivar|iasgn)
     case exp
-    when s{ s(:defn, atom, t(:args), s(:ivar, atom)) } then # TODO: atom -> _
+    when s{ q(:defn, atom, t(:args), q(:ivar, atom)) } then # TODO: atom -> _
       _, ivar = body.first
       ivar = ivar.to_s[1..-1] # remove leading @
       reader = name.to_s
       return "attr_reader #{name.inspect}" if reader == ivar
-    when s{ s(:defn, atom, t(:args), s(:iasgn, atom, s(:lvar, atom))) } then
+    when s{ q(:defn, atom, t(:args), q(:iasgn, atom, q(:lvar, atom))) } then
       _, ivar, _val = body.first
       ivar = ivar.to_s[1..-1] # remove leading @
       reader = name.to_s.chomp "="
@@ -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"