rubocop 0.49.1 → 0.52.0

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

@@ -33,7 +33,7 @@ module RuboCop
             if current_level > max
               self.max = current_level
               unless part_of_ignored_node?(node)
-                add_offense(node, :expression, message(max)) do
+                add_offense(node, message: message(max)) do
                   ignore_node(node)
                 end
               end

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,8 +43,11 @@ module RuboCop
         end
 
         def register_offense(loc, line)
-          message = format(MSG, line.length, max)
-          add_offense(nil, loc, message) { self.max = line.length }
+          message = format(MSG, length: line.length, max: max)
+
+          add_offense(nil, location: loc, message: message) do
+            self.max = line.length
+          end
         end
 
         def excess_range(uri_range, line, index)
@@ -118,12 +121,12 @@ module RuboCop
         def valid_uri?(uri_ish_string)
           URI.parse(uri_ish_string)
           true
-        rescue
+        rescue URI::InvalidURIError, NoMethodError
           false
         end
 
         def uri_regexp
-          @regexp ||= URI::Parser.new.make_regexp(cop_config['URISchemes'])
+          @regexp ||= URI::DEFAULT_PARSER.make_regexp(cop_config['URISchemes'])
         end
 
         def check_directive_line(line, index)

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

@@ -7,17 +7,22 @@ module RuboCop
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       class MethodLength < Cop
-        include OnMethodDef
         include TooManyLines
 
         LABEL = 'Method'.freeze
 
-        private
+        def on_def(node)
+          check_code_length(node)
+        end
+        alias on_defs on_def
 
-        def on_method_def(node, _method_name, _args, _body)
+        def on_block(node)
+          return unless node.send_node.method_name == :define_method
           check_code_length(node)
         end
 
+        private
+
         def cop_label
           LABEL
         end

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

@@ -5,25 +5,34 @@ module RuboCop
     module Metrics
       # This cop checks for methods with too many parameters.
       # The maximum number of parameters is configurable.
-      # On Ruby 2.0+ keyword arguments can optionally
-      # be excluded from the total count.
+      # Keyword arguments can optionally be excluded from the total count.
       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
 
-          message = format(MSG, max_params, count, max_params)
-          add_offense(node, :expression, message) do
+          return if argument_to_lambda_or_proc?(node)
+
+          add_offense(node) do
             self.max = count
           end
         end
 
         private
 
+        def_node_matcher :argument_to_lambda_or_proc?, <<-PATTERN
+          ^lambda_or_proc?
+        PATTERN
+
+        def message(node)
+          format(MSG, max: max_params, count: args_count(node))
+        end
+
         def args_count(node)
           if count_keyword_args?
             node.children.size

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/array_hash_indentation.rb

@@ -72,8 +72,9 @@ module RuboCop
       end
 
       def incorrect_style_detected(styles, first, left_parenthesis)
-        add_offense(first, :expression,
-                    message(base_description(left_parenthesis))) do
+        msg = message(base_description(left_parenthesis))
+
+        add_offense(first, message: msg) do
           ambiguous_style_detected(*styles)
         end
       end

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

@@ -39,9 +39,9 @@ module RuboCop
             # autocorrecting it. Two rewrites in the same area by the same
             # cop can not be handled. The next iteration will find the
             # offense again and correct it.
-            add_offense(nil, expr)
+            add_offense(nil, location: expr)
           else
-            add_offense(current, :expression)
+            add_offense(current)
           end
         end
       end

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

@@ -18,7 +18,7 @@ module RuboCop
         length = code_length(node)
         return unless length > max_length
 
-        add_offense(node, :expression, message(length, max_length)) do
+        add_offense(node, message: message(length, max_length)) do
           self.max = length
         end
       end

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

@@ -12,7 +12,7 @@ module RuboCop
         if valid_name?(node, name)
           correct_style_detected
         else
-          add_offense(node, name_range, message(style)) do
+          add_offense(node, location: name_range, message: message(style)) do
             report_opposing_styles(node, name)
           end
         end

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

@@ -20,7 +20,7 @@ module RuboCop
       end
 
       def_node_matcher :non_public_modifier?, <<-PATTERN
-        (send nil {:private :protected} ({def defs} ...))
+        (send nil? {:private :protected} ({def defs} ...))
       PATTERN
     end
   end

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}'
@@ -102,7 +104,7 @@ module RuboCop
 
           offset = style == :empty_lines && msg.include?('end.') ? 2 : 1
           range = source_range(processed_source.buffer, line + offset, 0)
-          add_offense([style, range], range, msg)
+          add_offense([style, range], location: range, message: msg)
         end
 
         def check_deferred_empty_line(body)
@@ -113,7 +115,12 @@ module RuboCop
           return if processed_source[line].empty?
 
           range = source_range(processed_source.buffer, line + 2, 0)
-          add_offense([:empty_lines, range], range, deferred_message(node))
+
+          add_offense(
+            [:empty_lines, range],
+            location: range,
+            message: deferred_message(node)
+          )
         end
 
         def namespace?(body, with_one_child: false)
@@ -149,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,9 +40,12 @@ 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)
-        add_offense(node, end_loc, msg)
+        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
 
       def style_parameter_name

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

@@ -10,19 +10,19 @@ module RuboCop
         PATTERN
 
         base.def_node_matcher :class_new_definition, <<-PATTERN
-        [!^(casgn nil :#{base::SUPERCLASS} ...) (send (const nil :Class) :new #{base::BASE_PATTERN})]
+        [!^(casgn nil? :#{base::SUPERCLASS} ...) (send (const nil? :Class) :new #{base::BASE_PATTERN})]
         PATTERN
       end
 
       def on_class(node)
         class_definition(node) do
-          add_offense(node.children[1], :expression, self.class::MSG)
+          add_offense(node.children[1])
         end
       end
 
       def on_send(node)
         class_new_definition(node) do
-          add_offense(node.children.last, :expression, self.class::MSG)
+          add_offense(node.children.last)
         end
       end
 

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

@@ -28,13 +28,22 @@ module RuboCop
         return if children.size < 2
 
         line = start.loc.line
-        min = children.min_by { |n| n.loc.first_line }
+
+        min = first_by_line(children)
         return if line != min.loc.first_line
 
-        max = children.max_by { |n| n.loc.last_line }
+        max = last_by_line(children)
         return if line == max.loc.last_line
 
-        add_offense(min, :expression, self.class::MSG)
+        add_offense(min)
+      end
+
+      def first_by_line(nodes)
+        nodes.min_by { |n| n.loc.first_line }
+      end
+
+      def last_by_line(nodes)
+        nodes.max_by { |n| n.loc.last_line }
       end
     end
   end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for working with heredoc strings.
+    module Heredoc
+      OPENING_DELIMITER = /<<[~-]?['"`]?([^'"`]+)['"`]?/
+
+      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
+
+      private
+
+      def delimiter_string(node)
+        node.source.match(OPENING_DELIMITER).captures.first
+      end
+    end
+  end
+end

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

@@ -4,24 +4,50 @@ module RuboCop
   module Cop
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
-      include OnMethodDef
       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 on_method_def(node, method_name, _args, _body)
+      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
 
-        add_offense(node, :keyword,
-                    format(self.class::MSG, method_name, complexity, max)) do
+        msg = format(self.class::MSG,
+                     method: method_name,
+                     complexity: complexity,
+                     max: max)
+
+        add_offense(node, message: msg) do
           self.max = complexity.ceil
         end
       end
 
-      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