rubocop 0.75.1

data/lib/rubocop/cached_data.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RuboCop
+  # Converts RuboCop objects to and from the serialization format JSON.
+  class CachedData
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def from_json(text)
+      deserialize_offenses(JSON.parse(text))
+    end
+
+    def to_json(offenses)
+      JSON.dump(offenses.map { |o| serialize_offense(o) })
+    end
+
+    private
+
+    def serialize_offense(offense)
+      {
+        # Calling #to_s here ensures that the serialization works when using
+        # other json serializers such as Oj. Some of these gems do not call
+        # #to_s implicitly.
+        severity: offense.severity.to_s,
+        location: {
+          begin_pos: offense.location.begin_pos,
+          end_pos: offense.location.end_pos
+        },
+        message:  message(offense),
+        cop_name: offense.cop_name,
+        status:   :uncorrected
+      }
+    end
+
+    def message(offense)
+      # JSON.dump will fail if the offense message contains text which is not
+      # valid UTF-8
+      offense.message.dup.force_encoding(::Encoding::UTF_8).scrub
+    end
+
+    # Restore an offense object loaded from a JSON file.
+    def deserialize_offenses(offenses)
+      source_buffer = Parser::Source::Buffer.new(@filename)
+      source_buffer.source = File.read(@filename, encoding: Encoding::UTF_8)
+      offenses.map! do |o|
+        location = Parser::Source::Range.new(source_buffer,
+                                             o['location']['begin_pos'],
+                                             o['location']['end_pos'])
+        Cop::Offense.new(o['severity'], location,
+                         o['message'],
+                         o['cop_name'], o['status'].to_sym)
+      end
+    end
+  end
+end

data/lib/rubocop/cli.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength
+module RuboCop
+  # The CLI is a class responsible of handling all the command line interface
+  # logic.
+  class CLI
+    include Formatter::TextUtil
+
+    PHASE_1 = 'Phase 1 of 2: run Metrics/LineLength cop'
+    PHASE_2 = 'Phase 2 of 2: run all cops'
+
+    PHASE_1_OVERRIDDEN = '(skipped because the default Metrics/LineLength:Max' \
+                         ' is overridden)'
+    PHASE_1_DISABLED   = '(skipped because Metrics/LineLength is ' \
+                         'disabled)'
+
+    STATUS_SUCCESS     = 0
+    STATUS_OFFENSES    = 1
+    STATUS_ERROR       = 2
+    STATUS_INTERRUPTED = 128 + Signal.list['INT']
+
+    class Finished < RuntimeError; end
+
+    attr_reader :options, :config_store
+
+    def initialize
+      @options = {}
+      @config_store = ConfigStore.new
+    end
+
+    # @api public
+    #
+    # Entry point for the application logic. Here we
+    # do the command line arguments processing and inspect
+    # the target files.
+    #
+    # @param args [Array<String>] command line arguments
+    # @return [Integer] UNIX exit code
+    #
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def run(args = ARGV)
+      @options, paths = Options.new.parse(args)
+
+      if @options[:init]
+        init_dotfile
+      else
+        validate_options_vs_config
+        act_on_options
+        apply_default_formatter
+        execute_runners(paths)
+      end
+    rescue ConfigNotFoundError, IncorrectCopNameError, OptionArgumentError => e
+      warn e.message
+      STATUS_ERROR
+    rescue RuboCop::Error => e
+      warn Rainbow("Error: #{e.message}").red
+      STATUS_ERROR
+    rescue Finished
+      STATUS_SUCCESS
+    rescue OptionParser::InvalidOption => e
+      warn e.message
+      warn 'For usage information, use --help'
+      STATUS_ERROR
+    rescue StandardError, SyntaxError, LoadError => e
+      warn e.message
+      warn e.backtrace
+      STATUS_ERROR
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    private
+
+    def execute_runners(paths)
+      if @options[:auto_gen_config]
+        reset_config_and_auto_gen_file
+        line_length_contents = maybe_run_line_length_cop(paths)
+        run_all_cops_auto_gen_config(line_length_contents, paths)
+      else
+        execute_runner(paths)
+      end
+    end
+
+    def maybe_run_line_length_cop(paths)
+      if !line_length_enabled?(@config_store.for(Dir.pwd))
+        puts Rainbow("#{PHASE_1} #{PHASE_1_DISABLED}").yellow
+        ''
+      elsif !same_max_line_length?(
+        @config_store.for(Dir.pwd), ConfigLoader.default_configuration
+      )
+        puts Rainbow("#{PHASE_1} #{PHASE_1_OVERRIDDEN}").yellow
+        ''
+      else
+        run_line_length_cop_auto_gen_config(paths)
+      end
+    end
+
+    def line_length_enabled?(config)
+      line_length_cop(config)['Enabled']
+    end
+
+    def same_max_line_length?(config1, config2)
+      max_line_length(config1) == max_line_length(config2)
+    end
+
+    def max_line_length(config)
+      line_length_cop(config)['Max']
+    end
+
+    def line_length_cop(config)
+      config.for_cop('Metrics/LineLength')
+    end
+
+    # Do an initial run with only Metrics/LineLength so that cops that depend
+    # on Metrics/LineLength:Max get the correct value for that parameter.
+    def run_line_length_cop_auto_gen_config(paths)
+      puts Rainbow(PHASE_1).yellow
+      @options[:only] = ['Metrics/LineLength']
+      execute_runner(paths)
+      @options.delete(:only)
+      @config_store = ConfigStore.new
+      # Save the todo configuration of the LineLength cop.
+      IO.read(ConfigLoader::AUTO_GENERATED_FILE)
+        .lines
+        .drop_while { |line| line.start_with?('#') }
+        .join
+    end
+
+    def run_all_cops_auto_gen_config(line_length_contents, paths)
+      puts Rainbow(PHASE_2).yellow
+      result = execute_runner(paths)
+      # This run was made with the current maximum length allowed, so append
+      # the saved setting for LineLength.
+      File.open(ConfigLoader::AUTO_GENERATED_FILE, 'a') do |f|
+        f.write(line_length_contents)
+      end
+      result
+    end
+
+    def init_dotfile
+      path = File.expand_path(ConfigLoader::DOTFILE)
+
+      if File.exist?(ConfigLoader::DOTFILE)
+        warn Rainbow("#{ConfigLoader::DOTFILE} already exists at #{path}").red
+
+        STATUS_ERROR
+      else
+        description = <<~DESC
+          # The behavior of RuboCop can be controlled via the .rubocop.yml
+          # configuration file. It makes it possible to enable/disable
+          # certain cops (checks) and to alter their behavior if they accept
+          # any parameters. The file can be placed either in your home
+          # directory or in some project directory.
+          #
+          # RuboCop will start looking for the configuration file in the directory
+          # where the inspected file is and continue its way up to the root directory.
+          #
+          # See https://github.com/rubocop-hq/rubocop/blob/master/manual/configuration.md
+        DESC
+
+        File.open(ConfigLoader::DOTFILE, 'w') do |f|
+          f.write(description)
+        end
+
+        puts "Writing new #{ConfigLoader::DOTFILE} to #{path}"
+
+        STATUS_SUCCESS
+      end
+    end
+
+    def reset_config_and_auto_gen_file
+      @config_store = ConfigStore.new
+      @config_store.options_config = @options[:config] if @options[:config]
+      File.open(ConfigLoader::AUTO_GENERATED_FILE, 'w') {}
+      ConfigLoader.add_inheritance_from_auto_generated_file
+    end
+
+    def validate_options_vs_config
+      if @options[:parallel] &&
+         !@config_store.for(Dir.pwd).for_all_cops['UseCache']
+        raise OptionArgumentError, '-P/--parallel uses caching to speed up ' \
+                                   'execution, so combining with AllCops: ' \
+                                   'UseCache: false is not allowed.'
+      end
+    end
+
+    def act_on_options
+      ConfigLoader.debug = @options[:debug]
+      ConfigLoader.auto_gen_config = @options[:auto_gen_config]
+      ConfigLoader.ignore_parent_exclusion = @options[:ignore_parent_exclusion]
+      ConfigLoader.options_config = @options[:config]
+
+      @config_store.options_config = @options[:config] if @options[:config]
+      @config_store.force_default_config! if @options[:force_default_config]
+
+      handle_exiting_options
+
+      if @options[:color]
+        # color output explicitly forced on
+        Rainbow.enabled = true
+      elsif @options[:color] == false
+        # color output explicitly forced off
+        Rainbow.enabled = false
+      end
+    end
+
+    def execute_runner(paths)
+      runner = Runner.new(@options, @config_store)
+
+      all_passed = runner.run(paths)
+      display_warning_summary(runner.warnings)
+      display_error_summary(runner.errors)
+      maybe_print_corrected_source
+
+      all_pass_or_excluded = all_passed || @options[:auto_gen_config]
+
+      if runner.aborting?
+        STATUS_INTERRUPTED
+      elsif all_pass_or_excluded && runner.errors.empty?
+        STATUS_SUCCESS
+      else
+        STATUS_OFFENSES
+      end
+    end
+
+    def handle_exiting_options
+      return unless Options::EXITING_OPTIONS.any? { |o| @options.key? o }
+
+      puts RuboCop::Version.version(false) if @options[:version]
+      puts RuboCop::Version.version(true) if @options[:verbose_version]
+      print_available_cops if @options[:show_cops]
+      raise Finished
+    end
+
+    def apply_default_formatter
+      # This must be done after the options have already been processed,
+      # because they can affect how ConfigStore behaves
+      @options[:formatters] ||= begin
+        if @options[:auto_gen_config]
+          formatter = 'autogenconf'
+        else
+          cfg = @config_store.for(Dir.pwd).for_all_cops
+          formatter = cfg['DefaultFormatter'] || 'progress'
+        end
+        [[formatter, @options[:output_path]]]
+      end
+
+      return unless @options[:auto_gen_config]
+
+      @options[:formatters] << [Formatter::DisabledConfigFormatter,
+                                ConfigLoader::AUTO_GENERATED_FILE]
+    end
+
+    def print_available_cops
+      # Load the configs so the require()s are done for custom cops
+      @config_store.for(Dir.pwd)
+      registry = Cop::Cop.registry
+      show_all = @options[:show_cops].empty?
+
+      if show_all
+        puts "# Available cops (#{registry.length}) + config for #{Dir.pwd}: "
+      end
+
+      registry.departments.sort!.each do |department|
+        print_cops_of_department(registry, department, show_all)
+      end
+    end
+
+    def print_cops_of_department(registry, department, show_all)
+      selected_cops = if show_all
+                        cops_of_department(registry, department)
+                      else
+                        selected_cops_of_department(registry, department)
+                      end
+
+      puts "# Department '#{department}' (#{selected_cops.length}):" if show_all
+
+      print_cop_details(selected_cops)
+    end
+
+    def print_cop_details(cops)
+      cops.each do |cop|
+        puts '# Supports --auto-correct' if cop.new.support_autocorrect?
+        puts "#{cop.cop_name}:"
+        puts config_lines(cop)
+        puts
+      end
+    end
+
+    def selected_cops_of_department(cops, department)
+      cops_of_department(cops, department).select do |cop|
+        @options[:show_cops].include?(cop.cop_name)
+      end
+    end
+
+    def cops_of_department(cops, department)
+      cops.with_department(department).sort!
+    end
+
+    def config_lines(cop)
+      cnf = @config_store.for(Dir.pwd).for_cop(cop)
+      cnf.to_yaml.lines.to_a.drop(1).map { |line| '  ' + line }
+    end
+
+    def display_warning_summary(warnings)
+      return if warnings.empty?
+
+      warn Rainbow("\n#{pluralize(warnings.size, 'warning')}:").yellow
+
+      warnings.each { |warning| warn warning }
+    end
+
+    def display_error_summary(errors)
+      return if errors.empty?
+
+      warn Rainbow("\n#{pluralize(errors.size, 'error')} occurred:").red
+
+      errors.each { |error| warn error }
+
+      warn <<~WARNING
+        Errors are usually caused by RuboCop bugs.
+        Please, report your problems to RuboCop's issue tracker.
+        #{Gem.loaded_specs['rubocop'].metadata['bug_tracker_uri']}
+
+        Mention the following information in the issue report:
+        #{RuboCop::Version.version(true)}
+      WARNING
+    end
+
+    def maybe_print_corrected_source
+      # If we are asked to autocorrect source code read from stdin, the only
+      # reasonable place to write it is to stdout
+      # Unfortunately, we also write other information to stdout
+      # So a delimiter is needed for tools to easily identify where the
+      # autocorrected source begins
+      return unless @options[:stdin] && @options[:auto_correct]
+
+      puts '=' * 20
+      print @options[:stdin]
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength

data/lib/rubocop/comment_config.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This class parses the special `rubocop:disable` comments in a source
+  # and provides a way to check if each cop is enabled at arbitrary line.
+  class CommentConfig
+    UNNEEDED_DISABLE = 'Lint/UnneededCopDisableDirective'
+
+    COP_NAME_PATTERN = '([A-Z]\w+/)?(?:[A-Z]\w+)'
+    COP_NAMES_PATTERN = "(?:#{COP_NAME_PATTERN} , )*#{COP_NAME_PATTERN}"
+    COPS_PATTERN = "(all|#{COP_NAMES_PATTERN})"
+
+    COMMENT_DIRECTIVE_REGEXP = Regexp.new(
+      ('# rubocop : ((?:disable|enable|todo))\b ' + COPS_PATTERN)
+        .gsub(' ', '\s*')
+    )
+
+    CopAnalysis = Struct.new(:line_ranges, :start_line_number)
+
+    attr_reader :processed_source
+
+    def initialize(processed_source)
+      @processed_source = processed_source
+    end
+
+    def cop_enabled_at_line?(cop, line_number)
+      cop = cop.cop_name if cop.respond_to?(:cop_name)
+      disabled_line_ranges = cop_disabled_line_ranges[cop]
+      return true unless disabled_line_ranges
+
+      disabled_line_ranges.none? { |range| range.include?(line_number) }
+    end
+
+    def cop_disabled_line_ranges
+      @cop_disabled_line_ranges ||= analyze
+    end
+
+    def extra_enabled_comments
+      extra_enabled_comments_with_names([], {})
+    end
+
+    private
+
+    def extra_enabled_comments_with_names(extras, names)
+      each_directive do |comment, cop_names, disabled|
+        next unless comment_only_line?(comment.loc.expression.line)
+
+        if !disabled && enable_all?(comment)
+          handle_enable_all(names, extras, comment)
+        else
+          handle_switch(cop_names, names, disabled, extras, comment)
+        end
+      end
+
+      extras
+    end
+
+    def analyze
+      analyses = Hash.new { |hash, key| hash[key] = CopAnalysis.new([], nil) }
+
+      each_mentioned_cop do |cop_name, disabled, line, single_line|
+        analyses[cop_name] =
+          analyze_cop(analyses[cop_name], disabled, line, single_line)
+      end
+
+      analyses.each_with_object({}) do |element, hash|
+        cop_name, analysis = *element
+        hash[cop_name] = cop_line_ranges(analysis)
+      end
+    end
+
+    def analyze_cop(analysis, disabled, line, single_line)
+      if single_line
+        analyze_single_line(analysis, line, disabled)
+      elsif disabled
+        analyze_disabled(analysis, line)
+      else
+        analyze_rest(analysis, line)
+      end
+    end
+
+    def analyze_single_line(analysis, line, disabled)
+      return analysis unless disabled
+
+      CopAnalysis.new(analysis.line_ranges + [(line..line)],
+                      analysis.start_line_number)
+    end
+
+    def analyze_disabled(analysis, line)
+      if (start_line = analysis.start_line_number)
+        # Cop already disabled on this line, so we end the current disabled
+        # range before we start a new range.
+        return CopAnalysis.new(analysis.line_ranges + [start_line..line], line)
+      end
+
+      CopAnalysis.new(analysis.line_ranges, line)
+    end
+
+    def analyze_rest(analysis, line)
+      if (start_line = analysis.start_line_number)
+        return CopAnalysis.new(analysis.line_ranges + [start_line..line], nil)
+      end
+
+      CopAnalysis.new(analysis.line_ranges, nil)
+    end
+
+    def cop_line_ranges(analysis)
+      return analysis.line_ranges unless analysis.start_line_number
+
+      analysis.line_ranges + [(analysis.start_line_number..Float::INFINITY)]
+    end
+
+    def each_mentioned_cop
+      each_directive do |comment, cop_names, disabled|
+        comment_line_number = comment.loc.expression.line
+        single_line = !comment_only_line?(comment_line_number)
+
+        cop_names.each do |cop_name|
+          yield qualified_cop_name(cop_name), disabled, comment_line_number,
+                single_line
+        end
+      end
+    end
+
+    def each_directive
+      return if processed_source.comments.nil?
+
+      processed_source.each_comment do |comment|
+        directive = directive_parts(comment)
+        next unless directive
+
+        yield comment, *directive
+      end
+    end
+
+    def directive_parts(comment)
+      match = comment.text.match(COMMENT_DIRECTIVE_REGEXP)
+      return unless match
+
+      switch, cops_string = match.captures
+
+      cop_names =
+        cops_string == 'all' ? all_cop_names : cops_string.split(/,\s*/)
+
+      disabled = %w[disable todo].include?(switch)
+
+      [cop_names, disabled]
+    end
+
+    def qualified_cop_name(cop_name)
+      Cop::Cop.qualified_cop_name(cop_name.strip, processed_source.file_path)
+    end
+
+    def all_cop_names
+      @all_cop_names ||= Cop::Cop.registry.names - [UNNEEDED_DISABLE]
+    end
+
+    def comment_only_line?(line_number)
+      non_comment_token_line_numbers.none? do |non_comment_line_number|
+        non_comment_line_number == line_number
+      end
+    end
+
+    def non_comment_token_line_numbers
+      @non_comment_token_line_numbers ||= begin
+        non_comment_tokens = processed_source.tokens.reject(&:comment?)
+        non_comment_tokens.map(&:line).uniq
+      end
+    end
+
+    def enable_all?(comment)
+      _, cops = comment.text.match(COMMENT_DIRECTIVE_REGEXP).captures
+      cops == 'all'
+    end
+
+    def handle_enable_all(names, extras, comment)
+      enabled_cops = 0
+      names.each do |name, counter|
+        next unless counter.positive?
+
+        names[name] -= 1
+        enabled_cops += 1
+      end
+
+      extras << [comment, 'all'] if enabled_cops.zero?
+    end
+
+    def handle_switch(cop_names, names, disabled, extras, comment)
+      cop_names.each do |name|
+        names[name] ||= 0
+        if disabled
+          names[name] += 1
+        elsif (names[name]).positive?
+          names[name] -= 1
+        else
+          extras << [comment, name]
+        end
+      end
+    end
+  end
+end