rubocop 0.51.0 → 0.87.0

data/lib/rubocop/cli.rb

@@ -4,7 +4,10 @@ module RuboCop
   # The CLI is a class responsible of handling all the command line interface
   # logic.
   class CLI
-    include Formatter::TextUtil
+    STATUS_SUCCESS     = 0
+    STATUS_OFFENSES    = 1
+    STATUS_ERROR       = 2
+    STATUS_INTERRUPTED = 128 + Signal.list['INT']
 
     class Finished < RuntimeError; end
 
@@ -23,54 +26,70 @@ module RuboCop
     #
     # @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)
-      validate_options_vs_config
-      act_on_options
-      apply_default_formatter
-
-      execute_runner(paths)
+      @env = Environment.new(@options, @config_store, paths)
+
+      if @options[:init]
+        run_command(:init)
+      else
+        act_on_options
+        validate_options_vs_config
+        apply_default_formatter
+        execute_runners
+      end
+    rescue ConfigNotFoundError, IncorrectCopNameError, OptionArgumentError => e
+      warn e.message
+      STATUS_ERROR
     rescue RuboCop::Error => e
       warn Rainbow("Error: #{e.message}").red
-      return 2
+      STATUS_ERROR
     rescue Finished
-      return 0
+      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
-      return 2
+      STATUS_ERROR
     end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
-    def trap_interrupt(runner)
-      Signal.trap('INT') do
-        exit!(1) if runner.aborting?
-        runner.abort
-        warn
-        warn 'Exiting... Interrupt again to exit immediately.'
-      end
+    private
+
+    def run_command(name)
+      @env.run(name)
     end
 
-    private
+    def execute_runners
+      if @options[:auto_gen_config]
+        run_command(:auto_gen_config)
+      else
+        run_command(:execute_runner)
+      end
+    end
 
     def validate_options_vs_config
       if @options[:parallel] &&
-         !@config_store.for(Dir.pwd).for_all_cops['UseCache']
-        raise ArgumentError, '-P/--parallel uses caching to speed up ' \
-                             'execution, so combining with AllCops: ' \
-                             'UseCache: false is not allowed.'
+         !@config_store.for_dir(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
-      handle_exiting_options
-
-      ConfigLoader.debug = @options[:debug]
-      ConfigLoader.auto_gen_config = @options[:auto_gen_config]
-      ConfigLoader.ignore_parent_exclusion = @options[:ignore_parent_exclusion]
+      set_options_to_config_loader
 
       @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
@@ -80,24 +99,18 @@ module RuboCop
       end
     end
 
-    def execute_runner(paths)
-      runner = Runner.new(@options, @config_store)
-
-      trap_interrupt(runner)
-      all_passed = runner.run(paths)
-      display_warning_summary(runner.warnings)
-      display_error_summary(runner.errors)
-      maybe_print_corrected_source
-
-      all_passed && !runner.aborting? && runner.errors.empty? ? 0 : 1
+    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]
     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]
       raise Finished
     end
 
@@ -105,100 +118,14 @@ module RuboCop
       # This must be done after the options have already been processed,
       # because they can affect how ConfigStore behaves
       @options[:formatters] ||= begin
-        cfg = @config_store.for(Dir.pwd).for_all_cops
-        formatter = cfg['DefaultFormatter'] || 'progress'
+        if @options[:auto_gen_config]
+          formatter = 'autogenconf'
+        else
+          cfg = @config_store.for_dir(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.butfirst.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.strip_indent
-        Errors are usually caused by RuboCop bugs.
-        Please, report your problems to RuboCop's issue tracker.
-        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

data/lib/rubocop/comment_config.rb

@@ -4,14 +4,15 @@ 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/UnneededDisable'.freeze
+    REDUNDANT_DISABLE = 'Lint/RedundantCopDisableDirective'
 
-    COP_NAME_PATTERN = '([A-Z]\w+/)?(?:[A-Z]\w+)'.freeze
-    COP_NAMES_PATTERN = "(?:#{COP_NAME_PATTERN} , )*#{COP_NAME_PATTERN}".freeze
-    COPS_PATTERN = "(all|#{COP_NAMES_PATTERN})".freeze
+    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 : ((?:dis|en)able)\b ' + COPS_PATTERN).gsub(' ', '\s*')
+      ('# rubocop : ((?:disable|enable|todo))\b ' + COPS_PATTERN)
+        .gsub(' ', '\s*')
     )
 
     CopAnalysis = Struct.new(:line_ranges, :start_line_number)
@@ -34,8 +35,26 @@ module RuboCop
       @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) }
 
@@ -94,7 +113,8 @@ module RuboCop
     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)
+        single_line = !comment_only_line?(comment_line_number) ||
+                      directive_on_comment_line?(comment)
 
         cop_names.each do |cop_name|
           yield qualified_cop_name(cop_name), disabled, comment_line_number,
@@ -103,10 +123,14 @@ module RuboCop
       end
     end
 
+    def directive_on_comment_line?(comment)
+      comment.text[1..-1].match?(COMMENT_DIRECTIVE_REGEXP)
+    end
+
     def each_directive
       return if processed_source.comments.nil?
 
-      processed_source.comments.each do |comment|
+      processed_source.each_comment do |comment|
         directive = directive_parts(comment)
         next unless directive
 
@@ -123,17 +147,17 @@ module RuboCop
       cop_names =
         cops_string == 'all' ? all_cop_names : cops_string.split(/,\s*/)
 
-      disabled = (switch == 'disable')
+      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.buffer.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]
+      @all_cop_names ||= Cop::Cop.registry.names - [REDUNDANT_DISABLE]
     end
 
     def comment_only_line?(line_number)
@@ -144,11 +168,38 @@ module RuboCop
 
     def non_comment_token_line_numbers
       @non_comment_token_line_numbers ||= begin
-        non_comment_tokens = processed_source.tokens.reject do |token|
-          token.type == :tCOMMENT
-        end
+        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?
 
-        non_comment_tokens.map { |token| token.pos.line }.uniq
+        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