rubocop 0.51.0 → 0.52.0

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

@@ -56,19 +56,16 @@ module RuboCop
         PERCENT_CAPITAL_W = '%W'.freeze
         PERCENT_I = '%i'.freeze
         PERCENT_CAPITAL_I = '%I'.freeze
-        ARRAY_NEW_PATTERN = '$(send (const nil? :Array) :new ...)'.freeze
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
-        def_node_matcher :literal_expansion?, <<-PATTERN
-          (splat {$({str dstr int float array} ...) (block #{ARRAY_NEW_PATTERN} ...) #{ARRAY_NEW_PATTERN}} ...)
+        def_node_matcher :array_new?, '$(send (const nil? :Array) :new ...)'
+
+        def_node_matcher :literal_expansion, <<-PATTERN
+          (splat {$({str dstr int float array} ...) (block $#array_new? ...) $#array_new?} ...)
         PATTERN
 
         def on_splat(node)
-          literal_expansion?(node) do |object|
-            if object.send_type?
-              return unless ASSIGNMENT_TYPES.include?(node.parent.parent.type)
-            end
-
+          unneeded_splat_expansion(node) do
             if array_splat?(node) &&
                (method_argument?(node) || part_of_an_array?(node))
               add_offense(node, message: ARRAY_PARAM_MSG)
@@ -78,20 +75,49 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          range, content = replacement_range_and_content(node)
+
+          lambda do |corrector|
+            corrector.replace(range, content)
+          end
+        end
+
         private
 
-        def autocorrect(node)
+        def unneeded_splat_expansion(node)
+          literal_expansion(node) do |expanded_item|
+            if expanded_item.send_type?
+              return if array_new_inside_array_literal?(expanded_item)
+
+              grandparent = node.parent.parent
+              return if grandparent &&
+                        !ASSIGNMENT_TYPES.include?(grandparent.type)
+            end
+
+            yield
+          end
+        end
+
+        def array_new_inside_array_literal?(array_new_node)
+          return false unless array_new?(array_new_node)
+
+          grandparent = array_new_node.parent.parent
+          grandparent.array_type? && grandparent.children.size > 1
+        end
+
+        def replacement_range_and_content(node)
           variable, = *node
           loc = node.loc
 
-          lambda do |corrector|
-            if !variable.array_type?
-              corrector.replace(loc.expression, "[#{variable.source}]")
-            elsif unneeded_brackets?(node)
-              corrector.replace(loc.expression, remove_brackets(variable))
-            else
-              corrector.remove(loc.operator)
-            end
+          if array_new?(variable)
+            [node.parent.loc.expression, variable.source]
+          elsif !variable.array_type?
+            [loc.expression, "[#{variable.source}]"]
+          elsif unneeded_brackets?(node)
+            [loc.expression, remove_brackets(variable)]
+          else
+            [loc.operator, '']
           end
         end
 

data/lib/rubocop/cop/message_annotator.rb

@@ -103,8 +103,10 @@ module RuboCop
       end
 
       def display_cop_names?
-        debug? || options[:display_cop_names] ||
-          config.for_all_cops['DisplayCopNames']
+        return true if debug?
+        return false if options[:display_cop_names] == false
+        return true if options[:display_cop_names]
+        config.for_all_cops['DisplayCopNames']
       end
 
       def details

data/lib/rubocop/cop/metrics/abc_size.rb

@@ -9,8 +9,8 @@ module RuboCop
       class AbcSize < Cop
         include MethodComplexity
 
-        MSG = 'Assignment Branch Condition size for %s is too high. ' \
-              '[%.4g/%.4g]'.freeze
+        MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \
+              '[%<complexity>.4g/%<max>.4g]'.freeze
         BRANCH_NODES = %i[send csend].freeze
         CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
 

data/lib/rubocop/cop/metrics/class_length.rb

@@ -16,7 +16,9 @@ module RuboCop
         private
 
         def message(length, max_length)
-          format('Class has too many lines. [%d/%d]', length, max_length)
+          format('Class has too many lines. [%<length>d/%<max>d]',
+                 length: length,
+                 max: max_length)
         end
       end
     end

data/lib/rubocop/cop/metrics/cyclomatic_complexity.rb

@@ -16,7 +16,8 @@ module RuboCop
       class CyclomaticComplexity < Cop
         include MethodComplexity
 
-        MSG = 'Cyclomatic complexity for %s is too high. [%d/%d]'.freeze
+        MSG = 'Cyclomatic complexity for %<method>s is too high. ' \
+              '[%<complexity>d/%<max>d]'.freeze
         COUNTED_NODES = %i[if while until for
                            rescue when and or].freeze
 

data/lib/rubocop/cop/metrics/line_length.rb

@@ -11,7 +11,7 @@ module RuboCop
         include ConfigurableMax
         include IgnoredPattern
 
-        MSG = 'Line is too long. [%d/%d]'.freeze
+        MSG = 'Line is too long. [%<length>d/%<max>d]'.freeze
 
         def investigate(processed_source)
           heredocs = extract_heredocs(processed_source.ast) if allow_heredoc?
@@ -43,7 +43,7 @@ module RuboCop
         end
 
         def register_offense(loc, line)
-          message = format(MSG, line.length, max)
+          message = format(MSG, length: line.length, max: max)
 
           add_offense(nil, location: loc, message: message) do
             self.max = line.length

data/lib/rubocop/cop/metrics/module_length.rb

@@ -16,7 +16,9 @@ module RuboCop
         private
 
         def message(length, max_length)
-          format('Module has too many lines. [%d/%d]', length, max_length)
+          format('Module has too many lines. [%<length>d/%<max>d]',
+                 length: length,
+                 max: max_length)
         end
       end
     end

data/lib/rubocop/cop/metrics/parameter_lists.rb

@@ -9,12 +9,15 @@ module RuboCop
       class ParameterLists < Cop
         include ConfigurableMax
 
-        MSG = 'Avoid parameter lists longer than %d parameters. [%d/%d]'.freeze
+        MSG = 'Avoid parameter lists longer than %<max>d parameters. ' \
+              '[%<count>d/%<max>d]'.freeze
 
         def on_args(node)
           count = args_count(node)
           return unless count > max_params
 
+          return if argument_to_lambda_or_proc?(node)
+
           add_offense(node) do
             self.max = count
           end
@@ -22,8 +25,12 @@ module RuboCop
 
         private
 
+        def_node_matcher :argument_to_lambda_or_proc?, <<-PATTERN
+          ^lambda_or_proc?
+        PATTERN
+
         def message(node)
-          format(MSG, max_params, args_count(node), max_params)
+          format(MSG, max: max_params, count: args_count(node))
         end
 
         def args_count(node)

data/lib/rubocop/cop/metrics/perceived_complexity.rb

@@ -29,7 +29,8 @@ module RuboCop
       class PerceivedComplexity < Cop
         include MethodComplexity
 
-        MSG = 'Perceived complexity for %s is too high. [%d/%d]'.freeze
+        MSG = 'Perceived complexity for %<method>s is too high. ' \
+              '[%<complexity>d/%<max>d]'.freeze
         COUNTED_NODES = %i[if case while until
                            for rescue and or].freeze
 

data/lib/rubocop/cop/mixin/documentation_comment.rb

@@ -24,7 +24,7 @@ module RuboCop
       end
 
       def preceding_comment?(n1, n2)
-        n1 && n2 && preceed?(n2, n1) &&
+        n1 && n2 && precede?(n2, n1) &&
           comment_line?(n2.loc.expression.source)
       end
 

data/lib/rubocop/cop/mixin/empty_lines_around_body.rb

@@ -9,9 +9,11 @@ module RuboCop
         extend NodePattern::Macros
         include ConfigurableEnforcedStyle
 
-        MSG_EXTRA = 'Extra empty line detected at %s body %s.'.freeze
-        MSG_MISSING = 'Empty line missing at %s body %s.'.freeze
-        MSG_DEFERRED = 'Empty line missing before first %s definition'.freeze
+        MSG_EXTRA = 'Extra empty line detected at %<kind>s body ' \
+                    '%<location>s.'.freeze
+        MSG_MISSING = 'Empty line missing at %<kind>s body %<location>s.'.freeze
+        MSG_DEFERRED = 'Empty line missing before first %<type>s ' \
+                       'definition'.freeze
 
         def_node_matcher :constant_definition?, '{class module}'
         def_node_matcher :empty_line_required?, '{def defs class module}'
@@ -154,11 +156,11 @@ module RuboCop
         end
 
         def message(type, desc)
-          format(type, self.class::KIND, desc)
+          format(type, kind: self.class::KIND, location: desc)
         end
 
         def deferred_message(node)
-          format(MSG_DEFERRED, node.type)
+          format(MSG_DEFERRED, type: node.type)
         end
       end
     end

data/lib/rubocop/cop/mixin/empty_parameter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common code for empty parameter cops.
+    module EmptyParameter
+      extend NodePattern::Macros
+
+      private
+
+      def_node_matcher :empty_arguments?, <<-PATTERN
+        (block _ $(args) _)
+      PATTERN
+
+      def check(node)
+        empty_arguments?(node) do |args|
+          return if args.empty_and_without_delimiters?
+          add_offense(args)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/end_keyword_alignment.rb

@@ -6,7 +6,8 @@ module RuboCop
     module EndKeywordAlignment
       include ConfigurableEnforcedStyle
 
-      MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'.freeze
+      MSG = '`end` at %<end_line>d, %<end_col>d is not aligned with ' \
+            '`%<source>s` at %<align_line>d, %<align_col>d.'.freeze
 
       private
 
@@ -39,8 +40,11 @@ module RuboCop
 
       def add_offense_for_misalignment(node, align_with)
         end_loc = node.loc.end
-        msg = format(MSG, end_loc.line, end_loc.column, align_with.source,
-                     align_with.line, align_with.column)
+        msg = format(MSG, end_line: end_loc.line,
+                          end_col: end_loc.column,
+                          source: align_with.source,
+                          align_line: align_with.line,
+                          align_col: align_with.column)
         add_offense(node, location: end_loc, message: msg)
       end
 

data/lib/rubocop/cop/mixin/heredoc.rb

@@ -1,28 +1,28 @@
 # frozen_string_literal: true
 
-# Common functionality for working with heredoc strings.
-module Heredoc
-  OPENING_DELIMITER = /<<[~-]?['"`]?([^'"`]+)['"`]?/
+module RuboCop
+  module Cop
+    # Common functionality for working with heredoc strings.
+    module Heredoc
+      OPENING_DELIMITER = /<<[~-]?['"`]?([^'"`]+)['"`]?/
 
-  def on_str(node)
-    return unless heredoc?(node)
+      def on_str(node)
+        return unless node.heredoc?
 
-    on_heredoc(node)
-  end
-  alias on_dstr on_str
-  alias on_xstr on_str
-
-  def on_heredoc(_node)
-    raise NotImplementedError
-  end
+        on_heredoc(node)
+      end
+      alias on_dstr on_str
+      alias on_xstr on_str
 
-  private
+      def on_heredoc(_node)
+        raise NotImplementedError
+      end
 
-  def heredoc?(node)
-    node.loc.is_a?(Parser::Source::Map::Heredoc)
-  end
+      private
 
-  def delimiter_string(node)
-    node.source.match(OPENING_DELIMITER).captures.first
+      def delimiter_string(node)
+        node.source.match(OPENING_DELIMITER).captures.first
+      end
+    end
   end
 end

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -5,25 +5,49 @@ module RuboCop
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
       include ConfigurableMax
+      extend NodePattern::Macros
 
       def on_def(node)
+        check_complexity(node, node.method_name)
+      end
+      alias on_defs on_def
+
+      def on_block(node)
+        define_method?(node) do |name|
+          check_complexity(node, name)
+        end
+      end
+
+      private
+
+      def_node_matcher :define_method?, <<-PATTERN
+        (block
+         (send nil? :define_method ({sym str} $_))
+         args
+         _)
+      PATTERN
+
+      def check_complexity(node, method_name)
+        # Accepts empty methods always.
+        return unless node.body
+
         max = cop_config['Max']
-        complexity = complexity(node)
+        complexity = complexity(node.body)
 
         return unless complexity > max
 
-        msg = format(self.class::MSG, node.method_name, complexity, max)
+        msg = format(self.class::MSG,
+                     method: method_name,
+                     complexity: complexity,
+                     max: max)
 
-        add_offense(node, location: :keyword, message: msg) do
+        add_offense(node, message: msg) do
           self.max = complexity.ceil
         end
       end
-      alias on_defs on_def
-
-      private
 
-      def complexity(node)
-        node.each_node(*self.class::COUNTED_NODES).reduce(1) do |score, n|
+      def complexity(body)
+        body.each_node(*self.class::COUNTED_NODES).reduce(1) do |score, n|
           score + complexity_score_for(n)
         end
       end

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -4,14 +4,15 @@ module RuboCop
   module Cop
     # Common functionality for checking multiline method calls and binary
     # operations.
-    module MultilineExpressionIndentation
+    module MultilineExpressionIndentation # rubocop:disable Metrics/ModuleLength
       KEYWORD_ANCESTOR_TYPES  = [:for, :return, *Util::MODIFIER_NODES].freeze
       UNALIGNED_RHS_TYPES     = %i[if while until for return
                                    array kwbegin].freeze
       ASSIGNMENT_RHS_TYPES    = [:send, *Util::ASGN_NODES].freeze
       DEFAULT_MESSAGE_TAIL    = 'an expression'.freeze
       ASSIGNMENT_MESSAGE_TAIL = 'an expression in an assignment'.freeze
-      KEYWORD_MESSAGE_TAIL    = 'a %s in %s `%s` statement'.freeze
+      KEYWORD_MESSAGE_TAIL    = 'a %<kind>s in %<article>s `%<keyword>s` ' \
+                                'statement'.freeze
 
       def on_send(node)
         return if !node.receiver || node.method?(:[])
@@ -103,12 +104,15 @@ module RuboCop
         kind    = keyword == 'for' ? 'collection' : 'condition'
         article = keyword =~ /^[iu]/ ? 'an' : 'a'
 
-        format(KEYWORD_MESSAGE_TAIL, kind, article, keyword)
+        format(KEYWORD_MESSAGE_TAIL, kind: kind,
+                                     article: article,
+                                     keyword: keyword)
       end
 
       def kw_node_with_special_indentation(node)
         keyword_node =
           node.each_ancestor(*KEYWORD_ANCESTOR_TYPES).find do |ancestor|
+            next if ancestor.if_type? && ancestor.ternary?
             within_node?(node, indented_keyword_expression(ancestor))
           end
 

data/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb

@@ -30,8 +30,8 @@ module RuboCop
           return if new_line_needed_before_closing_brace?(node)
 
           lambda do |corrector|
-            corrector.remove(range_with_surrounding_space(node.loc.end,
-                                                          :left))
+            corrector.remove(range_with_surrounding_space(range: node.loc.end,
+                                                          side: :left))
 
             corrector.insert_after(last_element_range_with_trailing_comma(node),
                                    node.loc.end.source)
@@ -113,8 +113,10 @@ module RuboCop
       end
 
       def last_element_trailing_comma_range(node)
-        range = range_with_surrounding_space(children(node).last.source_range,
-                                             :right).end.resize(1)
+        range = range_with_surrounding_space(
+          range: children(node).last.source_range,
+          side: :right
+        ).end.resize(1)
         range.source == ',' ? range : nil
       end