rubocop 1.18.0 → 1.56.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks uses of the `then` keyword
+      # Checks uses of the `then` keyword
       # in multi-line when statements.
       #
       # @example
@@ -39,9 +39,7 @@ module RuboCop
 
           range = node.loc.begin
           add_offense(range) do |corrector|
-            corrector.remove(
-              range_with_surrounding_space(range: range, side: :left, newlines: false)
-            )
+            corrector.remove(range_with_surrounding_space(range, side: :left, newlines: false))
           end
         end
 
@@ -54,7 +52,7 @@ module RuboCop
           end
           return false unless when_node.body
 
-          when_node.loc.line == when_node.body.loc.line
+          same_line?(when_node, when_node.body)
         end
 
         def accept_node_type?(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks against comparing a variable with multiple items, where
+      # Checks against comparing a variable with multiple items, where
       # `Array#include?`, `Set#include?` or a `case` could be used instead
       # to avoid code repetition.
       # It accepts comparisons of multiple method calls to avoid unnecessary method calls
@@ -40,6 +40,15 @@ module RuboCop
       #
       #   # good
       #   foo if [b.lightweight, b.heavyweight].include?(a)
+      #
+      # @example ComparisonsThreshold: 2 (default)
+      #   # bad
+      #   foo if a == 'a' || a == 'b'
+      #
+      # @example ComparisonsThreshold: 3
+      #   # good
+      #   foo if a == 'a' || a == 'b'
+      #
       class MultipleComparison < Base
         extend AutoCorrector
 
@@ -58,6 +67,7 @@ module RuboCop
           return unless node == root_of_or_node
           return unless nested_variable_comparison?(root_of_or_node)
           return if @allowed_method_comparison
+          return if @compared_elements.size < comparisons_threshold
 
           add_offense(node) do |corrector|
             elements = @compared_elements.join(', ')
@@ -151,6 +161,10 @@ module RuboCop
         def allow_method_comparison?
           cop_config.fetch('AllowMethodComparison', true)
         end
+
+        def comparisons_threshold
+          cop_config.fetch('ComparisonsThreshold', 2)
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks whether some constant value isn't a
+      # Checks whether some constant value isn't a
       # mutable literal (e.g. array or hash).
       #
       # Strict mode can be used to freeze all constants, rather than
@@ -14,8 +14,25 @@ module RuboCop
       # positives. Luckily, there is no harm in freezing an already
       # frozen object.
       #
+      # From Ruby 3.0, this cop honours the magic comment
+      # 'shareable_constant_value'. When this magic comment is set to any
+      # acceptable value other than none, it will suppress the offenses
+      # raised by this cop. It enforces frozen state.
+      #
       # NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
       #
+      # NOTE: From Ruby 3.0, interpolated strings are not frozen when
+      # `# frozen-string-literal: true` is used, so this cop enforces explicit
+      # freezing for such strings.
+      #
+      # NOTE: From Ruby 3.0, this cop allows explicit freezing of constants when
+      # the `shareable_constant_value` directive is used.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe since any mutations on objects that
+      #   are made frozen will change from being accepted to raising `FrozenError`,
+      #   and will need to be manually refactored.
+      #
       # @example EnforcedStyle: literals (default)
       #   # bad
       #   CONST = [1, 2, 3]
@@ -52,7 +69,55 @@ module RuboCop
       #       puts 1
       #     end
       #   end.freeze
+      #
+      # @example
+      #   # Magic comment - shareable_constant_value: literal
+      #
+      #   # bad
+      #   CONST = [1, 2, 3]
+      #
+      #   # good
+      #   # shareable_constant_value: literal
+      #   CONST = [1, 2, 3]
+      #
       class MutableConstant < Base
+        # Handles magic comment shareable_constant_value with O(n ^ 2) complexity
+        # n - number of lines in the source
+        # Iterates over all lines before a CONSTANT
+        # until it reaches shareable_constant_value
+        module ShareableConstantValue
+          module_function
+
+          def recent_shareable_value?(node)
+            shareable_constant_comment = magic_comment_in_scope node
+            return false if shareable_constant_comment.nil?
+
+            shareable_constant_value = MagicComment.parse(shareable_constant_comment)
+                                                   .shareable_constant_value
+            shareable_constant_value_enabled? shareable_constant_value
+          end
+
+          # Identifies the most recent magic comment with valid shareable constant values
+          # that's in scope for this node
+          def magic_comment_in_scope(node)
+            processed_source_till_node(node).reverse_each.find do |line|
+              MagicComment.parse(line).valid_shareable_constant_value?
+            end
+          end
+
+          private
+
+          def processed_source_till_node(node)
+            processed_source.lines[0..(node.last_line - 1)]
+          end
+
+          def shareable_constant_value_enabled?(value)
+            %w[literal experimental_everything experimental_copy].include? value
+          end
+        end
+        private_constant :ShareableConstantValue
+
+        include ShareableConstantValue
         include FrozenStringLiteral
         include ConfigurableEnforcedStyle
         extend AutoCorrector
@@ -61,13 +126,12 @@ module RuboCop
 
         def on_casgn(node)
           _scope, _const_name, value = *node
-          on_assignment(value)
-        end
+          if value.nil? # This is only the case for `CONST += ...` or similarg66
+            parent = node.parent
+            return unless parent.or_asgn_type? # We only care about `CONST ||= ...`
 
-        def on_or_asgn(node)
-          lhs, value = *node
-
-          return unless lhs&.casgn_type?
+            value = parent.children.last
+          end
 
           on_assignment(value)
         end
@@ -86,18 +150,18 @@ module RuboCop
           return if immutable_literal?(value)
           return if operation_produces_immutable_object?(value)
           return if frozen_string_literal?(value)
+          return if shareable_constant_value?(value)
 
           add_offense(value) { |corrector| autocorrect(corrector, value) }
         end
 
         def check(value)
           range_enclosed_in_parentheses = range_enclosed_in_parentheses?(value)
-
           return unless mutable_literal?(value) ||
-                        target_ruby_version <= 2.7 && range_enclosed_in_parentheses
+                        (target_ruby_version <= 2.7 && range_enclosed_in_parentheses)
 
-          return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
-                    frozen_string_literals_enabled?
+          return if frozen_string_literal?(value)
+          return if shareable_constant_value?(value)
 
           add_offense(value) { |corrector| autocorrect(corrector, value) }
         end
@@ -118,18 +182,19 @@ module RuboCop
         end
 
         def mutable_literal?(value)
-          return false if value.nil?
           return false if frozen_regexp_or_range_literals?(value)
 
           value.mutable_literal?
         end
 
         def immutable_literal?(node)
-          node.nil? || frozen_regexp_or_range_literals?(node) || node.immutable_literal?
+          frozen_regexp_or_range_literals?(node) || node.immutable_literal?
         end
 
-        def frozen_string_literal?(node)
-          FROZEN_STRING_LITERAL_TYPES.include?(node.type) && frozen_string_literals_enabled?
+        def shareable_constant_value?(node)
+          return false if target_ruby_version < 3.0
+
+          recent_shareable_value? node
         end
 
         def frozen_regexp_or_range_literals?(node)

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

@@ -90,7 +90,7 @@ module RuboCop
         end
 
         def correct_style?(node)
-          style == :prefix && node.modifier_form? || style == :postfix && !node.modifier_form?
+          (style == :prefix && node.modifier_form?) || (style == :postfix && !node.modifier_form?)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of `if-else` and ternary operators with a negated condition
+      # Checks for uses of `if-else` and ternary operators with a negated condition
       # which can be simplified by inverting condition and swapping branches.
       #
       # @example
@@ -48,12 +48,11 @@ module RuboCop
 
         def on_if(node)
           return unless if_else?(node)
-
-          condition = node.condition
+          return unless (condition = unwrap_begin_nodes(node.condition))
           return if double_negation?(condition) || !negated_condition?(condition)
 
-          type = node.ternary? ? 'ternary' : 'if-else'
-          add_offense(node, message: format(MSG, type: type)) do |corrector|
+          message = message(node)
+          add_offense(node, message: message) do |corrector|
             unless corrected_ancestor?(node)
               correct_negated_condition(corrector, condition)
               swap_branches(corrector, node)
@@ -71,11 +70,23 @@ module RuboCop
           !node.elsif? && else_branch && (!else_branch.if_type? || !else_branch.elsif?)
         end
 
+        def unwrap_begin_nodes(node)
+          node = node.children.first while node && (node.begin_type? || node.kwbegin_type?)
+
+          node
+        end
+
         def negated_condition?(node)
           node.send_type? &&
             (node.negation_method? || NEGATED_EQUALITY_METHODS.include?(node.method_name))
         end
 
+        def message(node)
+          type = node.ternary? ? 'ternary' : 'if-else'
+
+          format(MSG, type: type)
+        end
+
         def corrected_ancestor?(node)
           node.each_ancestor(:if).any? { |ancestor| @corrected_nodes&.include?(ancestor) }
         end
@@ -97,11 +108,7 @@ module RuboCop
           if node.if_branch.nil?
             corrector.remove(range_by_whole_lines(node.loc.else, include_final_newline: true))
           else
-            if_range = if_range(node)
-            else_range = else_range(node)
-
-            corrector.replace(if_range, else_range.source)
-            corrector.replace(else_range, if_range.source)
+            corrector.swap(if_range(node), else_range(node))
           end
         end
 
@@ -110,7 +117,7 @@ module RuboCop
           if node.ternary?
             node.if_branch
           else
-            range_between(node.condition.loc.expression.end_pos, node.loc.else.begin_pos)
+            range_between(node.condition.source_range.end_pos, node.loc.else.begin_pos)
           end
         end
 

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

@@ -80,7 +80,7 @@ module RuboCop
         end
 
         def correct_style?(node)
-          style == :prefix && node.modifier_form? || style == :postfix && !node.modifier_form?
+          (style == :prefix && node.modifier_form?) || (style == :postfix && !node.modifier_form?)
         end
       end
     end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # 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/nested_modifier.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for nested use of if, unless, while and until in their
+      # Checks for nested use of if, unless, while and until in their
       # modifier form.
       #
       # @example

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

@@ -3,8 +3,12 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for unparenthesized method calls in the argument list
+      # Checks for unparenthesized method calls in the argument list
       # of a parenthesized method call.
+      # `be`, `be_a`, `be_an`, `be_between`, `be_falsey`, `be_kind_of`, `be_instance_of`,
+      # `be_truthy`, `be_within`, `eq`, `eql`, `end_with`, `include`, `match`, `raise_error`,
+      # `respond_to`, and `start_with` methods are allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # good
@@ -12,6 +16,11 @@ module RuboCop
       #
       #   # bad
       #   method1(method2 arg)
+      #
+      # @example AllowedMethods: [foo]
+      #   # good
+      #   method1(foo arg)
+      #
       class NestedParenthesizedCalls < Base
         include RangeHelp
         include AllowedMethods
@@ -44,7 +53,7 @@ module RuboCop
           last_arg = nested.last_argument.source_range
 
           leading_space =
-            range_with_surrounding_space(range: first_arg.begin,
+            range_with_surrounding_space(first_arg.begin,
                                          side: :left,
                                          whitespace: true,
                                          continuations: true)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for nested ternary op expressions.
+      # Checks for nested ternary op expressions.
       #
       # @example
       #   # bad
@@ -17,6 +17,8 @@ module RuboCop
       #   end
       class NestedTernaryOperator < Base
         extend AutoCorrector
+        include RangeHelp
+        include IgnoredNode
 
         MSG = 'Ternary operators must not be nested. Prefer `if` or `else` constructs instead.'
 
@@ -26,14 +28,10 @@ module RuboCop
           node.each_descendant(:if).select(&:ternary?).each do |nested_ternary|
             add_offense(nested_ternary) do |corrector|
               if_node = if_node(nested_ternary)
+              next if part_of_ignored_node?(if_node)
 
-              corrector.replace(if_node, <<~RUBY.chop)
-                if #{if_node.condition.source}
-                  #{remove_parentheses(if_node.if_branch.source)}
-                else
-                  #{if_node.else_branch.source}
-                end
-              RUBY
+              autocorrect(corrector, if_node)
+              ignore_node(if_node)
             end
           end
         end
@@ -47,11 +45,25 @@ module RuboCop
           if_node(node)
         end
 
+        def autocorrect(corrector, if_node)
+          replace_loc_and_whitespace(corrector, if_node.loc.question, "\n")
+          replace_loc_and_whitespace(corrector, if_node.loc.colon, "\nelse\n")
+          corrector.replace(if_node.if_branch, remove_parentheses(if_node.if_branch.source))
+          corrector.wrap(if_node, 'if ', "\nend")
+        end
+
         def remove_parentheses(source)
           return source unless source.start_with?('(')
 
           source.delete_prefix('(').delete_suffix(')')
         end
+
+        def replace_loc_and_whitespace(corrector, range, replacement)
+          corrector.replace(
+            range_with_surrounding_space(range: range, whitespace: true),
+            replacement
+          )
+        end
       end
     end
   end

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

@@ -71,6 +71,8 @@ module RuboCop
           check(node)
         end
 
+        alias on_numblock on_block
+
         def on_while(node)
           check(node)
         end
@@ -185,7 +187,7 @@ module RuboCop
         end
 
         def end_followed_by_whitespace_only?(source_buffer, end_pos)
-          /\A\s*$/.match?(source_buffer.source[end_pos..-1])
+          /\A\s*$/.match?(source_buffer.source[end_pos..])
         end
 
         def reindentable_lines(node)
@@ -223,11 +225,7 @@ module RuboCop
           adjustment = delta + @reindented_lines[lineno]
           @reindented_lines[lineno] = adjustment
 
-          if adjustment.positive?
-            corrector.remove_leading(buffer.line_range(lineno), adjustment)
-          elsif adjustment.negative?
-            corrector.insert_before(buffer.line_range(lineno), ' ' * -adjustment)
-          end
+          corrector.remove_leading(buffer.line_range(lineno), adjustment) if adjustment.positive?
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for comparison of something with nil using `==` and
+      # Checks for comparison of something with nil using `==` and
       # `nil?`.
       #
       # Supported styles are: predicate, comparison.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for lambdas and procs that always return nil,
+      # Checks for lambdas and procs that always return nil,
       # which can be replaced with an empty lambda or proc instead.
       #
       # @example
@@ -43,8 +43,8 @@ module RuboCop
           { ({return next break} nil) (nil) }
         PATTERN
 
-        def on_block(node)
-          return unless node.lambda? || node.proc?
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless node.lambda_or_proc?
           return unless nil_return?(node.body)
 
           message = format(MSG, type: node.lambda? ? 'lambda' : 'proc')
@@ -57,9 +57,9 @@ module RuboCop
 
         def autocorrect(corrector, node)
           range = if node.single_line?
-                    range_with_surrounding_space(range: node.body.loc.expression)
+                    range_with_surrounding_space(node.body.source_range)
                   else
-                    range_by_whole_lines(node.body.loc.expression, include_final_newline: true)
+                    range_by_whole_lines(node.body.source_range, include_final_newline: true)
                   end
 
           corrector.remove(range)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for non-nil checks, which are usually redundant.
+      # Checks for non-nil checks, which are usually redundant.
       #
       # With `IncludeSemanticChanges` set to `false` by default, this cop
       # does not report offenses for `!x.nil?` and does no changes that might
@@ -63,7 +63,7 @@ module RuboCop
 
         def on_send(node)
           return if ignored_node?(node) ||
-                    !include_semantic_changes? && nil_comparison_style == 'comparison'
+                    (!include_semantic_changes? && nil_comparison_style == 'comparison')
           return unless register_offense?(node)
 
           message = message(node)
@@ -87,7 +87,7 @@ module RuboCop
 
         def register_offense?(node)
           not_equal_to_nil?(node) ||
-            include_semantic_changes? && (not_and_nil_check?(node) || unless_and_nil_check?(node))
+            (include_semantic_changes? && (not_and_nil_check?(node) || unless_and_nil_check?(node)))
         end
 
         def autocorrect(corrector, node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of the keyword `not` instead of `!`.
+      # Checks for uses of the keyword `not` instead of `!`.
       #
       # @example
       #
@@ -33,7 +33,7 @@ module RuboCop
           return unless node.prefix_not?
 
           add_offense(node.loc.selector) do |corrector|
-            range = range_with_surrounding_space(range: node.loc.selector, side: :right)
+            range = range_with_surrounding_space(node.loc.selector, side: :right)
 
             if opposite_method?(node.receiver)
               correct_opposite_method(corrector, range, node.receiver)
@@ -53,8 +53,8 @@ module RuboCop
 
         def requires_parens?(child)
           child.and_type? || child.or_type? ||
-            child.send_type? && child.binary_operation? ||
-            child.if_type? && child.ternary?
+            (child.send_type? && child.binary_operation?) ||
+            (child.if_type? && child.ternary?)
         end
 
         def correct_opposite_method(corrector, range, child)

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for numbered parameters.
+      #
+      # It can either restrict the use of numbered parameters to
+      # single-lined blocks, or disallow completely numbered parameters.
+      #
+      # @example EnforcedStyle: allow_single_line (default)
+      #   # bad
+      #   collection.each do
+      #     puts _1
+      #   end
+      #
+      #   # good
+      #   collection.each { puts _1 }
+      #
+      # @example EnforcedStyle: disallow
+      #   # bad
+      #   collection.each { puts _1 }
+      #
+      #   # good
+      #   collection.each { |item| puts item }
+      #
+      class NumberedParameters < Base
+        include ConfigurableEnforcedStyle
+        extend TargetRubyVersion
+
+        MSG_DISALLOW = 'Avoid using numbered parameters.'
+        MSG_MULTI_LINE = 'Avoid using numbered parameters for multi-line blocks.'
+
+        minimum_target_ruby_version 2.7
+
+        def on_numblock(node)
+          if style == :disallow
+            add_offense(node, message: MSG_DISALLOW)
+          elsif node.multiline?
+            add_offense(node, message: MSG_MULTI_LINE)
+          end
+        end
+      end
+    end
+  end
+end