rubocop 1.25.1 → 1.27.0

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks if `include` or `prepend` is called in `refine` block.
+      # These methods are deprecated and should be replaced with `Refinement#import_methods`.
+      #
+      # It emulates deprecation warnings in Ruby 3.1.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because `include M` will affect the included class
+      #   if any changes are made to module `M`.
+      #   On the other hand, `import_methods M` uses a snapshot of method definitions,
+      #   thus it will not be affected if module `M` changes.
+      #
+      # @example
+      #
+      #   # bad
+      #   refine Foo do
+      #     include Bar
+      #   end
+      #
+      #   # bad
+      #   refine Foo do
+      #     prepend Bar
+      #   end
+      #
+      #   # good
+      #   refine Foo do
+      #     import_methods Bar
+      #   end
+      #
+      class RefinementImportMethods < Base
+        extend TargetRubyVersion
+
+        MSG = 'Use `import_methods` instead of `%<current>s` because it is deprecated in Ruby 3.1.'
+        RESTRICT_ON_SEND = %i[include prepend].freeze
+
+        minimum_target_ruby_version 3.1
+
+        def on_send(node)
+          return if node.receiver
+          return unless node.parent.block_type? && node.parent.method?(:refine)
+
+          add_offense(node.loc.selector, message: format(MSG, current: node.method_name))
+        end
+      end
+    end
+  end
+end

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

@@ -57,10 +57,20 @@ module RuboCop
 
           outer_local_variable = variable_table.find_variable(variable.name)
           return unless outer_local_variable
+          return if same_conditions_node_different_branch?(variable, outer_local_variable)
 
           message = format(MSG, variable: variable.name)
           add_offense(variable.declaration_node, message: message)
         end
+
+        def same_conditions_node_different_branch?(variable, outer_local_variable)
+          variable_node = variable.scope.node.parent
+          return false unless variable_node.conditional?
+
+          outer_local_variable_node = outer_local_variable.scope.node
+
+          outer_local_variable_node.conditional? && variable_node == outer_local_variable_node
+        end
       end
     end
   end

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

@@ -147,13 +147,14 @@ module RuboCop
           # will be ignored.
           return unless node.value.to_s.match?(/\A[a-z0-9_]/i)
 
-          correction = node.value.inspect.delete_prefix(':')
+          correction = node.value.inspect
+          correction = correction.delete_prefix(':') if node.parent.colon?
           return if properly_quoted?(node.source, correction)
 
           register_offense(
             node,
             correction: correction,
-            message: format(MSG, correction: "#{correction}:")
+            message: format(MSG, correction: node.parent.colon? ? "#{correction}:" : correction)
           )
         end
 

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

@@ -9,8 +9,7 @@ module RuboCop
         def on_other_file
           add_offense_from_error(processed_source.parser_error) if processed_source.parser_error
           processed_source.diagnostics.each do |diagnostic|
-            add_offense_from_diagnostic(diagnostic,
-                                        processed_source.ruby_version)
+            add_offense_from_diagnostic(diagnostic, processed_source.ruby_version)
           end
           super
         end

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

@@ -64,7 +64,7 @@ module RuboCop
 
         # @!method not_implemented?(node)
         def_node_matcher :not_implemented?, <<~PATTERN
-          {(send nil? :raise (const {nil? cbase} :NotImplementedError))
+          {(send nil? :raise (const {nil? cbase} :NotImplementedError) ...)
            (send nil? :fail ...)}
         PATTERN
 

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

@@ -51,20 +51,24 @@ module RuboCop
           node = node.block_node if node.block_literal?
 
           add_offense(node, message: format(MSG, count: count)) do |corrector|
-            next unless own_line?(node)
-
-            if never_process?(count, node)
-              remove_node(corrector, node)
-            elsif !proc_name.empty?
-              autocorrect_block_pass(corrector, node, proc_name)
-            else
-              autocorrect_block(corrector, node)
-            end
+            next if !own_line?(node) || node.parent&.send_type?
+
+            autocorrect(corrector, count, node, proc_name)
           end
         end
 
         private
 
+        def autocorrect(corrector, count, node, proc_name)
+          if never_process?(count, node)
+            remove_node(corrector, node)
+          elsif !proc_name.empty?
+            autocorrect_block_pass(corrector, node, proc_name)
+          else
+            autocorrect_block(corrector, node)
+          end
+        end
+
         def never_process?(count, node)
           count < 1 || (node.block_type? && node.body.nil?)
         end

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

@@ -101,8 +101,7 @@ module RuboCop
             children = node.masgn_type? ? node.children[0].children : node.children
 
             will_be_miscounted = children.count do |child|
-              child.respond_to?(:setter_method?) &&
-                !child.setter_method?
+              child.respond_to?(:setter_method?) && !child.setter_method?
             end
             @assignment += will_be_miscounted
 

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

@@ -4,8 +4,6 @@ module RuboCop
   module Cop
     # Help methods for working with nodes containing comments.
     module CommentsHelp
-      include VisibilityHelp
-
       def source_range_with_comment(node)
         begin_pos = begin_pos_with_comment(node)
         end_pos = end_position_for(node)
@@ -13,6 +11,13 @@ module RuboCop
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
+      def contains_comments?(node)
+        start_line = node.source_range.line
+        end_line = find_end_line(node)
+
+        processed_source.each_comment_in_lines(start_line...end_line).any?
+      end
+
       private
 
       def end_position_for(node)
@@ -37,6 +42,21 @@ module RuboCop
       def buffer
         processed_source.buffer
       end
+
+      # Returns the end line of a node, which might be a comment and not part of the AST
+      # End line is considered either the line at which another node starts, or
+      # the line at which the parent node ends.
+      def find_end_line(node)
+        if node.if_type? && node.loc.else
+          node.loc.else.line
+        elsif (next_sibling = node.right_sibling)
+          next_sibling.loc.line
+        elsif (parent = node.parent)
+          parent.loc.end.line
+        else
+          node.loc.end.line
+        end
+      end
     end
   end
 end

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

@@ -41,7 +41,7 @@ module RuboCop
       end
 
       def require_hash_value?(hash_key_source, node)
-        return true if require_hash_value_for_around_hash_literal?(node)
+        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?
@@ -65,9 +65,8 @@ module RuboCop
 
       def use_modifier_form_without_parenthesized_method_call?(ancestor)
         return false if ancestor.respond_to?(:parenthesized?) && ancestor.parenthesized?
-        return false unless (parent = ancestor.parent)
 
-        parent.respond_to?(:modifier_form?) && parent.modifier_form?
+        ancestor.ancestors.any? { |node| node.respond_to?(:modifier_form?) && node.modifier_form? }
       end
 
       def without_parentheses_call_expr_follows?(ancestor)

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

@@ -39,12 +39,7 @@ module RuboCop
           pos + indentation_difference(line)
         end
 
-        # Extend the end position until the start of the next word, if any.
-        # This allows for URIs that are wrapped in quotes or parens to be handled properly
-        # while not allowing additional words to be added after the URL.
-        if (match = line[end_position..line_length(line)]&.match(/^\S+(?=\s|$)/))
-          end_position += match.offset(0).last
-        end
+        end_position = extend_uri_end_position(line, end_position)
 
         return nil if begin_position < max_line_length && end_position < max_line_length
 
@@ -65,6 +60,22 @@ module RuboCop
         (line.index(/[^\t]/) || 0) * (tab_indentation_width - 1)
       end
 
+      def extend_uri_end_position(line, end_position)
+        # Extend the end position YARD comments with linked URLs of the form {<uri> <title>}
+        if line&.match(/{(\s|\S)*}$/)
+          match = line[end_position..line_length(line)]&.match(/(\s|\S)*}/)
+          end_position += match.offset(0).last
+        end
+
+        # Extend the end position until the start of the next word, if any.
+        # This allows for URIs that are wrapped in quotes or parens to be handled properly
+        # while not allowing additional words to be added after the URL.
+        if (match = line[end_position..line_length(line)]&.match(/^\S+(?=\s|$)/))
+          end_position += match.offset(0).last
+        end
+        end_position
+      end
+
       def tab_indentation_width
         config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
           config.for_cop('Layout/IndentationWidth')['Width']

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

@@ -29,7 +29,9 @@ module RuboCop
       #   b c { block }.            <-- b is indented relative to a
       #   d                         <-- d is indented relative to a
       def left_hand_side(lhs)
-        lhs = lhs.parent while lhs.parent&.send_type? && lhs.parent.loc.dot
+        while lhs.parent&.send_type? && lhs.parent.loc.dot && !lhs.parent.assignment_method?
+          lhs = lhs.parent
+        end
         lhs
       end
 
@@ -194,8 +196,7 @@ module RuboCop
 
       def not_for_this_cop?(node)
         node.ancestors.any? do |ancestor|
-          grouped_expression?(ancestor) ||
-            inside_arg_list_parentheses?(node, ancestor)
+          grouped_expression?(ancestor) || inside_arg_list_parentheses?(node, ancestor)
         end
       end
 

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

@@ -44,7 +44,8 @@ module RuboCop
         if extra_space?(left_token, :left) && !start_ok
           space_offense(node, left_token, :right, message, NO_SPACE_COMMAND)
         end
-        return if !extra_space?(right_token, :right) || end_ok
+        return if (!extra_space?(right_token, :right) || end_ok) ||
+                  (autocorrect_with_disable_uncorrectable? && !start_ok)
 
         space_offense(node, right_token, :left, message, NO_SPACE_COMMAND)
       end
@@ -58,7 +59,8 @@ module RuboCop
         unless extra_space?(left_token, :left) || start_ok
           space_offense(node, left_token, :none, message, SPACE_COMMAND)
         end
-        return if extra_space?(right_token, :right) || end_ok
+        return if (extra_space?(right_token, :right) || end_ok) ||
+                  (autocorrect_with_disable_uncorrectable? && !start_ok)
 
         space_offense(node, right_token, :none, message, SPACE_COMMAND)
       end

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

@@ -107,7 +107,7 @@ module RuboCop
         def use_block_argument_as_local_variable?(node, last_argument)
           return if node.body.nil?
 
-          node.body.each_descendant(:lvar).any? do |lvar|
+          node.body.each_descendant(:lvar, :lvasgn).any? do |lvar|
             !lvar.parent.block_pass_type? && lvar.source == last_argument
           end
         end

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

@@ -7,17 +7,21 @@ module RuboCop
       # potential security issues leading to remote code execution when
       # loading from an untrusted source.
       #
+      # NOTE: Ruby 3.1+ (Psych 4) uses `Psych.load` as `Psych.safe_load` by default.
+      #
       # @safety
       #   The behaviour of the code might change depending on what was
       #   in the YAML payload, since `YAML.safe_load` is more restrictive.
       #
       # @example
       #   # bad
-      #   YAML.load("--- foo")
+      #   YAML.load("--- !ruby/object:Foo {}") # Psych 3 is unsafe by default
       #
       #   # good
-      #   YAML.safe_load("--- foo")
-      #   YAML.dump("foo")
+      #   YAML.safe_load("--- !ruby/object:Foo {}", [Foo])                    # Ruby 2.5  (Psych 3)
+      #   YAML.safe_load("--- !ruby/object:Foo {}", permitted_classes: [Foo]) # Ruby 3.0- (Psych 3)
+      #   YAML.load("--- !ruby/object:Foo {}", permitted_classes: [Foo])      # Ruby 3.1+ (Psych 4)
+      #   YAML.dump(foo)
       #
       class YAMLLoad < Base
         extend AutoCorrector
@@ -31,6 +35,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return if target_ruby_version >= 3.1
+
           yaml_load(node) do
             add_offense(node.loc.selector) do |corrector|
               corrector.replace(node.loc.selector, 'safe_load')

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

@@ -11,27 +11,33 @@ module RuboCop
       #
       #   # bad
       #   def foo()
-      #     # does a thing
+      #     do_something
       #   end
       #
       #   # good
       #   def foo
-      #     # does a thing
+      #     do_something
       #   end
       #
-      #   # also good
-      #   def foo() does_a_thing end
+      #   # bad
+      #   def foo() = do_something
+      #
+      #   # good
+      #   def foo = do_something
+      #
+      #   # good (without parentheses it's a syntax error)
+      #   def foo() do_something end
       #
       # @example
       #
       #   # bad
       #   def Baz.foo()
-      #     # does a thing
+      #     do_something
       #   end
       #
       #   # good
       #   def Baz.foo
-      #     # does a thing
+      #     do_something
       #   end
       class DefWithParentheses < Base
         extend AutoCorrector
@@ -39,12 +45,11 @@ module RuboCop
         MSG = "Omit the parentheses in defs when the method doesn't accept any arguments."
 
         def on_def(node)
-          return if node.single_line?
-          return unless !node.arguments? && (node_arguments_loc_begin = node.arguments.loc.begin)
+          return if node.single_line? && !node.endless?
+          return unless !node.arguments? && (node_arguments = node.arguments.source_range)
 
-          add_offense(node_arguments_loc_begin) do |corrector|
-            corrector.remove(node_arguments_loc_begin)
-            corrector.remove(node.arguments.loc.end)
+          add_offense(node_arguments) do |corrector|
+            corrector.remove(node_arguments)
           end
         end
         alias on_defs on_def

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

@@ -72,9 +72,14 @@ module RuboCop
         def end_of_method_definition?(node)
           return false unless (def_node = find_def_node_from_ascendant(node))
 
+          conditional_node = find_conditional_node_from_ascendant(node)
           last_child = find_last_child(def_node.body)
 
-          last_child.last_line == node.last_line
+          if conditional_node
+            double_negative_condition_return_value?(node, last_child, conditional_node)
+          else
+            last_child.last_line == node.last_line
+          end
         end
 
         def find_def_node_from_ascendant(node)
@@ -84,6 +89,13 @@ module RuboCop
           find_def_node_from_ascendant(node.parent)
         end
 
+        def find_conditional_node_from_ascendant(node)
+          return unless (parent = node.parent)
+          return parent if parent.conditional?
+
+          find_conditional_node_from_ascendant(parent)
+        end
+
         def find_last_child(node)
           case node.type
           when :rescue
@@ -94,6 +106,25 @@ module RuboCop
             node.child_nodes.last
           end
         end
+
+        def double_negative_condition_return_value?(node, last_child, conditional_node)
+          parent = find_parent_not_enumerable(node)
+          if parent.begin_type?
+            node.loc.line == parent.loc.last_line
+          else
+            last_child.last_line <= conditional_node.last_line
+          end
+        end
+
+        def find_parent_not_enumerable(node)
+          return unless (parent = node.parent)
+
+          if parent.pair_type? || parent.hash_type? || parent.array_type?
+            find_parent_not_enumerable(parent)
+          else
+            parent
+          end
+        end
       end
     end
   end

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

@@ -47,8 +47,7 @@ module RuboCop
           branch_bodies = [*case_node.when_branches.map(&:body), case_node.else_branch].compact
 
           return if branch_bodies.any? do |body|
-            body.return_type? ||
-            body.each_descendant.any?(&:return_type?)
+            body.return_type? || body.each_descendant.any?(&:return_type?)
           end
 
           add_offense(case_node.loc.keyword) { |corrector| autocorrect(corrector, case_node) }

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

@@ -5,6 +5,17 @@ module RuboCop
     module Style
       # Favor `File.(bin)write` convenience methods.
       #
+      # NOTE: There are different method signatures between `File.write` (class method)
+      # and `File#write` (instance method). The following case will be allowed because
+      # static analysis does not know the contents of the splat argument:
+      #
+      # [source,ruby]
+      # ----
+      # File.open(filename, 'w') do |f|
+      #   f.write(*objects)
+      # end
+      # ----
+      #
       # @example
       #   ## text mode
       #   # bad
@@ -85,6 +96,7 @@ module RuboCop
           content = send_write?(node) || block_write?(node) do |block_arg, lvar, write_arg|
             write_arg if block_arg == lvar
           end
+          return false if content&.splat_type?
 
           yield(content) if content
         end

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

@@ -38,6 +38,10 @@ module RuboCop
       #     end
       #   end
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because the scope of
+      #   variables is different between `each` and `for`.
+      #
       class For < Base
         include ConfigurableEnforcedStyle
         include RangeHelp

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

@@ -22,45 +22,37 @@ module RuboCop
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
+        MSG = 'Prefer the use of `%<prefer>s` over `%<current>s`.'
         RESTRICT_ON_SEND = %i[call].freeze
 
         def on_send(node)
           return unless node.receiver
 
           if offense?(node)
-            add_offense(node) do |corrector|
+            prefer = prefer(node)
+            current = node.source
+
+            add_offense(node, message: format(MSG, prefer: prefer, current: current)) do |corrector|
               opposite_style_detected
-              autocorrect(corrector, node)
+              corrector.replace(node, prefer)
             end
           else
             correct_style_detected
           end
         end
 
-        def autocorrect(corrector, node)
-          if explicit_style?
-            receiver = node.receiver.source
-            replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
-
-            corrector.replace(node, replacement)
-          else
-            add_parentheses(node, corrector) unless node.parenthesized?
-            corrector.remove(node.loc.selector)
-          end
-        end
-
         private
 
         def offense?(node)
           (explicit_style? && node.implicit_call?) || (implicit_style? && !node.implicit_call?)
         end
 
-        def message(_node)
-          if explicit_style?
-            'Prefer the use of `lambda.call(...)` over `lambda.(...)`.'
-          else
-            'Prefer the use of `lambda.(...)` over `lambda.call(...)`.'
-          end
+        def prefer(node)
+          receiver = node.receiver.source
+          arguments = node.arguments.map(&:source).join(', ')
+          method = explicit_style? ? "call(#{arguments})" : "(#{arguments})"
+
+          "#{receiver}.#{method}"
         end
 
         def implicit_style?

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for nested `File.dirname`.
+      # It replaces nested `File.dirname` with the level argument introduced in Ruby 3.1.
+      #
+      # @example
+      #
+      #   # bad
+      #   File.dirname(File.dirname(path))
+      #
+      #   # good
+      #   File.dirname(path, 2)
+      #
+      class NestedFileDirname < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `dirname(%<path>s, %<level>s)` instead.'
+        RESTRICT_ON_SEND = %i[dirname].freeze
+
+        minimum_target_ruby_version 3.1
+
+        # @!method file_dirname?(node)
+        def_node_matcher :file_dirname?, <<~PATTERN
+          (send
+            (const {cbase nil?} :File) :dirname ...)
+        PATTERN
+
+        def on_send(node)
+          return if file_dirname?(node.parent) || !file_dirname?(node.first_argument)
+
+          path, level = path_with_dir_level(node, 1)
+          return if level < 2
+
+          message = format(MSG, path: path, level: level)
+          range = offense_range(node)
+
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, "dirname(#{path}, #{level})")
+          end
+        end
+
+        private
+
+        def path_with_dir_level(node, level)
+          first_argument = node.first_argument
+
+          if file_dirname?(first_argument)
+            level += 1
+            path_with_dir_level(first_argument, level)
+          else
+            [first_argument.source, level]
+          end
+        end
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -54,8 +54,9 @@ module RuboCop
         private
 
         def format_message(argument)
-          source = argument.source
-          format(MSG, original: source, replacement: source.sub(/\s+=/, ':'))
+          replacement = "#{argument.name}: #{argument.default_value.source}"
+
+          format(MSG, original: argument.source, replacement: replacement)
         end
       end
     end

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

@@ -107,8 +107,7 @@ module RuboCop
 
           first_arg = node.first_argument
 
-          return unless first_arg.send_type? && first_arg.method?(:new)
-          return if acceptable_exploded_args?(first_arg.arguments)
+          return if !use_new_method?(first_arg) || acceptable_exploded_args?(first_arg.arguments)
 
           return if allowed_non_exploded_type?(first_arg)
 
@@ -120,6 +119,10 @@ module RuboCop
           end
         end
 
+        def use_new_method?(first_arg)
+          first_arg.send_type? && first_arg.receiver && first_arg.method?(:new)
+        end
+
         def acceptable_exploded_args?(args)
           # Allow code like `raise Ex.new(arg1, arg2)`.
           return true if args.size > 1