rubocop 0.93.1 → 1.79.2

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for mistyped shorthand assignments.
+      #
+      # @example
+      #   # bad
+      #   x =- y
+      #   x =+ y
+      #   x =* y
+      #   x =! y
+      #
+      #   # good
+      #   x -= y # or x = -y
+      #   x += y # or x = +y
+      #   x *= y # or x = *y
+      #   x != y # or x = !y
+      #
+      class AmbiguousAssignment < Base
+        include RangeHelp
+
+        MSG = 'Suspicious assignment detected. Did you mean `%<op>s`?'
+
+        SIMPLE_ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].freeze
+
+        MISTAKES = { '=-' => '-=', '=+' => '+=', '=*' => '*=', '=!' => '!=' }.freeze
+
+        def on_asgn(node)
+          return unless (rhs = rhs(node))
+
+          range = range_between(node.loc.operator.end_pos - 1, rhs.source_range.begin_pos + 1)
+          source = range.source
+          return unless MISTAKES.key?(source)
+
+          add_offense(range, message: format(MSG, op: MISTAKES[source]))
+        end
+
+        SIMPLE_ASSIGNMENT_TYPES.each { |asgn_type| alias_method :"on_#{asgn_type}", :on_asgn }
+
+        private
+
+        def rhs(node)
+          if node.casgn_type?
+            node.children[2]
+          else
+            node.children[1]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,16 +3,17 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for ambiguous block association with method
+      # Checks for ambiguous block association with method
       # when param passed without parentheses.
       #
+      # This cop can customize allowed methods with `AllowedMethods`.
+      # By default, there are no methods to allowed.
+      #
       # @example
       #
       #   # bad
       #   some_method a { |val| puts val }
       #
-      # @example
-      #
       #   # good
       #   # With parentheses, there's no ambiguity.
       #   some_method(a { |val| puts val })
@@ -26,7 +27,34 @@ module RuboCop
       #   # good
       #   # Lambda arguments require no disambiguation
       #   foo = ->(bar) { bar.baz }
+      #
+      # @example AllowedMethods: [] (default)
+      #
+      #   # bad
+      #   expect { do_something }.to change { object.attribute }
+      #
+      # @example AllowedMethods: [change]
+      #
+      #   # good
+      #   expect { do_something }.to change { object.attribute }
+      #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   expect { do_something }.to change { object.attribute }
+      #
+      # @example AllowedPatterns: ['change']
+      #
+      #   # good
+      #   expect { do_something }.to change { object.attribute }
+      #   expect { do_something }.to not_change { object.attribute }
+      #
       class AmbiguousBlockAssociation < Base
+        extend AutoCorrector
+
+        include AllowedMethods
+        include AllowedPattern
+
         MSG = 'Parenthesize the param `%<param>s` to make sure that the ' \
               'block will be associated with the `%<method>s` method ' \
               'call.'
@@ -35,31 +63,41 @@ module RuboCop
           return unless node.arguments?
 
           return unless ambiguous_block_association?(node)
-          return if node.parenthesized? ||
-                    node.last_argument.lambda? || allowed_method?(node)
+          return if node.parenthesized? || node.last_argument.lambda_or_proc? ||
+                    allowed_method_pattern?(node)
 
           message = message(node)
 
-          add_offense(node, message: message)
+          add_offense(node, message: message) do |corrector|
+            wrap_in_parentheses(corrector, node)
+          end
         end
         alias on_csend on_send
 
         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?(node)
-          node.assignment? || node.operator_method? || node.method?(:[])
+        def allowed_method_pattern?(node)
+          node.assignment? || node.operator_method? || node.method?(:[]) ||
+            allowed_method?(node.last_argument.method_name) ||
+            matches_allowed_pattern?(node.last_argument.send_node.source)
         end
 
         def message(send_node)
           block_param = send_node.last_argument
 
-          format(MSG, param: block_param.source,
-                      method: block_param.send_node.source)
+          format(MSG, param: block_param.source, method: block_param.send_node.source)
+        end
+
+        def wrap_in_parentheses(corrector, node)
+          range = node.loc.selector.end.join(node.first_argument.source_range.begin)
+
+          corrector.remove(range)
+          corrector.insert_before(range, '(')
+          corrector.insert_after(node.last_argument, ')')
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for ambiguous operators in the first argument of a
+      # Checks for ambiguous operators in the first argument of a
       # method invocation without parentheses.
       #
       # @example
@@ -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.
@@ -24,11 +22,11 @@ module RuboCop
         extend AutoCorrector
 
         AMBIGUITIES = {
-          '+'  => { actual: 'positive number', possible: 'addition' },
-          '-'  => { actual: 'negative number', possible: 'subtraction' },
-          '*'  => { actual: 'splat',           possible: 'multiplication' },
-          '&'  => { actual: 'block',           possible: 'binary AND' },
-          '**' => { actual: 'keyword splat',   possible: 'exponent' }
+          '+'  => { actual: 'positive number', possible: 'an addition' },
+          '-'  => { actual: 'negative number', possible: 'a subtraction' },
+          '*'  => { actual: 'splat',           possible: 'a multiplication' },
+          '&'  => { actual: 'block',           possible: 'a binary AND' },
+          '**' => { actual: 'keyword splat',   possible: 'an exponent' }
         }.each do |key, hash|
           hash[:operator] = key
         end
@@ -36,7 +34,11 @@ module RuboCop
         MSG_FORMAT = 'Ambiguous %<actual>s operator. Parenthesize the method ' \
                      "arguments if it's surely a %<actual>s operator, or add " \
                      'a whitespace to the right of the `%<operator>s` if it ' \
-                     'should be a %<possible>s.'
+                     'should be %<possible>s.'
+
+        def self.autocorrect_incompatible_with
+          [Naming::BlockForwarding]
+        end
 
         def on_new_investigation
           processed_source.diagnostics.each do |diagnostic|

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Looks for expressions containing multiple binary operators
+      # where precedence is ambiguous due to lack of parentheses. For example,
+      # in `1 + 2 * 3`, the multiplication will happen before the addition, but
+      # lexically it appears that the addition will happen first.
+      #
+      # The cop does not consider unary operators (ie. `!a` or `-b`) or comparison
+      # operators (ie. `a =~ b`) because those are not ambiguous.
+      #
+      # NOTE: Ranges are handled by `Lint/AmbiguousRange`.
+      #
+      # @example
+      #   # bad
+      #   a + b * c
+      #   a || b && c
+      #   a ** b + c
+      #
+      #   # good (different precedence)
+      #   a + (b * c)
+      #   a || (b && c)
+      #   (a ** b) + c
+      #
+      #   # good (same precedence)
+      #   a + b + c
+      #   a * b / c % d
+      class AmbiguousOperatorPrecedence < Base
+        extend AutoCorrector
+
+        # See https://ruby-doc.org/core-3.0.2/doc/syntax/precedence_rdoc.html
+        PRECEDENCE = [
+          %i[**],
+          %i[* / %],
+          %i[+ -],
+          %i[<< >>],
+          %i[&],
+          %i[| ^],
+          %i[&&],
+          %i[||]
+        ].freeze
+        RESTRICT_ON_SEND = PRECEDENCE.flatten.freeze
+        MSG = 'Wrap expressions with varying precedence with parentheses to avoid ambiguity.'
+
+        def on_new_investigation
+          # Cache the precedence of each node being investigated
+          # so that we only need to calculate it once
+          @node_precedences = {}
+          super
+        end
+
+        def on_and(node)
+          return unless (parent = node.parent)
+
+          return if parent.begin_type? # if the `and` is in a `begin`, it's parenthesized already
+          return unless parent.or_type?
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def on_send(node)
+          return if node.parenthesized?
+
+          return unless (parent = node.parent)
+          return unless operator?(parent)
+          return unless greater_precedence?(node, parent)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def precedence(node)
+          @node_precedences.fetch(node) do
+            PRECEDENCE.index { |operators| operators.include?(operator_name(node)) }
+          end
+        end
+
+        def operator?(node)
+          (node.send_type? && RESTRICT_ON_SEND.include?(node.method_name)) || node.operator_keyword?
+        end
+
+        def greater_precedence?(node1, node2)
+          node1_precedence = precedence(node1)
+          node2_precedence = precedence(node2)
+          return false unless node1_precedence && node2_precedence
+
+          node2_precedence > node1_precedence
+        end
+
+        def operator_name(node)
+          if node.send_type?
+            node.method_name
+          else
+            node.operator.to_sym
+          end
+        end
+
+        def autocorrect(corrector, node)
+          corrector.wrap(node, '(', ')')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for ambiguous ranges.
+      #
+      # Ranges have quite low precedence, which leads to unexpected behavior when
+      # using a range with other operators. This cop avoids that by making ranges
+      # explicit by requiring parenthesis around complex range boundaries (anything
+      # that is not a literal: numerics, strings, symbols, etc.).
+      #
+      # 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.
+      #
+      # 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 autocorrects 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 autocorrect is unsafe (it will not
+      #   change the behavior of the code, but will not necessarily match the
+      #   intent of the program).
+      #
+      # @example
+      #   # bad
+      #   x || 1..2
+      #   x - 1..2
+      #   (x || 1..2)
+      #   x || 1..y || 2
+      #   1..2.to_a
+      #
+      #   # good, unambiguous
+      #   1..2
+      #   'a'..'z'
+      #   :bar..:baz
+      #   MyClass::MIN..MyClass::MAX
+      #   @min..@max
+      #   a..b
+      #   -a..b
+      #
+      #   # good, ambiguity removed
+      #   x || (1..2)
+      #   (x - 1)..2
+      #   (x || 1)..2
+      #   (x || 1)..(y || 2)
+      #   (1..2).to_a
+      #
+      # @example RequireParenthesesForMethodChains: false (default)
+      #   # good
+      #   a.foo..b.bar
+      #   (a.foo)..(b.bar)
+      #
+      # @example RequireParenthesesForMethodChains: true
+      #   # bad
+      #   a.foo..b.bar
+      #
+      #   # good
+      #   (a.foo)..(b.bar)
+      class AmbiguousRange < Base
+        include RationalLiteral
+        extend AutoCorrector
+
+        MSG = 'Wrap complex range boundaries with parentheses to avoid ambiguity.'
+
+        def on_irange(node)
+          each_boundary(node) do |boundary|
+            next if acceptable?(boundary)
+
+            add_offense(boundary) do |corrector|
+              corrector.wrap(boundary, '(', ')')
+            end
+          end
+        end
+        alias on_erange on_irange
+
+        private
+
+        def each_boundary(range)
+          yield range.begin if range.begin
+          yield range.end if range.end
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def acceptable?(node)
+          node.begin_type? ||
+            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?
+
+          # Require parentheses when making a method call on a literal
+          # 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
+
+        def require_parentheses_for_method_chain?
+          !cop_config['RequireParenthesesForMethodChains']
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for ambiguous regexp literals in the first argument of
+      # Checks for ambiguous regexp literals in the first argument of
       # a method invocation without parentheses.
       #
       # @example
@@ -15,8 +15,6 @@ module RuboCop
       #   # (i.e. `do_something./(pattern)./(i)`)
       #   do_something /pattern/i
       #
-      # @example
-      #
       #   # good
       #
       #   # With parentheses, there's no ambiguity.
@@ -30,7 +28,11 @@ module RuboCop
 
         def on_new_investigation
           processed_source.diagnostics.each do |diagnostic|
-            next unless diagnostic.reason == :ambiguous_literal
+            if target_ruby_version >= 3.0
+              next unless diagnostic.reason == :ambiguous_regexp
+            else
+              next unless diagnostic.reason == :ambiguous_literal
+            end
 
             offense_node = find_offense_node_by(diagnostic)
 
@@ -46,20 +48,24 @@ module RuboCop
           node = processed_source.ast.each_node(:regexp).find do |regexp_node|
             regexp_node.source_range.begin_pos == diagnostic.location.begin_pos
           end
-
           find_offense_node(node.parent, node)
         end
 
         def find_offense_node(node, regexp_receiver)
-          return node unless node.parent
+          return node if first_argument_is_regexp?(node) || !node.parent
 
-          if node.parent.send_type? || method_chain_to_regexp_receiver?(node, regexp_receiver)
+          if (node.parent.send_type? && node.receiver) ||
+             method_chain_to_regexp_receiver?(node, regexp_receiver)
             node = find_offense_node(node.parent, regexp_receiver)
           end
 
           node
         end
 
+        def first_argument_is_regexp?(node)
+          node.send_type? && node.first_argument&.regexp_type?
+        end
+
         def method_chain_to_regexp_receiver?(node, regexp_receiver)
           return false unless (parent = node.parent)
           return false unless (parent_receiver = parent.receiver)

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