rubocop 0.78.0 → 1.13.0

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

@@ -37,11 +37,12 @@ module RuboCop
       #   class Foo; end
       #   # EOF
       #
-      class TrailingEmptyLines < Cop
+      class TrailingEmptyLines < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
-        def investigate(processed_source)
+        def on_new_investigation
           buffer = processed_source.buffer
           return if buffer.source.empty?
 
@@ -57,28 +58,22 @@ module RuboCop
 
           return unless blank_lines != wanted_blank_lines
 
-          offense_detected(buffer, wanted_blank_lines, blank_lines,
-                           whitespace_at_end)
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            corrector.replace(range, style == :final_newline ? "\n" : "\n\n")
-          end
+          offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end)
         end
 
         private
 
-        def offense_detected(buffer, wanted_blank_lines, blank_lines,
-                             whitespace_at_end)
+        def offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end)
           begin_pos = buffer.source.length - whitespace_at_end.length
           autocorrect_range = range_between(begin_pos, buffer.source.length)
           begin_pos += 1 unless whitespace_at_end.empty?
           report_range = range_between(begin_pos, buffer.source.length)
 
-          add_offense(autocorrect_range,
-                      location: report_range,
-                      message: message(wanted_blank_lines, blank_lines))
+          add_offense(
+            report_range, message: message(wanted_blank_lines, blank_lines)
+          ) do |corrector|
+            corrector.replace(autocorrect_range, style == :final_newline ? "\n" : "\n\n")
+          end
         end
 
         def ends_in_end?(processed_source)

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

@@ -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,49 +39,62 @@ module RuboCop
       #     x = 0
       #   RUBY
       #
-      class TrailingWhitespace < Cop
+      class TrailingWhitespace < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Trailing whitespace detected.'
 
-        def investigate(processed_source)
-          heredoc_ranges = extract_heredoc_ranges(processed_source.ast)
+        def on_new_investigation
+          @heredocs = extract_heredocs(processed_source.ast)
           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))
 
-            add_offense(range, location: range)
+            process_line(line, index + 1)
           end
         end
 
-        def autocorrect(range)
-          ->(corrector) { corrector.remove(range) }
+        private
+
+        def process_line(line, lineno)
+          heredoc = find_heredoc(lineno)
+          return if skip_heredoc? && heredoc
+
+          range = offense_range(lineno, line)
+          add_offense(range) do |corrector|
+            if heredoc
+              corrector.wrap(range, "\#{'", "'}") unless static?(heredoc)
+            else
+              corrector.remove(range)
+            end
+          end
         end
 
-        private
+        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 extract_heredoc_ranges(ast)
+        def extract_heredocs(ast)
           return [] unless ast
 
           ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
             body = node.location.heredoc_body
-            (body.first_line...body.last_line)
+            [node, body.first_line...body.last_line]
           end
         end
+
+        def offense_range(lineno, line)
+          source_range(processed_source.buffer, lineno, (line.rstrip.length)...(line.length))
+        end
       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/cop_api_v1_changelog.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/cop_api_v1_changelog.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
+      # This cop 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

@@ -6,6 +6,8 @@ module RuboCop
       # This cop checks for ambiguous block association with method
       # when param passed without parentheses.
       #
+      # This cop can customize ignored methods with `IgnoredMethods`.
+      #
       # @example
       #
       #   # bad
@@ -15,6 +17,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 +28,45 @@ module RuboCop
       #   # good
       #   # Lambda arguments require no disambiguation
       #   foo = ->(bar) { bar.baz }
-      class AmbiguousBlockAssociation < Cop
+      #
+      # @example IgnoredMethods: [change]
+      #
+      #   # good
+      #   expect { do_something }.to change { object.attribute }
+      class AmbiguousBlockAssociation < Base
+        include IgnoredMethods
+
         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? || allowed_method?(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?(:[])
+          node.assignment? || node.operator_method? || node.method?(:[]) ||
+            ignored_method?(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

@@ -20,8 +20,8 @@ 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' },
@@ -38,17 +38,65 @@ module RuboCop
                      'a whitespace to the right of the `%<operator>s` if it ' \
                      'should be a %<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_regexp_literal.rb

@@ -21,21 +21,51 @@ module RuboCop
       #
       #   # With parentheses, there's no ambiguity.
       #   do_something(/pattern/i)
-      class AmbiguousRegexpLiteral < Cop
-        include ParserDiagnostic
+      class AmbiguousRegexpLiteral < Base
+        extend AutoCorrector
 
         MSG = 'Ambiguous regexp literal. Parenthesize the method arguments ' \
               "if it's surely a regexp literal, or add a whitespace to the " \
               'right of the `/` if it should be a division.'
 
+        def on_new_investigation
+          processed_source.diagnostics.each do |diagnostic|
+            next unless diagnostic.reason == :ambiguous_literal
+
+            offense_node = find_offense_node_by(diagnostic)
+
+            add_offense(diagnostic.location, severity: diagnostic.level) do |corrector|
+              add_parentheses(offense_node, corrector)
+            end
+          end
+        end
+
         private
 
-        def relevant_diagnostic?(diagnostic)
-          diagnostic.reason == :ambiguous_literal
+        def find_offense_node_by(diagnostic)
+          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 alternative_message(_diagnostic)
-          MSG
+        def find_offense_node(node, regexp_receiver)
+          return node unless node.parent
+
+          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 method_chain_to_regexp_receiver?(node, regexp_receiver)
+          return false unless (parent = node.parent)
+          return false unless (parent_receiver = parent.receiver)
+
+          parent.parent && parent_receiver.receiver == regexp_receiver
         end
       end
     end