rubocop 1.66.0 → 1.72.1

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Checks for code on multiple lines that could be rewritten on a single line
+    # without changing semantics or exceeding the `Max` parameter of `Layout/LineLength`.
+    module CheckSingleLineSuitability
+      def suitable_as_single_line?(node)
+        !too_long?(node) &&
+          !comment_within?(node) &&
+          safe_to_split?(node)
+      end
+
+      private
+
+      def too_long?(node)
+        lines = processed_source.lines[(node.first_line - 1)...node.last_line]
+        to_single_line(lines.join("\n")).length > max_line_length
+      end
+
+      def to_single_line(source)
+        source
+          .gsub(/" *\\\n\s*'/, %q(" + ')) # Double quote, backslash, and then single quote
+          .gsub(/' *\\\n\s*"/, %q(' + ")) # Single quote, backslash, and then double quote
+          .gsub(/(["']) *\\\n\s*\1/, '')  # Double or single quote, backslash, then same quote
+          .gsub(/\n\s*(?=(&)?\.\w)/, '')  # Extra space within method chaining which includes `&.`
+          .gsub(/\s*\\?\n\s*/, ' ')       # Any other line break, with or without backslash
+      end
+
+      def max_line_length
+        config.for_cop('Layout/LineLength')['Max']
+      end
+
+      def comment_within?(node)
+        comment_line_numbers = processed_source.comments.map { |comment| comment.loc.line }
+
+        comment_line_numbers.any? do |comment_line_number|
+          comment_line_number >= node.first_line && comment_line_number <= node.last_line
+        end
+      end
+
+      def safe_to_split?(node)
+        node.each_descendant(:if, :case, :kwbegin, :def, :defs).none? &&
+          node.each_descendant(:dstr, :str).none? { |n| n.heredoc? || n.value.include?("\n") } &&
+          node.each_descendant(:begin, :sym).none? { |b| !b.single_line? }
+      end
+    end
+  end
+end

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

@@ -16,6 +16,8 @@ module RuboCop
       end
 
       def comments_in_range(node)
+        return [] unless node.source_range
+
         start_line = node.source_range.line
         end_line = find_end_line(node)
 
@@ -71,13 +73,16 @@ module RuboCop
             node.else_branch.loc.line
           elsif node.elsif?
             node.each_ancestor(:if).find(&:if?).loc.end.line
+          elsif node.if? && node.parent && parentheses?(node.parent)
+            node.parent.loc.end.line
           end
-        elsif node.block_type? || node.numblock_type?
+        elsif node.any_block_type?
           node.loc.end.line
-        elsif (next_sibling = node.right_sibling) && next_sibling.is_a?(AST::Node)
+        elsif (next_sibling = node.right_sibling) && next_sibling.is_a?(AST::Node) &&
+              next_sibling.source_range
           next_sibling.loc.line
         elsif (parent = node.parent)
-          if parent.loc.respond_to?(:end) && parent.loc.end
+          if parent.loc?(:end)
             parent.loc.end.line
           else
             parent.loc.line

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Help methods for working with `Enumerable#dig` in cops.
+    # Used by `Style::DigChain` and `Style::SingleArgumentDig`
+    module DigHelp
+      extend NodePattern::Macros
+
+      # @!method dig?(node)
+      def_node_matcher :dig?, <<~PATTERN
+        (call _ :dig !{hash block_pass}+)
+      PATTERN
+
+      # @!method single_argument_dig?(node)
+      def_node_matcher :single_argument_dig?, <<~PATTERN
+        (send _ :dig $!splat)
+      PATTERN
+
+      private
+
+      def dig_chain_enabled?
+        @config.cop_enabled?('Style/DigChain')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for rewriting endless methods to normal method definitions
+    module EndlessMethodRewriter
+      def correct_to_multiline(corrector, node)
+        replacement = <<~RUBY.strip
+          def #{node.method_name}#{arguments(node)}
+            #{node.body.source}
+          end
+        RUBY
+
+        corrector.replace(node, replacement)
+      end
+
+      private
+
+      def arguments(node, missing = '')
+        node.arguments.any? ? node.arguments.source : missing
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module RuboCop
     module FrozenStringLiteral
       module_function
 
-      FROZEN_STRING_LITERAL = '# frozen_string_literal:'
+      FROZEN_STRING_LITERAL_REGEXP = /#\s*frozen[-_]?string[-_]?literal:/i.freeze
       FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'
       FROZEN_STRING_LITERAL_TYPES_RUBY27 = %i[str dstr].freeze
 
@@ -29,7 +29,9 @@ module RuboCop
       end
 
       def uninterpolated_string?(node)
-        node.str_type? || (node.dstr_type? && node.each_descendant(:begin).none?)
+        node.str_type? || (
+          node.dstr_type? && node.each_descendant(:begin, :ivar, :cvar, :gvar).none?
+        )
       end
 
       def uninterpolated_heredoc?(node)

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

@@ -11,6 +11,24 @@ module RuboCop
       DO_NOT_MIX_OMIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{OMIT_HASH_VALUE_MSG}"
       DO_NOT_MIX_EXPLICIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{EXPLICIT_HASH_VALUE_MSG}"
 
+      DefNode = Struct.new(:node) do
+        def selector
+          if node.loc.respond_to?(:selector)
+            node.loc.selector
+          else
+            node.loc.keyword
+          end
+        end
+
+        def first_argument
+          node.first_argument
+        end
+
+        def last_argument
+          node.last_argument
+        end
+      end
+
       def on_hash_for_mixed_shorthand(hash_node)
         return if ignore_mixed_hash_shorthand_syntax?(hash_node)
 
@@ -86,7 +104,7 @@ module RuboCop
         return true if !node.key.sym_type? || require_hash_value_for_around_hash_literal?(node)
 
         hash_value = node.value
-        return true unless hash_value.send_type? || hash_value.lvar_type?
+        return true unless hash_value.type?(:send, :lvar)
 
         hash_key_source != hash_value.source || hash_key_source.end_with?('!', '?')
       end
@@ -109,7 +127,7 @@ module RuboCop
         return if dispatch_node.parent && parentheses?(dispatch_node.parent)
         return if last_expression?(dispatch_node) && !method_dispatch_as_argument?(dispatch_node)
 
-        def_node = node.each_ancestor(:send, :csend, :super, :yield).first
+        def_node = node.each_ancestor(:call, :super, :yield).first
 
         DefNode.new(def_node) unless def_node && def_node.arguments.empty?
       end
@@ -117,7 +135,7 @@ module RuboCop
 
       def find_ancestor_method_dispatch_node(node)
         return unless (ancestor = node.parent.parent)
-        return unless ancestor.call_type? || ancestor.super_type? || ancestor.yield_type?
+        return unless ancestor.type?(:call, :super, :yield)
         return if brackets?(ancestor)
 
         ancestor
@@ -150,7 +168,7 @@ module RuboCop
         parent = method_dispatch_node.parent
         return false unless parent
 
-        parent.call_type? || parent.super_type? || parent.yield_type?
+        parent.type?(:call, :super, :yield)
       end
 
       def breakdown_value_types_of_hash(hash_node)
@@ -212,24 +230,6 @@ module RuboCop
           register_offense(pair_node, OMIT_HASH_VALUE_MSG, replacement)
         end
       end
-
-      DefNode = Struct.new(:node) do
-        def selector
-          if node.loc.respond_to?(:selector)
-            node.loc.selector
-          else
-            node.loc.keyword
-          end
-        end
-
-        def first_argument
-          node.first_argument
-        end
-
-        def last_argument
-          node.last_argument
-        end
-      end
     end
   end
   # rubocop:enable Metrics/ModuleLength

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

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Style/HashExcept and Style/HashSlice cops.
+    # It registers an offense on methods with blocks that are equivalent
+    # to Hash#except or Hash#slice.
+    # rubocop:disable Metrics/ModuleLength
+    module HashSubset
+      include RangeHelp
+      extend NodePattern::Macros
+
+      RESTRICT_ON_SEND = %i[reject select filter].freeze
+
+      SUBSET_METHODS = %i[== != eql? include?].freeze
+      ACTIVE_SUPPORT_SUBSET_METHODS = (SUBSET_METHODS + %i[in? exclude?]).freeze
+
+      MSG = 'Use `%<prefer>s` instead.'
+
+      # @!method block_with_first_arg_check?(node)
+      def_node_matcher :block_with_first_arg_check?, <<~PATTERN
+        (block
+          (call _ _)
+          (args
+            $(arg _key)
+            (arg _))
+          {
+            $(send
+              {(lvar _key) $_ _ | _ $_ (lvar _key)})
+            (send
+              $(send
+                {(lvar _key) $_ _ | _ $_ (lvar _key)}) :!)
+            })
+      PATTERN
+
+      def on_send(node)
+        offense_range, key_source = extract_offense(node)
+
+        return unless offense_range
+        return unless semantically_subset_method?(node)
+
+        preferred_method = "#{preferred_method_name}(#{key_source})"
+        add_offense(offense_range, message: format(MSG, prefer: preferred_method)) do |corrector|
+          corrector.replace(offense_range, preferred_method)
+        end
+      end
+      alias on_csend on_send
+
+      private
+
+      def semantically_subset_method?(node)
+        raise NotImplementedError
+      end
+
+      def preferred_method_name
+        raise NotImplementedError
+      end
+
+      def extract_offense(node)
+        block = node.parent
+        return unless extracts_hash_subset?(block)
+
+        except_key = except_key(block)
+        return if except_key.nil? || !safe_to_register_offense?(block, except_key)
+
+        [offense_range(node), except_key_source(except_key)]
+      end
+
+      def extracts_hash_subset?(block)
+        block_with_first_arg_check?(block) do |key_arg, send_node, method|
+          # Only consider methods that have one argument
+          return false unless send_node.arguments.one?
+
+          return false unless supported_subset_method?(method)
+          return false if range_include?(send_node)
+
+          case method
+          when :include?, :exclude?
+            send_node.first_argument.source == key_arg.source
+          when :in?
+            send_node.receiver.source == key_arg.source
+          else
+            true
+          end
+        end
+      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.
+        # ie. `(1..5).include?(k)` or `k.in?('a'..'z')`
+
+        return true if send_node.first_argument.range_type?
+
+        receiver = send_node.receiver
+        receiver = receiver.child_nodes.first while receiver.begin_type?
+        receiver.range_type?
+      end
+
+      def supported_subset_method?(method)
+        if active_support_extensions_enabled?
+          ACTIVE_SUPPORT_SUBSET_METHODS.include?(method)
+        else
+          SUBSET_METHODS.include?(method)
+        end
+      end
+
+      def semantically_except_method?(node)
+        block = node.parent
+        body, negated = extract_body_if_negated(block.body)
+
+        if node.method?('reject')
+          body.method?('==') || body.method?('eql?') || included?(body, negated)
+        else
+          body.method?('!=') || not_included?(body, negated)
+        end
+      end
+
+      def semantically_slice_method?(node)
+        !semantically_except_method?(node)
+      end
+
+      def included?(body, negated)
+        if negated
+          body.method?('exclude?')
+        else
+          body.method?('include?') || body.method?('in?')
+        end
+      end
+
+      def not_included?(body, negated)
+        included?(body, !negated)
+      end
+
+      def safe_to_register_offense?(block, except_key)
+        body = block.body
+
+        if body.method?('==') || body.method?('!=')
+          except_key.type?(:sym, :str)
+        else
+          true
+        end
+      end
+
+      def extract_body_if_negated(body)
+        if body.method?('!')
+          [body.receiver, true]
+        else
+          [body, false]
+        end
+      end
+
+      def except_key_source(key)
+        if key.array_type?
+          key = if key.percent_literal?
+                  key.each_value.map { |v| decorate_source(v) }
+                else
+                  key.each_value.map(&:source)
+                end
+          return key.join(', ')
+        end
+
+        key.literal? ? key.source : "*#{key.source}"
+      end
+
+      def decorate_source(value)
+        return ":\"#{value.source}\"" if value.dsym_type?
+        return "\"#{value.source}\"" if value.dstr_type?
+        return ":#{value.source}" if value.sym_type?
+
+        "'#{value.source}'"
+      end
+
+      def except_key(node)
+        key_arg = node.argument_list.first.source
+        body, = extract_body_if_negated(node.body)
+        lhs, _method_name, rhs = *body
+
+        lhs.source == key_arg ? rhs : lhs
+      end
+
+      def offense_range(node)
+        range_between(node.loc.selector.begin_pos, node.parent.loc.end.end_pos)
+      end
+    end
+    # rubocop:enable Metrics/ModuleLength
+  end
+end

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

@@ -9,6 +9,80 @@ module RuboCop
 
       RESTRICT_ON_SEND = %i[[] to_h].freeze
 
+      # Internal helper class to hold match data
+      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? &&
+            transforming_body_expr.children == [transformed_argname]
+        end
+
+        def transformation_uses_both_args?
+          transforming_body_expr.descendants.include?(unchanged_body_expr)
+        end
+
+        def use_transformed_argname?
+          transforming_body_expr.each_descendant(:lvar).any? do |node|
+            node.source == transformed_argname.to_s
+          end
+        end
+      end
+
+      # Internal helper class to hold autocorrect data
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, 'Hash['.length, ']'.length)
+        end
+
+        def self.from_map_to_h(node, match)
+          if node.parent&.block_type? && node.parent.send_node == node
+            strip_trailing_chars = 0
+          else
+            map_range = node.children.first.source_range
+            node_range = node.source_range
+            strip_trailing_chars = node_range.end_pos - map_range.end_pos
+          end
+
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def self.from_to_h(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.source_range
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object`
+            # case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          body_source = transforming_body_expr.source
+          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
+            body_source = "{ #{body_source} }"
+          end
+
+          corrector.replace(block_node.body, body_source)
+        end
+      end
+
       # @!method array_receiver?(node)
       def_node_matcher :array_receiver?, <<~PATTERN
         {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
@@ -113,80 +187,6 @@ module RuboCop
         correction.set_new_arg_name(captures.transformed_argname, corrector)
         correction.set_new_body_expression(captures.transforming_body_expr, corrector)
       end
-
-      # Internal helper class to hold match data
-      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
-        def noop_transformation?
-          transforming_body_expr.lvar_type? &&
-            transforming_body_expr.children == [transformed_argname]
-        end
-
-        def transformation_uses_both_args?
-          transforming_body_expr.descendants.include?(unchanged_body_expr)
-        end
-
-        def use_transformed_argname?
-          transforming_body_expr.each_descendant(:lvar).any? do |node|
-            node.source == transformed_argname.to_s
-          end
-        end
-      end
-
-      # Internal helper class to hold autocorrect data
-      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
-        def self.from_each_with_object(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def self.from_hash_brackets_map(node, match)
-          new(match, node.children.last, 'Hash['.length, ']'.length)
-        end
-
-        def self.from_map_to_h(node, match)
-          if node.parent&.block_type? && node.parent.send_node == node
-            strip_trailing_chars = 0
-          else
-            map_range = node.children.first.source_range
-            node_range = node.source_range
-            strip_trailing_chars = node_range.end_pos - map_range.end_pos
-          end
-
-          new(match, node.children.first, 0, strip_trailing_chars)
-        end
-
-        def self.from_to_h(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def strip_prefix_and_suffix(node, corrector)
-          expression = node.source_range
-          corrector.remove_leading(expression, leading)
-          corrector.remove_trailing(expression, trailing)
-        end
-
-        def set_new_method_name(new_method_name, corrector)
-          range = block_node.send_node.loc.selector
-          if (send_end = block_node.send_node.loc.end)
-            # If there are arguments (only true in the `each_with_object`
-            # case)
-            range = range.begin.join(send_end)
-          end
-          corrector.replace(range, new_method_name)
-        end
-
-        def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
-        end
-
-        def set_new_body_expression(transforming_body_expr, corrector)
-          body_source = transforming_body_expr.source
-          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
-            body_source = "{ #{body_source} }"
-          end
-
-          corrector.replace(block_node.body, body_source)
-        end
-      end
     end
   end
 end

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

@@ -37,12 +37,13 @@ module RuboCop
         last_uri_match = match_uris(line).last
         return nil unless last_uri_match
 
-        begin_position, end_position = last_uri_match.offset(0).map do |pos|
-          pos + indentation_difference(line)
-        end
-
+        begin_position, end_position = last_uri_match.offset(0)
         end_position = extend_uri_end_position(line, end_position)
 
+        line_indentation_difference = indentation_difference(line)
+        begin_position += line_indentation_difference
+        end_position += line_indentation_difference
+
         return nil if begin_position < max_line_length && end_position < max_line_length
 
         begin_position...end_position

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

@@ -35,7 +35,7 @@ module RuboCop
 
       # @!method define_method?(node)
       def_node_matcher :define_method?, <<~PATTERN
-        ({block numblock}
+        (any_block
          (send nil? :define_method ({sym str} $_)) _ _)
       PATTERN
 

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

@@ -121,12 +121,10 @@ module RuboCop
 
       def indented_keyword_expression(node)
         if node.for_type?
-          expression = node.collection
+          node.collection
         else
-          expression, = *node
+          node.children.first
         end
-
-        expression
       end
 
       def argument_in_method_call(node, kind) # rubocop:todo Metrics/CyclomaticComplexity
@@ -187,12 +185,10 @@ module RuboCop
 
       def assignment_rhs(node)
         case node.type
-        when :casgn   then _scope, _lhs, rhs = *node
-        when :op_asgn then _lhs, _op, rhs = *node
-        when :send, :csend then rhs = node.last_argument
-        else               _lhs, rhs = *node
+        when :casgn, :op_asgn then node.rhs
+        when :send, :csend    then node.last_argument
+        else                       node.children.last
         end
-        rhs
       end
 
       def not_for_this_cop?(node)

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

@@ -15,7 +15,7 @@ module RuboCop
         parent = node.parent
 
         parent&.send_type? && parent.arguments.include?(node) &&
-          !parent.parenthesized? && parent&.block_literal?
+          !parent.parenthesized? && parent.block_literal?
       end
 
       # Override to determine values that are invalid in a percent array

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

@@ -21,7 +21,7 @@ module RuboCop
       end
 
       def begin_source(node)
-        node.loc.begin.source if node.loc.respond_to?(:begin) && node.loc.begin
+        node.loc.begin.source if node.loc?(:begin)
       end
 
       def type(node)