rubocop 1.3.0 → 1.5.0

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_regeneration.rb

@@ -16,7 +16,7 @@ module RuboCop
       match = generation_command.match(COMMAND_REGEX)
       return DEFAULT_OPTIONS unless match
 
-      options = match[1].split(' ')
+      options = match[1].split
       Options.new.parse(options).first
     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/correctors/percent_literal_corrector.rb

@@ -48,7 +48,7 @@ module RuboCop
       def autocorrect_multiline_words(node, escape, delimiters)
         contents = process_multiline_words(node, escape, delimiters)
         contents << end_content(node.source)
-        contents.join('')
+        contents.join
       end
 
       def autocorrect_words(node, escape, delimiters)

data/lib/rubocop/cop/generator.rb

@@ -17,7 +17,6 @@ module RuboCop
       SOURCE_TEMPLATE = <<-RUBY.gsub(/^ {8}/, '')
         # frozen_string_literal: true
 
-        # TODO: when finished, run `rake generate_cops_documentation` to update the docs
         module RuboCop
           module Cop
             module %<department>s
@@ -134,13 +133,13 @@ module RuboCop
       end
 
       def inject_config(config_file_path: 'config/default.yml',
-                        version_added: bump_minor_version)
+                        version_added: '<<next>>')
         injector =
           ConfigurationInjector.new(configuration_file_path: config_file_path,
                                     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
@@ -213,12 +212,6 @@ module RuboCop
           .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')
           .downcase
       end
-
-      def bump_minor_version
-        versions = RuboCop::Version::STRING.split('.')
-
-        "#{versions[0]}.#{versions[1].succ}"
-      end
     end
   end
 end

data/lib/rubocop/cop/generator/configuration_injector.rb

@@ -14,7 +14,7 @@ module RuboCop
             VersionAdded: '%<version_added>s'
         YAML
 
-        def initialize(configuration_file_path:, badge:, version_added:)
+        def initialize(configuration_file_path:, badge:, version_added: '<<next>>')
           @configuration_file_path = configuration_file_path
           @badge = badge
           @version_added = version_added

data/lib/rubocop/cop/internal_affairs/useless_message_assertion.rb

@@ -38,7 +38,7 @@ module RuboCop
 
         def assertions_using_described_class_msg
           described_class_msg(processed_source.ast).reject do |node|
-            node.ancestors.any?(&method(:rspec_expectation_on_msg?))
+            node.ancestors.any? { |ancestor| rspec_expectation_on_msg?(ancestor) }
           end
         end
 

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

@@ -147,6 +147,10 @@ module RuboCop
         MSG = '`%<category>s` is supposed to appear before ' \
               '`%<previous>s`.'
 
+        def_node_matcher :dynamic_constant?, <<~PATTERN
+          (casgn nil? _ (send ...))
+        PATTERN
+
         # Validates code style on class declaration.
         # Add offense when find a node out of expected order.
         def on_class(class_node)
@@ -168,11 +172,10 @@ module RuboCop
 
         # Autocorrect by swapping between two nodes autocorrecting them
         def autocorrect(corrector, node)
-          node_classification = classify(node)
           previous = node.left_siblings.find do |sibling|
-            classification = classify(sibling)
-            !ignore?(classification) && node_classification != classification
+            !ignore_for_autocorrect?(node, sibling)
           end
+          return unless previous
 
           current_range = source_range_with_comment(node)
           previous_range = source_range_with_comment(previous)
@@ -241,6 +244,15 @@ module RuboCop
             expected_order.index(classification).nil?
         end
 
+        def ignore_for_autocorrect?(node, sibling)
+          classification = classify(node)
+          sibling_class = classify(sibling)
+
+          ignore?(sibling_class) ||
+            classification == sibling_class ||
+            dynamic_constant?(node)
+        end
+
         def humanize_node(node)
           if node.def_type?
             return :initializer if node.method?(:initialize)

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

@@ -3,17 +3,18 @@
 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
+      # @example EmptyLineBetweenMethodDefs: true (default)
+      #   # checks for empty lines between method definitions.
       #
       #   # bad
       #   def a
@@ -29,11 +30,57 @@ module RuboCop
       #
       #   def b
       #   end
+      #
+      # @example EmptyLineBetweenClassDefs: true (default)
+      #   # checks for empty lines between class definitions.
+      #
+      #   # bad
+      #   class A
+      #   end
+      #   class B
+      #   end
+      #   def b
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   class A
+      #   end
+      #
+      #   class B
+      #   end
+      #
+      #   def b
+      #   end
+      #
+      # @example EmptyLineBetweenModuleDefs: true (default)
+      #   # checks for empty lines between module definitions.
+      #
+      #   # bad
+      #   module A
+      #   end
+      #   module B
+      #   end
+      #   def b
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   module A
+      #   end
+      #
+      #   module B
+      #   end
+      #
+      #   def b
+      #   end
       class EmptyLineBetweenDefs < Base
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use empty lines between method definitions.'
+        MSG = 'Use empty lines between %<type>s definitions.'
 
         def self.autocorrect_incompatible_with
           [Layout::EmptyLines]
@@ -47,7 +94,7 @@ module RuboCop
         def on_begin(node)
           node.children.each_cons(2) do |prev, n|
             nodes = [prev, n]
-            check_defs(nodes) if nodes.all?(&method(:def_node?))
+            check_defs(nodes) if nodes.all? { |def_candidate| candidate?(def_candidate) }
           end
         end
 
@@ -57,8 +104,9 @@ module RuboCop
           return if nodes.all?(&:single_line?) &&
                     cop_config['AllowAdjacentOneLineDefs']
 
-          location = nodes.last.loc.keyword.join(nodes.last.loc.name)
-          add_offense(location) do |corrector|
+          correction_node = nodes.last
+          location = correction_node.loc.keyword.join(correction_node.loc.name)
+          add_offense(location, message: message(correction_node)) do |corrector|
             autocorrect(corrector, *nodes)
           end
         end
@@ -83,10 +131,32 @@ module RuboCop
 
         private
 
-        def def_node?(node)
+        def candidate?(node)
           return unless node
 
-          node.def_type? || node.defs_type?
+          method_candidate?(node) || class_candidate?(node) || module_candidate?(node)
+        end
+
+        def method_candidate?(node)
+          cop_config['EmptyLineBetweenMethodDefs'] && (node.def_type? || node.defs_type?)
+        end
+
+        def class_candidate?(node)
+          cop_config['EmptyLineBetweenClassDefs'] && node.class_type?
+        end
+
+        def module_candidate?(node)
+          cop_config['EmptyLineBetweenModuleDefs'] && node.module_type?
+        end
+
+        def message(node)
+          type = case node.type
+                 when :def, :defs
+                   :method
+                 else
+                   node.type
+                 end
+          format(MSG, type: type)
         end
 
         def multiple_blank_lines_groups?(first_def_node, second_def_node)

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