rubocop 1.4.0 → 1.5.2

data/lib/rubocop/cli.rb

@@ -69,10 +69,14 @@ module RuboCop
       if @options[:auto_gen_config]
         run_command(:auto_gen_config)
       else
-        run_command(:execute_runner)
+        run_command(:execute_runner).tap { suggest_extensions }
       end
     end
 
+    def suggest_extensions
+      run_command(:suggest_extensions)
+    end
+
     def validate_options_vs_config
       if @options[:parallel] &&
          !@config_store.for_pwd.for_all_cops['UseCache']

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # Run all the selected cops and report the result.
+      # @api private
+      class SuggestExtensions < Base
+        # Combination of short and long formatter names.
+        INCLUDED_FORMATTERS = %w[p progress fu fuubar pa pacman].freeze
+
+        self.command_name = :suggest_extensions
+
+        class << self
+          # Gems that the current bundle depends on
+          # Suggestions are only made for gems that are 1st party dependencies
+          def dependent_gems
+            bundler do |gems|
+              gems.dependencies.map(&:name)
+            end
+          end
+
+          # All installed gems in the current bundle
+          # If a suggestion is installed but not depended on, it still should not
+          # be suggested.
+          def installed_gems
+            bundler do
+              # Load specs from the lockfile without trying to resolve them
+              return [] unless Bundler.default_lockfile
+
+              lockfile = Bundler.read_file(Bundler.default_lockfile)
+              Bundler::LockfileParser.new(lockfile).specs.map(&:name)
+            end
+          end
+
+          private
+
+          def bundler
+            return [] unless defined?(Bundler)
+
+            yield Bundler.load
+          rescue Bundler::BundlerError
+            []
+          end
+        end
+
+        def run
+          return if skip? || extensions.none?
+
+          puts
+          puts 'Tip: Based on detected gems, the following '\
+            'RuboCop extension libraries might be helpful:'
+
+          extensions.sort.each do |extension|
+            puts "  * #{extension} (http://github.com/rubocop-hq/#{extension})"
+          end
+
+          puts
+          puts 'You can opt out of this message by adding the following to your config '\
+            '(see https://docs.rubocop.org/rubocop/extensions.html#extension-suggestions '\
+            'for more options):'
+          puts '  AllCops:'
+          puts '    SuggestExtensions: false'
+
+          puts if @options[:display_time]
+        end
+
+        private
+
+        def skip?
+          # Disable outputting the notification:
+          # 1. On CI
+          # 2. When given RuboCop options that it doesn't make sense for
+          # 3. For all formatters except specified in `INCLUDED_FORMATTERS'`
+          ENV['CI'] ||
+            @options[:only] || @options[:debug] || @options[:list_target_files] || @options[:out] ||
+            !INCLUDED_FORMATTERS.include?(current_formatter)
+        end
+
+        def current_formatter
+          @options[:format] || @config_store.for_pwd.for_all_cops['DefaultFormatter'] || 'p'
+        end
+
+        def extensions
+          return [] unless dependent_gems.any?
+
+          @extensions ||= begin
+            extensions = @config_store.for_pwd.for_all_cops['SuggestExtensions'] || {}
+            extensions.select { |_, v| (Array(v) & dependent_gems).any? }.keys - installed_gems
+          end
+        end
+
+        def puts(*args)
+          output = (@options[:stderr] ? $stderr : $stdout)
+          output.puts(*args)
+        end
+
+        def dependent_gems
+          @dependent_gems ||= self.class.dependent_gems
+        end
+
+        def installed_gems
+          @installed_gems ||= self.class.installed_gems
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/config_loader.rb

@@ -109,7 +109,7 @@ module RuboCop
         end
 
         merge_with_default(config, config_file).tap do |merged_config|
-          warn_on_pending_cops(merged_config.pending_cops) unless possible_new_cops?(config)
+          warn_on_pending_cops(merged_config.pending_cops) unless possible_new_cops?(merged_config)
         end
       end
 

data/lib/rubocop/config_loader_resolver.rb

@@ -92,7 +92,7 @@ module RuboCop
       keys_appearing_in_both.each do |key|
         if opts[:unset_nil] && derived_hash[key].nil?
           result.delete(key)
-        elsif base_hash[key].is_a?(Hash)
+        elsif merge_hashes?(base_hash, derived_hash, key)
           result[key] = merge(base_hash[key], derived_hash[key], **opts)
         elsif should_union?(base_hash, key, opts[:inherit_mode])
           result[key] = base_hash[key] | derived_hash[key]
@@ -164,6 +164,10 @@ module RuboCop
         inherit_mode['merge'].include?(key)
     end
 
+    def merge_hashes?(base_hash, derived_hash, key)
+      base_hash[key].is_a?(Hash) && derived_hash[key].is_a?(Hash)
+    end
+
     def base_configs(path, inherit_from, file)
       configs = Array(inherit_from).compact.map do |f|
         ConfigLoader.load_file(inherited_file(path, f, file))

data/lib/rubocop/config_obsoletion.rb

@@ -104,6 +104,7 @@ module RuboCop
     OBSOLETE_COPS = Hash[*(RENAMED_COPS + MOVED_COPS + REMOVED_COPS +
                            REMOVED_COPS_WITH_REASON + SPLIT_COPS).flatten]
 
+    # Parameters can be deprecated but not disabled by setting `severity: :warning`
     OBSOLETE_PARAMETERS = [
       {
         cops: %w[Layout/SpaceAroundOperators Style/SpaceAroundOperators],
@@ -201,6 +202,12 @@ module RuboCop
         parameters: 'NameWhitelist',
         alternative: '`NameWhitelist` has been renamed to ' \
                      '`AllowedMethods`.'
+      },
+      {
+        cops: %w[Metrics/BlockLength Metrics/MethodLength],
+        parameters: 'ExcludedMethods',
+        alternative: '`ExcludedMethods` has been renamed to `IgnoredMethods`.',
+        severity: :warning
       }
     ].freeze
 
@@ -214,8 +221,11 @@ module RuboCop
       }
     ].freeze
 
+    attr_reader :warnings
+
     def initialize(config)
       @config = config
+      @warnings = []
     end
 
     def reject_obsolete_cops_and_parameters
@@ -256,9 +266,17 @@ module RuboCop
     end
 
     def obsolete_parameters
-      OBSOLETE_PARAMETERS.map do |params|
-        obsolete_parameter_message(params[:cops], params[:parameters],
-                                   params[:alternative])
+      OBSOLETE_PARAMETERS.collect do |params|
+        messages = obsolete_parameter_message(params[:cops], params[:parameters],
+                                              params[:alternative])
+
+        # Warnings are collected separately and not added to the error message
+        if messages && params.fetch(:severity, :error) == :warning
+          @warnings.concat(messages)
+          next
+        end
+
+        messages
       end
     end
 

data/lib/rubocop/config_validator.rb

@@ -42,7 +42,7 @@ module RuboCop
         ConfigLoader.default_configuration.key?(key)
       end
 
-      @config_obsoletion.reject_obsolete_cops_and_parameters
+      check_obsoletions
 
       alert_about_unrecognized_cops(invalid_cop_names)
       check_target_ruby
@@ -68,6 +68,13 @@ module RuboCop
 
     attr_reader :target_ruby
 
+    def check_obsoletions
+      @config_obsoletion.reject_obsolete_cops_and_parameters
+      return unless @config_obsoletion.warnings.any?
+
+      warn Rainbow("Warning: #{@config_obsoletion.warnings.join("\n")}").yellow
+    end
+
     def check_target_ruby
       return if target_ruby.supported?
 

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -39,16 +39,31 @@ module RuboCop
       private
 
       def disable_offense(range)
-        eol_comment = " # rubocop:todo #{cop_name}"
-        needed_line_length = (range.source_line + eol_comment).length
-        if needed_line_length <= max_line_length
-          disable_offense_at_end_of_line(range_of_first_line(range),
-                                         eol_comment)
+        heredoc_range = surrounding_heredoc(range)
+        if heredoc_range
+          disable_offense_before_and_after(range_by_lines(heredoc_range))
         else
-          disable_offense_before_and_after(range_by_lines(range))
+          eol_comment = " # rubocop:todo #{cop_name}"
+          needed_line_length = (range.source_line + eol_comment).length
+          if needed_line_length <= max_line_length
+            disable_offense_at_end_of_line(range_of_first_line(range), eol_comment)
+          else
+            disable_offense_before_and_after(range_by_lines(range))
+          end
         end
       end
 
+      def surrounding_heredoc(offense_range)
+        # The empty offense range is an edge case that can be reached from the Lint/Syntax cop.
+        return nil if offense_range.empty?
+
+        heredoc_nodes = processed_source.ast.each_descendant.select do |node|
+          node.respond_to?(:heredoc?) && node.heredoc?
+        end
+        heredoc_nodes.map { |node| node.loc.expression.join(node.loc.heredoc_end) }
+                     .find { |range| range.contains?(offense_range) }
+      end
+
       def range_of_first_line(range)
         begin_of_first_line = range.begin_pos - range.column
         end_of_first_line = begin_of_first_line + range.source_line.length

data/lib/rubocop/cop/generator.rb

@@ -139,7 +139,7 @@ module RuboCop
                                     badge: badge,
                                     version_added: version_added)
 
-        injector.inject do
+        injector.inject do # rubocop:disable Lint/UnexpectedBlockArity
           output.puts(format(CONFIGURATION_ADDED_MESSAGE,
                              configuration_file_path: config_file_path))
         end

data/lib/rubocop/cop/layout/empty_line_between_defs.rb

@@ -3,15 +3,15 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether method definitions are
-      # separated by one empty line.
+      # This cop checks whether class/module/method definitions are
+      # separated by one or more empty lines.
       #
       # `NumberOfEmptyLines` can be an integer (default is 1) or
       # an array (e.g. [1, 2]) to specify a minimum and maximum
       # number of empty lines permitted.
       #
       # `AllowAdjacentOneLineDefs` configures whether adjacent
-      # one-line method definitions are considered an offense.
+      # one-line definitions are considered an offense.
       #
       # @example EmptyLineBetweenMethodDefs: true (default)
       #   # checks for empty lines between method definitions.

data/lib/rubocop/cop/layout/empty_lines_around_arguments.rb

@@ -45,7 +45,8 @@ module RuboCop
         MSG = 'Empty line detected around arguments.'
 
         def on_send(node)
-          return if node.single_line? || node.arguments.empty?
+          return if node.single_line? || node.arguments.empty? ||
+                    receiver_and_method_call_on_different_lines?(node)
 
           extra_lines(node) do |range|
             add_offense(range) do |corrector|
@@ -57,6 +58,10 @@ module RuboCop
 
         private
 
+        def receiver_and_method_call_on_different_lines?(node)
+          node.receiver && node.receiver.loc.last_line != node.loc.selector&.line
+        end
+
         def empty_lines(node)
           lines = processed_lines(node)
           lines.select! { |code, _| code.empty? }

data/lib/rubocop/cop/layout/end_of_line.rb

@@ -37,14 +37,14 @@ module RuboCop
       #   # good
       #   puts 'Hello' # Return character is CR+LF on all platfoms.
       #
-      class EndOfLine < Cop
+      class EndOfLine < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
 
         MSG_DETECTED = 'Carriage return character detected.'
         MSG_MISSING = 'Carriage return character missing.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           last_line = last_line(processed_source)
 
           processed_source.raw_source.each_line.with_index do |line, index|
@@ -54,9 +54,9 @@ module RuboCop
             next unless msg
             next if unimportant_missing_cr?(index, last_line, line)
 
-            range =
-              source_range(processed_source.buffer, index + 1, 0, line.length)
-            add_offense(nil, location: range, message: msg)
+            range = source_range(processed_source.buffer, index + 1, 0, line.length)
+
+            add_offense(range, message: msg)
             # Usually there will be carriage return characters on all or none
             # of the lines in a file, so we report only one offense.
             break

data/lib/rubocop/cop/layout/first_argument_indentation.rb

@@ -207,8 +207,13 @@ module RuboCop
         PATTERN
 
         def base_range(send_node, arg_node)
-          range_between(send_node.source_range.begin_pos,
-                        arg_node.source_range.begin_pos)
+          parent = send_node.parent
+          start_node = if parent && (parent.splat_type? || parent.kwsplat_type?)
+                         send_node.parent
+                       else
+                         send_node
+                       end
+          range_between(start_node.source_range.begin_pos, arg_node.source_range.begin_pos)
         end
 
         # Returns the column of the given range. For single line ranges, this

data/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb

@@ -69,6 +69,7 @@ module RuboCop
           return unless outermost_send
           return unless outermost_send.loc.end
           return unless heredoc_arg.first_line != outermost_send.loc.end.line
+          return if subsequent_closing_parentheses_in_same_line?(outermost_send)
 
           add_offense(outermost_send.loc.end) do |corrector|
             autocorrect(corrector, outermost_send)
@@ -160,6 +161,17 @@ module RuboCop
 
         # Closing parenthesis helpers.
 
+        def subsequent_closing_parentheses_in_same_line?(outermost_send)
+          last_arg_of_outer_send = outermost_send.last_argument
+          return false unless last_arg_of_outer_send&.loc.respond_to?(:end) &&
+                              (end_of_last_arg_of_outer_send = last_arg_of_outer_send.loc.end)
+
+          end_of_outer_send = outermost_send.loc.end
+
+          end_of_outer_send.line == end_of_last_arg_of_outer_send.line &&
+            end_of_outer_send.column == end_of_last_arg_of_outer_send.column + 1
+        end
+
         def fix_closing_parenthesis(node, corrector)
           remove_incorrect_closing_paren(node, corrector)
           add_correct_closing_paren(node, corrector)

data/lib/rubocop/cop/layout/multiline_method_call_indentation.rb

@@ -77,7 +77,7 @@ module RuboCop
 
           @base = alignment_base(node, rhs, given_style)
           correct_column = if @base
-                             @base.column + extra_indentation(given_style)
+                             @base.column + extra_indentation(given_style, node.parent)
                            else
                              indentation(lhs) + correct_indentation(node)
                            end
@@ -85,9 +85,13 @@ module RuboCop
           rhs if @column_delta.nonzero?
         end
 
-        def extra_indentation(given_style)
+        def extra_indentation(given_style, parent)
           if given_style == :indented_relative_to_receiver
-            configured_indentation_width
+            if parent && (parent.splat_type? || parent.kwsplat_type?)
+              configured_indentation_width - parent.loc.operator.length
+            else
+              configured_indentation_width
+            end
           else
             0
           end

data/lib/rubocop/cop/lint/interpolation_check.rb

@@ -23,10 +23,11 @@ module RuboCop
               'Use double quoted strings if you need interpolation.'
 
         def on_str(node)
-          parent = node.parent
-          return if parent && (parent.dstr_type? || parent.regexp_type?)
+          return unless node
+          return if string_or_regex?(node.parent)
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
+          return unless node.loc.begin && node.loc.end
 
           add_offense(node) do |corrector|
             autocorrect(corrector, node)
@@ -35,6 +36,10 @@ module RuboCop
 
         private
 
+        def string_or_regex?(node)
+          node&.dstr_type? || node&.regexp_type?
+        end
+
         def autocorrect(corrector, node)
           starting_token, ending_token = if node.source.include?('"')
                                            ['%{', '}']

data/lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb

@@ -40,7 +40,7 @@ module RuboCop
       #                     do_something
       #                   end
       #
-      class NoReturnInBeginEndBlocks < Cop
+      class NoReturnInBeginEndBlocks < Base
         MSG = 'Do not `return` in `begin..end` blocks in assignment contexts.'
 
         def on_lvasgn(node)