rubocop 0.42.0 → 0.52.1

data/lib/rubocop/{ast_node → ast}/traversal.rb

@@ -1,8 +1,7 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
-  class Node
+  module AST
     # Provides methods for traversing an AST.
     # Does not transform an AST; for that, use Parser::AST::Processor.
     # Override methods to perform custom processing. Remember to call `super`
@@ -14,54 +13,54 @@ module RuboCop
         nil
       end
 
-      NO_CHILD_NODES    = [:true, :false, :nil, :int, :float, :complex,
-                           :rational, :str, :sym, :regopt, :self, :lvar,
-                           :ivar, :cvar, :gvar, :nth_ref, :back_ref, :cbase,
-                           :arg, :restarg, :blockarg, :shadowarg,
-                           :kwrestarg, :zsuper, :lambda, :redo, :retry].freeze
-      ONE_CHILD_NODE    = [:splat, :kwsplat, :block_pass, :not, :break, :next,
-                           :preexe, :postexe, :match_current_line, :defined?,
-                           :arg_expr].freeze
-      MANY_CHILD_NODES  = [:dstr, :dsym, :xstr, :regexp, :array, :hash, :pair,
-                           :irange, :erange, :mlhs, :masgn, :or_asgn, :and_asgn,
-                           :undef, :alias, :args, :super, :yield, :or, :and,
-                           :while_post, :until_post, :iflipflop, :eflipflop,
-                           :match_with_lvasgn, :begin, :kwbegin, :return].freeze
-      SECOND_CHILD_ONLY = [:lvasgn, :ivasgn, :cvasgn, :gvasgn, :optarg, :kwarg,
-                           :kwoptarg].freeze
+      NO_CHILD_NODES    = %i[true false nil int float complex
+                             rational str sym regopt self lvar
+                             ivar cvar gvar nth_ref back_ref cbase
+                             arg restarg blockarg shadowarg
+                             kwrestarg zsuper lambda redo retry].freeze
+      ONE_CHILD_NODE    = %i[splat kwsplat block_pass not break next
+                             preexe postexe match_current_line defined?
+                             arg_expr].freeze
+      MANY_CHILD_NODES  = %i[dstr dsym xstr regexp array hash pair
+                             irange erange mlhs masgn or_asgn and_asgn
+                             undef alias args super yield or and
+                             while_post until_post iflipflop eflipflop
+                             match_with_lvasgn begin kwbegin return].freeze
+      SECOND_CHILD_ONLY = %i[lvasgn ivasgn cvasgn gvasgn optarg kwarg
+                             kwoptarg].freeze
 
       NO_CHILD_NODES.each do |type|
-        module_eval("def on_#{type}(node); end")
+        module_eval("def on_#{type}(node); end", __FILE__, __LINE__)
       end
 
       ONE_CHILD_NODE.each do |type|
-        module_eval(<<-END)
+        module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           def on_#{type}(node)
             if (child = node.children[0])
               send(:"on_\#{child.type}", child)
             end
           end
-        END
+        RUBY
       end
 
       MANY_CHILD_NODES.each do |type|
-        module_eval(<<-END)
+        module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           def on_#{type}(node)
             node.children.each { |child| send(:"on_\#{child.type}", child) }
             nil
           end
-        END
+        RUBY
       end
 
       SECOND_CHILD_ONLY.each do |type|
         # Guard clause is for nodes nested within mlhs
-        module_eval(<<-END)
+        module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           def on_#{type}(node)
             if (child = node.children[1])
               send(:"on_\#{child.type}", child)
             end
           end
-        END
+        RUBY
       end
 
       def on_const(node)

data/lib/rubocop/cached_data.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'json'
@@ -11,7 +10,7 @@ module RuboCop
     end
 
     def from_json(text)
-      deserialize_offenses(JSON.load(text))
+      deserialize_offenses(JSON.parse(text))
     end
 
     def to_json(offenses)
@@ -21,15 +20,6 @@ module RuboCop
     private
 
     def serialize_offense(offense)
-      # JSON.dump will fail if the offense message contains text which is not
-      # valid UTF-8
-      message = offense.message
-      message = if message.respond_to?(:scrub)
-                  message.scrub
-                else
-                  message.chars.select(&:valid_encoding?).join
-                end
-
       {
         # Calling #to_s here ensures that the serialization works when using
         # other json serializers such as Oj. Some of these gems do not call
@@ -39,40 +29,30 @@ module RuboCop
           begin_pos: offense.location.begin_pos,
           end_pos: offense.location.end_pos
         },
-        message:  message,
+        message:  message(offense),
         cop_name: offense.cop_name,
         status:   offense.status
       }
     end
 
+    def message(offense)
+      # JSON.dump will fail if the offense message contains text which is not
+      # valid UTF-8
+      offense.message.scrub
+    end
+
     # Restore an offense object loaded from a JSON file.
     def deserialize_offenses(offenses)
-      source_buffer = utf8_source_buffer
+      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,
-                         # We know that we wrote a UTF-8 encoded string to the
-                         # cache file, so it's safe to force-encode it back to
-                         # UTF-8 if it happens to be ASCII-8BIT.
-                         o['message'].force_encoding('UTF-8'),
+                         o['message'],
                          o['cop_name'], o['status'].to_sym)
       end
     end
-
-    # Return a source buffer that has a UTF-8 encoded source.
-    def utf8_source_buffer
-      # We are given a source with an encoding of ASCII-8BIT
-      ascii_source = Parser::Source::Buffer.new(@filename).read.source
-
-      # Correct the encoding of the source as we expect UTF-8
-      source = ascii_source.dup.force_encoding('UTF-8')
-
-      # The existing source is immutable so we need a new object
-      source_buffer = Parser::Source::Buffer.new(@filename)
-      source_buffer.source = source
-      source_buffer
-    end
   end
 end

data/lib/rubocop/cli.rb

@@ -1,12 +1,16 @@
-# encoding: utf-8
 # 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
 
+    SKIPPED_PHASE_1 = 'Phase 1 of 2: run Metrics/LineLength cop (skipped ' \
+                      'because the default Metrics/LineLength:Max is ' \
+                      'overridden)'.freeze
+
     class Finished < RuntimeError; end
 
     attr_reader :options, :config_store
@@ -16,45 +20,119 @@ 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
-    # @return [Fixnum] UNIX exit code
+    # the target files.
+    #
+    # @param args [Array<String>] command line arguments
+    # @return [Integer] UNIX exit code
+    #
+    # rubocop:disable Metrics/MethodLength
     def run(args = ARGV)
       @options, paths = Options.new.parse(args)
+      validate_options_vs_config
       act_on_options
       apply_default_formatter
-
-      execute_runner(paths)
+      execute_runners(paths)
     rescue RuboCop::Error => e
-      $stderr.puts Rainbow("Error: #{e.message}").red
+      warn Rainbow("Error: #{e.message}").red
       return 2
     rescue Finished
       return 0
-    rescue StandardError, SyntaxError => e
-      $stderr.puts e.message
-      $stderr.puts e.backtrace
+    rescue IncorrectCopNameError => e
+      warn e.message
+      return 2
+    rescue StandardError, SyntaxError, LoadError => e
+      warn e.message
+      warn e.backtrace
       return 2
     end
+    # rubocop:enable Metrics/MethodLength
 
     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.'
+        warn
+        warn 'Exiting... Interrupt again to exit immediately.'
       end
     end
 
     private
 
-    def act_on_options
-      handle_exiting_options
+    def execute_runners(paths)
+      if @options[:auto_gen_config]
+        reset_config_and_auto_gen_file
+        line_length_contents =
+          if max_line_length(@config_store.for(Dir.pwd)) ==
+             max_line_length(ConfigLoader.default_configuration)
+            run_line_length_cop_auto_gen_config(paths)
+          else
+            puts Rainbow(SKIPPED_PHASE_1).yellow
+            ''
+          end
+        run_all_cops_auto_gen_config(line_length_contents, paths)
+      else
+        execute_runner(paths)
+      end
+    end
+
+    def max_line_length(config)
+      config.for_cop('Metrics/LineLength')['Max']
+    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 of 2: run Metrics/LineLength cop').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 of 2: run all cops').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 reset_config_and_auto_gen_file
+      @config_store = ConfigStore.new
+      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 ArgumentError, '-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]
 
       @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
@@ -95,37 +173,41 @@ module RuboCop
         [[formatter, @options[:output_path]]]
       end
 
-      if @options[:auto_gen_config]
-        @options[:formatters] << [Formatter::DisabledConfigFormatter,
-                                  ConfigLoader::AUTO_GENERATED_FILE]
-      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)
-      cops = Cop::Cop.all
+      registry = Cop::Cop.registry
       show_all = @options[:show_cops].empty?
 
       if show_all
-        puts "# Available cops (#{cops.length}) + config for #{Dir.pwd}: "
+        puts "# Available cops (#{registry.length}) + config for #{Dir.pwd}: "
       end
 
-      cops.types.sort!.each { |type| print_cops_of_type(cops, type, show_all) }
+      registry.departments.sort!.each do |department|
+        print_cops_of_department(registry, department, show_all)
+      end
     end
 
-    def print_cops_of_type(cops, type, show_all)
+    def print_cops_of_department(registry, department, show_all)
       selected_cops = if show_all
-                        cops_of_type(cops, type)
+                        cops_of_department(registry, department)
                       else
-                        selected_cops_of_type(cops, type)
+                        selected_cops_of_department(registry, department)
                       end
 
-      if show_all
-        puts "# Type '#{type.to_s.capitalize}' (#{selected_cops.size}):"
-      end
+      puts "# Department '#{department}' (#{selected_cops.length}):" if show_all
+
+      print_cop_details(selected_cops)
+    end
 
-      selected_cops.each do |cop|
+    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)
@@ -133,14 +215,14 @@ module RuboCop
       end
     end
 
-    def selected_cops_of_type(cops, type)
-      cops_of_type(cops, type).select do |cop|
+    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_type(cops, type)
-      cops.with_type(type).sort_by!(&:cop_name)
+    def cops_of_department(cops, department)
+      cops.with_department(department).sort!
     end
 
     def config_lines(cop)
@@ -163,12 +245,12 @@ module RuboCop
 
       errors.each { |error| warn error }
 
-      warn <<-END.strip_indent
+      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)}
-      END
+      WARNING
     end
 
     def maybe_print_corrected_source
@@ -183,3 +265,4 @@ module RuboCop
     end
   end
 end
+# rubocop:enable Metrics/ClassLength

data/lib/rubocop/comment_config.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -12,7 +11,7 @@ module RuboCop
     COPS_PATTERN = "(all|#{COP_NAMES_PATTERN})".freeze
 
     COMMENT_DIRECTIVE_REGEXP = Regexp.new(
-      ('\A# rubocop : ((?:dis|en)able)\b ' + COPS_PATTERN).gsub(' ', '\s*')
+      ('# rubocop : ((?:dis|en)able)\b ' + COPS_PATTERN).gsub(' ', '\s*')
     )
 
     CopAnalysis = Struct.new(:line_ranges, :start_line_number)
@@ -134,9 +133,7 @@ module RuboCop
     end
 
     def all_cop_names
-      @all_cop_names ||= Cop::Cop.all.map(&:cop_name).reject do |cop_name|
-        cop_name == UNNEEDED_DISABLE
-      end
+      @all_cop_names ||= Cop::Cop.registry.names - [UNNEEDED_DISABLE]
     end
 
     def comment_only_line?(line_number)
@@ -147,11 +144,8 @@ 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.map { |token| token.pos.line }.uniq
+        non_comment_tokens = processed_source.tokens.reject(&:comment?)
+        non_comment_tokens.map(&:line).uniq
       end
     end
   end