phillipug-foodie 0.1.0

data/.vendor/ruby/3.0.0/gems/rubocop-1.24.0/lib/rubocop/runner.rb

@@ -0,0 +1,415 @@
+# 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(' -> ')
+
+        message = 'Infinite loop detected'
+        message += " in #{path}" if path
+        message += " and caused by #{root_cause}" if root_cause
+        super message
+      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) { |target_file| file_offenses(target_file) }
+    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 { |path| puts PathUtil.relative_path(path) }
+    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)
+      return unless config.for_cop(Cop::Lint::RedundantCopDisableDirective).fetch('Enabled')
+
+      cop = Cop::Lint::RedundantCopDisableDirective.new(config, @options)
+      yield cop if cop.relevant_file?(file)
+    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) # rubocop:disable Metrics/AbcSize
+      @mobilized_cop_classes ||= {}.compare_by_identity
+      @mobilized_cop_classes[config] ||= begin
+        cop_classes = Cop::Registry.all
+
+        # `@options[:only]` and `@options[:except]` are not qualified until
+        # needed so that the Registry can be fully loaded, including any
+        # cops added by `require`s.
+        qualify_option_cop_names
+
+        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 qualify_option_cop_names
+      %i[only except].each do |option|
+        next unless @options[option]
+
+        @options[option].map! do |cop_name|
+          Cop::Registry.qualified_cop_name(cop_name, "--#{option} option")
+        end
+      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 { |formatter_key, output_path| set.add_formatter(formatter_key, output_path) }
+        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
+        # Unless given explicitly as `fail_level`, `:info` severity offenses do not fail
+        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 ||= {}.compare_by_identity
+      @team_by_config[config] ||=
+        Cop::Team.mobilize(mobilized_cop_classes(config), config, @options)
+    end
+  end
+end

data/.vendor/ruby/3.0.0/gems/rubocop-1.24.0/lib/rubocop/string_interpreter.rb

@@ -0,0 +1,60 @@
+# 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/ruby/3.0.0/gems/rubocop-1.24.0/lib/rubocop/target_finder.rb

@@ -0,0 +1,206 @@
+# 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
+    HIDDEN_PATH_SUBSTRING = "#{File::SEPARATOR}."
+
+    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)
+      # use file.include? for performance optimization
+      hidden_files = all_files.select { |file| file.include?(HIDDEN_PATH_SUBSTRING) }.sort
+      base_dir_config = @config_store.for(base_dir)
+
+      target_files = all_files.select { |file| to_inspect?(file, hidden_files, base_dir_config) }
+
+      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.bsearch do |hidden_file|
+        file <=> hidden_file
+      end && 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)
+      # get all wanted directories first to improve speed of finding all files
+      exclude_pattern = combined_exclude_glob_patterns(base_dir)
+      dir_flags = flags | File::FNM_PATHNAME | File::FNM_EXTGLOB
+      patterns = wanted_dir_patterns(base_dir, exclude_pattern, dir_flags)
+      patterns.map! { |dir| File.join(dir, '*') }
+      # We need this special case to avoid creating the pattern
+      # /**/* which searches the entire file system.
+      patterns = [File.join(dir, '**/*')] if patterns.empty?
+
+      Dir.glob(patterns, flags).select { |path| FileTest.file?(path) }
+    end
+
+    def wanted_dir_patterns(base_dir, exclude_pattern, flags)
+      base_dir = base_dir.gsub('/{}/', '/\{}/')
+      dirs = Dir.glob(File.join(base_dir.gsub('/*/', '/\*/').gsub('/**/', '/\**/'), '*/'), flags)
+                .reject do |dir|
+                  next true if dir.end_with?('/./', '/../')
+                  next true if File.fnmatch?(exclude_pattern, dir, flags)
+
+                  symlink_excluded_or_infinite_loop?(base_dir, dir, exclude_pattern, flags)
+                end
+      dirs.flat_map { |dir| wanted_dir_patterns(dir, exclude_pattern, flags) }.unshift(base_dir)
+    end
+
+    def symlink_excluded_or_infinite_loop?(base_dir, current_dir, exclude_pattern, flags)
+      dir_realpath = File.realpath(current_dir)
+      File.symlink?(current_dir.chomp('/')) && (
+        File.fnmatch?(exclude_pattern, "#{dir_realpath}/", flags) ||
+        File.realpath(base_dir).start_with?(dir_realpath)
+      )
+    end
+
+    def combined_exclude_glob_patterns(base_dir)
+      exclude = @config_store.for(base_dir).for_all_cops['Exclude']
+      patterns = exclude.select { |pattern| pattern.is_a?(String) && pattern.end_with?('/**/*') }
+                        .map { |pattern| pattern.sub("#{base_dir}/", '') }
+      "#{base_dir}/{#{patterns.join(',')}}"
+    end
+
+    def ruby_extension?(file)
+      ruby_extensions.include?(File.extname(file))
+    end
+
+    def ruby_extensions
+      @ruby_extensions ||= begin
+        ext_patterns = all_cops_include.select { |pattern| pattern.start_with?('**/*.') }
+        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 { |pattern| pattern.start_with?('**/*.') }
+        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