rubocop 0.80.0 → 1.42.0

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

@@ -3,32 +3,57 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks if the length a module exceeds some maximum value.
+      # Checks if the length of 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 constructs you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
+      # will be counted as one line regardless of its actual size.
+      #
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
+      #
+      #   module M
+      #     ARRAY = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     HASH = {          # +3
+      #       key: 'value'
+      #     }
+      #
+      #     MSG = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 6 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 numblock} (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

@@ -3,14 +3,79 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks for methods with too many parameters.
+      # 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.
+      #
+      # NOTE: Explicit block argument `&block` is not counted to prevent
+      # erroneous change that is avoided by making block argument implicit.
+      #
+      # @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 +83,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
+            node.children.count { |a| !a.blockarg_type? }
           else
-            node.children.count { |a| !%i[kwoptarg kwarg].include?(a.type) }
+            node.children.count { |a| !NAMED_KEYWORD_TYPES.include?(a.type) && !a.blockarg_type? }
           end
         end
 
@@ -45,6 +107,10 @@ module RuboCop
           cop_config['Max']
         end
 
+        def max_optional_parameters
+          cop_config['MaxOptionalParameters']
+        end
+
         def count_keyword_args?
           cop_config['CountKeywordArgs']
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop tries to produce a complexity score that's a measure of the
+      # Tries to produce a complexity score that's a measure of the
       # complexity the reader experiences when looking at a method. For that
       # reason it considers `when` nodes as something that doesn't add as much
       # complexity as an `if` or a `&&`. Except if it's one of those special
@@ -26,13 +26,10 @@ module RuboCop
       #       do_something until a && b   # 2
       #     end                           # ===
       #   end                             # 7 complexity points
-      class PerceivedComplexity < Cop
-        include MethodComplexity
+      class PerceivedComplexity < CyclomaticComplexity
+        MSG = 'Perceived complexity for %<method>s is too high. [%<complexity>d/%<max>d]'
 
-        MSG = 'Perceived complexity for %<method>s is too high. ' \
-              '[%<complexity>d/%<max>d]'
-        COUNTED_NODES = %i[if case while until
-                           for rescue and or].freeze
+        COUNTED_NODES = (CyclomaticComplexity::COUNTED_NODES - [:when] + [:case]).freeze
 
         private
 
@@ -42,17 +39,18 @@ module RuboCop
             # If cond is nil, that means each when has an expression that
             # evaluates to true or false. It's just an alternative to
             # if/elsif/elsif... so the when nodes count.
+            nb_branches = node.when_branches.length + (node.else_branch ? 1 : 0)
             if node.condition.nil?
-              node.when_branches.length
+              nb_branches
             else
               # Otherwise, the case node gets 0.8 complexity points and each
               # when gets 0.2.
-              (0.8 + 0.2 * node.when_branches.length).round
+              ((nb_branches * 0.2) + 0.8).round
             end
           when :if
             node.else? && !node.elsif? ? 2 : 1
           else
-            1
+            super
           end
         end
       end

data/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb

@@ -11,18 +11,27 @@ module RuboCop
         # We separate the *calculator* from the *cop* so that the calculation,
         # the formula itself, is easier to test.
         class AbcSizeCalculator
+          include IteratingBlock
+          include RepeatedCsendDiscount
+          prepend RepeatedAttributeDiscount
+
           # > Branch -- an explicit forward program branch out of scope -- a
           # > function call, class method call ..
           # > http://c2.com/cgi/wiki?AbcMetric
-          BRANCH_NODES = %i[send csend].freeze
+          BRANCH_NODES = %i[send csend yield].freeze
 
           # > Condition -- a logical/Boolean test, == != <= >= < > else case
           # > default try catch ? and unary conditionals.
           # > http://c2.com/cgi/wiki?AbcMetric
           CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
 
-          def self.calculate(node)
-            new(node).calculate
+          # TODO: move to rubocop-ast
+          ARGUMENT_TYPES = %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg].freeze
+
+          private_constant :BRANCH_NODES, :CONDITION_NODES, :ARGUMENT_TYPES
+
+          def self.calculate(node, discount_repeated_attributes: false)
+            new(node, discount_repeated_attributes: discount_repeated_attributes).calculate
           end
 
           def initialize(node)
@@ -30,21 +39,14 @@ module RuboCop
             @branch = 0
             @condition = 0
             @node = node
+            reset_repeated_csend
           end
 
           def calculate
-            @node.each_node do |child|
-              if child.assignment?
-                @assignment += 1
-              elsif branch?(child)
-                evaluate_branch_nodes(child)
-              elsif condition?(child)
-                evaluate_condition_node(child)
-              end
-            end
+            visit_depth_last(@node) { |child| calculate_node(child) }
 
             [
-              Math.sqrt(@assignment**2 + @branch**2 + @condition**2).round(2),
+              Math.sqrt((@assignment**2) + (@branch**2) + (@condition**2)).round(2),
               "<#{@assignment}, #{@branch}, #{@condition}>"
             ]
           end
@@ -54,6 +56,7 @@ module RuboCop
               @condition += 1
             else
               @branch += 1
+              @condition += 1 if node.csend_type? && !discount_for_repeated_csend?(node)
             end
           end
 
@@ -63,18 +66,75 @@ module RuboCop
           end
 
           def else_branch?(node)
-            %i[case if].include?(node.type) &&
-              node.else? &&
-              node.loc.else.is?('else')
+            %i[case if].include?(node.type) && node.else? && node.loc.else.is?('else')
           end
 
           private
 
+          def visit_depth_last(node, &block)
+            node.each_child_node { |child| visit_depth_last(child, &block) }
+            yield node
+          end
+
+          def calculate_node(node)
+            @assignment += 1 if assignment?(node)
+
+            if branch?(node)
+              evaluate_branch_nodes(node)
+            elsif condition?(node)
+              evaluate_condition_node(node)
+            end
+          end
+
+          def assignment?(node)
+            return compound_assignment(node) if node.masgn_type? || node.shorthand_asgn?
+
+            node.for_type? ||
+              (node.respond_to?(:setter_method?) && node.setter_method?) ||
+              simple_assignment?(node) ||
+              argument?(node)
+          end
+
+          def compound_assignment(node)
+            # Methods setter cannot be detected for multiple assignments
+            # and shorthand assigns, so we'll count them here instead
+            children = node.masgn_type? ? node.children[0].children : node.children
+
+            will_be_miscounted = children.count do |child|
+              child.respond_to?(:setter_method?) && !child.setter_method?
+            end
+            @assignment += will_be_miscounted
+
+            false
+          end
+
+          def simple_assignment?(node)
+            if !node.equals_asgn?
+              false
+            elsif node.lvasgn_type?
+              reset_on_lvasgn(node)
+              capturing_variable?(node.children.first)
+            else
+              true
+            end
+          end
+
+          def capturing_variable?(name)
+            # TODO: Remove `Symbol#to_s` after supporting only Ruby >= 2.7.
+            name && !name.to_s.start_with?('_')
+          end
+
           def branch?(node)
             BRANCH_NODES.include?(node.type)
           end
 
+          def argument?(node)
+            ARGUMENT_TYPES.include?(node.type) && capturing_variable?(node.children.first)
+          end
+
           def condition?(node)
+            return false if iterating_block?(node) == false
+
             CONDITION_NODES.include?(node.type)
           end
         end

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # Helps to calculate code length for the provided node.
+        class CodeLengthCalculator
+          extend NodePattern::Macros
+          include Util
+
+          FOLDABLE_TYPES = %i[array hash heredoc send csend].freeze
+          CLASSLIKE_TYPES = %i[class module].freeze
+          private_constant :FOLDABLE_TYPES, :CLASSLIKE_TYPES
+
+          def initialize(node, processed_source, count_comments: false, foldable_types: [])
+            @node = node
+            @processed_source = processed_source
+            @count_comments = count_comments
+            @foldable_checks = build_foldable_checks(foldable_types)
+            @foldable_types = normalize_foldable_types(foldable_types)
+          end
+
+          def calculate
+            length = code_length(@node)
+            return length if @foldable_types.empty?
+
+            each_top_level_descendant(@node, @foldable_types) do |descendant|
+              next unless foldable_node?(descendant)
+
+              descendant_length = code_length(descendant)
+              length = length - descendant_length + 1
+              # Subtract length of opening and closing brace if method argument omits hash braces.
+              length -= omit_length(descendant) if descendant.hash_type? && !descendant.braces?
+            end
+
+            length
+          end
+
+          private
+
+          def build_foldable_checks(types) # rubocop:disable Metrics/MethodLength
+            types.map do |type|
+              case type
+              when :array
+                ->(node) { node.array_type? }
+              when :hash
+                ->(node) { node.hash_type? }
+              when :heredoc
+                ->(node) { heredoc_node?(node) }
+              when :method_call
+                ->(node) { node.call_type? }
+              else
+                raise ArgumentError, "Unknown foldable type: #{type.inspect}. " \
+                                     "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
+              end
+            end
+          end
+
+          def normalize_foldable_types(types)
+            types.push(:str, :dstr) if types.delete(:heredoc)
+            types.push(:send, :csend) if types.delete(:method_call)
+            types
+          end
+
+          def code_length(node)
+            if classlike_node?(node)
+              classlike_code_length(node)
+            elsif heredoc_node?(node)
+              heredoc_length(node)
+            else
+              body = extract_body(node)
+              return 0 unless body
+
+              body.source.each_line.count { |line| !irrelevant_line?(line) }
+            end
+          end
+
+          def heredoc_node?(node)
+            node.respond_to?(:heredoc?) && node.heredoc?
+          end
+
+          def classlike_code_length(node)
+            return 0 if namespace_module?(node)
+
+            body_line_numbers = line_range(node).to_a[1...-1]
+
+            target_line_numbers = body_line_numbers -
+                                  line_numbers_of_inner_nodes(node, :module, :class)
+
+            target_line_numbers.reduce(0) do |length, line_number|
+              source_line = @processed_source[line_number]
+              next length if irrelevant_line?(source_line)
+
+              length + 1
+            end
+          end
+
+          def namespace_module?(node)
+            classlike_node?(node.body)
+          end
+
+          def line_numbers_of_inner_nodes(node, *types)
+            line_numbers = Set.new
+
+            node.each_descendant(*types) do |inner_node|
+              line_range = line_range(inner_node)
+              line_numbers.merge(line_range)
+            end
+
+            line_numbers.to_a
+          end
+
+          def heredoc_length(node)
+            lines = node.loc.heredoc_body.source.lines
+            lines.count { |line| !irrelevant_line?(line) } + 2
+          end
+
+          def each_top_level_descendant(node, types, &block)
+            node.each_child_node do |child|
+              next if classlike_node?(child)
+
+              if types.include?(child.type)
+                yield child
+              else
+                each_top_level_descendant(child, types, &block)
+              end
+            end
+          end
+
+          def classlike_node?(node)
+            CLASSLIKE_TYPES.include?(node&.type)
+          end
+
+          def foldable_node?(node)
+            @foldable_checks.any? { |check| check.call(node) }
+          end
+
+          def extract_body(node)
+            case node.type
+            when :class, :module, :block, :numblock, :def, :defs
+              node.body
+            when :casgn
+              _scope, _name, value = *node
+              extract_body(value)
+            else
+              node
+            end
+          end
+
+          # Returns true for lines that shall not be included in the count.
+          def irrelevant_line?(source_line)
+            source_line.blank? || (!count_comments? && comment_line?(source_line))
+          end
+
+          def count_comments?
+            @count_comments
+          end
+
+          def omit_length(descendant)
+            parent = descendant.parent
+            return 0 if another_args?(parent)
+            return 0 unless parenthesized?(parent)
+
+            [
+              parent.loc.begin.end_pos != descendant.loc.expression.begin_pos,
+              parent.loc.end.begin_pos != descendant.loc.expression.end_pos
+            ].count(true)
+          end
+
+          def parenthesized?(node)
+            node.call_type? && node.parenthesized?
+          end
+
+          def another_args?(node)
+            node.call_type? && node.arguments.count > 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/utils/iterating_block.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # Used to identify iterating blocks like `.map{}` and `.map(&:...)`
+        module IteratingBlock
+          enumerable = %i[
+            all? any? chain chunk chunk_while collect collect_concat count cycle
+            detect drop drop_while each each_cons each_entry each_slice
+            each_with_index each_with_object entries filter filter_map find
+            find_all find_index flat_map grep grep_v group_by inject lazy map
+            max max_by min min_by minmax minmax_by none? one? partition reduce
+            reject reverse_each select slice_after slice_before slice_when sort
+            sort_by sum take take_while tally to_h uniq zip
+          ]
+
+          enumerator = %i[with_index with_object]
+
+          array = %i[
+            bsearch bsearch_index collect! combination d_permutation delete_if
+            each_index keep_if map! permutation product reject! repeat
+            repeated_combination select! sort sort! sort_by sort_by
+          ]
+
+          hash = %i[
+            each_key each_pair each_value fetch fetch_values has_key? merge
+            merge! transform_keys transform_keys! transform_values
+            transform_values!
+          ]
+
+          KNOWN_ITERATING_METHODS = (Set.new(enumerable) + enumerator + array + hash).freeze
+
+          # Returns the name of the method called with a block
+          # if node is a block node, or a block-pass node.
+          def block_method_name(node)
+            case node.type
+            when :block
+              node.method_name
+            when :block_pass
+              node.parent.method_name
+            end
+          end
+
+          # Returns true iff name is a known iterating type (e.g. :each, :transform_values)
+          def iterating_method?(name)
+            KNOWN_ITERATING_METHODS.include? name
+          end
+
+          # Returns nil if node is neither a block node or a block-pass node.
+          # Otherwise returns true/false if method call is a known iterating call
+          def iterating_block?(node)
+            name = block_method_name(node)
+            name && iterating_method?(name)
+          end
+        end
+      end
+    end
+  end
+end