rubocop 1.81.1 → 1.82.1

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -52,32 +52,39 @@ module RuboCop
           scope.variables.each_value { |variable| check_for_unused_assignments(variable) }
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
         def check_for_unused_assignments(variable)
           return if variable.should_be_unused?
 
           variable.assignments.reverse_each do |assignment|
-            assignment_node = assignment.node
-            next if assignment.used? || part_of_ignored_node?(assignment_node)
+            check_for_unused_assignment(variable, assignment)
+          end
+        end
 
-            message = message_for_useless_assignment(assignment)
-            range = offense_range(assignment)
+        def check_for_unused_assignment(variable, assignment)
+          assignment_node = assignment.node
 
-            add_offense(range, message: message) do |corrector|
-              # In cases like `x = 1, y = 2`, where removing a variable would cause a syntax error,
-              # and where changing `x ||= 1` to `x = 1` would cause `NameError`,
-              # the autocorrect will be skipped, even if the variable is unused.
-              if sequential_assignment?(assignment_node) || assignment_node.parent&.or_asgn_type?
-                next
-              end
+          return if ignored_assignment?(variable, assignment_node, assignment)
 
-              autocorrect(corrector, assignment)
-            end
+          message = message_for_useless_assignment(assignment)
+          range = offense_range(assignment)
 
-            ignore_node(assignment_node) if chained_assignment?(assignment_node)
+          add_offense(range, message: message) do |corrector|
+            # In cases like `x = 1, y = 2`, where removing a variable would cause a syntax error,
+            # and where changing `x ||= 1` to `x = 1` would cause `NameError`,
+            # the autocorrect will be skipped, even if the variable is unused.
+            next if sequential_assignment?(assignment_node) ||
+                    assignment_node.parent&.or_asgn_type?
+
+            autocorrect(corrector, assignment)
           end
+
+          ignore_node(assignment_node) if chained_assignment?(assignment_node)
+        end
+
+        def ignored_assignment?(variable, assignment_node, assignment)
+          assignment.used? || part_of_ignored_node?(assignment_node) ||
+            variable_in_loop_condition?(assignment_node, variable)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
@@ -208,6 +215,27 @@ module RuboCop
         def remove_local_variable_assignment_part(corrector, node)
           corrector.replace(node, node.expression.source)
         end
+
+        def variable_in_loop_condition?(assignment_node, variable)
+          return false if assignment_node.each_ancestor(:any_def).any?
+
+          loop_node = assignment_node.each_ancestor.find do |ancestor|
+            ancestor.type?(*VariableForce::LOOP_TYPES)
+          end
+
+          return false unless loop_node.respond_to?(:condition)
+
+          condition_node = loop_node.condition
+          variable_name = variable.name
+
+          return true if condition_node.lvar_type? && condition_node.children.first == variable_name
+
+          condition_node.each_descendant(:lvar) do |lvar_node|
+            return true if lvar_node.children.first == variable_name
+          end
+
+          false
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/useless_or.rb

@@ -9,6 +9,13 @@ module RuboCop
       # on `nil` (e.g. `nil.to_i` evaluates to `0`). Therefore, OR expressions
       # appended after these methods will never evaluate.
       #
+      # @safety
+      #   As shown in the examples below, there are generally two possible ways to correct the
+      #   offense, but this cop’s autocorrection always chooses the option that preserves the
+      #   current behavior. While this does not change how the code behaves, that option is not
+      #   necessarily the appropriate fix in every situation. For this reason, the autocorrection
+      #   provided by this cop is considered unsafe.
+      #
       # @example
       #
       #   # bad
@@ -64,6 +71,8 @@ module RuboCop
       #   x&.to_s or fallback
       #
       class UselessOr < Base
+        extend AutoCorrector
+
         MSG = '`%<rhs>s` will never evaluate because `%<lhs>s` always returns a truthy value.'
 
         TRUTHY_RETURN_VALUE_METHODS = Set[:to_a, :to_c, :to_d, :to_i, :to_f, :to_h, :to_r,
@@ -89,8 +98,12 @@ module RuboCop
         private
 
         def report_offense(or_node, truthy_node)
-          add_offense(or_node.loc.operator.join(or_node.rhs.source_range),
-                      message: format(MSG, lhs: truthy_node.source, rhs: or_node.rhs.source))
+          add_offense(
+            or_node.loc.operator.join(or_node.rhs.source_range),
+            message: format(MSG, lhs: truthy_node.source, rhs: or_node.rhs.source)
+          ) do |corrector|
+            corrector.replace(or_node, or_node.lhs.source)
+          end
         end
       end
     end

data/lib/rubocop/cop/lint/utils/nil_receiver_checker.rb

@@ -31,7 +31,7 @@ module RuboCop
             @checked_nodes[node] = true
 
             case node.type
-            when :def, :class, :module, :sclass
+            when :def, :defs, :class, :module, :sclass
               return false
             when :send
               return non_nil_method?(node.method_name) if node.receiver == receiver

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

@@ -84,7 +84,10 @@ module RuboCop
           end
 
           def assignment?(node)
-            return compound_assignment(node) if node.masgn_type? || node.shorthand_asgn?
+            if node.masgn_type? || node.shorthand_asgn?
+              compound_assignment(node)
+              return false
+            end
 
             node.for_type? ||
               (node.respond_to?(:setter_method?) && node.setter_method?) ||
@@ -101,8 +104,6 @@ module RuboCop
               child.respond_to?(:setter_method?) && !child.setter_method?
             end
             @assignment += will_be_miscounted
-
-            false
           end
 
           def simple_assignment?(node)

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

@@ -14,6 +14,8 @@ module RuboCop
       private
 
       def too_long?(node)
+        return false unless max_line_length
+
         lines = processed_source.lines[(node.first_line - 1)...node.last_line]
         to_single_line(lines.join("\n")).length > max_line_length
       end
@@ -27,10 +29,6 @@ module RuboCop
           .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 }
 

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

@@ -59,7 +59,7 @@ module RuboCop
         return node.loc.name if node.casgn_type?
 
         if LSP.enabled?
-          end_range = node.loc.respond_to?(:name) ? node.loc.name : node.loc.begin
+          end_range = node.loc?(:name) ? node.loc.name : node.loc.begin
           node.source_range.begin.join(end_range)
         else
           node.source_range

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

@@ -13,7 +13,7 @@ module RuboCop
 
       DefNode = Struct.new(:node) do
         def selector
-          if node.loc.respond_to?(:selector)
+          if node.loc?(:selector)
             node.loc.selector
           else
             node.loc.keyword

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

@@ -8,8 +8,27 @@ module RuboCop
 
       private
 
-      def ignore_cop_directives?
-        config.for_cop('Layout/LineLength')['IgnoreCopDirectives']
+      def allow_rbs_inline_annotation?
+        config.for_cop('Layout/LineLength')['AllowRBSInlineAnnotation']
+      end
+
+      def rbs_inline_annotation_on_source_line?(line_index)
+        source_line_number = line_index + processed_source.buffer.first_line
+        comment = processed_source.comment_at_line(source_line_number)
+
+        return false unless comment
+
+        comment.text.start_with?(/#:|#\[.+\]|#\|/)
+      end
+
+      def allow_cop_directives?
+        # TODO: This logic for backward compatibility with deprecated `IgnoreCopDirectives` option.
+        # The following three lines will be removed in RuboCop 2.0.
+        ignore_cop_directives = config.for_cop('Layout/LineLength')['IgnoreCopDirectives']
+        return true if ignore_cop_directives
+        return false if ignore_cop_directives == false
+
+        config.for_cop('Layout/LineLength')['AllowCopDirectives']
       end
 
       def directive_on_source_line?(line_index)

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

@@ -73,7 +73,7 @@ module RuboCop
 
       def location(node)
         if LSP.enabled?
-          end_range = node.loc.respond_to?(:name) ? node.loc.name : node.loc.begin
+          end_range = node.loc?(:name) ? node.loc.name : node.loc.begin
           node.source_range.begin.join(end_range)
         else
           node.source_range

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

@@ -200,7 +200,7 @@ module RuboCop
       end
 
       def grouped_expression?(node)
-        node.begin_type? && node.loc.respond_to?(:begin) && node.loc.begin
+        node.begin_type? && node.loc?(:begin) && node.loc.begin
       end
 
       def inside_arg_list_parentheses?(node, ancestor)

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

@@ -127,7 +127,7 @@ module RuboCop
         parent ||= node
 
         if node.respond_to?(:loc) &&
-           node.loc.respond_to?(:heredoc_end) &&
+           node.loc?(:heredoc_end) &&
            node.loc.heredoc_end.last_line >= parent.last_line
           return true
         end

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

@@ -8,8 +8,8 @@ module RuboCop
       MSG = 'Space missing after %<token>s.'
 
       def on_new_investigation
-        each_missing_space(processed_source.tokens) do |token|
-          add_offense(token.pos, message: format(MSG, token: kind(token))) do |corrector|
+        each_missing_space(processed_source.tokens) do |token, kind|
+          add_offense(token.pos, message: format(MSG, token: kind)) do |corrector|
             PunctuationCorrector.add_space(corrector, token)
           end
         end
@@ -19,11 +19,12 @@ module RuboCop
 
       def each_missing_space(tokens)
         tokens.each_cons(2) do |token1, token2|
-          next unless kind(token1)
+          kind = kind(token1, token2)
+          next unless kind
           next unless space_missing?(token1, token2)
           next unless space_required_before?(token2)
 
-          yield token1
+          yield token1, kind
         end
       end
 

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

@@ -100,12 +100,6 @@ module RuboCop
         node.parent.send_type?
       end
 
-      def max_line_length
-        return unless config.cop_enabled?('Layout/LineLength')
-
-        config.for_cop('Layout/LineLength')['Max']
-      end
-
       def comment_disables_cop?(comment)
         regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
         Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)

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

@@ -95,13 +95,16 @@ module RuboCop
         node.multiline? && !allowed_multiline_argument?(node)
       end
 
+      # rubocop:disable Metrics/AbcSize
       def method_name_and_arguments_on_same_line?(node)
-        return false unless node.call_type?
+        return false if !node.call_type? || node.last_line != node.last_argument.last_line
+        return true if node.last_argument.hash_type? && node.last_argument.braces?
 
-        line = node.loc.selector.nil? ? node.loc.line : node.loc.selector.line
+        line = node.loc.selector&.line || node.loc.line
 
-        line == node.last_argument.last_line && node.last_line == node.last_argument.last_line
+        line == node.last_argument.last_line
       end
+      # rubocop:enable Metrics/AbcSize
 
       # A single argument with the closing bracket on the same line as the end
       # of the argument is not considered multiline, even if the argument
@@ -185,7 +188,7 @@ module RuboCop
 
       def heredoc?(node)
         return false unless node.is_a?(RuboCop::AST::Node)
-        return true if node.loc.respond_to?(:heredoc_body)
+        return true if node.loc?(:heredoc_body)
 
         return heredoc_send?(node) if node.send_type?
 

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

@@ -147,7 +147,9 @@ module RuboCop
         alias on_defs on_def
 
         def on_alias(node)
-          handle_method_name(node.new_identifier, node.new_identifier.value)
+          return unless (new_identifier = node.new_identifier).sym_type?
+
+          handle_method_name(new_identifier, new_identifier.value)
         end
 
         private
@@ -232,7 +234,7 @@ module RuboCop
         end
 
         def range_position(node)
-          if node.loc.respond_to?(:selector)
+          if node.loc?(:selector)
             selector_end_pos = node.loc.selector.end_pos + 1
             expr_end_pos = node.source_range.end_pos
 

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

@@ -193,8 +193,7 @@ module RuboCop
             return_values << extract_return_value(return_node)
           end
 
-          last_value = last_value(node)
-          return_values << last_value if last_value
+          return_values << last_value(node)
 
           process_return_values(return_values)
         end
@@ -247,8 +246,9 @@ module RuboCop
         end
 
         def last_value(node)
-          value = node.begin_type? ? node.children.last : node
-          value&.return_type? ? extract_return_value(value) : value
+          value = node.begin_type? ? node.children.last || s(:nil) : node
+
+          value.return_type? ? extract_return_value(value) : value
         end
 
         def process_return_values(return_values)

data/lib/rubocop/cop/security/json_load.rb

@@ -6,22 +6,40 @@ module RuboCop
       # Checks for the use of JSON class methods which have potential
       # security issues.
       #
+      # `JSON.load` and similar methods allow deserialization of arbitrary ruby objects:
+      #
+      # [source,ruby]
+      # ----
+      # require 'json/add/string'
+      # result = JSON.load('{ "json_class": "String", "raw": [72, 101, 108, 108, 111] }')
+      # pp result # => "Hello"
+      # ----
+      #
+      # Never use `JSON.load` for untrusted user input. Prefer `JSON.parse` unless you have
+      # a concrete use-case for `JSON.load`.
+      #
+      # NOTE: Starting with `json` gem version 2.8.0, triggering this behavior without explicitly
+      # passing the `create_additions` keyword argument emits a deprecation warning, with the
+      # goal of being secure by default in the next major version 3.0.0.
+      #
       # @safety
       #   This cop's autocorrection is unsafe because it's potentially dangerous.
-      #   If using a stream, like `JSON.load(open('file'))`, it will need to call
+      #   If using a stream, like `JSON.load(open('file'))`, you will need to call
       #   `#read` manually, like `JSON.parse(open('file').read)`.
-      #   If reading single values (rather than proper JSON objects), like
-      #   `JSON.load('false')`, it will need to pass the `quirks_mode: true`
-      #   option, like `JSON.parse('false', quirks_mode: true)`.
       #   Other similar issues may apply.
       #
       # @example
       #   # bad
-      #   JSON.load("{}")
-      #   JSON.restore("{}")
+      #   JSON.load('{}')
+      #   JSON.restore('{}')
       #
       #   # good
-      #   JSON.parse("{}")
+      #   JSON.parse('{}')
+      #   JSON.unsafe_load('{}')
+      #
+      #   # good - explicit use of `create_additions` option
+      #   JSON.load('{}', create_additions: true)
+      #   JSON.load('{}', create_additions: false)
       #
       class JSONLoad < Base
         extend AutoCorrector
@@ -29,13 +47,17 @@ module RuboCop
         MSG = 'Prefer `JSON.parse` over `JSON.%<method>s`.'
         RESTRICT_ON_SEND = %i[load restore].freeze
 
-        # @!method json_load(node)
-        def_node_matcher :json_load, <<~PATTERN
-          (send (const {nil? cbase} :JSON) ${:load :restore} ...)
+        # @!method insecure_json_load(node)
+        def_node_matcher :insecure_json_load, <<~PATTERN
+          (
+            send (const {nil? cbase} :JSON) ${:load :restore}
+            ...
+            !(hash `(sym $:create_additions))
+          )
         PATTERN
 
         def on_send(node)
-          json_load(node) do |method|
+          insecure_json_load(node) do |method|
             add_offense(node.loc.selector, message: format(MSG, method: method)) do |corrector|
               corrector.replace(node.loc.selector, 'parse')
             end

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

@@ -95,7 +95,7 @@ module RuboCop
           $(call
             {
               (begin (send $_ :& $_))
-              (call $_ :intersection $_)
+              (call $!nil? :intersection $_)
             }
             $%1
           )
@@ -107,7 +107,7 @@ module RuboCop
             $(call
               {
                 (begin (send $_ :& $_))
-                (call $_ :intersection $_)
+                (call $!nil? :intersection $_)
               }
               %ARRAY_SIZE_METHODS
             )

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

@@ -41,8 +41,7 @@ module RuboCop
 
         def check(node)
           return if node.heredoc?
-          return unless node.loc.respond_to?(:begin)
-          return unless node.loc.begin
+          return unless node.loc?(:begin)
 
           source = node.loc.begin.source
           if requires_percent_q?(source)

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

@@ -3,31 +3,36 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of the case equality operator(===).
+      # Checks for uses of the case equality operator (`===`).
       #
       # If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of
       # the case equality operator is a constant.
-
+      #
       # If `AllowOnSelfClass` option is enabled, the cop will ignore violations when the receiver of
       # the case equality operator is `self.class`. Note intermediate variables are not accepted.
       #
+      # NOTE: Regexp case equality (`/regexp/ === var`) is allowed because changing it to
+      # `/regexp/.match?(var)` needs to take into account `Regexp.last_match?`, `$~`, `$1`, etc.
+      # This potentially incompatible transformation is handled by `Performance/RegexpMatch` cop.
+      #
       # @example
       #   # bad
       #   (1..100) === 7
-      #   /something/ === some_string
       #
       #   # good
-      #   something.is_a?(Array)
       #   (1..100).include?(7)
-      #   /something/.match?(some_string)
       #
       # @example AllowOnConstant: false (default)
       #   # bad
       #   Array === something
       #
+      #   # good
+      #   something.is_a?(Array)
+      #
       # @example AllowOnConstant: true
       #   # good
       #   Array === something
+      #   something.is_a?(Array)
       #
       # @example AllowOnSelfClass: false (default)
       #   # bad
@@ -51,7 +56,7 @@ module RuboCop
 
         def on_send(node)
           case_equality?(node) do |lhs, rhs|
-            return if lhs.const_type? && !lhs.module_name?
+            return if lhs.regexp_type? || (lhs.const_type? && !lhs.module_name?)
 
             add_offense(node.loc.selector) do |corrector|
               replacement = replacement(lhs, rhs)
@@ -71,13 +76,6 @@ module RuboCop
 
         def replacement(lhs, rhs)
           case lhs.type
-          when :regexp
-            # The automatic correction from `a === b` to `a.match?(b)` needs to
-            # consider `Regexp.last_match?`, `$~`, `$1`, and etc.
-            # This correction is expected to be supported by `Performance/Regexp` cop.
-            # See: https://github.com/rubocop/rubocop-performance/issues/152
-            #
-            # So here is noop.
           when :begin
             begin_replacement(lhs, rhs)
           when :const

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

@@ -183,6 +183,7 @@ module RuboCop
 
         def check_nested_style(node)
           return unless compact_node_name?(node)
+          return if node.parent&.type?(:class, :module)
 
           add_offense(node.loc.name, message: NESTED_MSG) do |corrector|
             autocorrect(corrector, node)

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

@@ -213,9 +213,7 @@ module RuboCop
         ASSIGN_TO_CONDITION_MSG = 'Assign variables inside of conditionals.'
         VARIABLE_ASSIGNMENT_TYPES = %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
         ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES + %i[and_asgn or_asgn op_asgn masgn].freeze
-        LINE_LENGTH = 'Layout/LineLength'
         ENABLED = 'Enabled'
-        MAX = 'Max'
         SINGLE_LINE_CONDITIONS_ONLY = 'SingleLineConditionsOnly'
 
         # The shovel operator `<<` does not have its own type. It is a `send`
@@ -399,7 +397,7 @@ module RuboCop
         # of the longest line + the length of the corrected assignment is
         # greater than the max configured line length
         def correction_exceeds_line_limit?(node, branches)
-          return false unless line_length_cop_enabled?
+          return false unless config.cop_enabled?('Layout/LineLength')
 
           assignment = lhs(tail(branches[0]))
 
@@ -417,14 +415,6 @@ module RuboCop
           assignment + longest_line
         end
 
-        def line_length_cop_enabled?
-          config.for_cop(LINE_LENGTH)[ENABLED]
-        end
-
-        def max_line_length
-          config.for_cop(LINE_LENGTH)[MAX]
-        end
-
         def single_line_conditions_only?
           cop_config[SINGLE_LINE_CONDITIONS_ONLY]
         end
@@ -444,7 +434,7 @@ module RuboCop
             next if child.parent.dstr_type?
 
             white_space = white_space_range(child, column)
-            corrector.remove(white_space) if white_space.source.strip.empty?
+            corrector.remove(white_space) if white_space
           end
 
           if condition.loc.else && !same_line?(condition.else_branch, condition)
@@ -465,9 +455,13 @@ module RuboCop
 
         def white_space_range(node, column)
           expression = node.source_range
-          begin_pos = expression.begin_pos - (expression.column - column - 2)
+          end_pos = expression.begin_pos
+          begin_pos = end_pos - (expression.column - column - 2)
+
+          return nil if begin_pos > end_pos
 
-          Parser::Source::Range.new(expression.source_buffer, begin_pos, expression.begin_pos)
+          white_space = Parser::Source::Range.new(expression.source_buffer, begin_pos, end_pos)
+          white_space if white_space.source.strip.empty?
         end
 
         def assignment(node)

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

@@ -29,25 +29,30 @@ module RuboCop
       # @example IgnoreModules: false (default)
       #   # bad
       #   class Foo
-      #     MyClass = Struct.new()
+      #     MyClass = Struct.new
       #   end
       #
       #   # good
       #   class Foo
-      #     MyClass = Struct.new()
+      #     MyClass = Struct.new
       #     public_constant :MyClass
       #   end
       #
       # @example IgnoreModules: true
       #   # good
       #   class Foo
-      #     MyClass = Struct.new()
+      #     MyClass = Struct.new
       #   end
       #
       class ConstantVisibility < Base
         MSG = 'Explicitly make `%<constant_name>s` public or private using ' \
               'either `#public_constant` or `#private_constant`.'
 
+        # @!method visibility_declaration_for(node)
+        def_node_matcher :visibility_declaration_for, <<~PATTERN
+          (send nil? {:public_constant :private_constant} $...)
+        PATTERN
+
         def on_casgn(node)
           return unless class_or_module_scope?(node)
           return if visibility_declaration?(node)
@@ -77,20 +82,20 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
         def visibility_declaration?(node)
           node.parent.each_child_node(:send).any? do |child|
-            visibility_declaration_for?(child, node.name)
-          end
-        end
+            next false unless (arguments = visibility_declaration_for(child))
 
-        # @!method visibility_declaration_for?(node, const_name)
-        def_node_matcher :visibility_declaration_for?, <<~PATTERN
-          (send nil? {:public_constant :private_constant} ({sym str} #match_name?(%1)))
-        PATTERN
+            arguments = arguments.first.children.first.to_a if arguments.first&.splat_type?
+            constant_values = arguments.map do |argument|
+              argument.value.to_sym if argument.respond_to?(:value)
+            end
 
-        def match_name?(name, constant_name)
-          name.to_sym == constant_name.to_sym
+            constant_values.include?(node.name)
+          end
         end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end