rubocop 1.52.1 → 1.79.2

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

@@ -22,51 +22,18 @@ module RuboCop
         RESTRICT_ON_SEND = %i[[] []=].freeze
 
         def on_send(node)
-          return unless (first_argument = node.first_argument)
+          return if node.loc.dot
 
-          begin_pos = first_argument.source_range.begin_pos
-          return unless (range = offense_range(node, begin_pos))
+          receiver_end_pos = node.receiver.source_range.end_pos
+          selector_begin_pos = node.loc.selector.begin_pos
+          return if receiver_end_pos >= selector_begin_pos
 
-          register_offense(range)
-        end
-
-        private
+          range = range_between(receiver_end_pos, selector_begin_pos)
 
-        def offense_range(node, begin_pos)
-          if reference_variable_with_brackets?(node)
-            receiver_end_pos = node.receiver.source_range.end_pos
-            selector_begin_pos = node.loc.selector.begin_pos
-            return if receiver_end_pos >= selector_begin_pos
-            return if dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
-
-            range_between(receiver_end_pos, selector_begin_pos)
-          elsif node.method?(:[]=)
-            offense_range_for_assignment(node, begin_pos)
+          add_offense(range) do |corrector|
+            corrector.remove(range)
           end
         end
-
-        def dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
-          return false unless node.loc.respond_to?(:dot) && (dot = node.loc.dot)
-
-          dot.begin_pos == receiver_end_pos && dot.end_pos == selector_begin_pos
-        end
-
-        def offense_range_for_assignment(node, begin_pos)
-          end_pos = node.receiver.source_range.end_pos
-
-          return if begin_pos - end_pos == 1 ||
-                    (range = range_between(end_pos, begin_pos - 1)).source.start_with?('[')
-
-          range
-        end
-
-        def register_offense(range)
-          add_offense(range) { |corrector| corrector.remove(range) }
-        end
-
-        def reference_variable_with_brackets?(node)
-          node.receiver&.variable? && node.method?(:[]) && node.arguments.size == 1
-        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for comma (,) preceded by space.
+      # Checks for comma (`,`) preceded by space.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for semicolon (;) preceded by space.
+      # Checks for semicolon (`;`) preceded by space.
       #
       # @example
       #   # bad

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

@@ -6,15 +6,19 @@ module RuboCop
       # Checks that brackets used for array literals have or don't have
       # surrounding space depending on configuration.
       #
+      # Array pattern matching is handled in the same way.
+      #
       # @example EnforcedStyle: no_space (default)
       #   # The `no_space` style enforces that array literals have
       #   # no surrounding space.
       #
       #   # bad
       #   array = [ a, b, c, d ]
+      #   array = [ a, [ b, c ]]
       #
       #   # good
       #   array = [a, b, c, d]
+      #   array = [a, [b, c]]
       #
       # @example EnforcedStyle: space
       #   # The `space` style enforces that array literals have
@@ -22,9 +26,11 @@ module RuboCop
       #
       #   # bad
       #   array = [a, b, c, d]
+      #   array = [ a, [ b, c ]]
       #
       #   # good
       #   array = [ a, b, c, d ]
+      #   array = [ a, [ b, c ] ]
       #
       # @example EnforcedStyle: compact
       #   # The `compact` style normally requires a space inside
@@ -32,6 +38,7 @@ module RuboCop
       #   # or right brackets are collapsed together in nested arrays.
       #
       #   # bad
+      #   array = [a, b, c, d]
       #   array = [ a, [ b, c ] ]
       #   array = [
       #     [ a ],
@@ -39,6 +46,7 @@ module RuboCop
       #   ]
       #
       #   # good
+      #   array = [ a, b, c, d ]
       #   array = [ a, [ b, c ]]
       #   array = [[ a ],
       #     [ b, c ]]
@@ -76,9 +84,11 @@ module RuboCop
         EMPTY_MSG = '%<command>s space inside empty array brackets.'
 
         def on_array(node)
-          return unless node.square_brackets?
+          return if node.array_type? && !node.square_brackets?
 
+          node = find_node_with_brackets(node)
           tokens, left, right = array_brackets(node)
+          return unless left && right
 
           if empty_brackets?(left, right, tokens: tokens)
             return empty_offenses(node, left, right, EMPTY_MSG)
@@ -89,9 +99,14 @@ module RuboCop
 
           issue_offenses(node, left, right, start_ok, end_ok)
         end
+        alias on_array_pattern on_array
 
         private
 
+        def find_node_with_brackets(node)
+          node.ancestors.find(&:const_pattern_type?) || node
+        end
+
         def autocorrect(corrector, node)
           tokens, left, right = array_brackets(node)
 
@@ -109,7 +124,7 @@ module RuboCop
         def array_brackets(node)
           tokens = processed_source.tokens_within(node)
 
-          left = tokens.find(&:left_array_bracket?)
+          left = tokens.find(&:left_bracket?)
           right = tokens.reverse_each.find(&:right_bracket?)
 
           [tokens, left, right]
@@ -182,7 +197,7 @@ module RuboCop
           if side == :right
             processed_source.tokens_within(node)[i].right_bracket?
           else
-            processed_source.tokens_within(node)[i].left_array_bracket?
+            processed_source.tokens_within(node)[i].left_bracket?
           end
         end
 

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

@@ -82,6 +82,10 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Style::BlockDelimiters]
+        end
+
         def on_block(node)
           return if node.keywords?
 
@@ -99,6 +103,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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

@@ -6,15 +6,19 @@ module RuboCop
       # Checks that braces used for hash literals have or don't have
       # surrounding space depending on configuration.
       #
+      # Hash pattern matching is handled in the same way.
+      #
       # @example EnforcedStyle: space (default)
       #   # The `space` style enforces that hash literals have
       #   # surrounding space.
       #
       #   # bad
       #   h = {a: 1, b: 2}
+      #   foo = {{ a: 1 } => { b: { c: 2 }}}
       #
       #   # good
       #   h = { a: 1, b: 2 }
+      #   foo = { { a: 1 } => { b: { c: 2 } } }
       #
       # @example EnforcedStyle: no_space
       #   # The `no_space` style enforces that hash literals have
@@ -22,9 +26,11 @@ module RuboCop
       #
       #   # bad
       #   h = { a: 1, b: 2 }
+      #   foo = {{ a: 1 } => { b: { c: 2 }}}
       #
       #   # good
       #   h = {a: 1, b: 2}
+      #   foo = {{a: 1} => {b: {c: 2}}}
       #
       # @example EnforcedStyle: compact
       #   # The `compact` style normally requires a space inside
@@ -83,6 +89,7 @@ module RuboCop
           check(tokens[-2], tokens[-1]) if tokens.size > 2
           check_whitespace_only_hash(node) if enforce_no_space_style_for_empty_braces?
         end
+        alias on_hash_pattern on_hash
 
         private
 
@@ -116,7 +123,7 @@ module RuboCop
 
         def incorrect_style_detected(token1, token2,
                                      expect_space, is_empty_braces)
-          brace = (token1.text == '{' ? token1 : token2).pos
+          brace = (token1.left_brace? ? token1 : token2).pos
           range = expect_space ? brace : space_range(brace)
           detected_style = expect_space ? 'no_space' : 'space'
 

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

@@ -168,7 +168,7 @@ module RuboCop
           # follows, and that the rules for space inside don't apply.
           return true if token2.comment?
 
-          return true unless same_line?(token1, token2) && !token1.space_after?
+          !same_line?(token1, token2) || token1.space_after?
         end
       end
     end

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

@@ -35,7 +35,7 @@ module RuboCop
         def check(node)
           expression = node.source
           op = node.loc.operator.source
-          escaped_op = op.gsub(/\./, '\.')
+          escaped_op = op.gsub('.', '\.')
 
           # account for multiline range literals
           expression.sub!(/#{escaped_op}\n\s*/, op)

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

@@ -22,11 +22,9 @@ module RuboCop
         include Interpolation
         include SurroundingSpace
         include ConfigurableEnforcedStyle
-        include RangeHelp
         extend AutoCorrector
 
-        NO_SPACE_MSG = 'Space inside string interpolation detected.'
-        SPACE_MSG = 'Missing space inside string interpolation detected.'
+        MSG = '%<command>s space inside string interpolation.'
 
         def on_interpolation(begin_node)
           return if begin_node.multiline?
@@ -36,9 +34,9 @@ module RuboCop
           return if empty_brackets?(left, right, tokens: tokens)
 
           if style == :no_space
-            no_space_offenses(begin_node, left, right, NO_SPACE_MSG)
+            no_space_offenses(begin_node, left, right, MSG)
           else
-            space_offenses(begin_node, left, right, SPACE_MSG)
+            space_offenses(begin_node, left, right, MSG)
           end
         end
 

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

@@ -51,6 +51,7 @@ module RuboCop
           # there could be good reasons why it needs to end with a certain
           # number of newlines.
           return if ends_in_end?(processed_source)
+          return if end_with_percent_blank_string?(processed_source)
 
           whitespace_at_end = buffer.source[/\s*\Z/]
           blank_lines = whitespace_at_end.count("\n") - 1
@@ -86,6 +87,10 @@ module RuboCop
           extra&.strip&.start_with?('__END__')
         end
 
+        def end_with_percent_blank_string?(processed_source)
+          processed_source.buffer.source.end_with?("%\n\n")
+        end
+
         def message(wanted_blank_lines, blank_lines)
           case blank_lines
           when -1

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

@@ -48,7 +48,7 @@ module RuboCop
 
         def on_new_investigation
           processed_source.lines.each_with_index do |line, index|
-            next unless line.end_with?(' ', "\t")
+            next unless line.match?(/[[:blank:]]\z/)
 
             process_line(line, index + 1)
           end
@@ -84,7 +84,7 @@ module RuboCop
         end
 
         def whitespace_is_indentation?(range, level)
-          range.source[/[ \t]+/].length <= level
+          range.source[/[[:blank:]]+/].length <= level
         end
 
         def whitespace_only?(range)
@@ -123,7 +123,9 @@ module RuboCop
         end
 
         def offense_range(lineno, line)
-          source_range(processed_source.buffer, lineno, (line.rstrip.length)...(line.length))
+          source_range(
+            processed_source.buffer, lineno, (line.sub(/[[:blank:]]+\z/, '').length)...(line.length)
+          )
         end
       end
     end

data/lib/rubocop/cop/legacy/corrector.rb

@@ -12,13 +12,23 @@ module RuboCop
           if corr.is_a?(CorrectionsProxy)
             merge!(corr.send(:corrector))
           else
-            # warn "Corrector.new with corrections is deprecated." unless corr.empty? TODO
+            unless corr.empty?
+              warn Rainbow(<<~WARNING).yellow, uplevel: 1
+                `Corrector.new` with corrections is deprecated.
+                See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
+              WARNING
+            end
+
             corr.each { |c| corrections << c }
           end
         end
 
         def corrections
-          # warn "#corrections is deprecated. Open an issue if you have a valid usecase." TODO
+          warn Rainbow(<<~WARNING).yellow, uplevel: 1
+            `Corrector#corrections` is deprecated. Open an issue if you have a valid usecase.
+            See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
+          WARNING
+
           CorrectionsProxy.new(self)
         end
       end

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

@@ -14,8 +14,6 @@ module RuboCop
       #   # bad
       #   some_method a { |val| puts val }
       #
-      # @example
-      #
       #   # good
       #   # With parentheses, there's no ambiguity.
       #   some_method(a { |val| puts val })
@@ -79,7 +77,7 @@ module RuboCop
         private
 
         def ambiguous_block_association?(send_node)
-          send_node.last_argument.block_type? && !send_node.last_argument.send_node.arguments?
+          send_node.last_argument.any_block_type? && !send_node.last_argument.send_node.arguments?
         end
 
         def allowed_method_pattern?(node)

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

@@ -14,8 +14,6 @@ module RuboCop
       #   # a `*` method invocation (i.e. `do_something.*(some_array)`).
       #   do_something *some_array
       #
-      # @example
-      #
       #   # good
       #
       #   # With parentheses, there's no ambiguity.

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

@@ -27,7 +27,9 @@ module RuboCop
       # @example
       #   # bad
       #   x || 1..2
+      #   x - 1..2
       #   (x || 1..2)
+      #   x || 1..y || 2
       #   1..2.to_a
       #
       #   # good, unambiguous
@@ -41,6 +43,7 @@ module RuboCop
       #
       #   # good, ambiguity removed
       #   x || (1..2)
+      #   (x - 1)..2
       #   (x || 1)..2
       #   (x || 1)..(y || 2)
       #   (1..2).to_a
@@ -57,6 +60,7 @@ module RuboCop
       #   # good
       #   (a.foo)..(b.bar)
       class AmbiguousRange < Base
+        include RationalLiteral
         extend AutoCorrector
 
         MSG = 'Wrap complex range boundaries with parentheses to avoid ambiguity.'
@@ -79,12 +83,14 @@ module RuboCop
           yield range.end if range.end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def acceptable?(node)
           node.begin_type? ||
-            node.literal? ||
+            node.literal? || rational_literal?(node) ||
             node.variable? || node.const_type? || node.self_type? ||
             (node.call_type? && acceptable_call?(node))
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def acceptable_call?(node)
           return true if node.unary_operation?
@@ -93,6 +99,8 @@ module RuboCop
           # to avoid the ambiguity of `1..2.to_a`.
           return false if node.receiver&.basic_literal?
 
+          return false if node.operator_method? && !node.method?(:[])
+
           require_parentheses_for_method_chain? || node.receiver.nil?
         end
 

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

@@ -15,8 +15,6 @@ module RuboCop
       #   # (i.e. `do_something./(pattern)./(i)`)
       #   do_something /pattern/i
       #
-      # @example
-      #
       #   # good
       #
       #   # With parentheses, there's no ambiguity.

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for an array literal interpolated inside a regexp.
+      #
+      # When interpolating an array literal, it is converted to a string. This means
+      # that when inside a regexp, it acts as a character class but with additional
+      # quotes, spaces and commas that are likely not intended. For example,
+      # `/#{%w[a b c]}/` parses as `/["a", "b", "c"]/` (or `/["a, bc]/` without
+      # repeated characters).
+      #
+      # The cop can autocorrect to a character class (if all items in the array are a
+      # single character) or alternation (if the array contains longer items).
+      #
+      # NOTE: This only considers interpolated arrays that contain only strings, symbols,
+      # integers, and floats. Any other type is not easily convertible to a character class
+      # or regexp alternation.
+      #
+      # @safety
+      #   Autocorrection is unsafe because it will change the regexp pattern, by
+      #   removing the additional quotes, spaces and commas from the character class.
+      #
+      # @example
+      #   # bad
+      #   /#{%w[a b c]}/
+      #
+      #   # good
+      #   /[abc]/
+      #
+      #   # bad
+      #   /#{%w[foo bar baz]}/
+      #
+      #   # good
+      #   /(?:foo|bar|baz)/
+      #
+      #   # bad - construct a regexp rather than interpolate an array of identifiers
+      #   /#{[foo, bar]}/
+      #
+      class ArrayLiteralInRegexp < Base
+        include Interpolation
+        extend AutoCorrector
+
+        LITERAL_TYPES = %i[str sym int float true false nil].freeze
+        private_constant :LITERAL_TYPES
+
+        MSG_CHARACTER_CLASS = 'Use a character class instead of interpolating an array in a regexp.'
+        MSG_ALTERNATION = 'Use alternation instead of interpolating an array in a regexp.'
+        MSG_UNKNOWN = 'Use alternation or a character class instead of interpolating an array ' \
+                      'in a regexp.'
+
+        def on_interpolation(begin_node)
+          return unless (final_node = begin_node.children.last)
+          return unless final_node.array_type?
+          return unless begin_node.parent.regexp_type?
+
+          if array_of_literal_values?(final_node)
+            register_array_of_literal_values(begin_node, final_node)
+          else
+            register_array_of_nonliteral_values(begin_node)
+          end
+        end
+
+        private
+
+        def array_of_literal_values?(node)
+          node.each_value.all? { |value| value.type?(*LITERAL_TYPES) }
+        end
+
+        def register_array_of_literal_values(begin_node, node)
+          array_values = array_values(node)
+
+          if character_class?(array_values)
+            message = MSG_CHARACTER_CLASS
+            replacement = character_class_for(array_values)
+          else
+            message = MSG_ALTERNATION
+            replacement = alternation_for(array_values)
+          end
+
+          add_offense(begin_node, message: message) do |corrector|
+            corrector.replace(begin_node, replacement)
+          end
+        end
+
+        def register_array_of_nonliteral_values(node)
+          # Add offense but do not correct if the array contains any nonliteral values.
+          add_offense(node, message: MSG_UNKNOWN)
+        end
+
+        def array_values(node)
+          node.each_value.map do |value|
+            value.respond_to?(:value) ? value.value : value.source
+          end
+        end
+
+        def character_class?(values)
+          values.all? { |v| v.to_s.length == 1 }
+        end
+
+        def character_class_for(values)
+          "[#{escape_values(values).join}]"
+        end
+
+        def alternation_for(values)
+          "(?:#{escape_values(values).join('|')})"
+        end
+
+        def escape_values(values)
+          # This may add extraneous escape characters, but they can be cleaned up
+          # by `Style/RedundantRegexpEscape`.
+          values.map { |value| Regexp.escape(value.to_s) }
+        end
+      end
+    end
+  end
+end

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

@@ -17,24 +17,24 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   if some_var = true
+      #   if some_var = value
       #     do_something
       #   end
       #
       #   # good
-      #   if some_var == true
+      #   if some_var == value
       #     do_something
       #   end
       #
       # @example AllowSafeAssignment: true (default)
       #   # good
-      #   if (some_var = true)
+      #   if (some_var = value)
       #     do_something
       #   end
       #
       # @example AllowSafeAssignment: false
       #   # bad
-      #   if (some_var = true)
+      #   if (some_var = value)
       #     do_something
       #   end
       #
@@ -50,11 +50,9 @@ module RuboCop
         MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED =
           'Use `==` if you meant to do a comparison or move the assignment ' \
           'up out of the condition.'
-        ASGN_TYPES = [:begin, *AST::Node::EQUALS_ASSIGNMENTS, :send].freeze
+        ASGN_TYPES = [:begin, *AST::Node::EQUALS_ASSIGNMENTS, :send, :csend].freeze
 
         def on_if(node)
-          return if node.condition.block_type?
-
           traverse_node(node.condition) do |asgn_node|
             next :skip_children if skip_children?(asgn_node)
             next if allowed_construct?(asgn_node)
@@ -88,14 +86,14 @@ module RuboCop
         end
 
         def skip_children?(asgn_node)
-          (asgn_node.send_type? && !asgn_node.assignment_method?) ||
+          (asgn_node.call_type? && !asgn_node.assignment_method?) ||
             empty_condition?(asgn_node) ||
             (safe_assignment_allowed? && safe_assignment?(asgn_node))
         end
 
         def traverse_node(node, &block)
           # if the node is a block, any assignments are irrelevant
-          return if node.block_type?
+          return if node.any_block_type?
 
           result = yield node if ASGN_TYPES.include?(node.type)
 

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

@@ -17,8 +17,7 @@ module RuboCop
       class BigDecimalNew < Base
         extend AutoCorrector
 
-        MSG = '`%<double_colon>sBigDecimal.new()` is deprecated. ' \
-              'Use `%<double_colon>sBigDecimal()` instead.'
+        MSG = '`BigDecimal.new()` is deprecated. Use `BigDecimal()` instead.'
         RESTRICT_ON_SEND = %i[new].freeze
 
         # @!method big_decimal_new(node)
@@ -28,13 +27,11 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          big_decimal_new(node) do |captured_value|
-            double_colon = captured_value ? '::' : ''
-            message = format(MSG, double_colon: double_colon)
-
-            add_offense(node.loc.selector, message: message) do |corrector|
+          big_decimal_new(node) do |cbase|
+            add_offense(node.loc.selector) do |corrector|
               corrector.remove(node.loc.selector)
               corrector.remove(node.loc.dot)
+              corrector.remove(cbase) if cbase
             end
           end
         end