rubocop 0.80.0 → 1.42.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop looks for trailing whitespace in the source code.
+      # Looks for trailing whitespace in the source code.
       #
       # @example
       #   # The line in this example contains spaces after the 0.
@@ -21,6 +21,17 @@ module RuboCop
       #     x = 0
       #   RUBY
       #
+      #   # ok
+      #   code = <<~RUBY
+      #     x = 0 #{}
+      #   RUBY
+      #
+      #   # good
+      #   trailing_whitespace = ' '
+      #   code = <<~RUBY
+      #     x = 0#{trailing_whitespace}
+      #   RUBY
+      #
       # @example AllowInHeredoc: true
       #   # The line in this example contains spaces after the 0.
       #   # good
@@ -28,48 +39,91 @@ module RuboCop
       #     x = 0
       #   RUBY
       #
-      class TrailingWhitespace < Cop
+      class TrailingWhitespace < Base
         include RangeHelp
+        include Heredoc
+        extend AutoCorrector
 
         MSG = 'Trailing whitespace detected.'
 
-        def investigate(processed_source)
-          heredoc_ranges = extract_heredoc_ranges(processed_source.ast)
+        def on_new_investigation
           processed_source.lines.each_with_index do |line, index|
-            lineno = index + 1
-
             next unless line.end_with?(' ', "\t")
-            next if skip_heredoc? && inside_heredoc?(heredoc_ranges, lineno)
 
-            range = source_range(processed_source.buffer,
-                                 lineno,
-                                 (line.rstrip.length)...(line.length))
+            process_line(line, index + 1)
+          end
+        end
+
+        def on_heredoc(_node); end
+
+        private
+
+        def process_line(line, lineno)
+          heredoc = find_heredoc(lineno)
+          return if skip_heredoc? && heredoc
 
-            add_offense(range, location: range)
+          range = offense_range(lineno, line)
+          add_offense(range) do |corrector|
+            if heredoc
+              process_line_in_heredoc(corrector, range, heredoc)
+            else
+              corrector.remove(range)
+            end
           end
         end
 
-        def autocorrect(range)
-          ->(corrector) { corrector.remove(range) }
+        def process_line_in_heredoc(corrector, range, heredoc)
+          indent_level = indent_level(find_heredoc(range.line).loc.heredoc_body.source)
+          whitespace_only = whitespace_only?(range)
+          if whitespace_only && whitespace_is_indentation?(range, indent_level)
+            corrector.remove(range)
+          elsif !static?(heredoc)
+            range = range_between(range.begin_pos + indent_level, range.end_pos) if whitespace_only
+            corrector.wrap(range, "\#{'", "'}")
+          end
         end
 
-        private
+        def whitespace_is_indentation?(range, level)
+          range.source[/[ \t]+/].length <= level
+        end
+
+        def whitespace_only?(range)
+          source = range_with_surrounding_space(range).source
+          source.start_with?("\n") && source.end_with?("\n")
+        end
+
+        def static?(heredoc)
+          heredoc.loc.expression.source.end_with? "'"
+        end
 
         def skip_heredoc?
           cop_config.fetch('AllowInHeredoc', false)
         end
 
-        def inside_heredoc?(heredoc_ranges, line_number)
-          heredoc_ranges.any? { |r| r.include?(line_number) }
+        def find_heredoc(line_number)
+          heredocs.each { |node, r| return node if r.include?(line_number) }
+          nil
+        end
+
+        def heredocs
+          @heredocs ||= extract_heredocs(processed_source.ast)
         end
 
-        def extract_heredoc_ranges(ast)
+        def extract_heredocs(ast)
           return [] unless ast
 
-          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
+          heredocs = []
+          ast.each_node(:str, :dstr, :xstr) do |node|
+            next unless node.heredoc?
+
             body = node.location.heredoc_body
-            (body.first_line...body.last_line)
+            heredocs << [node, body.first_line...body.last_line]
           end
+          heredocs
+        end
+
+        def offense_range(lineno, line)
+          source_range(processed_source.buffer, lineno, (line.rstrip.length)...(line.length))
         end
       end
     end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Legacy
+      # Legacy support for Corrector#corrections
+      # See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
+      class CorrectionsProxy
+        def initialize(corrector)
+          @corrector = corrector
+        end
+
+        def <<(callable)
+          suppress_clobbering { @corrector.transaction { callable.call(@corrector) } }
+        end
+
+        def empty?
+          @corrector.empty?
+        end
+
+        def concat(corrections)
+          if corrections.is_a?(CorrectionsProxy)
+            suppress_clobbering { corrector.merge!(corrections.corrector) }
+          else
+            corrections.each { |correction| self << correction }
+          end
+        end
+
+        protected
+
+        attr_reader :corrector
+
+        private
+
+        def suppress_clobbering
+          yield
+        rescue ::Parser::ClobberingError
+          # ignore Clobbering errors
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Legacy
+      # Legacy Corrector for v0 API support.
+      # See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
+      class Corrector < RuboCop::Cop::Corrector
+        # Support legacy second argument
+        def initialize(source, corr = [])
+          super(source)
+          if corr.is_a?(CorrectionsProxy)
+            merge!(corr.send(:corrector))
+          else
+            # warn "Corrector.new with corrections is deprecated." unless corr.empty? TODO
+            corr.each { |c| corrections << c }
+          end
+        end
+
+        def corrections
+          # warn "#corrections is deprecated. Open an issue if you have a valid usecase." TODO
+          CorrectionsProxy.new(self)
+        end
+      end
+    end
+  end
+end

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,9 +3,12 @@
 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
@@ -15,6 +18,8 @@ module RuboCop
       #
       #   # good
       #   # With parentheses, there's no ambiguity.
+      #   some_method(a { |val| puts val })
+      #   # or (different meaning)
       #   some_method(a) { |val| puts val }
       #
       #   # good
@@ -24,37 +29,65 @@ module RuboCop
       #   # good
       #   # Lambda arguments require no disambiguation
       #   foo = ->(bar) { bar.baz }
-      class AmbiguousBlockAssociation < Cop
+      #
+      # @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
+        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.'
 
         def on_send(node)
-          return if !node.arguments? || node.parenthesized? ||
-                    node.last_argument.lambda? || allowed_method?(node)
+          return unless node.arguments?
 
           return unless ambiguous_block_association?(node)
+          return if node.parenthesized? || node.last_argument.lambda_or_proc? ||
+                    allowed_method_pattern?(node)
+
+          message = message(node)
 
-          add_offense(node)
+          add_offense(node, message: message)
         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.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
       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
@@ -20,15 +20,15 @@ module RuboCop
       #
       #   # With parentheses, there's no ambiguity.
       #   do_something(*some_array)
-      class AmbiguousOperator < Cop
-        include ParserDiagnostic
+      class AmbiguousOperator < Base
+        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,19 +36,67 @@ 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 on_new_investigation
+          processed_source.diagnostics.each do |diagnostic|
+            next unless diagnostic.reason == :ambiguous_prefix
+
+            offense_node = find_offense_node_by(diagnostic)
+            next unless offense_node
+
+            message = message(diagnostic)
+
+            add_offense(
+              diagnostic.location, message: message, severity: diagnostic.level
+            ) do |corrector|
+              add_parentheses(offense_node, corrector)
+            end
+          end
+        end
 
         private
 
-        def relevant_diagnostic?(diagnostic)
-          diagnostic.reason == :ambiguous_prefix
+        def find_offense_node_by(diagnostic)
+          ast = processed_source.ast
+          ast.each_node(:splat, :block_pass, :kwsplat) do |node|
+            next unless offense_position?(node, diagnostic)
+
+            offense_node = offense_node(node)
+            return offense_node if offense_node
+          end
+
+          ast.each_node(:send).find do |send_node|
+            first_argument = send_node.first_argument
+
+            first_argument &&
+              offense_position?(first_argument, diagnostic) &&
+              unary_operator?(first_argument, diagnostic)
+          end
         end
 
-        def alternative_message(diagnostic)
+        def message(diagnostic)
           operator = diagnostic.location.source
           hash = AMBIGUITIES[operator]
           format(MSG_FORMAT, hash)
         end
+
+        def offense_position?(node, diagnostic)
+          node.source_range.begin_pos == diagnostic.location.begin_pos
+        end
+
+        def offense_node(node)
+          case node.type
+          when :splat, :block_pass
+            node.parent
+          when :kwsplat
+            node.parent.parent
+          end
+        end
+
+        def unary_operator?(node, diagnostic)
+          node.source.start_with?(diagnostic.arguments[:prefix])
+        end
       end
     end
   end

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,105 @@
+# 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)
+      #   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)..(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
+        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
+
+        def acceptable?(node)
+          node.begin_type? ||
+            node.literal? ||
+            node.variable? || node.const_type? || node.self_type? ||
+            (node.call_type? && acceptable_call?(node))
+        end
+
+        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?
+
+          require_parentheses_for_method_chain? || node.receiver.nil?
+        end
+
+        def require_parentheses_for_method_chain?
+          !cop_config['RequireParenthesesForMethodChains']
+        end
+      end
+    end
+  end
+end