rubocop 1.34.1 → 1.54.0

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

@@ -8,8 +8,8 @@ module RuboCop
       # The maximum allowed length is configurable.
       # The cop can be configured to ignore blocks passed to certain methods.
       #
-      # You can set literals you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # 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.
       #
       #
@@ -17,7 +17,7 @@ module RuboCop
       # for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
       # instead. By default, there are no methods to allowed.
       #
-      # @example CountAsOne: ['array', 'heredoc']
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   something do
       #     array = [         # +1
@@ -33,7 +33,12 @@ module RuboCop
       #       Heredoc
       #       content.
       #     HEREDOC
-      #   end                 # 5 points
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 6 points
       #
       # NOTE: This cop does not apply for `Struct` definitions.
       class BlockLength < Base
@@ -46,7 +51,7 @@ module RuboCop
         def on_block(node)
           return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
           return if method_receiver_excluded?(node)
-          return if node.class_constructor? || node.struct_constructor?
+          return if node.class_constructor?
 
           check_code_length(node)
         end

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

@@ -12,7 +12,7 @@ module RuboCop
       #
       # The maximum level of nesting allowed is configurable.
       class BlockNesting < Base
-        NESTING_BLOCKS = %i[case if while while_post until until_post for resbody].freeze
+        NESTING_BLOCKS = %i[case case_match if while while_post until until_post for resbody].freeze
 
         exclude_limit 'Max'
 
@@ -44,7 +44,7 @@ module RuboCop
         def consider_node?(node)
           return true if NESTING_BLOCKS.include?(node.type)
 
-          count_blocks? && node.block_type?
+          count_blocks? && (node.block_type? || node.numblock_type?)
         end
 
         def message(max)

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

@@ -3,15 +3,15 @@
 module RuboCop
   module Cop
     module Metrics
-      # Checks if the length a class exceeds some maximum value.
+      # 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 literals you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # 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']
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   class Foo
       #     ARRAY = [         # +1
@@ -27,7 +27,12 @@ module RuboCop
       #       Heredoc
       #       content.
       #     HEREDOC
-      #   end                 # 5 points
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 6 points
       #
       #
       # NOTE: This cop also applies for `Struct` definitions.
@@ -37,6 +42,7 @@ module RuboCop
         def on_class(node)
           check_code_length(node)
         end
+        alias on_sclass on_class
 
         def on_casgn(node)
           parent = node.parent

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

@@ -0,0 +1,76 @@
+# 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
+
+        def on_array(node)
+          add_offense(node) if node.children.length >= collection_threshold
+        end
+        alias on_hash on_array
+
+        def on_index(node)
+          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

@@ -35,7 +35,7 @@ module RuboCop
 
         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
+                           rescue when in_pattern and or or_asgn and_asgn].freeze
 
         private
 

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

@@ -7,8 +7,8 @@ module RuboCop
       # Comment lines can optionally be allowed.
       # The maximum allowed length is configurable.
       #
-      # You can set literals you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # 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
@@ -16,7 +16,7 @@ module RuboCop
       # Please use `AllowedMethods` and `AllowedPatterns` instead.
       # By default, there are no methods to allowed.
       #
-      # @example CountAsOne: ['array', 'heredoc']
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   def m
       #     array = [       # +1
@@ -32,7 +32,12 @@ module RuboCop
       #       Heredoc
       #       content.
       #     HEREDOC
-      #   end               # 5 points
+      #
+      #     foo(            # +1
+      #       1,
+      #       2
+      #     )
+      #   end               # 6 points
       #
       class MethodLength < Base
         include CodeLength

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

@@ -3,15 +3,15 @@
 module RuboCop
   module Cop
     module Metrics
-      # 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.
       #
-      # You can set literals you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # 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']
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   module M
       #     ARRAY = [         # +1
@@ -27,7 +27,12 @@ module RuboCop
       #       Heredoc
       #       content.
       #     HEREDOC
-      #   end                 # 5 points
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 6 points
       #
       class ModuleLength < Base
         include CodeLength

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

@@ -9,6 +9,20 @@ module RuboCop
       # 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.
       #
@@ -63,6 +77,16 @@ module RuboCop
         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
@@ -78,6 +102,9 @@ module RuboCop
         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
 

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

@@ -45,7 +45,7 @@ module RuboCop
             else
               # Otherwise, the case node gets 0.8 complexity points and each
               # when gets 0.2.
-              (0.8 + (0.2 * nb_branches)).round
+              ((nb_branches * 0.2) + 0.8).round
             end
           when :if
             node.else? && !node.elsif? ? 2 : 1

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

@@ -25,15 +25,12 @@ module RuboCop
           # > http://c2.com/cgi/wiki?AbcMetric
           CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
 
+          private_constant :BRANCH_NODES, :CONDITION_NODES
+
           def self.calculate(node, discount_repeated_attributes: false)
             new(node, discount_repeated_attributes: discount_repeated_attributes).calculate
           end
 
-          # 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 initialize(node)
             @assignment = 0
             @branch = 0
@@ -120,8 +117,7 @@ module RuboCop
           end
 
           def capturing_variable?(name)
-            # TODO: Remove `Symbol#to_s` after supporting only Ruby >= 2.7.
-            name && !name.to_s.start_with?('_')
+            name && !name.start_with?('_')
           end
 
           def branch?(node)
@@ -129,7 +125,7 @@ module RuboCop
           end
 
           def argument?(node)
-            ARGUMENT_TYPES.include?(node.type) && capturing_variable?(node.children.first)
+            node.argument_type? && capturing_variable?(node.children.first)
           end
 
           def condition?(node)

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

@@ -9,8 +9,8 @@ module RuboCop
           extend NodePattern::Macros
           include Util
 
-          FOLDABLE_TYPES = %i[array hash heredoc].freeze
-          CLASSLIKE_TYPES = %i[class module].freeze
+          FOLDABLE_TYPES = %i[array hash heredoc send csend].freeze
+          CLASSLIKE_TYPES = %i[class module sclass].freeze
           private_constant :FOLDABLE_TYPES, :CLASSLIKE_TYPES
 
           def initialize(node, processed_source, count_comments: false, foldable_types: [])
@@ -39,7 +39,7 @@ module RuboCop
 
           private
 
-          def build_foldable_checks(types)
+          def build_foldable_checks(types) # rubocop:disable Metrics/MethodLength
             types.map do |type|
               case type
               when :array
@@ -48,6 +48,8 @@ module RuboCop
                 ->(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(', ')}."
@@ -56,11 +58,12 @@ module RuboCop
           end
 
           def normalize_foldable_types(types)
-            types.concat(%i[str dstr]) if types.delete(:heredoc)
+            types.push(:str, :dstr) if types.delete(:heredoc)
+            types.push(:send, :csend) if types.delete(:method_call)
             types
           end
 
-          def code_length(node)
+          def code_length(node) # rubocop:disable Metrics/MethodLength
             if classlike_node?(node)
               classlike_code_length(node)
             elsif heredoc_node?(node)
@@ -69,7 +72,14 @@ module RuboCop
               body = extract_body(node)
               return 0 unless body
 
-              body.source.each_line.count { |line| !irrelevant_line?(line) }
+              source =
+                if node_with_heredoc?(body)
+                  source_from_node_with_heredoc(body)
+                else
+                  body.source.lines
+                end
+
+              source.count { |line| !irrelevant_line?(line) }
             end
           end
 
@@ -160,8 +170,8 @@ module RuboCop
             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
+              parent.loc.begin.end_pos != descendant.source_range.begin_pos,
+              parent.loc.end.begin_pos != descendant.source_range.end_pos
             ].count(true)
           end
 
@@ -172,6 +182,27 @@ module RuboCop
           def another_args?(node)
             node.call_type? && node.arguments.count > 1
           end
+
+          def node_with_heredoc?(node)
+            node.each_descendant(:str, :dstr).any? { |descendant| heredoc_node?(descendant) }
+          end
+
+          def source_from_node_with_heredoc(node)
+            last_line = -1
+            node.each_descendant do |descendant|
+              next unless descendant.loc
+
+              descendant_last_line =
+                if heredoc_node?(descendant)
+                  descendant.loc.heredoc_end.line
+                else
+                  descendant.last_line
+                end
+
+              last_line = [last_line, descendant_last_line].max
+            end
+            @processed_source[(node.first_line - 1)..(last_line - 1)]
+          end
         end
       end
     end

data/lib/rubocop/cop/migration/department_name.rb

@@ -16,7 +16,7 @@ module RuboCop
         # The token that makes up a disable comment.
         # The allowed specification for comments after `# rubocop: disable` is
         # `DepartmentName/CopName` or` all`.
-        DISABLING_COPS_CONTENT_TOKEN = %r{[A-z]+/[A-z]+|all}.freeze
+        DISABLING_COPS_CONTENT_TOKEN = %r{[A-Za-z]+/[A-Za-z]+|all}.freeze
 
         def on_new_investigation
           processed_source.comments.each do |comment|
@@ -45,7 +45,7 @@ module RuboCop
         end
 
         def check_cop_name(name, comment, offset)
-          start = comment.location.expression.begin_pos + offset
+          start = comment.source_range.begin_pos + offset
           range = range_between(start, start + name.length)
 
           add_offense(range) do |corrector|
@@ -67,7 +67,7 @@ module RuboCop
         end
 
         def contain_unexpected_character_for_department_name?(name)
-          name.match?(%r{[^A-z/, ]})
+          name.match?(%r{[^A-Za-z/, ]})
         end
 
         def qualified_legacy_cop_name(cop_name)

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

@@ -12,7 +12,7 @@ module RuboCop
       attr_reader :column_delta
 
       def configured_indentation_width
-        cop_config['IndentationWidth'] || config.for_cop('Layout/IndentationWidth')['Width']
+        cop_config['IndentationWidth'] || config.for_cop('Layout/IndentationWidth')['Width'] || 2
       end
 
       def indentation(node)
@@ -28,7 +28,7 @@ module RuboCop
 
         each_bad_alignment(items, base_column) do |current|
           expr = current.source_range
-          if @current_offenses.any? { |o| within?(expr, o.location) }
+          if @current_offenses&.any? { |o| within?(expr, o.location) }
             # If this offense is within a line range that is already being
             # realigned by autocorrect, we report the offense without
             # autocorrecting it. Two rewrites in the same area by the same

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

@@ -7,11 +7,11 @@ module RuboCop
       SIGILS = '@$' # if a variable starts with a sigil it will be removed
 
       def allowed_identifier?(name)
-        allowed_identifiers.include?(name.to_s.delete(SIGILS))
+        !allowed_identifiers.empty? && allowed_identifiers.include?(name.to_s.delete(SIGILS))
       end
 
       def allowed_identifiers
-        cop_config.fetch('AllowedIdentifiers', [])
+        cop_config.fetch('AllowedIdentifiers') { [] }
       end
     end
   end

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     # This module encapsulates the ability to allow certain methods when
-    # parsing.
+    # parsing. Even if the code is in offense, if it contains methods
+    # that are allowed. This module is equivalent to the IgnoredMethods module,
+    # which will be deprecated in RuboCop 2.0.
     module AllowedMethods
       private
 
@@ -17,16 +19,21 @@ module RuboCop
 
       # @api public
       def allowed_methods
-        deprecated_values = cop_config_deprecated_values
-        if deprecated_values.any?(Regexp)
-          cop_config.fetch('AllowedMethods', [])
+        if cop_config_deprecated_values.any?(Regexp)
+          cop_config_allowed_methods
         else
-          Array(cop_config['AllowedMethods']).concat(deprecated_values)
+          cop_config_allowed_methods + cop_config_deprecated_values
         end
       end
 
+      def cop_config_allowed_methods
+        @cop_config_allowed_methods ||= Array(cop_config.fetch('AllowedMethods', []))
+      end
+
       def cop_config_deprecated_values
-        Array(cop_config['IgnoredMethods']).concat(Array(cop_config['ExcludedMethods']))
+        @cop_config_deprecated_values ||=
+          Array(cop_config.fetch('IgnoredMethods', [])) +
+          Array(cop_config.fetch('ExcludedMethods', []))
       end
     end
     # @deprecated IgnoredMethods class has been replaced with AllowedMethods.

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

@@ -30,15 +30,23 @@ module RuboCop
       def allowed_patterns
         # Since there could be a pattern specified in the default config, merge the two
         # arrays together.
-        patterns = Array(cop_config['AllowedPatterns']).concat(Array(cop_config['IgnoredPatterns']))
-        deprecated_values = cop_config_deprecated_methods_values
-        return patterns unless deprecated_values.any?(Regexp)
+        if cop_config_deprecated_methods_values.any?(Regexp)
+          cop_config_patterns_values + cop_config_deprecated_methods_values
+        else
+          cop_config_patterns_values
+        end
+      end
 
-        Array(patterns.concat(deprecated_values))
+      def cop_config_patterns_values
+        @cop_config_patterns_values ||=
+          Array(cop_config.fetch('AllowedPatterns', [])) +
+          Array(cop_config.fetch('IgnoredPatterns', []))
       end
 
       def cop_config_deprecated_methods_values
-        Array(cop_config['IgnoredMethods']).concat(Array(cop_config['ExcludedMethods']))
+        @cop_config_deprecated_methods_values ||=
+          Array(cop_config.fetch('IgnoredMethods', [])) +
+          Array(cop_config.fetch('ExcludedMethods', []))
       end
     end
 

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to allow certain receivers in a cop.
+    module AllowedReceivers
+      def allowed_receiver?(receiver)
+        receiver_name = receiver_name(receiver)
+
+        allowed_receivers.include?(receiver_name)
+      end
+
+      def receiver_name(receiver)
+        if receiver.receiver && !receiver.receiver.const_type?
+          return receiver_name(receiver.receiver)
+        end
+
+        if receiver.send_type?
+          if receiver.receiver
+            "#{receiver_name(receiver.receiver)}.#{receiver.method_name}"
+          else
+            receiver.method_name.to_s
+          end
+        else
+          receiver.source
+        end
+      end
+
+      def allowed_receivers
+        cop_config.fetch('AllowedReceivers', [])
+      end
+    end
+  end
+end

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

@@ -29,7 +29,7 @@ module RuboCop
 
       # Returns the range bounds for just the annotation
       def bounds
-        start = comment.loc.expression.begin_pos + margin.length
+        start = comment.source_range.begin_pos + margin.length
         length = [keyword, colon, space].reduce(0) { |len, elem| len + elem.to_s.length }
         [start, start + length]
       end
@@ -41,18 +41,25 @@ module RuboCop
       def split_comment(comment)
         # Sort keywords by reverse length so that if a keyword is in a phrase
         # but also on its own, both will match properly.
-        keywords_regex = Regexp.new(
-          Regexp.union(keywords.sort_by { |w| -w.length }).source,
-          Regexp::IGNORECASE
-        )
-        regex = /^(# ?)(\b#{keywords_regex}\b)(\s*:)?(\s+)?(\S+)?/i
-
         match = comment.text.match(regex)
         return false unless match
 
         match.captures
       end
 
+      KEYWORDS_REGEX_CACHE = {} # rubocop:disable Style/MutableConstant
+      private_constant :KEYWORDS_REGEX_CACHE
+
+      def regex
+        KEYWORDS_REGEX_CACHE[keywords] ||= begin
+          keywords_regex = Regexp.new(
+            Regexp.union(keywords.sort_by { |w| -w.length }).source,
+            Regexp::IGNORECASE
+          )
+          /^(# ?)(\b#{keywords_regex}\b)(\s*:)?(\s+)?(\S+)?/i
+        end
+      end
+
       def keyword_appearance?
         keyword && (colon || space)
       end

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

@@ -220,7 +220,7 @@ module RuboCop
       def already_on_multiple_lines?(node)
         return node.first_line != node.arguments.last.last_line if node.def_type?
 
-        node.first_line != node.last_line
+        !node.single_line?
       end
     end
   end

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

@@ -36,7 +36,7 @@ module RuboCop
         length = calculator.calculate
         return if length <= max_length
 
-        location = node.casgn_type? ? node.loc.name : node.loc.expression
+        location = node.casgn_type? ? node.loc.name : node.source_range
 
         add_offense(location, message: message(length, max_length)) { self.max = length }
       end