rubocop 0.76.0 → 1.50.0

data/lib/rubocop/cli.rb

@@ -1,26 +1,23 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ClassLength
+require 'fileutils'
+
 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']
+    STATUS_INTERRUPTED = Signal.list['INT'] + 128
+    DEFAULT_PARALLEL_OPTIONS = %i[
+      color debug display_style_guide display_time display_only_fail_level_offenses
+      display_only_failed except extra_details fail_level fix_layout format
+      ignore_disable_comments lint only only_guide_cops require safe
+      autocorrect safe_autocorrect autocorrect_all
+    ].freeze
 
-    class Finished < RuntimeError; end
+    class Finished < StandardError; end
 
     attr_reader :options, :config_store
 
@@ -41,14 +38,18 @@ module RuboCop
     # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
     def run(args = ARGV)
       @options, paths = Options.new.parse(args)
+      @env = Environment.new(@options, @config_store, paths)
 
-      if @options[:init]
-        init_dotfile
-      else
-        validate_options_vs_config
-        act_on_options
-        apply_default_formatter
-        execute_runners(paths)
+      profile_if_needed do
+        if @options[:init]
+          run_command(:init)
+        else
+          act_on_options
+          validate_options_vs_config
+          parallel_by_default!
+          apply_default_formatter
+          execute_runners
+        end
       end
     rescue ConfigNotFoundError, IncorrectCopNameError, OptionArgumentError => e
       warn e.message
@@ -71,127 +72,85 @@ module RuboCop
 
     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
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def profile_if_needed
+      return yield unless @options[:profile]
 
-    def maybe_run_line_length_cop(paths)
-      if !line_length_enabled?(@config_store.for(Dir.pwd))
-        skip_line_length_cop(PHASE_1_DISABLED)
-      elsif !same_max_line_length?(
-        @config_store.for(Dir.pwd), ConfigLoader.default_configuration
-      )
-        skip_line_length_cop(PHASE_1_OVERRIDDEN)
-      else
-        run_line_length_cop_auto_gen_config(paths)
-      end
-    end
+      return STATUS_ERROR unless require_gem('stackprof')
 
-    def skip_line_length_cop(reason)
-      puts Rainbow("#{PHASE_1} #{reason}").yellow
-      ''
-    end
+      with_memory = @options[:memory]
+      if with_memory
+        return STATUS_ERROR unless require_gem('memory_profiler')
 
-    def line_length_enabled?(config)
-      line_length_cop(config)['Enabled']
-    end
+        MemoryProfiler.start
+      end
 
-    def same_max_line_length?(config1, config2)
-      max_line_length(config1) == max_line_length(config2)
-    end
+      tmp_dir = File.join(ConfigFinder.project_root, 'tmp')
+      FileUtils.mkdir_p(tmp_dir)
+      cpu_profile_file = File.join(tmp_dir, 'rubocop-stackprof.dump')
+      status = nil
 
-    def max_line_length(config)
-      line_length_cop(config)['Max']
+      StackProf.run(out: cpu_profile_file) do
+        status = yield
+      end
+      puts "Profile report generated at #{cpu_profile_file}"
+
+      if with_memory
+        puts 'Building memory report...'
+        report = MemoryProfiler.stop
+        memory_profile_file = File.join(tmp_dir, 'rubocop-memory_profiler.txt')
+        report.pretty_print(to_file: memory_profile_file, scale_bytes: true)
+        puts "Memory report generated at #{memory_profile_file}"
+      end
+      status
     end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
-    def line_length_cop(config)
-      config.for_cop('Metrics/LineLength')
+    def require_gem(name)
+      require name
+      true
+    rescue LoadError
+      warn("You don't have #{name} installed. Add it to your Gemfile and run `bundle install`")
+      false
     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
+    def run_command(name)
+      @env.run(name)
     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)
+    def execute_runners
+      if @options[:auto_gen_config]
+        run_command(:auto_gen_config)
+      else
+        run_command(:execute_runner).tap { suggest_extensions }
       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
+    def suggest_extensions
+      run_command(:suggest_extensions)
+    end
 
-        puts "Writing new #{ConfigLoader::DOTFILE} to #{path}"
+    def validate_options_vs_config
+      return unless @options[:parallel] && !@config_store.for_pwd.for_all_cops['UseCache']
 
-        STATUS_SUCCESS
-      end
+      raise OptionArgumentError, '-P/--parallel uses caching to speed up execution, so combining ' \
+                                 'with AllCops: UseCache: false is not allowed.'
     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 parallel_by_default!
+      # See https://github.com/rubocop/rubocop/pull/4537 for JRuby and Windows constraints.
+      return if RUBY_ENGINE != 'ruby' || RuboCop::Platform.windows?
 
-    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.'
+      if (@options.keys - DEFAULT_PARALLEL_OPTIONS).empty? &&
+         @config_store.for_pwd.for_all_cops['UseCache'] != false
+        puts 'Use parallel by default.' if @options[:debug]
+
+        @options[:parallel] = true
       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]
+      set_options_to_config_loader
 
       @config_store.options_config = @options[:config] if @options[:config]
       @config_store.force_default_config! if @options[:force_default_config]
@@ -207,31 +166,20 @@ module RuboCop
       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
+    def set_options_to_config_loader
+      ConfigLoader.debug = @options[:debug]
+      ConfigLoader.disable_pending_cops = @options[:disable_pending_cops]
+      ConfigLoader.enable_pending_cops = @options[:enable_pending_cops]
+      ConfigLoader.ignore_parent_exclusion = @options[:ignore_parent_exclusion]
+      ConfigLoader.ignore_unrecognized_cops = @options[:ignore_unrecognized_cops]
     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]
+      run_command(:version) if @options[:version] || @options[:verbose_version]
+      run_command(:show_cops) if @options[:show_cops]
+      run_command(:show_docs_url) if @options[:show_docs_url]
       raise Finished
     end
 
@@ -242,105 +190,11 @@ module RuboCop
         if @options[:auto_gen_config]
           formatter = 'autogenconf'
         else
-          cfg = @config_store.for(Dir.pwd).for_all_cops
+          cfg = @config_store.for_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

@@ -4,23 +4,36 @@ 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
-    REDUNDANT_DISABLE = 'Lint/RedundantCopDisableDirective'
+    extend Forwardable
 
-    COP_NAME_PATTERN = '([A-Z]\w+/)?(?:[A-Z]\w+)'
-    COP_NAMES_PATTERN = "(?:#{COP_NAME_PATTERN} , )*#{COP_NAME_PATTERN}"
-    COPS_PATTERN = "(all|#{COP_NAMES_PATTERN})"
+    CONFIG_DISABLED_LINE_RANGE_MIN = -Float::INFINITY
 
-    COMMENT_DIRECTIVE_REGEXP = Regexp.new(
-      ('# rubocop : ((?:disable|enable|todo))\b ' + COPS_PATTERN)
-        .gsub(' ', '\s*')
-    )
+    # This class provides an API compatible with RuboCop::DirectiveComment
+    # to be used for cops that are disabled in the config file
+    class ConfigDisabledCopDirectiveComment
+      include RuboCop::Ext::Comment
+
+      attr_reader :text, :loc, :line_number
+
+      Loc = Struct.new(:expression)
+      Expression = Struct.new(:line)
+
+      def initialize(cop_name)
+        @text = "# rubocop:disable #{cop_name}"
+        @line_number = CONFIG_DISABLED_LINE_RANGE_MIN
+        @loc = Loc.new(Expression.new(CONFIG_DISABLED_LINE_RANGE_MIN))
+      end
+    end
 
     CopAnalysis = Struct.new(:line_ranges, :start_line_number)
 
     attr_reader :processed_source
 
+    def_delegators :@processed_source, :config, :registry
+
     def initialize(processed_source)
       @processed_source = processed_source
+      @no_directives = !processed_source.raw_source.include?('rubocop')
     end
 
     def cop_enabled_at_line?(cop, line_number)
@@ -31,36 +44,66 @@ module RuboCop
       disabled_line_ranges.none? { |range| range.include?(line_number) }
     end
 
+    def cop_opted_in?(cop)
+      opt_in_cops.include?(cop.cop_name)
+    end
+
     def cop_disabled_line_ranges
       @cop_disabled_line_ranges ||= analyze
     end
 
     def extra_enabled_comments
-      extra_enabled_comments_with_names([], {})
+      disable_count = Hash.new(0)
+      registry.disabled(config).each do |cop|
+        disable_count[cop.cop_name] += 1
+      end
+      extra_enabled_comments_with_names(extras: Hash.new { |h, k| h[k] = [] }, names: disable_count)
+    end
+
+    def comment_only_line?(line_number)
+      non_comment_token_line_numbers.none?(line_number)
     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)
+    def extra_enabled_comments_with_names(extras:, names:)
+      each_directive do |directive|
+        next unless comment_only_line?(directive.line_number)
 
-        if !disabled && enable_all?(comment)
-          handle_enable_all(names, extras, comment)
+        if directive.enabled_all?
+          handle_enable_all(directive, names, extras)
         else
-          handle_switch(cop_names, names, disabled, extras, comment)
+          handle_switch(directive, names, extras)
         end
       end
 
       extras
     end
 
-    def analyze
+    def opt_in_cops
+      @opt_in_cops ||= begin
+        cops = Set.new
+        each_directive do |directive|
+          next unless directive.enabled?
+          next if directive.all_cops?
+
+          cops.merge(directive.cop_names)
+        end
+        cops
+      end
+    end
+
+    def analyze # rubocop:todo Metrics/AbcSize
+      return {} if @no_directives
+
       analyses = Hash.new { |hash, key| hash[key] = CopAnalysis.new([], nil) }
+      inject_disabled_cops_directives(analyses)
 
-      each_mentioned_cop do |cop_name, disabled, line, single_line|
-        analyses[cop_name] =
-          analyze_cop(analyses[cop_name], disabled, line, single_line)
+      each_directive do |directive|
+        directive.cop_names.each do |cop_name|
+          cop_name = qualified_cop_name(cop_name)
+          analyses[cop_name] = analyze_cop(analyses[cop_name], directive)
+        end
       end
 
       analyses.each_with_object({}) do |element, hash|
@@ -69,37 +112,51 @@ module RuboCop
       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)
+    def inject_disabled_cops_directives(analyses)
+      registry.disabled(config).each do |cop|
+        analyses[cop.cop_name] = analyze_cop(
+          analyses[cop.cop_name],
+          DirectiveComment.new(ConfigDisabledCopDirectiveComment.new(cop.cop_name))
+        )
+      end
+    end
+
+    def analyze_cop(analysis, directive)
+      # Disabling cops after comments like `#=SomeDslDirective` does not related to single line
+      if !comment_only_line?(directive.line_number) || directive.single_line?
+        analyze_single_line(analysis, directive)
+      elsif directive.disabled?
+        analyze_disabled(analysis, directive)
       else
-        analyze_rest(analysis, line)
+        analyze_rest(analysis, directive)
       end
     end
 
-    def analyze_single_line(analysis, line, disabled)
-      return analysis unless disabled
+    def analyze_single_line(analysis, directive)
+      return analysis unless directive.disabled?
+
+      line = directive.line_number
+      start_line = analysis.start_line_number
 
-      CopAnalysis.new(analysis.line_ranges + [(line..line)],
-                      analysis.start_line_number)
+      CopAnalysis.new(analysis.line_ranges + [(line..line)], start_line)
     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
+    def analyze_disabled(analysis, directive)
+      line = directive.line_number
+      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) if start_line
 
       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
+    def analyze_rest(analysis, directive)
+      line = directive.line_number
+      start_line = analysis.start_line_number
+
+      return CopAnalysis.new(analysis.line_ranges + [start_line..line], nil) if start_line
 
       CopAnalysis.new(analysis.line_ranges, nil)
     end
@@ -110,55 +167,17 @@ module RuboCop
       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
+      return if @no_directives
 
-        yield comment, *directive
+      processed_source.comments.each do |comment|
+        directive = DirectiveComment.new(comment)
+        yield directive if directive.cop_names
       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 - [REDUNDANT_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
+      Cop::Registry.qualified_cop_name(cop_name.strip, processed_source.file_path)
     end
 
     def non_comment_token_line_numbers
@@ -168,12 +187,7 @@ module RuboCop
       end
     end
 
-    def enable_all?(comment)
-      _, cops = comment.text.match(COMMENT_DIRECTIVE_REGEXP).captures
-      cops == 'all'
-    end
-
-    def handle_enable_all(names, extras, comment)
+    def handle_enable_all(directive, names, extras)
       enabled_cops = 0
       names.each do |name, counter|
         next unless counter.positive?
@@ -182,18 +196,19 @@ module RuboCop
         enabled_cops += 1
       end
 
-      extras << [comment, 'all'] if enabled_cops.zero?
+      extras[directive.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
+    # Collect cops that have been disabled or enabled by name in a directive comment
+    # so that `Lint/RedundantCopEnableDirective` can register offenses correctly.
+    def handle_switch(directive, names, extras)
+      directive.cop_names.each do |name|
+        if directive.disabled?
           names[name] += 1
         elsif (names[name]).positive?
           names[name] -= 1
         else
-          extras << [comment, name]
+          extras[directive.comment] << name
         end
       end
     end