rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks for excessive nesting of conditional and looping constructs.
+      #
+      # You can configure if blocks are considered using the `CountBlocks` and `CountModifierForms`
+      # options. When both are set to `false` (the default) blocks and modifier forms are not
+      # counted towards the nesting level. Set them to `true` to include these in the nesting level
+      # calculation as well.
+      #
+      # The maximum level of nesting allowed is configurable.
+      class BlockNesting < Base
+        NESTING_BLOCKS = %i[case case_match if while while_post until until_post for resbody].freeze
+
+        exclude_limit 'Max'
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          max = cop_config['Max']
+          check_nesting_level(processed_source.ast, max, 0)
+        end
+
+        private
+
+        def check_nesting_level(node, max, current_level)
+          if consider_node?(node)
+            current_level += 1 if count_if_block?(node)
+            if current_level > max
+              self.max = current_level
+              unless part_of_ignored_node?(node)
+                add_offense(node, message: message(max)) { ignore_node(node) }
+              end
+            end
+          end
+
+          node.each_child_node do |child_node|
+            check_nesting_level(child_node, max, current_level)
+          end
+        end
+
+        def count_if_block?(node)
+          return true unless node.if_type?
+          return false if node.elsif?
+          return count_modifier_forms? if node.modifier_form?
+
+          true
+        end
+
+        def consider_node?(node)
+          return true if NESTING_BLOCKS.include?(node.type)
+
+          count_blocks? && node.any_block_type?
+        end
+
+        def message(max)
+          "Avoid more than #{max} levels of block nesting."
+        end
+
+        def count_blocks?
+          cop_config.fetch('CountBlocks', false)
+        end
+
+        def count_modifier_forms?
+          cop_config.fetch('CountModifierForms', false)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks if the length of a class exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      #
+      # 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.
+      #
+      # NOTE: This cop also applies for `Struct` definitions.
+      #
+      # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
+      #
+      #   class Foo
+      #     ARRAY = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     HASH = {          # +1
+      #       key: 'value'
+      #     }
+      #
+      #     MSG = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 4 points
+      #
+      class ClassLength < Base
+        include CodeLength
+
+        def on_class(node)
+          check_code_length(node)
+        end
+
+        def on_sclass(node)
+          return if node.each_ancestor(:class).any?
+
+          on_class(node)
+        end
+
+        def on_casgn(node)
+          block_node = node.expression || find_expression_within_parent(node.parent)
+
+          return unless block_node.respond_to?(:class_definition?) && block_node.class_definition?
+
+          check_code_length(block_node)
+        end
+
+        private
+
+        def message(length, max_length)
+          format('Class has too many lines. [%<length>d/%<max>d]', length: length, max: max_length)
+        end
+
+        def find_expression_within_parent(parent)
+          if parent&.assignment?
+            parent.expression
+          elsif parent&.parent&.masgn_type?
+            parent.parent.expression
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks for literals with extremely many entries. This is indicative of
+      # configuration or data that may be better extracted somewhere else, like
+      # a database, fetched from an API, or read from a non-code file (CSV,
+      # JSON, YAML, etc.).
+      #
+      # @example
+      #   # bad
+      #   # Huge Array literal
+      #   [1, 2, '...', 999_999_999]
+      #
+      #   # bad
+      #   # Huge Hash literal
+      #   { 1 => 1, 2 => 2, '...' => '...', 999_999_999 => 999_999_999}
+      #
+      #   # bad
+      #   # Huge Set "literal"
+      #   Set[1, 2, '...', 999_999_999]
+      #
+      #   # good
+      #   # Reasonably sized Array literal
+      #   [1, 2, '...', 10]
+      #
+      #   # good
+      #   # Reading huge Array from external data source
+      #   # File.readlines('numbers.txt', chomp: true).map!(&:to_i)
+      #
+      #   # good
+      #   # Reasonably sized Hash literal
+      #   { 1 => 1, 2 => 2, '...' => '...', 10 => 10}
+      #
+      #   # good
+      #   # Reading huge Hash from external data source
+      #   CSV.foreach('numbers.csv', headers: true).each_with_object({}) do |row, hash|
+      #     hash[row["key"].to_i] = row["value"].to_i
+      #   end
+      #
+      #   # good
+      #   # Reasonably sized Set "literal"
+      #   Set[1, 2, '...', 10]
+      #
+      #   # good
+      #   # Reading huge Set from external data source
+      #   SomeFramework.config_for(:something)[:numbers].to_set
+      #
+      class CollectionLiteralLength < Base
+        MSG = 'Avoid hard coding large quantities of data in code. ' \
+              'Prefer reading the data from an external source.'
+        RESTRICT_ON_SEND = [:[]].freeze
+
+        # @!method set_const?(node)
+        def_node_matcher :set_const?, <<~PATTERN
+          (const {cbase nil?} :Set)
+        PATTERN
+
+        def on_array(node)
+          add_offense(node) if node.children.length >= collection_threshold
+        end
+        alias on_hash on_array
+
+        def on_index(node)
+          return unless set_const?(node.receiver)
+
+          add_offense(node) if node.arguments.length >= collection_threshold
+        end
+
+        def on_send(node)
+          on_index(node) if node.method?(:[])
+        end
+
+        private
+
+        def collection_threshold
+          cop_config.fetch('LengthThreshold', Float::INFINITY)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks that the cyclomatic complexity of methods is not higher
+      # than the configured maximum. The cyclomatic complexity is the number of
+      # linearly independent paths through a method. The algorithm counts
+      # decision points and adds one.
+      #
+      # An if statement (or unless or ?:) increases the complexity by one. An
+      # else branch does not, since it doesn't add a decision point. The &&
+      # 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.
+      # Blocks that are calls to builtin iteration methods
+      # (e.g. `ary.map{...}`) also add one, others are ignored.
+      #
+      # @example
+      #
+      #   def each_child_node(*types)               # count begins: 1
+      #     unless block_given?                     # unless: +1
+      #       return to_enum(__method__, *types)
+      #     end
+      #
+      #     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 csend block block_pass
+                           rescue when in_pattern and or or_asgn and_asgn].freeze
+
+        private
+
+        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 count_block?(block)
+          KNOWN_ITERATING_METHODS.include? block.method_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks if the length of a method exceeds some maximum value.
+      # Comment lines can optionally be allowed.
+      # The maximum allowed length is configurable.
+      #
+      # 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.
+      #
+      # NOTE: The `ExcludedMethods` and `IgnoredMethods` configuration is
+      # deprecated and only kept for backwards compatibility.
+      # Please use `AllowedMethods` and `AllowedPatterns` instead.
+      # By default, there are no methods to allowed.
+      #
+      # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
+      #
+      #   def m
+      #     array = [       # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     hash = {        # +1
+      #       key: 'value'
+      #     }
+      #
+      #     <<~HEREDOC      # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #
+      #     foo(            # +1
+      #       1,
+      #       2
+      #     )
+      #   end               # 4 points
+      #
+      class MethodLength < Base
+        include CodeLength
+        include AllowedMethods
+        include AllowedPattern
+
+        LABEL = 'Method'
+
+        def on_def(node)
+          return if allowed?(node.method_name)
+
+          check_code_length(node)
+        end
+        alias on_defs on_def
+
+        def on_block(node)
+          return unless node.method?(:define_method)
+
+          method_name = node.send_node.first_argument
+          return if method_name.basic_literal? && allowed?(method_name.value)
+
+          check_code_length(node)
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        def cop_label
+          LABEL
+        end
+
+        def allowed?(method_name)
+          allowed_method?(method_name) || matches_allowed_pattern?(method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks if the length of a module exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      #
+      # 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', 'hash', 'heredoc', 'method_call']
+      #
+      #   module M
+      #     ARRAY = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     HASH = {          # +1
+      #       key: 'value'
+      #     }
+      #
+      #     MSG = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 4 points
+      #
+      class ModuleLength < Base
+        include CodeLength
+
+        def on_module(node)
+          check_code_length(node)
+        end
+
+        def on_casgn(node)
+          module_definition?(node) { check_code_length(node) }
+        end
+
+        private
+
+        # @!method module_definition?(node)
+        def_node_matcher :module_definition?, <<~PATTERN
+          (casgn nil? _ (any_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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks for methods with too many parameters.
+      #
+      # The maximum number of parameters is configurable.
+      # Keyword arguments can optionally be excluded from the total count,
+      # as they add less complexity than positional or optional parameters.
+      #
+      # Any number of arguments for `initialize` method inside a block of
+      # `Struct.new` and `Data.define` like this is always allowed:
+      #
+      # [source,ruby]
+      # ----
+      # Struct.new(:one, :two, :three, :four, :five, keyword_init: true) do
+      #   def initialize(one:, two:, three:, four:, five:)
+      #   end
+      # end
+      # ----
+      #
+      # This is because checking the number of arguments of the `initialize` method
+      # does not make sense.
+      #
+      # 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]'
+        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
+
+        # @!method struct_new_or_data_define_block?(node)
+        def_node_matcher :struct_new_or_data_define_block?, <<~PATTERN
+          (block
+            {
+              (send (const {nil? cbase} :Struct) :new ...)
+              (send (const {nil? cbase} :Data) :define ...)
+            }
+            (args) ...)
+        PATTERN
+
+        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)
+          parent = node.parent
+          return if parent.method?(:initialize) && struct_new_or_data_define_block?(parent.parent)
+
+          count = args_count(node)
+          return unless count > max_params
+
+          return if argument_to_lambda_or_proc?(node)
+
+          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 args_count(node)
+          if count_keyword_args?
+            node.children.count { |a| !a.blockarg_type? }
+          else
+            node.children.count { |a| !NAMED_KEYWORD_TYPES.include?(a.type) && !a.blockarg_type? }
+          end
+        end
+
+        def max_params
+          cop_config['Max']
+        end
+
+        def max_optional_parameters
+          cop_config['MaxOptionalParameters']
+        end
+
+        def count_keyword_args?
+          cop_config['CountKeywordArgs']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # 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
+      # `case`/`when` constructs where there's no expression after `case`. Then
+      # the cop treats it as an `if`/`elsif`/`elsif`... and lets all the `when`
+      # nodes count. In contrast to the CyclomaticComplexity cop, this cop
+      # considers `else` nodes as adding complexity.
+      #
+      # @example
+      #
+      #   def my_method                   # 1
+      #     if cond                       # 1
+      #       case var                    # 2 (0.8 + 4 * 0.2, rounded)
+      #       when 1 then func_one
+      #       when 2 then func_two
+      #       when 3 then func_three
+      #       when 4..10 then func_other
+      #       end
+      #     else                          # 1
+      #       do_something until a && b   # 2
+      #     end                           # ===
+      #   end                             # 7 complexity points
+      class PerceivedComplexity < CyclomaticComplexity
+        MSG = 'Perceived complexity for `%<method>s` is too high. [%<complexity>d/%<max>d]'
+
+        COUNTED_NODES = (CyclomaticComplexity::COUNTED_NODES - [:when] + [:case]).freeze
+
+        private
+
+        def complexity_score_for(node)
+          case node.type
+          when :case
+            # 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?
+              nb_branches
+            else
+              # Otherwise, the case node gets 0.8 complexity points and each
+              # when gets 0.2.
+              ((nb_branches * 0.2) + 0.8).round
+            end
+          when :if
+            node.else? && !node.elsif? ? 2 : 1
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end