rubocop 0.48.1 → 1.16.0

data/lib/rubocop/ast_aliases.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# These aliases are for compatibility.
+module RuboCop
+  NodePattern = AST::NodePattern
+  ProcessedSource = AST::ProcessedSource
+  Token = AST::Token
+end

data/lib/rubocop/cached_data.rb

@@ -4,6 +4,7 @@ require 'json'
 
 module RuboCop
   # Converts RuboCop objects to and from the serialization format JSON.
+  # @api private
   class CachedData
     def initialize(filename)
       @filename = filename
@@ -20,6 +21,7 @@ module RuboCop
     private
 
     def serialize_offense(offense)
+      status = :uncorrected if %i[corrected corrected_with_todo].include?(offense.status)
       {
         # Calling #to_s here ensures that the serialization works when using
         # other json serializers such as Oj. Some of these gems do not call
@@ -31,19 +33,14 @@ module RuboCop
         },
         message:  message(offense),
         cop_name: offense.cop_name,
-        status:   offense.status
+        status:   status || offense.status
       }
     end
 
     def message(offense)
       # JSON.dump will fail if the offense message contains text which is not
       # valid UTF-8
-      message = offense.message
-      if message.respond_to?(:scrub)
-        message.scrub
-      else
-        message.chars.select(&:valid_encoding?).join
-      end
+      offense.message.dup.force_encoding(::Encoding::UTF_8).scrub
     end
 
     # Restore an offense object loaded from a JSON file.
@@ -54,9 +51,7 @@ module RuboCop
         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)
+        Cop::Offense.new(o['severity'], location, o['message'], o['cop_name'], o['status'].to_sym)
       end
     end
   end

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
 
@@ -15,47 +18,80 @@ module RuboCop
       @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
+    # 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)
-      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
-      $stderr.puts Rainbow("Error: #{e.message}").red
-      return 2
+      warn Rainbow("Error: #{e.message}").red
+      STATUS_ERROR
     rescue Finished
-      return 0
-    rescue StandardError, SyntaxError => e
-      $stderr.puts e.message
-      $stderr.puts e.backtrace
-      return 2
+      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 run_command(name)
+      @env.run(name)
     end
 
-    def trap_interrupt(runner)
-      Signal.trap('INT') do
-        exit!(1) if runner.aborting?
-        runner.abort
-        $stderr.puts
-        $stderr.puts 'Exiting... Interrupt again to exit immediately.'
+    def execute_runners
+      if @options[:auto_gen_config]
+        run_command(:auto_gen_config)
+      else
+        run_command(:execute_runner).tap { suggest_extensions }
       end
     end
 
-    private
+    def suggest_extensions
+      run_command(:suggest_extensions)
+    end
 
-    def act_on_options
-      handle_exiting_options
+    def validate_options_vs_config
+      return unless @options[:parallel] && !@config_store.for_pwd.for_all_cops['UseCache']
 
-      ConfigLoader.debug = @options[:debug]
-      ConfigLoader.auto_gen_config = @options[:auto_gen_config]
+      raise OptionArgumentError, '-P/--parallel uses caching to speed up execution, so combining ' \
+                                 'with AllCops: UseCache: false is not allowed.'
+    end
+
+    def act_on_options
+      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
@@ -65,24 +101,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
 
@@ -90,100 +120,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_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 <<-END.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)}
-      END
-    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/cli/command.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    # Home of subcommands in the CLI.
+    # @api private
+    module Command
+      class << self
+        # Find the command with a given name and run it in an environment.
+        def run(env, name)
+          class_for(name).new(env).run
+        end
+
+        private
+
+        def class_for(name)
+          Base.by_command_name(name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cli/command/auto_genenerate_config.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # Generate a configuration file acting as a TODO list.
+      # @api private
+      class AutoGenerateConfig < Base
+        self.command_name = :auto_gen_config
+
+        AUTO_GENERATED_FILE = '.rubocop_todo.yml'
+        YAML_OPTIONAL_DOC_START = /\A---(\s+#|\s*\z)/.freeze
+
+        PHASE_1 = 'Phase 1 of 2: run Layout/LineLength cop'
+        PHASE_2 = 'Phase 2 of 2: run all cops'
+
+        PHASE_1_OVERRIDDEN = '(skipped because the default Layout/LineLength:Max is overridden)'
+        PHASE_1_DISABLED = '(skipped because Layout/LineLength is disabled)'
+
+        def run
+          add_formatter
+          reset_config_and_auto_gen_file
+          line_length_contents = maybe_run_line_length_cop
+          run_all_cops(line_length_contents)
+        end
+
+        private
+
+        def maybe_run_line_length_cop
+          if !line_length_enabled?(@config_store.for_pwd)
+            skip_line_length_cop(PHASE_1_DISABLED)
+          elsif !same_max_line_length?(@config_store.for_pwd, ConfigLoader.default_configuration)
+            skip_line_length_cop(PHASE_1_OVERRIDDEN)
+          else
+            run_line_length_cop
+          end
+        end
+
+        def skip_line_length_cop(reason)
+          puts Rainbow("#{PHASE_1} #{reason}").yellow
+          ''
+        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('Layout/LineLength')
+        end
+
+        # Do an initial run with only Layout/LineLength so that cops that
+        # depend on Layout/LineLength:Max get the correct value for that
+        # parameter.
+        def run_line_length_cop
+          puts Rainbow(PHASE_1).yellow
+          @options[:only] = ['Layout/LineLength']
+          execute_runner
+          @options.delete(:only)
+          @config_store = ConfigStore.new
+          # Save the todo configuration of the LineLength cop.
+          File.read(AUTO_GENERATED_FILE).lines.drop_while { |line| line.start_with?('#') }.join
+        end
+
+        def run_all_cops(line_length_contents)
+          puts Rainbow(PHASE_2).yellow
+          result = execute_runner
+          # This run was made with the current maximum length allowed, so append
+          # the saved setting for LineLength.
+          File.open(AUTO_GENERATED_FILE, 'a') { |f| f.write(line_length_contents) }
+          result
+        end
+
+        def reset_config_and_auto_gen_file
+          @config_store = ConfigStore.new
+          @config_store.options_config = @options[:config] if @options[:config]
+          File.open(AUTO_GENERATED_FILE, 'w') {} # create or truncate if exists
+          add_inheritance_from_auto_generated_file(@options[:config])
+        end
+
+        def add_formatter
+          @options[:formatters] << [Formatter::DisabledConfigFormatter, AUTO_GENERATED_FILE]
+        end
+
+        def execute_runner
+          Environment.new(@options, @config_store, @paths).run(:execute_runner)
+        end
+
+        def add_inheritance_from_auto_generated_file(config_file)
+          file_string = " #{AUTO_GENERATED_FILE}"
+
+          config_file ||= ConfigLoader::DOTFILE
+
+          if File.exist?(config_file)
+            files = Array(ConfigLoader.load_yaml_configuration(config_file)['inherit_from'])
+
+            return if files.include?(AUTO_GENERATED_FILE)
+
+            files.unshift(AUTO_GENERATED_FILE)
+            file_string = "\n  - #{files.join("\n  - ")}" if files.size > 1
+            rubocop_yml_contents = existing_configuration(config_file)
+          end
+
+          write_config_file(config_file, file_string, rubocop_yml_contents)
+
+          puts "Added inheritance from `#{AUTO_GENERATED_FILE}` in `#{ConfigLoader::DOTFILE}`."
+        end
+
+        def existing_configuration(config_file)
+          File.read(config_file, encoding: Encoding::UTF_8)
+              .sub(/^inherit_from: *[^\n]+/, '')
+              .sub(/^inherit_from: *(\n *- *[^\n]+)+/, '')
+        end
+
+        def write_config_file(file_name, file_string, rubocop_yml_contents)
+          lines = /\S/.match?(rubocop_yml_contents) ? rubocop_yml_contents.split("\n", -1) : []
+          doc_start_index = lines.index { |line| YAML_OPTIONAL_DOC_START.match?(line) } || -1
+          lines.insert(doc_start_index + 1, "inherit_from:#{file_string}\n")
+          File.open(file_name, 'w') { |f| f.write lines.join("\n") }
+        end
+      end
+    end
+  end
+end