brakeman 5.1.1 → 5.2.1

data/bundle/ruby/2.7.0/gems/{parallel-1.20.1 → parallel-1.21.0}/lib/parallel.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rbconfig'
 require 'parallel/version'
 require 'parallel/processor_count'
@@ -12,7 +13,9 @@ module Parallel
 
   class Break < StandardError
     attr_reader :value
+
     def initialize(value = nil)
+      super()
       @value = value
     end
   end
@@ -22,6 +25,7 @@ module Parallel
 
   class UndumpableException < StandardError
     attr_reader :backtrace
+
     def initialize(original)
       super "#{original.class}: #{original.message}"
       @backtrace = original.backtrace
@@ -30,6 +34,7 @@ module Parallel
 
   class ExceptionWrapper
     attr_reader :exception
+
     def initialize(exception)
       # Remove the bindings stack added by the better_errors gem,
       # because it cannot be marshalled
@@ -40,7 +45,7 @@ module Parallel
       @exception =
         begin
           Marshal.dump(exception) && exception
-        rescue
+        rescue StandardError
           UndumpableException.new(exception)
         end
     end
@@ -49,8 +54,11 @@ module Parallel
   class Worker
     attr_reader :pid, :read, :write
     attr_accessor :thread
+
     def initialize(read, write, pid)
-      @read, @write, @pid = read, write, pid
+      @read = read
+      @write = write
+      @pid = pid
     end
 
     def stop
@@ -77,7 +85,7 @@ module Parallel
       rescue EOFError
         raise DeadWorker
       end
-      raise result.exception if ExceptionWrapper === result
+      raise result.exception if result.is_a?(ExceptionWrapper)
       result
     end
 
@@ -144,7 +152,7 @@ module Parallel
     end
 
     def queue_wrapper(array)
-      array.respond_to?(:num_waiting) && array.respond_to?(:pop) && lambda { array.pop(false) }
+      array.respond_to?(:num_waiting) && array.respond_to?(:pop) && -> { array.pop(false) }
     end
   end
 
@@ -160,7 +168,7 @@ module Parallel
 
         if @to_be_killed.empty?
           old_interrupt = trap_interrupt(signal) do
-            $stderr.puts 'Parallel execution interrupted, exiting ...'
+            warn 'Parallel execution interrupted, exiting ...'
             @to_be_killed.flatten.each { |pid| kill(pid) }
           end
         end
@@ -204,32 +212,30 @@ module Parallel
   end
 
   class << self
-    def in_threads(options={:count => 2})
+    def in_threads(options = { count: 2 })
       threads = []
-      count, _ = extract_count_from_options(options)
+      count, = extract_count_from_options(options)
 
       Thread.handle_interrupt(Exception => :never) do
-        begin
-          Thread.handle_interrupt(Exception => :immediate) do
-            count.times do |i|
-              threads << Thread.new { yield(i) }
-            end
-            threads.map(&:value)
+        Thread.handle_interrupt(Exception => :immediate) do
+          count.times do |i|
+            threads << Thread.new { yield(i) }
           end
-        ensure
-          threads.each(&:kill)
+          threads.map(&:value)
         end
+      ensure
+        threads.each(&:kill)
       end
     end
 
     def in_processes(options = {}, &block)
       count, options = extract_count_from_options(options)
       count ||= processor_count
-      map(0...count, options.merge(:in_processes => count), &block)
+      map(0...count, options.merge(in_processes: count), &block)
     end
 
-    def each(array, options={}, &block)
-      map(array, options.merge(:preserve_results => false), &block)
+    def each(array, options = {}, &block)
+      map(array, options.merge(preserve_results: false), &block)
     end
 
     def any?(*args, &block)
@@ -242,8 +248,8 @@ module Parallel
       !!each(*args) { |*a| raise Kill unless block.call(*a) }
     end
 
-    def each_with_index(array, options={}, &block)
-      each(array, options.merge(:with_index => true), &block)
+    def each_with_index(array, options = {}, &block)
+      each(array, options.merge(with_index: true), &block)
     end
 
     def map(source, options = {}, &block)
@@ -251,8 +257,8 @@ module Parallel
       options[:mutex] = Mutex.new
 
       if options[:in_processes] && options[:in_threads]
-        raise ArgumentError.new("Please specify only one of `in_processes` or `in_threads`.")
-      elsif RUBY_PLATFORM =~ /java/ and not options[:in_processes]
+        raise ArgumentError, "Please specify only one of `in_processes` or `in_threads`."
+      elsif RUBY_PLATFORM =~ (/java/) && !(options[:in_processes])
         method = :in_threads
         size = options[method] || processor_count
       elsif options[:in_threads]
@@ -278,9 +284,9 @@ module Parallel
         if size == 0
           work_direct(job_factory, options, &block)
         elsif method == :in_threads
-          work_in_threads(job_factory, options.merge(:count => size), &block)
+          work_in_threads(job_factory, options.merge(count: size), &block)
         else
-          work_in_processes(job_factory, options.merge(:count => size), &block)
+          work_in_processes(job_factory, options.merge(count: size), &block)
         end
 
       return result.value if result.is_a?(Break)
@@ -288,8 +294,8 @@ module Parallel
       options[:return_results] ? result : source
     end
 
-    def map_with_index(array, options={}, &block)
-      map(array, options.merge(:with_index => true), &block)
+    def map_with_index(array, options = {}, &block)
+      map(array, options.merge(with_index: true), &block)
     end
 
     def flat_map(*args, &block)
@@ -343,7 +349,7 @@ module Parallel
             call_with_index(item, index, options, &block)
           end
         end
-      rescue
+      rescue StandardError
         exception = $!
       end
       exception || results
@@ -367,7 +373,7 @@ module Parallel
               call_with_index(item, index, options, &block)
             end
             results_mutex.synchronize { results[index] = result }
-          rescue
+          rescue StandardError
             exception = $!
           end
         end
@@ -407,9 +413,9 @@ module Parallel
                 results_mutex.synchronize { results[index] = result } # arrays are not threads safe on jRuby
               rescue StandardError => e
                 exception = e
-                if Kill === exception
+                if exception.is_a?(Kill)
                   (workers - [worker]).each do |w|
-                    w.thread.kill if w.thread
+                    w.thread&.kill
                     UserInterruptHandler.kill(w.pid)
                   end
                 end
@@ -423,15 +429,15 @@ module Parallel
       exception || results
     end
 
-    def replace_worker(job_factory, workers, i, options, blk)
+    def replace_worker(job_factory, workers, index, options, blk)
       options[:mutex].synchronize do
         # old worker is no longer used ... stop it
-        worker = workers[i]
+        worker = workers[index]
         worker.stop
 
         # create a new replacement worker
         running = workers - [worker]
-        workers[i] = worker(job_factory, options.merge(started_workers: running, worker_number: i), &blk)
+        workers[index] = worker(job_factory, options.merge(started_workers: running, worker_number: index), &blk)
       end
     end
 
@@ -473,14 +479,17 @@ module Parallel
       until read.eof?
         data = Marshal.load(read)
         item, index = job_factory.unpack(data)
-        result = begin
-          call_with_index(item, index, options, &block)
-        # https://github.com/rspec/rspec-support/blob/673133cdd13b17077b3d88ece8d7380821f8d7dc/lib/rspec/support.rb#L132-L140
-        rescue NoMemoryError, SignalException, Interrupt, SystemExit
-          raise $!
-        rescue Exception
-          ExceptionWrapper.new($!)
-        end
+
+        result =
+          begin
+            call_with_index(item, index, options, &block)
+          # https://github.com/rspec/rspec-support/blob/673133cdd13b17077b3d88ece8d7380821f8d7dc/lib/rspec/support.rb#L132-L140
+          rescue NoMemoryError, SignalException, Interrupt, SystemExit # rubocop:disable Lint/ShadowedException
+            raise $!
+          rescue Exception # # rubocop:disable Lint/RescueException
+            ExceptionWrapper.new($!)
+          end
+
         begin
           Marshal.dump(result, write)
         rescue Errno::EPIPE
@@ -503,10 +512,10 @@ module Parallel
     def call_with_index(item, index, options, &block)
       args = [item]
       args << index if options[:with_index]
+      results = block.call(*args)
       if options[:return_results]
-        block.call(*args)
+        results
       else
-        block.call(*args)
         nil # avoid GC overhead of passing large results around
       end
     end

data/bundle/ruby/2.7.0/gems/{ruby_parser-3.16.0 → ruby_parser-3.18.1}/History.rdoc

@@ -1,3 +1,91 @@
+=== 3.18.1 / 2021-11-10
+
+* 1 minor enhancement:
+
+  * All parser tests are now explicitly testing line numbers at every level.
+
+* 3 bug fixes:
+
+  * Fixed endless method with noargs. (mitsuru)
+  * Fixed line numbers on some yield forms.
+  * Handle and clearly report if unifdef is missing.
+
+=== 3.18.0 / 2021-10-27
+
+Holy crap... 58 commits! 2.7 and 3.0 are feature complete. Strings
+& heredocs have been rewritten.
+
+* 9 major enhancements:
+
+  * !!! Rewrote lexer (and friends) for strings, heredocs, and %*[] constructs.
+  * Massive overhaul on line numbers.
+  * Freeze input! Finally!!! No more modifying the input string for heredocs.
+  * Overhauled RPStringScanner. Removed OLD compatibility methods!
+  * Removed Sexp methods: value, to_sym, add, add_all, node_type, values.
+    * value moved to sexp_processor.
+  * Removed String#grep monkey-patch.
+  * Removed String#lineno monkey-patch.
+  * Removed string_to_pos, charpos, etc hacks for ancient ruby versions.
+  * Removed unread_many... NO! NO EDITING THE INPUT STRING!
+
+* 31 minor enhancements:
+
+  * 2.7/3.0: many more pattern edge cases
+  * 2.7: Added `mlhs = rhs rescue expr`
+  * 2.7: refactored destructured args (`|(k,v)|`) and unfactored(?!) case_body/args.
+  * 3.0: excessed_comma
+  * 3.0: finished most everything: endless methods, patterns, etc.
+  * 3.0: refactored / added new pattern changes
+  * Added RubyLexer#in_heredoc? (ie, is there old_ss ?)
+  * Added RubyLexer#old_ss and old_lineno and removed much of SSStack(ish).
+  * Added Symbol#end_with? when necessary
+  * Added TALLY and DEBUG options for ss.getch and ss.scan
+  * Added ignore_body_comments to make parser productions more clear.
+  * Added support for no_kwarg (eg `def f(**nil)`).
+  * Added support for no_kwarg in blocks (eg `f { |**nil| }`).
+  * Augmented generated parser files to have frozen_string_literal comments and fixed tests.
+  * Broke out 3.0 parser into its own to ease development.
+  * Bumped dependencies on sexp_processor and oedipus_lex.
+  * Clean generated 3.x files.
+  * Extracted all string scanner methods to their own module.
+  * Fixed some precedence decls.
+  * Implemented most of pattern matching for 2.7+.
+  * Improve lex_state= to report location in verbose debug mode.
+  * Made it easier to debug with a particular version of ruby via rake.
+  * Make sure ripper uses the same version of ruby we specified.
+  * Moved all string/heredoc/etc code to ruby_lexer_strings.rb
+  * Remove warning from newer bisons.
+  * Sprinkled in some frozen_string_literal, but mostly helped by oedipus bump.
+  * Switch to comparing against ruby binary since ripper is buggy.
+  * bugs task should try both bug*.rb and bad*.rb.
+  * endless methods
+  * f_any_kwrest refactoring.
+  * refactored defn/defs
+
+* 15 bug fixes:
+
+  * Cleaned a bunch of old hacks. Initializing RubyLexer w/ Parser is cleaner now.
+  * Corrected some lex_state errors in process_token_keyword.
+  * Fixed ancient ruby2 change (use #lines) in ruby_parse_extract_error.
+  * Fixed bug where else without rescue only raises on 2.6+
+  * Fixed caller for getch and scan when DEBUG=1
+  * Fixed comments in the middle of message cascades.
+  * Fixed differences w/ symbol productions against ruby 2.7.
+  * Fixed dsym to use string_contents production.
+  * Fixed error in bdot2/3 in some edge cases. Fixed p_alt line.
+  * Fixed heredoc dedenting in the presence of empty lines. (mvz)
+  * Fixed some leading whitespace / comment processing
+  * Fixed up how class/module/defn/defs comments were collected.
+  * Overhauled ripper.rb to deal with buggy ripper w/ yydebug.
+  * Removed dsym from literal.
+  * Removed tUBANG lexeme but kept it distinct as a method name (eg: `def !@`).
+
+=== 3.17.0 / 2021-08-03
+
+* 1 minor enhancement:
+
+  * Added support for arg forwarding (eg `def f(...); m(...); end`) (presidentbeef)
+
 === 3.16.0 / 2021-05-15
 
 * 1 major enhancement:

data/bundle/ruby/2.7.0/gems/{ruby_parser-3.16.0 → ruby_parser-3.18.1}/Manifest.txt

@@ -7,6 +7,7 @@ bin/ruby_parse
 bin/ruby_parse_extract_error
 compare/normalize.rb
 debugging.md
+gauntlet.md
 lib/.document
 lib/rp_extensions.rb
 lib/rp_stringscanner.rb
@@ -28,9 +29,11 @@ lib/ruby27_parser.rb
 lib/ruby27_parser.y
 lib/ruby30_parser.rb
 lib/ruby30_parser.y
+lib/ruby3_parser.yy
 lib/ruby_lexer.rb
 lib/ruby_lexer.rex
 lib/ruby_lexer.rex.rb
+lib/ruby_lexer_strings.rb
 lib/ruby_parser.rb
 lib/ruby_parser.yy
 lib/ruby_parser_extras.rb

data/bundle/ruby/2.7.0/gems/{ruby_parser-3.16.0 → ruby_parser-3.18.1}/README.rdoc

@@ -32,6 +32,7 @@ Tested against 801,039 files from the latest of all rubygems (as of 2013-05):
 * 1.8 parser is at 99.9739% accuracy, 3.651 sigma
 * 1.9 parser is at 99.9940% accuracy, 4.013 sigma
 * 2.0 parser is at 99.9939% accuracy, 4.008 sigma
+* 2.6 parser is at 99.9972% accuracy, 4.191 sigma
 
 == FEATURES/PROBLEMS:
 

data/bundle/ruby/2.7.0/gems/{ruby_parser-3.16.0 → ruby_parser-3.18.1}/compare/normalize.rb

@@ -84,6 +84,7 @@ def munge s
 
              "' '",             "tSPACE", # needs to be later to avoid bad hits
 
+             "%empty",          "none", # newer bison
              "/* empty */",     "none",
              /^\s*$/,           "none",
 
@@ -140,6 +141,7 @@ def munge s
              '"do for block"',     "kDO_BLOCK",
              '"do for condition"', "kDO_COND",
              '"do for lambda"',    "kDO_LAMBDA",
+             "tLABEL",             "kLABEL",
 
              # UGH
              "k_LINE__",       "k__LINE__",
@@ -155,7 +157,10 @@ def munge s
              /\"(\w+) \(?modifier\)?\"/, proc { |x| "k#{$1.upcase}_MOD" },
              /\"(\w+)\"/,                proc { |x| "k#{$1.upcase}" },
 
-             /@(\d+)(\s+|$)/,       "",
+             /\$?@(\d+)(\s+|$)/,    "", # newer bison
+
+             # TODO: remove for 3.0 work:
+             "lex_ctxt ", "" # 3.0 production that's mostly noise right now
             ]
 
   renames.each_slice(2) do |(a, b)|

data/bundle/ruby/2.7.0/gems/ruby_parser-3.18.1/gauntlet.md

@@ -0,0 +1,106 @@
+# Running the Gauntlet
+
+## Maintaining a Gem Mirror
+
+I use rubygems-mirror to keep an archive of all the latest rubygems on
+an external disk. Here is the config:
+
+```
+---
+- from: https://rubygems.org
+  to: /Volumes/StuffA/gauntlet/mirror
+  parallelism: 10
+  retries: 3
+  delete: true
+  skiperror: true
+  hashdir: true
+```
+
+And I update using rake:
+
+```
+% cd ~/Work/git/rubygems/rubygems-mirror
+% git down
+% rake mirror:latest
+% /Volumes/StuffA/gauntlet/bin/cleanup.rb
+```
+
+This rather quickly updates my mirror to the latest versions of
+everything and then deletes all old versions. I then run a cleanup
+script that fixes the file dates to their publication date and deletes
+any gems that have invalid specs. This can argue with the mirror a
+bit, but it is pretty minimal (currently ~20 bad gems).
+
+## Curating an Archive of Ruby Files
+
+Next, I process the gem mirror into a much more digestable structure
+using `hash.rb` (TODO: needs a better name):
+
+```
+% cd RP
+% /Volumes/StuffA/gauntlet/bin/unpack_gems.rb
+... waaaait ...
+% mv hashed.noindex gauntlet.$(today).noindex
+% lrztar gauntlet.$(today).noindex
+% mv gauntlet.$(today).noindex.lrz /Volumes/StuffA/gauntlet/
+```
+
+This script filters all the newer gems (TODO: WHY?), unpacks them,
+finds all the files that look like they're valid ruby, ensures they're
+valid ruby (using the current version of ruby to compile them), and
+then moves them into a SHA dir structure that looks something like
+this:
+
+```
+hashed.noindex/a/b/c/<full_file_sha>.rb
+```
+
+This removes all duplicates and puts everything in a fairly even,
+wide, flat directory layout.
+
+This process takes a very long time, even with a lot of
+parallelization. There are currently about 160k gems in the mirror.
+Unpacking, validating, SHA'ing everything is disk and CPU intensive.
+The `.noindex` extension stops spotlight from indexing the continous
+churn of files being unpacked and moved and saves time.
+
+Finally, I rename and archive it all up (currently using lrztar, but
+I'm not in love with it).
+
+### Stats
+
+```
+9696 % find gauntlet.$(today).noindex -type f | lc
+  561270
+3.5G gauntlet.2021-08-06.noindex
+239M gauntlet.2021-08-06.noindex.tar.lrz
+```
+
+So I wind up with a little over half a million unique ruby files to
+parse. It's about 3.5g but compresses very nicely down to 240m
+
+## Running the Gauntlet
+
+Assuming you're starting from scratch, unpack the archive once:
+
+```
+% lrzuntar gauntlet.$(today).noindex.lrz
+```
+
+Then, either run a single process (easier to read):
+
+```
+% ./gauntlet/bin/gauntlet.rb gauntlet/*.noindex/?
+```
+
+Or max out your machine using xargs (note the `-P 16` and choose accordingly):
+
+```
+% ls -d gauntlet/*.noindex/?/? | xargs -n 1 -P 16 ./gauntlet/bin/gauntlet.rb
+```
+
+In another terminal I usually monitor the progress like so:
+
+```
+% while true ; do clear; fd . -t d -t e gauntlet/*.noindex -X rmdir -p 2> /dev/null ; for D in gauntlet/*.noindex/? ; do echo -n "$D: "; fd .rb $D | wc -l ; done ; echo ; sleep 30 ; done
+```

data/bundle/ruby/2.7.0/gems/{ruby_parser-3.16.0 → ruby_parser-3.18.1}/lib/rp_extensions.rb

@@ -12,26 +12,24 @@ class Regexp
 end
 # :startdoc:
 
-############################################################
-# HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK
-
-unless "".respond_to?(:grep) then
-  class String
-    def grep re
-      lines.grep re
-    end
+class Array
+  def prepend *vals
+    self[0,0] = vals
   end
-end
+end unless [].respond_to?(:prepend)
 
-class String
-  ##
-  # This is a hack used by the lexer to sneak in line numbers at the
-  # identifier level. This should be MUCH smaller than making
-  # process_token return [value, lineno] and modifying EVERYTHING that
-  # reduces tIDENTIFIER.
+# :stopdoc:
+class Symbol
+  def end_with? o
+    self.to_s.end_with? o
+  end
+end unless :woot.respond_to?(:end_with?)
+# :startdoc:
 
-  attr_accessor :lineno
+############################################################
+# HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK
 
+class String
   def clean_caller
     self.sub(File.dirname(__FILE__), "./lib").sub(/:in.*/, "")
   end if $DEBUG
@@ -40,34 +38,15 @@ end
 require "sexp"
 
 class Sexp
-  attr_writer :paren
+  attr_writer :paren # TODO: retire
 
   def paren
     @paren ||= false
   end
 
-  def value
-    raise "multi item sexp" if size > 2
-    last
-  end
-
-  def to_sym
-    raise "no: #{self.inspect}.to_sym is a bug"
-    self.value.to_sym
-  end
-
-  alias :add :<<
-
-  def add_all x
-    self.concat x.sexp_body
-  end
-
   def block_pass?
     any? { |s| Sexp === s && s.sexp_type == :block_pass }
   end
-
-  alias :node_type :sexp_type
-  alias :values :sexp_body # TODO: retire
 end
 
 # END HACK

data/bundle/ruby/2.7.0/gems/ruby_parser-3.18.1/lib/rp_stringscanner.rb

@@ -0,0 +1,33 @@
+require "strscan"
+
+class RPStringScanner < StringScanner
+  if ENV["DEBUG"] || ENV["TALLY"] then
+    def getch
+      c = super
+      where = caller.drop_while { |s| s =~ /(getch|nextc).$/ }.first
+      where = where.split(/:/).first(2).join(":")
+      if ENV["TALLY"] then
+        d getch:where
+      else
+        d getch:[c, where]
+      end
+      c
+    end
+
+    def scan re
+      s = super
+      where = caller.drop_while { |x| x =~ /scan.$/ }.first
+      where = where.split(/:/).first(2).join(":")
+      if ENV["TALLY"] then
+        d scan:[where]
+      else
+        d scan:[s, where] if s
+      end
+      s
+    end
+
+    def d o
+      STDERR.puts o.inspect
+    end
+  end
+end