rubocop 1.9.1 → 1.22.3

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

@@ -34,8 +34,7 @@ module RuboCop
           # interpolation should not be removed if the expanded value
           # contains a space character.
           expanded_value = autocorrected_value(final_node)
-          return if in_array_percent_literal?(begin_node) &&
-                    /\s/.match?(expanded_value)
+          return if in_array_percent_literal?(begin_node) && /\s/.match?(expanded_value)
 
           add_offense(final_node) do |corrector|
             return if final_node.dstr_type? # nested, fixed in next iteration
@@ -56,8 +55,7 @@ module RuboCop
 
         def special_keyword?(node)
           # handle strings like __FILE__
-          (node.str_type? && !node.loc.respond_to?(:begin)) ||
-            node.source_range.is?('__LINE__')
+          (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
         end
 
         def autocorrected_value(node)
@@ -101,8 +99,7 @@ module RuboCop
         # Does node print its own source when converted to a string?
         def prints_as_self?(node)
           node.basic_literal? ||
-            (COMPOSITE.include?(node.type) &&
-              node.children.all? { |child| prints_as_self?(child) })
+            (COMPOSITE.include?(node.type) && node.children.all? { |child| prints_as_self?(child) })
         end
 
         def space_literal?(node)

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

@@ -5,9 +5,10 @@ module RuboCop
     module Lint
       # This cop checks for uses of `begin...end while/until something`.
       #
-      # The cop is marked as unsafe because behaviour can change in some cases, including
-      # if a local variable inside the loop body is accessed outside of it, or if the
-      # loop body raises a `StopIteration` exception (which `Kernel#loop` rescues).
+      # @safety
+      #   The cop is unsafe because behaviour can change in some cases, including
+      #   if a local variable inside the loop body is accessed outside of it, or if the
+      #   loop body raises a `StopIteration` exception (which `Kernel#loop` rescues).
       #
       # @example
       #
@@ -49,8 +50,7 @@ module RuboCop
       class Loop < Base
         extend AutoCorrector
 
-        MSG = 'Use `Kernel#loop` with `break` rather than ' \
-              '`begin/end/until`(or `while`).'
+        MSG = 'Use `Kernel#loop` with `break` rather than `begin/end/until`(or `while`).'
 
         def on_while_post(node)
           register_offense(node)

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

@@ -45,41 +45,52 @@ module RuboCop
       class MissingCopEnableDirective < Base
         include RangeHelp
 
-        MSG = 'Re-enable %<cop>s cop with `# rubocop:enable` after ' \
-              'disabling it.'
-        MSG_BOUND = 'Re-enable %<cop>s cop within %<max_range>s lines after ' \
-                    'disabling it.'
+        MSG = 'Re-enable %<cop>s %<type>s with `# rubocop:enable` after disabling it.'
+        MSG_BOUND = 'Re-enable %<cop>s %<type>s within %<max_range>s lines after disabling it.'
 
-        # rubocop:disable Metrics/AbcSize
         def on_new_investigation
-          max_range = cop_config['MaximumRangeSize']
-          processed_source.disabled_line_ranges.each do |cop, line_ranges|
-            line_ranges.each do |line_range|
-              # This has to remain a strict inequality to handle
-              # the case when max_range is Float::INFINITY
-              next if line_range.max - line_range.min < max_range + 2
+          each_missing_enable do |cop, line_range|
+            # This has to remain a strict inequality to handle
+            # the case when max_range is Float::INFINITY
+            next if line_range.max - line_range.min < max_range + 2
 
-              range = source_range(processed_source.buffer,
-                                   line_range.min,
-                                   (0..0))
+            range = source_range(processed_source.buffer, line_range.min, (0..0))
+            comment = processed_source.comment_at_line(line_range.begin)
 
-              add_offense(range, message: message(max_range: max_range, cop: cop))
-            end
+            add_offense(range, message: message(cop, comment))
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
-        def message(max_range:, cop:)
+        def each_missing_enable
+          processed_source.disabled_line_ranges.each do |cop, line_ranges|
+            line_ranges.each { |line_range| yield cop, line_range }
+          end
+        end
+
+        def max_range
+          @max_range ||= cop_config['MaximumRangeSize']
+        end
+
+        def message(cop, comment, type = 'cop')
+          if department_enabled?(cop, comment)
+            type = 'department'
+            cop = cop.split('/').first
+          end
+
           if max_range == Float::INFINITY
-            format(MSG, cop: cop)
+            format(MSG, cop: cop, type: type)
           else
-            format(MSG_BOUND, cop: cop, max_range: max_range)
+            format(MSG_BOUND, cop: cop, type: type, max_range: max_range)
           end
         end
+
+        def department_enabled?(cop, comment)
+          DirectiveComment.new(comment).in_directive_department?(cop)
+        end
       end
     end
   end
 end
-# rubocop:enable Lint/RedundantCopDisableDirective, Layout/SpaceAroundOperators
+# rubocop:enable Lint/RedundantCopDisableDirective

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

@@ -53,8 +53,7 @@ module RuboCop
                                          singleton_method_added singleton_method_removed
                                          singleton_method_undefined].freeze
 
-        CALLBACKS = (CLASS_LIFECYCLE_CALLBACKS +
-                     METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
+        CALLBACKS = (CLASS_LIFECYCLE_CALLBACKS + METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
 
         def on_def(node)
           return unless offender?(node)

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

@@ -21,8 +21,7 @@ module RuboCop
       #   /(FOO)(BAR)/
       #
       class MixedRegexpCaptureTypes < Base
-        MSG = 'Do not mix named captures and numbered captures ' \
-              'in a Regexp literal.'
+        MSG = 'Do not mix named captures and numbered captures in a Regexp literal.'
 
         def on_regexp(node)
           return if node.interpolation?

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

@@ -11,14 +11,10 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   x < y < z
       #   10 <= x <= 20
       #
-      # @example
-      #
       #   # good
-      #
       #   x < y && y < z
       #   10 <= x && x <= 20
       class MultipleComparison < Base
@@ -26,14 +22,19 @@ module RuboCop
 
         MSG = 'Use the `&&` operator to compare multiple values.'
         COMPARISON_METHODS = %i[< > <= >=].freeze
+        SET_OPERATION_OPERATORS = %i[& | ^].freeze
         RESTRICT_ON_SEND = COMPARISON_METHODS
 
+        # @!method multiple_compare?(node)
         def_node_matcher :multiple_compare?, <<~PATTERN
           (send (send _ {:< :> :<= :>=} $_) {:#{COMPARISON_METHODS.join(' :')}} _)
         PATTERN
 
         def on_send(node)
           return unless (center = multiple_compare?(node))
+          # It allows multiple comparison using `&`, `|`, and `^` set operation operators.
+          # e.g. `x >= y & y < z`
+          return if center.send_type? && SET_OPERATION_OPERATORS.include?(center.method_name)
 
           add_offense(node) do |corrector|
             new_center = "#{center.source} && #{center.source}"

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

@@ -55,8 +55,7 @@ module RuboCop
       #     end
       #   end
       class NestedMethodDefinition < Base
-        MSG = 'Method definitions must not be nested. ' \
-              'Use `lambda` instead.'
+        MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
           subject, = *node
@@ -81,14 +80,17 @@ module RuboCop
             class_or_module_or_struct_new_call?(child)
         end
 
+        # @!method eval_call?(node)
         def_node_matcher :eval_call?, <<~PATTERN
           (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
+        # @!method exec_call?(node)
         def_node_matcher :exec_call?, <<~PATTERN
           (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
 
+        # @!method class_or_module_or_struct_new_call?(node)
         def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
           (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
         PATTERN

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

@@ -33,15 +33,13 @@ module RuboCop
         include PercentLiteral
 
         MSG = 'Within percent literals, nested percent literals do not ' \
-          'function and may be unwanted in the result.'
+              'function and may be unwanted in the result.'
 
         # The array of regular expressions representing percent literals that,
         # if found within a percent literal expression, will cause a
         # NestedPercentLiteral violation to be emitted.
         PERCENT_LITERAL_TYPES = PreferredDelimiters::PERCENT_LITERAL_TYPES
-        REGEXES = PERCENT_LITERAL_TYPES.map do |percent_literal|
-          /\A#{percent_literal}\W/
-        end.freeze
+        REGEXES = PERCENT_LITERAL_TYPES.map { |percent_literal| /\A#{percent_literal}\W/ }.freeze
 
         def on_array(node)
           process(node, *PERCENT_LITERAL_TYPES)

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

@@ -25,6 +25,7 @@ module RuboCop
       class NextWithoutAccumulator < Base
         MSG = 'Use `next` with an accumulator argument in a `reduce`.'
 
+        # @!method on_body_of_reduce(node)
         def_node_matcher :on_body_of_reduce, <<~PATTERN
           (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
         PATTERN

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

@@ -14,7 +14,11 @@ module RuboCop
       # `Dir.glob` and `Dir[]` sort globbed results by default in Ruby 3.0.
       # So all bad cases are acceptable when Ruby 3.0 or higher are used.
       #
-      # This cop will be deprecated and removed when supporting only Ruby 3.0 and higher.
+      # NOTE: This cop will be deprecated and removed when supporting only Ruby 3.0 and higher.
+      #
+      # @safety
+      #   This cop is unsafe in the case where sorting files changes existing
+      #   expected behaviour.
       #
       # @example
       #
@@ -66,9 +70,7 @@ module RuboCop
           loop_variable(node.arguments) do |var_name|
             return unless var_is_required?(node.body, var_name)
 
-            add_offense(node.send_node) do |corrector|
-              correct_block(corrector, node.send_node)
-            end
+            add_offense(node.send_node) { |corrector| correct_block(corrector, node.send_node) }
           end
         end
 
@@ -129,32 +131,39 @@ module RuboCop
           unsorted_dir_glob_pass?(node) || unsorted_dir_each_pass?(node)
         end
 
+        # @!method unsorted_dir_block?(node)
         def_node_matcher :unsorted_dir_block?, <<~PATTERN
           (send (const {nil? cbase} :Dir) :glob ...)
         PATTERN
 
+        # @!method unsorted_dir_each?(node)
         def_node_matcher :unsorted_dir_each?, <<~PATTERN
           (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each)
         PATTERN
 
+        # @!method method_require?(node)
         def_node_matcher :method_require?, <<~PATTERN
           (block-pass (send nil? :method (sym :require)))
         PATTERN
 
+        # @!method unsorted_dir_glob_pass?(node)
         def_node_matcher :unsorted_dir_glob_pass?, <<~PATTERN
           (send (const {nil? cbase} :Dir) :glob ...
             (block-pass (send nil? :method (sym :require))))
         PATTERN
 
+        # @!method unsorted_dir_each_pass?(node)
         def_node_matcher :unsorted_dir_each_pass?, <<~PATTERN
           (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each
             (block-pass (send nil? :method (sym :require))))
         PATTERN
 
+        # @!method loop_variable(node)
         def_node_matcher :loop_variable, <<~PATTERN
           (args (arg $_))
         PATTERN
 
+        # @!method var_is_required?(node, name)
         def_node_search :var_is_required?, <<~PATTERN
           (send nil? :require (lvar %1))
         PATTERN

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

@@ -73,7 +73,10 @@ module RuboCop
           !return_node.children.empty?
         end
 
+        # @!method chained_send?(node)
         def_node_matcher :chained_send?, '(send !nil? ...)'
+
+        # @!method define_method?(node)
         def_node_matcher :define_method?, <<~PATTERN
           (send _ {:define_method :define_singleton_method} _)
         PATTERN

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

@@ -18,6 +18,11 @@ module RuboCop
       # cop by default). Similarly, Rails' duration methods do not work well
       # with `Integer()` and can be ignored with `IgnoredMethods`.
       #
+      # @safety
+      #   Autocorrection is unsafe because it is not guaranteed that the
+      #   replacement `Kernel` methods are able to properly handle the
+      #   input if it is not a standard class.
+      #
       # @example
       #
       #   # bad
@@ -58,14 +63,17 @@ module RuboCop
         }.freeze
         MSG = 'Replace unsafe number conversion with number '\
               'class parsing, instead of using '\
-              '%<current>s, use stricter '\
-              '%<corrected_method>s.'
+              '`%<current>s`, use stricter '\
+              '`%<corrected_method>s`.'
+        CONVERSION_METHODS = %i[Integer Float Complex to_i to_f to_c].freeze
         METHODS = CONVERSION_METHOD_CLASS_MAPPING.keys.map(&:inspect).join(' ')
 
+        # @!method to_method(node)
         def_node_matcher :to_method, <<~PATTERN
           (send $_ ${#{METHODS}})
         PATTERN
 
+        # @!method to_method_symbol(node)
         def_node_matcher :to_method_symbol, <<~PATTERN
           {(send _ $_ ${(sym ${#{METHODS}})} ...)
            (send _ $_ ${(block_pass (sym ${#{METHODS}}))} ...)}
@@ -95,7 +103,7 @@ module RuboCop
 
         def handle_as_symbol(node)
           to_method_symbol(node) do |receiver, sym_node, to_method|
-            next if receiver.nil?
+            next if receiver.nil? || !node.arguments.one?
 
             message = format(
               MSG,
@@ -103,14 +111,15 @@ module RuboCop
               corrected_method: correct_sym_method(to_method)
             )
             add_offense(node, message: message) do |corrector|
+              remove_parentheses(corrector, node) if node.parenthesized?
+
               corrector.replace(sym_node, correct_sym_method(to_method))
             end
           end
         end
 
         def correct_method(node, receiver)
-          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name],
-                 number_object: receiver.source)
+          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name], number_object: receiver.source)
         end
 
         def correct_sym_method(to_method)
@@ -118,8 +127,14 @@ module RuboCop
           "{ |i| #{body} }"
         end
 
+        def remove_parentheses(corrector, node)
+          corrector.replace(node.loc.begin, ' ')
+          corrector.remove(node.loc.end)
+        end
+
         def ignore_receiver?(receiver)
-          if receiver.send_type? && ignored_method?(receiver.method_name)
+          if receiver.numeric_type? || (receiver.send_type? &&
+            (conversion_method?(receiver.method_name) || ignored_method?(receiver.method_name)))
             true
           elsif (receiver = top_receiver(receiver))
             receiver.const_type? && ignored_class?(receiver.const_name)
@@ -134,6 +149,10 @@ module RuboCop
           receiver
         end
 
+        def conversion_method?(method_name)
+          CONVERSION_METHODS.include?(method_name)
+        end
+
         def ignored_classes
           cop_config.fetch('IgnoredClasses', [])
         end

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

@@ -10,7 +10,7 @@ module RuboCop
       #   ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin19]
       #   -e:1: warning: `_1' is reserved for numbered parameter; consider another name
       #
-      # Assiging to numbered parameter (from `_1` to `_9`) cause an error in Ruby 3.0.
+      # Assigning to a numbered parameter (from `_1` to `_9`) causes an error in Ruby 3.0.
       #
       #   % ruby -ve '_1 = :value'
       #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]

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

@@ -9,8 +9,10 @@ module RuboCop
       # should always be the same. If constants are assigned in multiple
       # locations, the result may vary depending on the order of `require`.
       #
-      # Also, if you already have such an implementation, auto-correction may
-      # change the result.
+      # @safety
+      #   This cop is unsafe because code that is already conditionally
+      #   assigning a constant may have its behaviour changed by
+      #   auto-correction.
       #
       # @example
       #

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

@@ -31,8 +31,7 @@ module RuboCop
         include FrozenStringLiteral
         extend AutoCorrector
 
-        MSG = 'The encoding magic comment should precede all other ' \
-              'magic comments.'
+        MSG = 'The encoding magic comment should precede all other magic comments.'
 
         def on_new_investigation
           return if processed_source.buffer.source.empty?

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

@@ -6,6 +6,23 @@ module RuboCop
       # This cops looks for references of Regexp captures that are out of range
       # and thus always returns nil.
       #
+      # @safety
+      #   This cop is unsafe because it is naive in how it determines what
+      #   references are available based on the last encountered regexp, but
+      #   it cannot handle some cases, such as conditional regexp matches, which
+      #   leads to false positives, such as:
+      #
+      #   [source,ruby]
+      #   ----
+      #   foo ? /(c)(b)/ =~ str : /(b)/ =~ str
+      #   do_something if $2
+      #   # $2 is defined for the first condition but not the second, however
+      #   # the cop will mark this as an offense.
+      #   ----
+      #
+      #   This might be a good indication of code that should be refactored,
+      #   however.
+      #
       # @example
       #
       #   /(foo)bar/ =~ 'foobar'
@@ -48,9 +65,7 @@ module RuboCop
         def on_when(node)
           regexp_conditions = node.conditions.select(&:regexp_type?)
 
-          @valid_ref = regexp_conditions.map do |condition|
-            check_regexp(condition)
-          end.compact.max
+          @valid_ref = regexp_conditions.map { |condition| check_regexp(condition) }.compact.max
         end
 
         def on_nth_ref(node)

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

@@ -29,9 +29,7 @@ module RuboCop
 
           range = space_range(node.first_argument.source_range, space_length)
 
-          add_offense(range) do |corrector|
-            corrector.remove(range)
-          end
+          add_offense(range) { |corrector| corrector.remove(range) }
         end
         alias on_csend on_send
 

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

@@ -9,6 +9,16 @@ module RuboCop
       # example, mistranslating an array of literals to percent string notation)
       # rather than meant to be part of the resulting strings.
       #
+      # @safety
+      #   The cop is unsafe because the correction changes the values in the array
+      #   and that might have been done purposely.
+      #
+      #   [source,ruby]
+      #   ----
+      #   %w('foo', "bar") #=> ["'foo',", '"bar"']
+      #   %w(foo bar)      #=> ['foo', 'bar']
+      #   ----
+      #
       # @example
       #
       #   # bad
@@ -29,7 +39,7 @@ module RuboCop
         TRAILING_QUOTE = /['"]?,?$/.freeze
 
         MSG = "Within `%w`/`%W`, quotes and ',' are unnecessary and may be " \
-          'unwanted in the resulting strings.'
+              'unwanted in the resulting strings.'
 
         def on_array(node)
           process(node, '%w', '%W')

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

@@ -25,7 +25,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = "Within `%i`/`%I`, ':' and ',' are unnecessary and may be " \
-          'unwanted in the resulting symbols.'
+              'unwanted in the resulting symbols.'
 
         def on_array(node)
           process(node, '%i', '%I')
@@ -34,9 +34,7 @@ module RuboCop
         def on_percent_literal(node)
           return unless contains_colons_or_commas?(node)
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
         private

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

@@ -13,6 +13,10 @@ module RuboCop
       # `Exception`. Alternatively, make `Exception` a fully qualified class
       # name with an explicit namespace.
       #
+      # @safety
+      #   This cop is unsafe because it will change the exception class being
+      #   raised, which is a change in behaviour.
+      #
       # @example
       #   # bad
       #   raise Exception, 'Error message here'
@@ -33,18 +37,19 @@ module RuboCop
         MSG = 'Use `StandardError` over `Exception`.'
         RESTRICT_ON_SEND = %i[raise fail].freeze
 
+        # @!method exception?(node)
         def_node_matcher :exception?, <<~PATTERN
           (send nil? {:raise :fail} $(const ${cbase nil?} :Exception) ... )
         PATTERN
 
+        # @!method exception_new_with_message?(node)
         def_node_matcher :exception_new_with_message?, <<~PATTERN
           (send nil? {:raise :fail}
             (send $(const ${cbase nil?} :Exception) :new ... ))
         PATTERN
 
         def on_send(node)
-          exception?(node, &check(node)) ||
-            exception_new_with_message?(node, &check(node))
+          exception?(node, &check(node)) || exception_new_with_message?(node, &check(node))
         end
 
         private

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

@@ -21,10 +21,10 @@ module RuboCop
       #
       #   0 # just use 0 instead
       class RandOne < Base
-        MSG = '`%<method>s` always returns `0`. ' \
-              'Perhaps you meant `rand(2)` or `rand`?'
+        MSG = '`%<method>s` always returns `0`. Perhaps you meant `rand(2)` or `rand`?'
         RESTRICT_ON_SEND = %i[rand].freeze
 
+        # @!method rand_one?(node)
         def_node_matcher :rand_one?, <<~PATTERN
           (send {(const {nil? cbase} :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
         PATTERN