RubyGems - plaid - Versions diffs - 14.7.0 → 14.8.0 - Mend

plaid 14.7.0 → 14.8.0

Files changed (2175) hide show

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/runner.rb DELETED Viewed

@@ -1,403 +0,0 @@
-# frozen_string_literal: true
-require 'parallel'
-module RuboCop
-  # This class handles the processing of files, which includes dealing with
-  # formatters and letting cops inspect the files.
-  class Runner # rubocop:disable Metrics/ClassLength
-    # An exception indicating that the inspection loop got stuck correcting
-    # offenses back and forth.
-    class InfiniteCorrectionLoop < RuntimeError
-      attr_reader :offenses
-      def initialize(path, offenses_by_iteration, loop_start: -1)
-        @offenses = offenses_by_iteration.flatten.uniq
-        root_cause = offenses_by_iteration[loop_start..-1]
-                     .map { |x| x.map(&:cop_name).uniq.join(', ') }
-                     .join(' -> ')
-        super "Infinite loop detected in #{path} and caused by #{root_cause}"
-      end
-    end
-    # @api private
-    MAX_ITERATIONS = 200
-    attr_reader :errors, :warnings
-    attr_writer :aborting
-    def initialize(options, config_store)
-      @options = options
-      @config_store = config_store
-      @errors = []
-      @warnings = []
-      @aborting = false
-    end
-    def run(paths)
-      target_files = find_target_files(paths)
-      if @options[:list_target_files]
-        list_files(target_files)
-      else
-        warm_cache(target_files) if @options[:parallel]
-        inspect_files(target_files)
-      end
-    rescue Interrupt
-      self.aborting = true
-      warn ''
-      warn 'Exiting...'
-      false
-    end
-    def aborting?
-      @aborting
-    end
-    private
-    # Warms up the RuboCop cache by forking a suitable number of rubocop
-    # instances that each inspects its allotted group of files.
-    def warm_cache(target_files)
-      puts 'Running parallel inspection' if @options[:debug]
-      Parallel.each(target_files, &method(:file_offenses))
-    end
-    def find_target_files(paths)
-      target_finder = TargetFinder.new(@config_store, @options)
-      mode = if @options[:only_recognized_file_types]
-               :only_recognized_file_types
-             else
-               :all_file_types
-             end
-      target_files = target_finder.find(paths, mode)
-      target_files.each(&:freeze).freeze
-    end
-    def inspect_files(files)
-      inspected_files = []
-      formatter_set.started(files)
-      each_inspected_file(files) { |file| inspected_files << file }
-    ensure
-      # OPTIMIZE: Calling `ResultCache.cleanup` takes time. This optimization
-      # mainly targets editors that integrates RuboCop. When RuboCop is run
-      # by an editor, it should be inspecting only one file.
-      if files.size > 1 && cached_run?
-        ResultCache.cleanup(@config_store, @options[:debug], @options[:cache_root])
-      end
-      formatter_set.finished(inspected_files.freeze)
-      formatter_set.close_output_files
-    end
-    def each_inspected_file(files)
-      files.reduce(true) do |all_passed, file|
-        offenses = process_file(file)
-        yield file
-        if offenses.any? { |o| considered_failure?(o) }
-          break false if @options[:fail_fast]
-          next false
-        end
-        all_passed
-      end
-    end
-    def list_files(paths)
-      paths.each do |path|
-        puts PathUtil.relative_path(path)
-      end
-    end
-    def process_file(file)
-      file_started(file)
-      offenses = file_offenses(file)
-    rescue InfiniteCorrectionLoop => e
-      offenses = e.offenses.compact.sort.freeze
-      raise
-    ensure
-      file_finished(file, offenses || [])
-    end
-    def file_offenses(file)
-      file_offense_cache(file) do
-        source, offenses = do_inspection_loop(file)
-        offenses = add_redundant_disables(file, offenses.compact.sort, source)
-        offenses.sort.reject(&:disabled?).freeze
-      end
-    end
-    def cached_result(file, team)
-      ResultCache.new(file, team, @options, @config_store)
-    end
-    def file_offense_cache(file)
-      config = @config_store.for_file(file)
-      cache = cached_result(file, standby_team(config)) if cached_run?
-      if cache&.valid?
-        offenses = cache.load
-        # If we're running --auto-correct and the cache says there are
-        # offenses, we need to actually inspect the file. If the cache shows no
-        # offenses, we're good.
-        real_run_needed = @options[:auto_correct] && offenses.any?
-      else
-        real_run_needed = true
-      end
-      if real_run_needed
-        offenses = yield
-        save_in_cache(cache, offenses)
-      end
-      offenses
-    end
-    def add_redundant_disables(file, offenses, source)
-      team_for_redundant_disables(file, offenses, source) do |team|
-        new_offenses, redundant_updated = inspect_file(source, team)
-        offenses += new_offenses
-        if redundant_updated
-          # Do one extra inspection loop if any redundant disables were
-          # removed. This is done in order to find rubocop:enable directives that
-          # have now become useless.
-          _source, new_offenses = do_inspection_loop(file)
-          offenses |= new_offenses
-        end
-      end
-      offenses
-    end
-    def team_for_redundant_disables(file, offenses, source)
-      return unless check_for_redundant_disables?(source)
-      config = @config_store.for_file(file)
-      team = Cop::Team.mobilize([Cop::Lint::RedundantCopDisableDirective], config, @options)
-      return if team.cops.empty?
-      team.cops.first.offenses_to_check = offenses
-      yield team
-    end
-    def check_for_redundant_disables?(source)
-      !source.disabled_line_ranges.empty? && !filtered_run?
-    end
-    def redundant_cop_disable_directive(file)
-      config = @config_store.for_file(file)
-      if config.for_cop(Cop::Lint::RedundantCopDisableDirective)
-               .fetch('Enabled')
-        cop = Cop::Lint::RedundantCopDisableDirective.new(config, @options)
-        yield cop if cop.relevant_file?(file)
-      end
-    end
-    def filtered_run?
-      @options[:except] || @options[:only]
-    end
-    def file_started(file)
-      puts "Scanning #{file}" if @options[:debug]
-      formatter_set.file_started(file,
-                                 cli_options: @options,
-                                 config_store: @config_store)
-    end
-    def file_finished(file, offenses)
-      if @options[:display_only_fail_level_offenses]
-        offenses = offenses.select { |o| considered_failure?(o) }
-      end
-      formatter_set.file_finished(file, offenses)
-    end
-    def cached_run?
-      @cached_run ||=
-        (@options[:cache] == 'true' ||
-         @options[:cache] != 'false' &&
-         @config_store.for_pwd.for_all_cops['UseCache']) &&
-        # When running --auto-gen-config, there's some processing done in the
-        # cops related to calculating the Max parameters for Metrics cops. We
-        # need to do that processing and cannot use caching.
-        !@options[:auto_gen_config] &&
-        # We can't cache results from code which is piped in to stdin
-        !@options[:stdin]
-    end
-    def save_in_cache(cache, offenses)
-      return unless cache
-      # Caching results when a cop has crashed would prevent the crash in the
-      # next run, since the cop would not be called then. We want crashes to
-      # show up the same in each run.
-      return if errors.any? || warnings.any?
-      cache.save(offenses)
-    end
-    def do_inspection_loop(file)
-      processed_source = get_processed_source(file)
-      # This variable is 2d array used to track corrected offenses after each
-      # inspection iteration. This is used to output meaningful infinite loop
-      # error message.
-      offenses_by_iteration = []
-      # When running with --auto-correct, we need to inspect the file (which
-      # includes writing a corrected version of it) until no more corrections
-      # are made. This is because automatic corrections can introduce new
-      # offenses. In the normal case the loop is only executed once.
-      iterate_until_no_changes(processed_source, offenses_by_iteration) do
-        # The offenses that couldn't be corrected will be found again so we
-        # only keep the corrected ones in order to avoid duplicate reporting.
-        !offenses_by_iteration.empty? && offenses_by_iteration.last.select!(&:corrected?)
-        new_offenses, updated_source_file = inspect_file(processed_source)
-        offenses_by_iteration.push(new_offenses)
-        # We have to reprocess the source to pickup the changes. Since the
-        # change could (theoretically) introduce parsing errors, we break the
-        # loop if we find any.
-        break unless updated_source_file
-        processed_source = get_processed_source(file)
-      end
-      # Return summary of corrected offenses after all iterations
-      offenses = offenses_by_iteration.flatten.uniq
-      [processed_source, offenses]
-    end
-    def iterate_until_no_changes(source, offenses_by_iteration)
-      # Keep track of the state of the source. If a cop modifies the source
-      # and another cop undoes it producing identical source we have an
-      # infinite loop.
-      @processed_sources = []
-      # It is also possible for a cop to keep adding indefinitely to a file,
-      # making it bigger and bigger. If the inspection loop runs for an
-      # excessively high number of iterations, this is likely happening.
-      iterations = 0
-      loop do
-        check_for_infinite_loop(source, offenses_by_iteration)
-        if (iterations += 1) > MAX_ITERATIONS
-          raise InfiniteCorrectionLoop.new(source.path, offenses_by_iteration)
-        end
-        source = yield
-        break unless source
-      end
-    end
-    # Check whether a run created source identical to a previous run, which
-    # means that we definitely have an infinite loop.
-    def check_for_infinite_loop(processed_source, offenses_by_iteration)
-      checksum = processed_source.checksum
-      if (loop_start_index = @processed_sources.index(checksum))
-        raise InfiniteCorrectionLoop.new(
-          processed_source.path,
-          offenses_by_iteration,
-          loop_start: loop_start_index
-        )
-      end
-      @processed_sources << checksum
-    end
-    def inspect_file(processed_source, team = mobilize_team(processed_source))
-      report = team.investigate(processed_source)
-      @errors.concat(team.errors)
-      @warnings.concat(team.warnings)
-      [report.offenses, team.updated_source_file?]
-    end
-    def mobilize_team(processed_source)
-      config = @config_store.for_file(processed_source.path)
-      Cop::Team.mobilize(mobilized_cop_classes(config), config, @options)
-    end
-    def mobilized_cop_classes(config)
-      @mobilized_cop_classes ||= {}
-      @mobilized_cop_classes[config.object_id] ||= begin
-        cop_classes = Cop::Registry.all
-        OptionsValidator.new(@options).validate_cop_options
-        if @options[:only]
-          cop_classes.select! { |c| c.match?(@options[:only]) }
-        else
-          filter_cop_classes(cop_classes, config)
-        end
-        cop_classes.reject! { |c| c.match?(@options[:except]) }
-        Cop::Registry.new(cop_classes, @options)
-      end
-    end
-    def filter_cop_classes(cop_classes, config)
-      # use only cops that link to a style guide if requested
-      return unless style_guide_cops_only?(config)
-      cop_classes.select! { |cop| config.for_cop(cop)['StyleGuide'] }
-    end
-    def style_guide_cops_only?(config)
-      @options[:only_guide_cops] || config.for_all_cops['StyleGuideCopsOnly']
-    end
-    def formatter_set
-      @formatter_set ||= begin
-        set = Formatter::FormatterSet.new(@options)
-        pairs = @options[:formatters] || [['progress']]
-        pairs.each do |formatter_key, output_path|
-          set.add_formatter(formatter_key, output_path)
-        end
-        set
-      end
-    end
-    def considered_failure?(offense)
-      # For :autocorrect level, any offense - corrected or not - is a failure.
-      return false if offense.disabled?
-      return true if @options[:fail_level] == :autocorrect
-      !offense.corrected? && offense.severity >= minimum_severity_to_fail
-    end
-    def minimum_severity_to_fail
-      @minimum_severity_to_fail ||= begin
-        name = @options[:fail_level] || :refactor
-        RuboCop::Cop::Severity.new(name)
-      end
-    end
-    def get_processed_source(file)
-      ruby_version = @config_store.for_file(file).target_ruby_version
-      if @options[:stdin]
-        ProcessedSource.new(@options[:stdin], ruby_version, file)
-      else
-        begin
-          ProcessedSource.from_file(file, ruby_version)
-        rescue Errno::ENOENT
-          raise RuboCop::Error, "No such file or directory: #{file}"
-        end
-      end
-    end
-    # A Cop::Team instance is stateful and may change when inspecting.
-    # The "standby" team for a given config is an initialized but
-    # otherwise dormant team that can be used for config- and option-
-    # level caching in ResultCache.
-    def standby_team(config)
-      @team_by_config ||= {}
-      @team_by_config[config.object_id] ||=
-        Cop::Team.mobilize(mobilized_cop_classes(config), config, @options)
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/string_interpreter.rb DELETED Viewed

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-module RuboCop
-  # Take a string with embedded escapes, and convert the escapes as the Ruby
-  # interpreter would when reading a double-quoted string literal.
-  # For example, "\\n" will be converted to "\n".
-  class StringInterpreter
-    STRING_ESCAPES = {
-      '\a' => "\a", '\b' => "\b", '\e' => "\e", '\f' => "\f", '\n' => "\n",
-      '\r' => "\r", '\s' => ' ',  '\t' => "\t", '\v' => "\v", "\\\n" => ''
-    }.freeze
-    STRING_ESCAPE_REGEX = /\\(?:
-                            [abefnrstv\n]     |   # simple escapes (above)
-                            \d{1,3}           |   # octal byte escape
-                            x[0-9a-fA-F]{1,2} |   # hex byte escape
-                            u[0-9a-fA-F]{4}   |   # unicode char escape
-                            u\{[^}]*\}        |   # extended unicode escape
-                            .                     # any other escaped char
-                          )/x.freeze
-    private_constant :STRING_ESCAPES, :STRING_ESCAPE_REGEX
-    class << self
-      def interpret(string)
-        # We currently don't handle \cx, \C-x, and \M-x
-        string.gsub(STRING_ESCAPE_REGEX) do |escape|
-          STRING_ESCAPES[escape] || interpret_string_escape(escape)
-        end
-      end
-      private
-      def interpret_string_escape(escape)
-        case escape[1]
-        when 'u' then interpret_unicode(escape)
-        when 'x' then interpret_hex(escape)
-        when /\d/       then interpret_octal(escape)
-        else
-          escape[1] # literal escaped char, like \\
-        end
-      end
-      def interpret_unicode(escape)
-        if escape[2] == '{'
-          escape[3..-1].split(/\s+/).map(&:hex).pack('U*')
-        else
-          [escape[2..-1].hex].pack('U')
-        end
-      end
-      def interpret_hex(escape)
-        [escape[2..-1].hex].pack('C')
-      end
-      def interpret_octal(escape)
-        [escape[1..-1].to_i(8)].pack('C')
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/target_finder.rb DELETED Viewed

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-module RuboCop
-  # This class finds target files to inspect by scanning the directory tree
-  # and picking ruby files.
-  # @api private
-  class TargetFinder
-    def initialize(config_store, options = {})
-      @config_store = config_store
-      @options = options
-    end
-    def force_exclusion?
-      @options[:force_exclusion]
-    end
-    def debug?
-      @options[:debug]
-    end
-    def fail_fast?
-      @options[:fail_fast]
-    end
-    # Generate a list of target files by expanding globbing patterns
-    # (if any). If args is empty, recursively find all Ruby source
-    # files under the current directory
-    # @return [Array] array of file paths
-    def find(args, mode)
-      return target_files_in_dir if args.empty?
-      files = []
-      args.uniq.each do |arg|
-        files += if File.directory?(arg)
-                   target_files_in_dir(arg.chomp(File::SEPARATOR))
-                 else
-                   process_explicit_path(arg, mode)
-                 end
-      end
-      files.map { |f| File.expand_path(f) }.uniq
-    end
-    # Finds all Ruby source files under the current or other supplied
-    # directory. A Ruby source file is defined as a file with the `.rb`
-    # extension or a file with no extension that has a ruby shebang line
-    # as its first line.
-    # It is possible to specify includes and excludes using the config file,
-    # so you can include other Ruby files like Rakefiles and gemspecs.
-    # @param base_dir Root directory under which to search for
-    #   ruby source files
-    # @return [Array] Array of filenames
-    def target_files_in_dir(base_dir = Dir.pwd)
-      # Support Windows: Backslashes from command-line -> forward slashes
-      base_dir = base_dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
-      all_files = find_files(base_dir, File::FNM_DOTMATCH)
-      hidden_files = Set.new(all_files - find_files(base_dir, 0))
-      base_dir_config = @config_store.for(base_dir)
-      target_files = all_files.select do |file|
-        to_inspect?(file, hidden_files, base_dir_config)
-      end
-      target_files.sort_by!(&order)
-    end
-    def to_inspect?(file, hidden_files, base_dir_config)
-      return false if base_dir_config.file_to_exclude?(file)
-      return true if !hidden_files.include?(file) && ruby_file?(file)
-      base_dir_config.file_to_include?(file)
-    end
-    # Search for files recursively starting at the given base directory using
-    # the given flags that determine how the match is made. Excluded files will
-    # be removed later by the caller, but as an optimization find_files removes
-    # the top level directories that are excluded in configuration in the
-    # normal way (dir/**/*).
-    def find_files(base_dir, flags)
-      wanted_toplevel_dirs = toplevel_dirs(base_dir, flags) -
-                             excluded_dirs(base_dir)
-      wanted_toplevel_dirs.map! { |dir| dir << '/**/*' }
-      pattern = if wanted_toplevel_dirs.empty?
-                  # We need this special case to avoid creating the pattern
-                  # /**/* which searches the entire file system.
-                  ["#{base_dir}/**/*"]
-                else
-                  # Search the non-excluded top directories, but also add files
-                  # on the top level, which would otherwise not be found.
-                  wanted_toplevel_dirs.unshift("#{base_dir}/*")
-                end
-      Dir.glob(pattern, flags).select { |path| FileTest.file?(path) }
-    end
-    def toplevel_dirs(base_dir, flags)
-      Dir.glob(File.join(base_dir, '*'), flags).select do |dir|
-        File.directory?(dir) && !dir.end_with?('/.', '/..')
-      end
-    end
-    def excluded_dirs(base_dir)
-      all_cops_config = @config_store.for(base_dir).for_all_cops
-      dir_tree_excludes = all_cops_config['Exclude'].select do |pattern|
-        pattern.is_a?(String) && pattern.end_with?('/**/*')
-      end
-      dir_tree_excludes.map { |pattern| pattern.sub(%r{/\*\*/\*$}, '') }
-    end
-    def ruby_extension?(file)
-      ruby_extensions.include?(File.extname(file))
-    end
-    def ruby_extensions
-      @ruby_extensions ||= begin
-        ext_patterns = all_cops_include.select do |pattern|
-          pattern.start_with?('**/*.')
-        end
-        ext_patterns.map { |pattern| pattern.sub('**/*', '') }
-      end
-    end
-    def ruby_filename?(file)
-      ruby_filenames.include?(File.basename(file))
-    end
-    def ruby_filenames
-      @ruby_filenames ||= begin
-        file_patterns = all_cops_include.reject do |pattern|
-          pattern.start_with?('**/*.')
-        end
-        file_patterns.map { |pattern| pattern.sub('**/', '') }
-      end
-    end
-    def all_cops_include
-      @all_cops_include ||=
-        @config_store.for_pwd.for_all_cops['Include'].map(&:to_s)
-    end
-    def ruby_executable?(file)
-      return false unless File.extname(file).empty? && File.exist?(file)
-      first_line = File.open(file, &:readline)
-      /#!.*(#{ruby_interpreters(file).join('|')})/.match?(first_line)
-    rescue EOFError, ArgumentError => e
-      warn("Unprocessable file #{file}: #{e.class}, #{e.message}") if debug?
-      false
-    end
-    def ruby_interpreters(file)
-      @config_store.for(file).for_all_cops['RubyInterpreters']
-    end
-    def stdin?
-      @options.key?(:stdin)
-    end
-    def ruby_file?(file)
-      stdin? || ruby_extension?(file) || ruby_filename?(file) ||
-        ruby_executable?(file)
-    end
-    def configured_include?(file)
-      @config_store.for_pwd.file_to_include?(file)
-    end
-    def included_file?(file)
-      ruby_file?(file) || configured_include?(file)
-    end
-    def process_explicit_path(path, mode)
-      files = path.include?('*') ? Dir[path] : [path]
-      if mode == :only_recognized_file_types || force_exclusion?
-        files.select! { |file| included_file?(file) }
-      end
-      return files unless force_exclusion?
-      files.reject do |file|
-        config = @config_store.for(file)
-        config.file_to_exclude?(file)
-      end
-    end
-    private
-    def order
-      if fail_fast?
-        # Most recently modified file first.
-        ->(path) { -Integer(File.mtime(path)) }
-      else
-        :itself
-      end
-    end
-  end
-end