rubocop 1.72.2 → 1.74.0

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

@@ -23,7 +23,7 @@ module RuboCop
           (call _ _)
           (args
             $(arg _key)
-            (arg _))
+            $(arg _))
           {
             $(send
               {(lvar _key) $_ _ | _ $_ (lvar _key)})
@@ -67,7 +67,7 @@ module RuboCop
       end
 
       def extracts_hash_subset?(block)
-        block_with_first_arg_check?(block) do |key_arg, send_node, method|
+        block_with_first_arg_check?(block) do |key_arg, value_arg, send_node, method|
           # Only consider methods that have one argument
           return false unless send_node.arguments.one?
 
@@ -76,15 +76,22 @@ module RuboCop
 
           case method
           when :include?, :exclude?
-            send_node.first_argument.source == key_arg.source
+            slices_key?(send_node, :first_argument, key_arg, value_arg)
           when :in?
-            send_node.receiver.source == key_arg.source
+            slices_key?(send_node, :receiver, key_arg, value_arg)
           else
             true
           end
         end
       end
 
+      def slices_key?(send_node, method, key_arg, value_arg)
+        return false if using_value_variable?(send_node, value_arg)
+
+        node = method == :receiver ? send_node.receiver : send_node.first_argument
+        node.source == key_arg.source
+      end
+
       def range_include?(send_node)
         # When checking `include?`, `exclude?` and `in?` for offenses, if the receiver
         # or first argument is a range, an offense should not be registered.
@@ -97,6 +104,14 @@ module RuboCop
         receiver.range_type?
       end
 
+      def using_value_variable?(send_node, value_arg)
+        # If the receiver of `include?` or `exclude?`, or the first argument of `in?` is the
+        # hash value block argument, an offense should not be registered.
+        # ie. `v.include?(k)` or `k.in?(v)`
+        (send_node.receiver.lvar_type? && send_node.receiver.name == value_arg.name) ||
+          (send_node.first_argument.lvar_type? && send_node.first_argument.name == value_arg.name)
+      end
+
       def supported_subset_method?(method)
         if active_support_extensions_enabled?
           ACTIVE_SUPPORT_SUBSET_METHODS.include?(method)

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

@@ -34,6 +34,18 @@ module RuboCop
         range_between(node.loc.begin.end_pos, node.loc.end.begin_pos)
       end
 
+      # A range containing the first to the last argument
+      # of a method call or method definition.
+      # def foo(a, b:)
+      #         ^^^^^
+      # bar(1, 2, 3, &blk)
+      #     ^^^^^^^^^^^^^
+      # baz { |x, y:, z:| }
+      #        ^^^^^^^^^
+      def arguments_range(node)
+        node.first_argument.source_range.join(node.last_argument.source_range)
+      end
+
       def range_between(start_pos, end_pos)
         Parser::Source::Range.new(processed_source.buffer, start_pos, end_pos)
       end

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

@@ -29,7 +29,7 @@ module RuboCop
         min = required_minimum_ruby_version || 0
         max = required_maximum_ruby_version || Float::INFINITY
 
-        min <= version && max >= version
+        version.between?(min, max)
       end
     end
   end

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     # Common methods shared by Style/TrailingCommaInArguments,
     # Style/TrailingCommaInArrayLiteral and Style/TrailingCommaInHashLiteral
+    # rubocop:disable Metrics/ModuleLength
     module TrailingComma
       include ConfigurableEnforcedStyle
       include RangeHelp
@@ -57,6 +58,8 @@ module RuboCop
           ', unless each item is on its own line'
         when :consistent_comma
           ', unless items are split onto multiple lines'
+        when :diff_comma
+          ', unless that item immediately precedes a newline'
         else
           ''
         end
@@ -68,6 +71,8 @@ module RuboCop
           multiline?(node) && no_elements_on_same_line?(node)
         when :consistent_comma
           multiline?(node) && !method_name_and_arguments_on_same_line?(node)
+        when :diff_comma
+          multiline?(node) && last_item_precedes_newline?(node)
         else
           false
         end
@@ -130,6 +135,12 @@ module RuboCop
         range1.last_line == range2.line
       end
 
+      def last_item_precedes_newline?(node)
+        after_last_item =
+          range_between(node.children.last.source_range.end_pos, node.loc.end.begin_pos)
+        after_last_item.source =~ /\A,?\s*\n/
+      end
+
       def avoid_comma(kind, comma_begin_pos, extra_info)
         range = range_between(comma_begin_pos, comma_begin_pos + 1)
         article = kind.include?('array') ? 'an' : 'a'
@@ -205,5 +216,6 @@ module RuboCop
         false
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/rubocop/cop/naming/variable_name.rb

@@ -3,8 +3,15 @@
 module RuboCop
   module Cop
     module Naming
-      # Makes sure that all variables use the configured style,
-      # snake_case or camelCase, for their names.
+      # Checks that the configured style (snake_case or camelCase) is used for all variable names.
+      # This includes local variables, instance variables, class variables, method arguments
+      # (positional, keyword, rest or block), and block arguments.
+      #
+      # The cop can also be configured to forbid using specific names for variables, using
+      # `ForbiddenIdentifiers` or `ForbiddenPatterns`. In addition to the above, this applies
+      # to global variables as well.
+      #
+      # Method definitions and method calls are not affected by this cop.
       #
       # @example EnforcedStyle: snake_case (default)
       #   # bad
@@ -26,7 +33,21 @@ module RuboCop
       #
       # @example AllowedPatterns: ['_v\d+\z']
       #   # good (with EnforcedStyle: camelCase)
-      #   :release_v1
+      #   release_v1 = true
+      #
+      # @example ForbiddenIdentifiers: ['fooBar']
+      #   # bad (in all cases)
+      #   fooBar = 1
+      #   @fooBar = 1
+      #   @@fooBar = 1
+      #   $fooBar = 1
+      #
+      # @example ForbiddenPatterns: ['_v\d+\z']
+      #   # bad (in all cases)
+      #   release_v1 = true
+      #   @release_v1 = true
+      #   @@release_v1 = true
+      #   $release_v1 = true
       #
       class VariableName < Base
         include AllowedIdentifiers
@@ -34,16 +55,21 @@ module RuboCop
         include AllowedPattern
 
         MSG = 'Use %<style>s for variable names.'
+        MSG_FORBIDDEN = '`%<identifier>s` is forbidden, use another name instead.'
 
         def valid_name?(node, name, given_style = style)
           super || matches_allowed_pattern?(name)
         end
 
         def on_lvasgn(node)
-          return unless node.name
-          return if allowed_identifier?(node.name)
+          return unless (name = node.name)
+          return if allowed_identifier?(name)
 
-          check_name(node, node.name, node.loc.name)
+          if forbidden_name?(name)
+            register_forbidden_name(node)
+          else
+            check_name(node, name, node.loc.name)
+          end
         end
         alias on_ivasgn    on_lvasgn
         alias on_cvasgn    on_lvasgn
@@ -56,11 +82,43 @@ module RuboCop
         alias on_blockarg  on_lvasgn
         alias on_lvar      on_lvasgn
 
+        # Only forbidden names are checked for global variable assignment
+        def on_gvasgn(node)
+          return unless (name = node.name)
+          return unless forbidden_name?(name)
+
+          register_forbidden_name(node)
+        end
+
         private
 
         def message(style)
           format(MSG, style: style)
         end
+
+        def forbidden_identifiers
+          cop_config.fetch('ForbiddenIdentifiers', [])
+        end
+
+        def forbidden_patterns
+          cop_config.fetch('ForbiddenPatterns', [])
+        end
+
+        def matches_forbidden_pattern?(name)
+          forbidden_patterns.any? { |pattern| Regexp.new(pattern).match?(name) }
+        end
+
+        def forbidden_name?(name)
+          name = name.to_s.delete(SIGILS)
+
+          (forbidden_identifiers.any? && forbidden_identifiers.include?(name)) ||
+            (forbidden_patterns.any? && matches_forbidden_pattern?(name))
+        end
+
+        def register_forbidden_name(node)
+          message = format(MSG_FORBIDDEN, identifier: node.name)
+          add_offense(node.loc.name, message: message)
+        end
       end
     end
   end

data/lib/rubocop/cop/style/accessor_grouping.rb

@@ -139,12 +139,16 @@ module RuboCop
           style == :separated
         end
 
+        def groupable_sibling_accessor?(node, sibling)
+          sibling.attribute_accessor? &&
+            sibling.method?(node.method_name) &&
+            node_visibility(sibling) == node_visibility(node) &&
+            groupable_accessor?(sibling) && !previous_line_comment?(sibling)
+        end
+
         def groupable_sibling_accessors(send_node)
           send_node.parent.each_child_node(:send).select do |sibling|
-            sibling.attribute_accessor? &&
-              sibling.method?(send_node.method_name) &&
-              node_visibility(sibling) == node_visibility(send_node) &&
-              groupable_accessor?(sibling) && !previous_line_comment?(sibling)
+            groupable_sibling_accessor?(send_node, sibling)
           end
         end
 
@@ -155,13 +159,23 @@ module RuboCop
 
         def preferred_accessors(node)
           if grouped_style?
+            return if skip_for_grouping?(node)
+
             accessors = groupable_sibling_accessors(node)
-            group_accessors(node, accessors) if node.loc == accessors.first.loc
+            if node.loc == accessors.first.loc || skip_for_grouping?(accessors.first)
+              group_accessors(node, accessors)
+            end
           else
             separate_accessors(node)
           end
         end
 
+        # Group after constants
+        def skip_for_grouping?(node)
+          node.right_siblings.any?(&:casgn_type?) &&
+            node.right_siblings.any? { |n| n.send_type? && groupable_sibling_accessor?(node, n) }
+        end
+
         def group_accessors(node, accessors)
           accessor_names = accessors.flat_map { |accessor| accessor.arguments.map(&:source) }.uniq
 

data/lib/rubocop/cop/style/class_and_module_children.rb

@@ -3,14 +3,26 @@
 module RuboCop
   module Cop
     module Style
-      # Checks the style of children definitions at classes and
-      # modules. Basically there are two different styles:
+      # Checks that namespaced classes and modules are defined with a consistent style.
+      #
+      # With `nested` style, classes and modules should be defined separately (one constant
+      # on each line, without `::`). With `compact` style, classes and modules should be
+      # defined with fully qualified names (using `::` for namespaces).
+      #
+      # NOTE: The style chosen will affect `Module.nesting` for the class or module. Using
+      # `nested` style will result in each level being added, whereas `compact` style will
+      # only include the fully qualified class or module name.
+      #
+      # By default, `EnforcedStyle` applies to both classes and modules. If desired, separate
+      # styles can be defined for classes and modules by using `EnforcedStyleForClasses` and
+      # `EnforcedStyleForModules` respectively. If not set, or set to nil, the `EnforcedStyle`
+      # value will be used.
       #
       # @safety
       #   Autocorrection is unsafe.
       #
-      #   Moving from compact to nested children requires knowledge of whether the
-      #   outer parent is a module or a class. Moving from nested to compact requires
+      #   Moving from `compact` to `nested` children requires knowledge of whether the
+      #   outer parent is a module or a class. Moving from `nested` to `compact` requires
       #   verification that the outer parent is defined elsewhere. RuboCop does not
       #   have the knowledge to perform either operation safely and thus requires
       #   manual oversight.
@@ -42,16 +54,18 @@ module RuboCop
         def on_class(node)
           return if node.parent_class && style != :nested
 
-          check_style(node, node.body)
+          check_style(node, node.body, style_for_classes)
         end
 
         def on_module(node)
-          check_style(node, node.body)
+          check_style(node, node.body, style_for_modules)
         end
 
         private
 
         def nest_or_compact(corrector, node)
+          style = node.class_type? ? style_for_classes : style_for_modules
+
           if style == :nested
             nest_definition(corrector, node)
           else
@@ -141,7 +155,7 @@ module RuboCop
           node.source_range.source_line[/\A\s*/]
         end
 
-        def check_style(node, body)
+        def check_style(node, body, style)
           return if node.identifier.namespace&.cbase_type?
 
           if style == :nested
@@ -183,6 +197,14 @@ module RuboCop
         def compact_node_name?(node)
           node.identifier.source.include?('::')
         end
+
+        def style_for_classes
+          cop_config['EnforcedStyleForClasses'] || style
+        end
+
+        def style_for_modules
+          cop_config['EnforcedStyleForModules'] || style
+        end
       end
     end
   end

data/lib/rubocop/cop/style/commented_keyword.rb

@@ -9,8 +9,8 @@ module RuboCop
       # These keywords are: `class`, `module`, `def`, `begin`, `end`.
       #
       # Note that some comments
-      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
-      # and RBS::Inline annotation comments are allowed.
+      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`),
+      # RBS::Inline annotation, and Steep annotation (`steep:ignore`) are allowed.
       #
       # Autocorrection removes comments from `end` keyword and keeps comments
       # for `class`, `module`, `def` and `begin` above the keyword.
@@ -57,9 +57,11 @@ module RuboCop
 
         REGEXP = /(?<keyword>\S+).*#/.freeze
 
-        SUBCLASS_DEFINITION = /\A\s*class\s+\w+\s*<\s*\w+/.freeze
+        SUBCLASS_DEFINITION = /\A\s*class\s+(\w|::)+\s*<\s*(\w|::)+/.freeze
         METHOD_DEFINITION = /\A\s*def\s/.freeze
 
+        STEEP_REGEXP = /#\ssteep:ignore(\s|\z)/.freeze
+
         def on_new_investigation
           processed_source.comments.each do |comment|
             next unless offensive?(comment) && (match = source_line(comment).match(REGEXP))
@@ -86,6 +88,7 @@ module RuboCop
         def offensive?(comment)
           line = source_line(comment)
           return false if rbs_inline_annotation?(line, comment)
+          return false if steep_annotation?(comment)
 
           KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
             ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
@@ -105,6 +108,10 @@ module RuboCop
             false
           end
         end
+
+        def steep_annotation?(comment)
+          comment.text.match?(STEEP_REGEXP)
+        end
       end
     end
   end

data/lib/rubocop/cop/style/comparable_between.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for logical comparison which can be replaced with `Comparable#between?`.
+      #
+      # NOTE: `Comparable#between?` is on average slightly slower than logical comparison,
+      # although the difference generally isn't observable. If you require maximum
+      # performance, consider using logical comparison.
+      #
+      # @example
+      #
+      #   # bad
+      #   x >= min && x <= max
+      #
+      #   # bad
+      #   x <= max && x >= min
+      #
+      #   # good
+      #   x.between?(min, max)
+      #
+      class ComparableBetween < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `%<prefer>s` over logical comparison.'
+
+        # @!method logical_comparison_between_by_min_first?(node)
+        def_node_matcher :logical_comparison_between_by_min_first?, <<~PATTERN
+          (and
+            (send
+              {$_value :>= $_min | $_min :<= $_value})
+            (send
+              {$_value :<= $_max | $_max :>= $_value}))
+        PATTERN
+
+        # @!method logical_comparison_between_by_max_first?(node)
+        def_node_matcher :logical_comparison_between_by_max_first?, <<~PATTERN
+          (and
+            (send
+              {$_value :<= $_max | $_max :>= $_value})
+            (send
+              {$_value :>= $_min | $_min :<= $_value}))
+        PATTERN
+
+        def on_and(node)
+          logical_comparison_between_by_min_first?(node) do |*args|
+            min_and_value, max_and_value = args.each_slice(2).to_a
+
+            register_offense(node, min_and_value, max_and_value)
+          end
+
+          logical_comparison_between_by_max_first?(node) do |*args|
+            max_and_value, min_and_value = args.each_slice(2).to_a
+
+            register_offense(node, min_and_value, max_and_value)
+          end
+        end
+
+        private
+
+        def register_offense(node, min_and_value, max_and_value)
+          value = (min_and_value & max_and_value).first
+          min = min_and_value.find { _1 != value }
+          max = max_and_value.find { _1 != value }
+
+          prefer = "#{value.source}.between?(#{min.source}, #{max.source})"
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/double_negation.rb

@@ -109,7 +109,7 @@ module RuboCop
         end
 
         def define_method?(node)
-          return false unless node.block_type?
+          return false unless node.any_block_type?
 
           child = node.child_nodes.first
           return false unless child.send_type?