rubocop 0.78.0 → 1.13.0

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

@@ -7,25 +7,59 @@ module RuboCop
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       # The cop can be configured to ignore blocks passed to certain methods.
-      class BlockLength < Cop
-        include TooManyLines
+      #
+      # You can set literals you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # will be counted as one line regardless of its actual size.
+      #
+      #
+      # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
+      # for backwards compatibility. Please use `IgnoredMethods` instead.
+      #
+      # @example CountAsOne: ['array', 'heredoc']
+      #
+      #   something do
+      #     array = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     hash = {          # +3
+      #       key: 'value'
+      #     }
+      #
+      #     msg = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #   end                 # 5 points
+      #
+      # NOTE: This cop does not apply for `Struct` definitions.
+      class BlockLength < Base
+        include CodeLength
+        include IgnoredMethods
+
+        ignored_methods deprecated_key: 'ExcludedMethods'
 
         LABEL = 'Block'
 
         def on_block(node)
-          return if excluded_method?(node)
-          return if node.class_constructor?
+          return if ignored_method?(node.method_name)
+          return if method_receiver_excluded?(node)
+          return if node.class_constructor? || node.struct_constructor?
 
           check_code_length(node)
         end
 
         private
 
-        def excluded_method?(node)
+        def method_receiver_excluded?(node)
           node_receiver = node.receiver&.source&.gsub(/\s+/, '')
           node_method = String(node.method_name)
 
-          excluded_methods.any? do |config|
+          ignored_methods.any? do |config|
+            next unless config.is_a?(String)
+
             receiver, method = config.split('.')
 
             unless method
@@ -37,10 +71,6 @@ module RuboCop
           end
         end
 
-        def excluded_methods
-          cop_config['ExcludedMethods'] || []
-        end
-
         def cop_label
           LABEL
         end

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

@@ -11,15 +11,12 @@ module RuboCop
       # towards the nesting level. Set to `true` to count blocks as well.
       #
       # The maximum level of nesting allowed is configurable.
-      class BlockNesting < Cop
-        include ConfigurableMax
+      class BlockNesting < Base
+        NESTING_BLOCKS = %i[case if while while_post until until_post for resbody].freeze
 
-        NESTING_BLOCKS = %i[
-          case if while while_post
-          until until_post for resbody
-        ].freeze
+        exclude_limit 'Max'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
           max = cop_config['Max']
@@ -34,9 +31,7 @@ module RuboCop
             if current_level > max
               self.max = current_level
               unless part_of_ignored_node?(node)
-                add_offense(node, message: message(max)) do
-                  ignore_node(node)
-                end
+                add_offense(node, message: message(max)) { ignore_node(node) }
               end
             end
           end

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

@@ -6,29 +6,58 @@ module RuboCop
       # This cop checks if the length a class exceeds some maximum value.
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
-      class ClassLength < Cop
-        include ClassishLength
+      #
+      # You can set literals you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # will be counted as one line regardless of its actual size.
+      #
+      # @example CountAsOne: ['array', 'heredoc']
+      #
+      #   class Foo
+      #     ARRAY = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     HASH = {          # +3
+      #       key: 'value'
+      #     }
+      #
+      #     MSG = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #   end                 # 5 points
+      #
+      #
+      # NOTE: This cop also applies for `Struct` definitions.
+      class ClassLength < Base
+        include CodeLength
 
         def on_class(node)
           check_code_length(node)
         end
 
         def on_casgn(node)
-          class_definition?(node) do
-            check_code_length(node)
+          parent = node.parent
+
+          if parent&.assignment?
+            block_node = parent.children[1]
+          elsif parent&.parent&.masgn_type?
+            block_node = parent.parent.children[1]
+          else
+            _scope, _name, block_node = *node
           end
+
+          return unless block_node.respond_to?(:class_definition?) && block_node.class_definition?
+
+          check_code_length(block_node)
         end
 
         private
 
-        def_node_matcher :class_definition?, <<~PATTERN
-          (casgn nil? _ (block (send (const nil? :Class) :new) ...))
-        PATTERN
-
         def message(length, max_length)
-          format('Class has too many lines. [%<length>d/%<max>d]',
-                 length: length,
-                 max: 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

@@ -13,19 +13,51 @@ module RuboCop
       # operator (or keyword and) can be converted to a nested if statement,
       # and ||/or is shorthand for a sequence of ifs, so they also add one.
       # Loops can be said to have an exit condition, so they add one.
-      class CyclomaticComplexity < Cop
+      # Blocks that are calls to builtin iteration methods
+      # (e.g. `ary.map{...}) also add one, others are ignored.
+      #
+      #   def each_child_node(*types)               # count begins: 1
+      #     unless block_given?                     # unless: +1
+      #       return to_enum(__method__, *types)
+      #
+      #     children.each do |child|                # each{}: +1
+      #       next unless child.is_a?(Node)         # unless: +1
+      #
+      #       yield child if types.empty? ||        # if: +1, ||: +1
+      #                      types.include?(child.type)
+      #     end
+      #
+      #     self
+      #   end                                       # total: 6
+      class CyclomaticComplexity < Base
         include MethodComplexity
+        include Utils::IteratingBlock
 
-        MSG = 'Cyclomatic complexity for %<method>s is too high. ' \
-              '[%<complexity>d/%<max>d]'
-        COUNTED_NODES = %i[if while until for
-                           rescue when and or].freeze
+        MSG = 'Cyclomatic complexity for %<method>s is too high. [%<complexity>d/%<max>d]'
+        COUNTED_NODES = %i[if while until for csend block block_pass
+                           rescue when and or or_asgn and_asgn].freeze
 
         private
 
-        def complexity_score_for(_node)
+        def complexity_score_for(node)
+          return 0 if iterating_block?(node) == false
+          return 0 if node.csend_type? && discount_for_repeated_csend?(node)
+
           1
         end
+
+        def block_method(node)
+          case node.type
+          when :block
+            node.method_name
+          when :block_pass
+            node.parent.method_name
+          end
+        end
+
+        def count_block?(block)
+          KNOWN_ITERATING_METHODS.include? block.method_name
+        end
       end
     end
   end

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

@@ -6,14 +6,42 @@ module RuboCop
       # This cop checks if the length of a method exceeds some maximum value.
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
-      class MethodLength < Cop
-        include TooManyLines
+      #
+      # You can set literals you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # will be counted as one line regardless of its actual size.
+      #
+      # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
+      # for backwards compatibility. Please use `IgnoredMethods` instead.
+      #
+      # @example CountAsOne: ['array', 'heredoc']
+      #
+      #   def m
+      #     array = [       # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     hash = {        # +3
+      #       key: 'value'
+      #     }
+      #
+      #     <<~HEREDOC      # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #   end               # 5 points
+      #
+      class MethodLength < Base
+        include CodeLength
+        include IgnoredMethods
+
+        ignored_methods deprecated_key: 'ExcludedMethods'
 
         LABEL = 'Method'
 
         def on_def(node)
-          excluded_methods = cop_config['ExcludedMethods']
-          return if excluded_methods.include?(String(node.method_name))
+          return if ignored_method?(node.method_name)
 
           check_code_length(node)
         end

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

@@ -6,29 +6,49 @@ module RuboCop
       # This cop checks if the length a module exceeds some maximum value.
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
-      class ModuleLength < Cop
-        include ClassishLength
+      #
+      # You can set literals you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # will be counted as one line regardless of its actual size.
+      #
+      # @example CountAsOne: ['array', 'heredoc']
+      #
+      #   module M
+      #     ARRAY = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     HASH = {          # +3
+      #       key: 'value'
+      #     }
+      #
+      #     MSG = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #   end                 # 5 points
+      #
+      class ModuleLength < Base
+        include CodeLength
 
         def on_module(node)
           check_code_length(node)
         end
 
         def on_casgn(node)
-          module_definition?(node) do
-            check_code_length(node)
-          end
+          module_definition?(node) { check_code_length(node) }
         end
 
         private
 
+        # @!method module_definition?(node)
         def_node_matcher :module_definition?, <<~PATTERN
-          (casgn nil? _ (block (send (const nil? :Module) :new) ...))
+          (casgn nil? _ (block (send (const {nil? cbase} :Module) :new) ...))
         PATTERN
 
         def message(length, max_length)
-          format('Module has too many lines. [%<length>d/%<max>d]',
-                 length: length,
-                 max: 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

@@ -4,13 +4,75 @@ module RuboCop
   module Cop
     module Metrics
       # This cop checks for methods with too many parameters.
+      #
       # The maximum number of parameters is configurable.
-      # Keyword arguments can optionally be excluded from the total count.
-      class ParameterLists < Cop
-        include ConfigurableMax
+      # Keyword arguments can optionally be excluded from the total count,
+      # as they add less complexity than positional or optional parameters.
+      #
+      # @example Max: 3
+      #   # good
+      #   def foo(a, b, c = 1)
+      #   end
+      #
+      # @example Max: 2
+      #   # bad
+      #   def foo(a, b, c = 1)
+      #   end
+      #
+      # @example CountKeywordArgs: true (default)
+      #   # counts keyword args towards the maximum
+      #
+      #   # bad (assuming Max is 3)
+      #   def foo(a, b, c, d: 1)
+      #   end
+      #
+      #   # good (assuming Max is 3)
+      #   def foo(a, b, c: 1)
+      #   end
+      #
+      # @example CountKeywordArgs: false
+      #   # don't count keyword args towards the maximum
+      #
+      #   # good (assuming Max is 3)
+      #   def foo(a, b, c, d: 1)
+      #   end
+      #
+      # This cop also checks for the maximum number of optional parameters.
+      # This can be configured using the `MaxOptionalParameters` config option.
+      #
+      # @example MaxOptionalParameters: 3 (default)
+      #   # good
+      #   def foo(a = 1, b = 2, c = 3)
+      #   end
+      #
+      # @example MaxOptionalParameters: 2
+      #   # bad
+      #   def foo(a = 1, b = 2, c = 3)
+      #   end
+      #
+      class ParameterLists < Base
+        exclude_limit 'Max'
+        exclude_limit 'MaxOptionalParameters'
 
-        MSG = 'Avoid parameter lists longer than %<max>d parameters. ' \
-              '[%<count>d/%<max>d]'
+        MSG = 'Avoid parameter lists longer than %<max>d parameters. [%<count>d/%<max>d]'
+        OPTIONAL_PARAMETERS_MSG = 'Method has too many optional parameters. [%<count>d/%<max>d]'
+
+        NAMED_KEYWORD_TYPES = %i[kwoptarg kwarg].freeze
+        private_constant :NAMED_KEYWORD_TYPES
+
+        def on_def(node)
+          optargs = node.arguments.select(&:optarg_type?)
+          return if optargs.count <= max_optional_parameters
+
+          message = format(
+            OPTIONAL_PARAMETERS_MSG,
+            max: max_optional_parameters,
+            count: optargs.count
+          )
+
+          add_offense(node, message: message) { self.max_optional_parameters = optargs.count }
+        end
+        alias on_defs on_def
 
         def on_args(node)
           count = args_count(node)
@@ -18,26 +80,23 @@ module RuboCop
 
           return if argument_to_lambda_or_proc?(node)
 
-          add_offense(node) do
+          add_offense(node, message: format(MSG, max: max_params, count: args_count(node))) do
             self.max = count
           end
         end
 
         private
 
+        # @!method argument_to_lambda_or_proc?(node)
         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
           else
-            node.children.count { |a| !%i[kwoptarg kwarg].include?(a.type) }
+            node.children.count { |a| !NAMED_KEYWORD_TYPES.include?(a.type) }
           end
         end
 
@@ -45,6 +104,10 @@ module RuboCop
           cop_config['Max']
         end
 
+        def max_optional_parameters
+          cop_config['MaxOptionalParameters']
+        end
+
         def count_keyword_args?
           cop_config['CountKeywordArgs']
         end