rubocop 1.21.0 → 1.22.0

data/lib/rubocop/cop/layout/space_inside_parens.rb

@@ -33,6 +33,27 @@ module RuboCop
       #   g = ( a + 3 )
       #   y()
       #
+      # @example EnforcedStyle: compact
+      #   # The `compact` style enforces that parentheses have a space at the
+      #   # beginning with the exception that successive parentheses are allowed.
+      #   # Note: Empty parentheses should not have spaces.
+      #
+      #   # bad
+      #   f(3)
+      #   g = (a + 3)
+      #   y( )
+      #   g( f( x ) )
+      #   g( f( x( 3 ) ), 5 )
+      #   g( ( ( 3 + 5 ) * f) ** x, 5 )
+      #
+      #   # good
+      #   f( 3 )
+      #   g = ( a + 3 )
+      #   y()
+      #   g( f( x ))
+      #   g( f( x( 3 )), 5 )
+      #   g((( 3 + 5 ) * f ) ** x, 5 )
+      #
       class SpaceInsideParens < Base
         include SurroundingSpace
         include RangeHelp
@@ -45,14 +66,13 @@ module RuboCop
         def on_new_investigation
           tokens = processed_source.sorted_tokens
 
-          if style == :space
+          case style
+          when :space
             process_with_space_style(tokens)
+          when :compact
+            process_with_compact_style(tokens)
           else
-            each_extraneous_space(tokens) do |range|
-              add_offense(range) do |corrector|
-                corrector.remove(range)
-              end
-            end
+            correct_extraneous_space(tokens)
           end
         end
 
@@ -60,20 +80,23 @@ module RuboCop
 
         def process_with_space_style(tokens)
           tokens.each_cons(2) do |token1, token2|
-            each_extraneous_space_in_empty_parens(token1, token2) do |range|
-              add_offense(range) do |corrector|
-                corrector.remove(range)
-              end
-            end
-            each_missing_space(token1, token2) do |range|
-              add_offense(range, message: MSG_SPACE) do |corrector|
-                corrector.insert_before(range, ' ')
-              end
+            correct_extraneous_space_in_empty_parens(token1, token2)
+            correct_missing_space(token1, token2)
+          end
+        end
+
+        def process_with_compact_style(tokens)
+          tokens.each_cons(2) do |token1, token2|
+            correct_extraneous_space_in_empty_parens(token1, token2)
+            if !left_parens?(token1, token2) && !right_parens?(token1, token2)
+              correct_missing_space(token1, token2)
+            else
+              correct_extaneus_space_between_consecutive_parens(token1, token2)
             end
           end
         end
 
-        def each_extraneous_space(tokens)
+        def correct_extraneous_space(tokens)
           tokens.each_cons(2) do |token1, token2|
             next unless parens?(token1, token2)
 
@@ -82,25 +105,44 @@ module RuboCop
             next if token2.comment?
             next unless same_line?(token1, token2) && token1.space_after?
 
-            yield range_between(token1.end_pos, token2.begin_pos)
+            range = range_between(token1.end_pos, token2.begin_pos)
+            add_offense(range) do |corrector|
+              corrector.remove(range)
+            end
+          end
+        end
+
+        def correct_extaneus_space_between_consecutive_parens(token1, token2)
+          return if range_between(token1.end_pos, token2.begin_pos).source != ' '
+
+          range = range_between(token1.end_pos, token2.begin_pos)
+          add_offense(range) do |corrector|
+            corrector.remove(range)
           end
         end
 
-        def each_extraneous_space_in_empty_parens(token1, token2)
+        def correct_extraneous_space_in_empty_parens(token1, token2)
           return unless token1.left_parens? && token2.right_parens?
 
           return if range_between(token1.begin_pos, token2.end_pos).source == '()'
 
-          yield range_between(token1.end_pos, token2.begin_pos)
+          range = range_between(token1.end_pos, token2.begin_pos)
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
         end
 
-        def each_missing_space(token1, token2)
+        def correct_missing_space(token1, token2)
           return if can_be_ignored?(token1, token2)
 
-          if token1.left_parens?
-            yield range_between(token2.begin_pos, token2.begin_pos + 1)
-          elsif token2.right_parens?
-            yield range_between(token2.begin_pos, token2.end_pos)
+          range = if token1.left_parens?
+                    range_between(token2.begin_pos, token2.begin_pos + 1)
+                  elsif token2.right_parens?
+                    range_between(token2.begin_pos, token2.end_pos)
+                  end
+
+          add_offense(range, message: MSG_SPACE) do |corrector|
+            corrector.insert_before(range, ' ')
           end
         end
 
@@ -112,6 +154,14 @@ module RuboCop
           token1.left_parens? || token2.right_parens?
         end
 
+        def left_parens?(token1, token2)
+          token1.left_parens? && token2.left_parens?
+        end
+
+        def right_parens?(token1, token2)
+          token1.right_parens? && token2.right_parens?
+        end
+
         def can_be_ignored?(token1, token2)
           return true unless parens?(token1, token2)
 

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

@@ -87,7 +87,11 @@ module RuboCop
         end
 
         def greater_precedence?(node1, node2)
-          precedence(node2) > precedence(node1)
+          node1_precedence = precedence(node1)
+          node2_precedence = precedence(node2)
+          return false unless node1_precedence && node2_precedence
+
+          node2_precedence > node1_precedence
         end
 
         def operator_name(node)

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

@@ -10,12 +10,6 @@ module RuboCop
       # explicit by requiring parenthesis around complex range boundaries (anything
       # that is not a basic literal: numerics, strings, symbols, etc.).
       #
-      # NOTE: The cop auto-corrects by wrapping the entire boundary in parentheses, which
-      # makes the outcome more explicit but is possible to not be the intention of the
-      # programmer. For this reason, this cop's auto-correct is marked as unsafe (it
-      # will not change the behaviour of the code, but will not necessarily match the
-      # intent of the program).
-      #
       # This cop can be configured with `RequireParenthesesForMethodChains` in order to
       # specify whether method chains (including `self.foo`) should be wrapped in parens
       # by this cop.
@@ -23,6 +17,13 @@ module RuboCop
       # NOTE: Regardless of this configuration, if a method receiver is a basic literal
       # value, it will be wrapped in order to prevent the ambiguity of `1..2.to_a`.
       #
+      # @safety
+      #   The cop auto-corrects by wrapping the entire boundary in parentheses, which
+      #   makes the outcome more explicit but is possible to not be the intention of the
+      #   programmer. For this reason, this cop's auto-correct is unsafe (it will not
+      #   change the behaviour of the code, but will not necessarily match the
+      #   intent of the program).
+      #
       # @example
       #   # bad
       #   x || 1..2
@@ -55,7 +56,6 @@ module RuboCop
       #
       #   # good
       #   (a.foo)..(b.bar)
-      #
       class AmbiguousRange < Base
         extend AutoCorrector
 

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

@@ -49,7 +49,7 @@ module RuboCop
         def on_if(node)
           return if node.condition.block_type?
 
-          traverse_node(node.condition, ASGN_TYPES) do |asgn_node|
+          traverse_node(node.condition) do |asgn_node|
             next :skip_children if skip_children?(asgn_node)
             next if allowed_construct?(asgn_node)
 
@@ -83,13 +83,15 @@ module RuboCop
             (safe_assignment_allowed? && safe_assignment?(asgn_node))
         end
 
-        # each_node/visit_descendants_with_types with :skip_children
-        def traverse_node(node, types, &block)
-          result = yield node if types.include?(node.type)
+        def traverse_node(node, &block)
+          # if the node is a block, any assignments are irrelevant
+          return if node.block_type?
+
+          result = yield node if ASGN_TYPES.include?(node.type)
 
           return if result == :skip_children
 
-          node.each_child_node { |child| traverse_node(child, types, &block) }
+          node.each_child_node { |child| traverse_node(child, &block) }
         end
       end
     end

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

@@ -5,15 +5,28 @@ module RuboCop
     module Lint
       # This cop checks for places where binary operator has identical operands.
       #
-      # It covers arithmetic operators: `+`, `-`, `*`, `/`, `%`, `**`;
+      # It covers arithmetic operators: `-`, `/`, `%`;
       # comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, `<=`;
-      # bitwise operators: `|`, `^`, `&`, `<<`, `>>`;
+      # bitwise operators: `|`, `^`, `&`;
       # boolean operators: `&&`, `||`
       # and "spaceship" operator - `<=>`.
       #
-      # This cop is marked as unsafe as it does not consider side effects when calling methods
-      # and thus can generate false positives:
+      # Simple arithmetic operations are allowed by this cop: `+`, `*`, `**`, `<<` and `>>`.
+      # Although these can be rewritten in a different way, it should not be necessary to
+      # do so. This does not include operations such as `-` or `/` where the result will
+      # always be the same (`x - x` will always be 0; `x / x` will always be 1), and
+      # thus are legitimate offenses.
+      #
+      # @safety
+      #   This cop is unsafe as it does not consider side effects when calling methods
+      #   and thus can generate false positives, for example:
+      #
+      #   [source,ruby]
+      #   ----
       #   if wr.take_char == '\0' && wr.take_char == '\0'
+      #     # ...
+      #   end
+      #   ----
       #
       # @example
       #   # bad
@@ -24,7 +37,7 @@ module RuboCop
       #     do_something
       #   end
       #
-      #   def childs?
+      #   def child?
       #     left_child || left_child
       #   end
       #

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

@@ -6,6 +6,11 @@ module RuboCop
       # This cop checks for `:true` and `:false` symbols.
       # In most cases it would be a typo.
       #
+      # @safety
+      #   Autocorrection is unsafe for this cop because code relying
+      #   on `:true` or `:false` symbols will break when those are
+      #   changed to actual booleans.
+      #
       # @example
       #
       #   # bad

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

@@ -58,12 +58,12 @@ module RuboCop
           end
 
           def to_s
-            [class_constant, method].compact.join(delimeter)
+            [class_constant, method].compact.join(delimiter)
           end
 
           private
 
-          def delimeter
+          def delimiter
             CLASS_METHOD_DELIMETER
           end
         end
@@ -81,12 +81,12 @@ module RuboCop
           end
 
           def to_s
-            [class_constant, method].compact.join(delimeter)
+            [class_constant, method].compact.join(delimiter)
           end
 
           private
 
-          def delimeter
+          def delimiter
             instance_method? ? INSTANCE_METHOD_DELIMETER : CLASS_METHOD_DELIMETER
           end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks constructors for disjunctive assignments that should
+      # This cop checks constructors for disjunctive assignments (`||=`) that should
       # be plain assignments.
       #
       # So far, this cop is only concerned with disjunctive assignment of
@@ -12,6 +12,29 @@ module RuboCop
       # In ruby, an instance variable is nil until a value is assigned, so the
       # disjunction is unnecessary. A plain assignment has the same effect.
       #
+      # @safety
+      #   This cop is unsafe because it can register a false positive when a
+      #   method is redefined in a subclass that calls super. For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class Base
+      #     def initialize
+      #       @config ||= 'base'
+      #     end
+      #   end
+      #
+      #   class Derived < Base
+      #     def initialize
+      #       @config = 'derived'
+      #       super
+      #     end
+      #   end
+      #   ----
+      #
+      #   Without the disjunctive assignment, `Derived` will be unable to override
+      #   the value for `@config`.
+      #
       # @example
       #   # bad
       #   def initialize

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

@@ -49,6 +49,9 @@ module RuboCop
         def on_if(node)
           return if node.ternary?
 
+          # If the if is on a single line, it'll be handled by `Style/OneLineConditional`
+          return if node.single_line?
+
           check(node)
         end
 
@@ -66,10 +69,7 @@ module RuboCop
 
         def check_else(node)
           else_branch = node.else_branch
-
-          return unless else_branch.begin_type?
-
-          first_else = else_branch.children.first
+          first_else = else_branch.begin_type? ? else_branch.children.first : else_branch
 
           return unless first_else
           return unless first_else.source_range.line == node.loc.else.line
@@ -81,9 +81,13 @@ module RuboCop
           corrector.insert_after(node.loc.else, "\n")
 
           blank_range = range_between(node.loc.else.end_pos, first_else.loc.expression.begin_pos)
-          indentation = indent(node.else_branch.children[1])
+          indentation = indent(node, offset: indentation_width)
           corrector.replace(blank_range, indentation)
         end
+
+        def indentation_width
+          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
+        end
       end
     end
   end

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

@@ -3,10 +3,19 @@
 module RuboCop
   module Cop
     module Lint
-      # Prefer using `Hash#compare_by_identity` than using `object_id` for hash keys.
+      # Prefer using `Hash#compare_by_identity` rather than using `object_id`
+      # for hash keys.
       #
-      # This cop is marked as unsafe as a hash possibly can contain other keys
-      # besides `object_id`s.
+      # This cop looks for hashes being keyed by objects' `object_id`, using
+      # one of these methods: `key?`, `has_key?`, `fetch`, `[]` and `[]=`.
+      #
+      # @safety
+      #   This cop is unsafe. Although unlikely, the hash could store both object
+      #   ids and other values that need be compared by value, and thus
+      #   could be a false positive.
+      #
+      #   Furthermore, this cop cannot guarantee that the receiver of one of the
+      #   methods (`key?`, etc.) is actually a hash.
       #
       # @example
       #   # bad

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

@@ -5,6 +5,11 @@ module RuboCop
     module Lint
       # This cop checks for interpolation in a single quoted string.
       #
+      # @safety
+      #   This cop is generally safe, but is marked as unsafe because
+      #   it is possible to actually intentionally have text inside
+      #   `#{...}` in a single quoted string.
+      #
       # @example
       #
       #   # bad

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
       #

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
       #

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

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/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'

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

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'

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

@@ -7,13 +7,14 @@ module RuboCop
       # `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`, and `equal?` methods
       # are checked by default. These are customizable with `AllowedMethods` option.
       #
-      # This cop is marked as unsafe, because auto-correction can change the
-      # return type of the expression. An offending expression that previously
-      # could return `nil` will be auto-corrected to never return `nil`.
-      #
       # In the example below, the safe navigation operator (`&.`) is unnecessary
       # because `NilClass` has methods like `respond_to?` and `is_a?`.
       #
+      # @safety
+      #   This cop is unsafe, because auto-correction can change the return type of
+      #   the expression. An offending expression that previously could return `nil`
+      #   will be auto-corrected to never return `nil`.
+      #
       # @example
       #   # bad
       #   do_something if attrs&.respond_to?(:[])

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for uses a file requiring itself with `require_relative`.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # foo.rb
+      #   require_relative 'foo'
+      #   require_relative 'bar'
+      #
+      #   # good
+      #
+      #   # foo.rb
+      #   require_relative 'bar'
+      #
+      class RequireRelativeSelfPath < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the `require_relative` that requires itself.'
+        RESTRICT_ON_SEND = %i[require_relative].freeze
+
+        def on_send(node)
+          return unless (required_feature = node.first_argument)
+          return unless same_file?(processed_source.file_path, required_feature.value)
+
+          add_offense(node) do |corrector|
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+          end
+        end
+
+        private
+
+        def same_file?(file_path, required_feature)
+          file_path == required_feature || remove_ext(file_path) == required_feature
+        end
+
+        def remove_ext(file_path)
+          File.basename(file_path, File.extname(file_path))
+        end
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module RuboCop
       #
       # NOTE: Shadowing of variables in block passed to `Ractor.new` is allowed
       # because `Ractor` should not access outer variables.
-      # eg. following syle is encouraged:
+      # eg. following style is encouraged:
       #
       #   worker_id, pipe = env
       #   Ractor.new(worker_id, pipe) do |worker_id, pipe|

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

@@ -143,7 +143,7 @@ module RuboCop
           # Although some operators can be converted to symbols normally
           # (ie. `:==`), these are not accepted as hash keys and will
           # raise a syntax error (eg. `{ ==: ... }`). Therefore, if the
-          # symbol does not start with an alpha-numeric or underscore, it
+          # symbol does not start with an alphanumeric or underscore, it
           # will be ignored.
           return unless node.value.to_s.match?(/\A[a-z0-9_]/i)
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for "triple quotes" (strings delimted by any odd number
+      # This cop checks for "triple quotes" (strings delimited by any odd number
       # of quotes greater than 1).
       #
       # Ruby allows multiple strings to be implicitly concatenated by just