rubocop 0.88.0 → 0.89.0

data/lib/rubocop/cop/internal_affairs/redundant_location_argument.rb

@@ -16,8 +16,9 @@ module RuboCop
       #   add_offense(node)
       #   add_offense(node, location: :selector)
       #
-      class RedundantLocationArgument < Cop
+      class RedundantLocationArgument < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Redundant location argument to `#add_offense`.'
 
@@ -28,15 +29,17 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          redundant_location_argument(node) { |argument| add_offense(argument) }
-        end
-
-        def autocorrect(node)
-          range = offending_range(node)
+          redundant_location_argument(node) do |argument|
+            add_offense(argument) do |corrector|
+              range = offending_range(argument)
 
-          ->(corrector) { corrector.remove(range) }
+              corrector.remove(range)
+            end
+          end
         end
 
+        private
+
         def offending_range(node)
           with_space = range_with_surrounding_space(range: node.loc.expression)
 

data/lib/rubocop/cop/internal_affairs/redundant_message_argument.rb

@@ -19,8 +19,9 @@ module RuboCop
       #   add_offense(node, message: CUSTOM_MSG)
       #   add_offense(node, message: message(other_node))
       #
-      class RedundantMessageArgument < Cop
+      class RedundantMessageArgument < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Redundant message argument to `#add_offense`.'
 
@@ -39,17 +40,15 @@ module RuboCop
         def on_send(node)
           node_type_check(node) do |node_arg, kwargs|
             find_offending_argument(node_arg, kwargs) do |pair|
-              add_offense(pair)
+              add_offense(pair) do |corrector|
+                range = offending_range(pair)
+
+                corrector.remove(range)
+              end
             end
           end
         end
 
-        def autocorrect(node)
-          range = offending_range(node)
-
-          ->(corrector) { corrector.remove(range) }
-        end
-
         private
 
         def offending_range(node)

data/lib/rubocop/cop/internal_affairs/useless_message_assertion.rb

@@ -13,7 +13,7 @@ module RuboCop
       #     # good
       #     expect(cop.messages).to eq(['Do not write bad code like that.'])
       #
-      class UselessMessageAssertion < Cop
+      class UselessMessageAssertion < Base
         MSG = 'Do not specify cop behavior using `described_class::MSG`.'
 
         def_node_search :described_class_msg, <<~PATTERN
@@ -24,7 +24,7 @@ module RuboCop
           (send (send nil? :expect #contains_described_class_msg?) :to ...)
         PATTERN
 
-        def investigate(_processed_source)
+        def on_new_investigation
           assertions_using_described_class_msg.each do |node|
             add_offense(node)
           end

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

@@ -213,7 +213,7 @@ module RuboCop
                 start_loc.column == source_line_column[:column]
             ''
           else
-            ' or ' + format_source_line_column(source_line_column)
+            " or #{format_source_line_column(source_line_column)}"
           end
         end
 

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module RuboCop
   module Cop
     module Layout

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module RuboCop
   module Cop
     module Layout
@@ -30,7 +28,8 @@ module RuboCop
       #   object.method(arg)         # this is a comment
       #   another_object.method(arg) # this is another comment
       #   some_object.method(arg)    # this is some comment
-      class ExtraSpacing < Cop
+      class ExtraSpacing < Base
+        extend AutoCorrector
         include PrecedingFollowingAlignment
         include RangeHelp
 
@@ -38,7 +37,7 @@ module RuboCop
         MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s ' \
                              'assignment.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
           @corrected = Set.new if force_equal_sign_alignment?
@@ -48,16 +47,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(range)
-          lambda do |corrector|
-            if range.source.end_with?('=')
-              align_equal_signs(range, corrector)
-            else
-              corrector.remove(range)
-            end
-          end
-        end
-
         private
 
         def check_tokens(ast, token1, token2)
@@ -74,7 +63,9 @@ module RuboCop
           return unless aligned_with_preceding_assignment(token) == :no
 
           message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
-          add_offense(token.pos, location: token.pos, message: message)
+          add_offense(token.pos, message: message) do |corrector|
+            align_equal_signs(token.pos, corrector)
+          end
         end
 
         def check_other(token1, token2, ast)
@@ -84,7 +75,9 @@ module RuboCop
           extra_space_range(token1, token2) do |range|
             next if ignored_range?(ast, range.begin_pos)
 
-            add_offense(range, location: range, message: MSG_UNNECESSARY)
+            add_offense(range, message: MSG_UNNECESSARY) do |corrector|
+              corrector.remove(range)
+            end
           end
         end
 

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

@@ -27,7 +27,7 @@ module RuboCop
               'multi-line method argument list.'
 
         def on_send(node)
-          args = node.arguments
+          args = node.arguments.dup
 
           # If there is a trailing hash arg without explicit braces, like this:
           #

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

@@ -161,11 +161,11 @@ module RuboCop
         end
 
         def heredoc_body(node)
-          node.loc.heredoc_body.source.scrub
+          node.loc.heredoc_body.source
         end
 
         def heredoc_end(node)
-          node.loc.heredoc_end.source.scrub
+          node.loc.heredoc_end.source
         end
       end
     end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module RuboCop
   module Cop
     module Layout

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

@@ -37,7 +37,7 @@ module RuboCop
           # ...then each key/value pair is treated as a method 'argument'
           # when determining where line breaks should appear.
           if (last_arg = args.last)
-            args = args.concat(args.pop.children) if last_arg.hash_type? && !last_arg.braces?
+            args = args[0...-1] + last_arg.children if last_arg.hash_type? && !last_arg.braces?
           end
 
           check_line_breaks(node, args)

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

@@ -96,7 +96,6 @@ module RuboCop
           )
         end
 
-        # rubocop:disable Metrics/AbcSize
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
@@ -115,7 +114,6 @@ module RuboCop
 
           range_between(starting_loc.begin_pos, ending_loc.end_pos).source
         end
-        # rubocop:enable Metrics/AbcSize
 
         # We will use ancestor or wrapper with access modifier.
 

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

@@ -66,7 +66,15 @@ module RuboCop
 
         def check_space_after_dot(node)
           dot_pos = node.loc.dot.end_pos
-          selector_pos = node.loc.selector.begin_pos
+
+          selector_pos =
+            # `Proc#call` shorthand syntax
+            if node.method?(:call) && !node.loc.selector
+              node.loc.begin.begin_pos
+            else
+              node.loc.selector.begin_pos
+            end
+
           check_space(dot_pos, selector_pos)
         end
 

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

@@ -24,18 +24,21 @@ module RuboCop
       #   # good
       #   # Lambda arguments require no disambiguation
       #   foo = ->(bar) { bar.baz }
-      class AmbiguousBlockAssociation < Cop
+      class AmbiguousBlockAssociation < Base
         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
 

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,18 +38,23 @@ module RuboCop
                      'a whitespace to the right of the `%<operator>s` if it ' \
                      'should be a %<possible>s.'
 
-        def autocorrect(node)
-          lambda do |corrector|
-            add_parentheses(node, corrector)
+        def on_new_investigation
+          processed_source.diagnostics.each do |diagnostic|
+            next unless diagnostic.reason == :ambiguous_prefix
+
+            offense_node = find_offense_node_by(diagnostic)
+            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
-        end
-
         def find_offense_node_by(diagnostic)
           ast = processed_source.ast
           ast.each_node(:splat, :block_pass, :kwsplat) do |node|
@@ -68,7 +73,7 @@ module RuboCop
           end
         end
 
-        def alternative_message(diagnostic)
+        def message(diagnostic)
           operator = diagnostic.location.source
           hash = AMBIGUITIES[operator]
           format(MSG_FORMAT, hash)

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

@@ -21,25 +21,27 @@ 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 autocorrect(node)
-          lambda do |corrector|
-            add_parentheses(node, corrector)
+        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
-        end
-
         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
@@ -47,10 +49,6 @@ module RuboCop
 
           node.parent
         end
-
-        def alternative_message(_diagnostic)
-          MSG
-        end
       end
     end
   end

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

@@ -34,7 +34,7 @@ module RuboCop
       #     do_something
       #   end
       #
-      class AssignmentInCondition < Cop
+      class AssignmentInCondition < Base
         include SafeAssignment
 
         MSG_WITH_SAFE_ASSIGNMENT_ALLOWED =
@@ -53,7 +53,7 @@ module RuboCop
             next :skip_children if skip_children?(asgn_node)
             next if allowed_construct?(asgn_node)
 
-            add_offense(asgn_node, location: :operator)
+            add_offense(asgn_node.loc.operator)
           end
         end
         alias on_while on_if

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

@@ -14,7 +14,9 @@ module RuboCop
       #   # good
       #   BigDecimal(123.456, 3)
       #
-      class BigDecimalNew < Cop
+      class BigDecimalNew < Base
+        extend AutoCorrector
+
         MSG = '`%<double_colon>sBigDecimal.new()` is deprecated. ' \
               'Use `%<double_colon>sBigDecimal()` instead.'
 
@@ -24,18 +26,16 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless big_decimal_new(node) do |captured_value|
+          return unless node.method?(:new)
+
+          big_decimal_new(node) do |captured_value|
             double_colon = captured_value ? '::' : ''
             message = format(MSG, double_colon: double_colon)
 
-            add_offense(node, location: :selector, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.loc.selector)
-            corrector.remove(node.loc.dot)
+            add_offense(node.loc.selector, message: message) do |corrector|
+              corrector.remove(node.loc.selector)
+              corrector.remove(node.loc.dot)
+            end
           end
         end
       end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for places where binary operator has identical operands.
+      #
+      # It covers arithmetic operators: `+`, `-`, `*`, `/`, `%`, `**`;
+      # comparison 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:
+      #   if wr.take_char == '\0' && wr.take_char == '\0'
+      #
+      # @example
+      #   # bad
+      #   x.top >= x.top
+      #
+      #   if a.x != 0 && a.x != 0
+      #     do_something
+      #   end
+      #
+      #   def childs?
+      #     left_child || left_child
+      #   end
+      #
+      class BinaryOperatorWithIdenticalOperands < Base
+        MSG = 'Binary operator `%<op>s` has identical operands.'
+
+        def on_send(node)
+          return unless node.binary_operation?
+
+          lhs, operation, rhs = *node
+          return if node.arithmetic_operation? && lhs.basic_literal? && rhs.basic_literal?
+
+          add_offense(node, message: format(MSG, op: operation)) if lhs == rhs
+        end
+
+        def on_and(node)
+          add_offense(node, message: format(MSG, op: node.operator)) if node.lhs == node.rhs
+        end
+        alias on_or on_and
+      end
+    end
+  end
+end