rubocop 0.85.1 → 0.89.1

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

@@ -0,0 +1,49 @@
+# 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 do
+            @corrector.transaction do
+              callable.call(@corrector)
+            end
+          end
+        end
+
+        def empty?
+          @corrector.empty?
+        end
+
+        def concat(corrections)
+          if corrections.is_a?(CorrectionsProxy)
+            suppress_clobbering do
+              corrector.merge!(corrections.corrector)
+            end
+          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,29 @@
+# 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 do |c|
+              corrections << c
+            end
+          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_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,50 @@
+# 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.'
+        MATH_OPERATORS = %i[+ - * / % ** << >> | ^].to_set.freeze
+
+        def on_send(node)
+          return unless node.binary_operation?
+
+          lhs, operation, rhs = *node
+          return if MATH_OPERATORS.include?(node.method_name) && 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

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

@@ -21,7 +21,9 @@ module RuboCop
       #
       #   # good
       #   false
-      class BooleanSymbol < Cop
+      class BooleanSymbol < Base
+        extend AutoCorrector
+
         MSG = 'Symbol with a boolean name - ' \
               'you probably meant to use `%<boolean>s`.'
 
@@ -30,19 +32,22 @@ module RuboCop
         def on_sym(node)
           return unless boolean_symbol?(node)
 
-          add_offense(node, message: format(MSG, boolean: node.value))
+          add_offense(node, message: format(MSG, boolean: node.value)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            boolean_literal = node.source.delete(':')
-            parent = node.parent
-            if parent&.pair_type? && node.equal?(parent.children[0])
-              corrector.remove(parent.loc.operator)
-              boolean_literal = "#{node.source} =>"
-            end
-            corrector.replace(node, boolean_literal)
+        private
+
+        def autocorrect(corrector, node)
+          boolean_literal = node.source.delete(':')
+          parent = node.parent
+          if parent&.pair_type? && node.equal?(parent.children[0])
+            corrector.remove(parent.loc.operator)
+            boolean_literal = "#{node.source} =>"
           end
+
+          corrector.replace(node, boolean_literal)
         end
       end
     end

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

@@ -47,7 +47,7 @@ module RuboCop
       #   def cook(dry_ingredients = self.dry_ingredients)
       #     dry_ingredients.combine
       #   end
-      class CircularArgumentReference < Cop
+      class CircularArgumentReference < Base
         MSG = 'Circular argument reference - `%<arg_name>s`.'
 
         def on_kwoptarg(node)

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Check that certain constants are fully qualified.
+      #
+      # This is not enabled by default because it would mark a lot of offenses
+      # unnecessarily.
+      #
+      # Generally, gems should fully qualify all constants to avoid conflicts with
+      # the code that uses the gem. Enable this cop without using `Only`/`Ignore`
+      #
+      # Large projects will over time end up with one or two constant names that
+      # are problematic because of a conflict with a library or just internally
+      # using the same name a namespace and a class. To avoid too many unnecessary
+      # offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
+      #
+      # @example
+      #   # By default checks every constant
+      #
+      #   # bad
+      #   User
+      #
+      #   # bad
+      #   User::Login
+      #
+      #   # good
+      #   ::User
+      #
+      #   # good
+      #   ::User::Login
+      #
+      # @example Only: ['Login']
+      #   # Restrict this cop to only being concerned about certain constants
+      #
+      #   # bad
+      #   Login
+      #
+      #   # good
+      #   ::Login
+      #
+      #   # good
+      #   User::Login
+      #
+      # @example Ignore: ['Login']
+      #   # Restrict this cop not being concerned about certain constants
+      #
+      #   # bad
+      #   User
+      #
+      #   # good
+      #   ::User::Login
+      #
+      #   # good
+      #   Login
+      #
+      class ConstantResolution < Base
+        MSG = 'Fully qualify this constant to avoid possibly ambiguous resolution.'
+
+        def_node_matcher :unqualified_const?, <<~PATTERN
+          (const nil? #const_name?)
+        PATTERN
+
+        def on_const(node)
+          return unless unqualified_const?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def const_name?(name)
+          name = name.to_s
+          (allowed_names.empty? || allowed_names.include?(name)) &&
+            !ignored_names.include?(name)
+        end
+
+        def allowed_names
+          cop_config['Only']
+        end
+
+        def ignored_names
+          cop_config['Ignore']
+        end
+      end
+    end
+  end
+end

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

@@ -32,9 +32,14 @@ module RuboCop
       #   def some_method
       #     do_something
       #   end
-      class Debugger < Cop
+      class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
 
+        DEBUGGER_METHODS = %i[
+          debugger byebug remote_byebug pry remote_pry pry_remote console rescue
+          save_and_open_page save_and_open_screenshot save_screenshot irb
+        ].to_set.freeze
+
         def_node_matcher :kernel?, <<~PATTERN
           {
             (const nil? :Kernel)
@@ -57,6 +62,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return unless DEBUGGER_METHODS.include?(node.method_name)
           return unless debugger_call?(node) || binding_irb?(node)
 
           add_offense(node)

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

@@ -20,7 +20,9 @@ module RuboCop
       #   File.exist?(some_path)
       #   Dir.exist?(some_path)
       #   block_given?
-      class DeprecatedClassMethods < Cop
+      class DeprecatedClassMethods < Base
+        extend AutoCorrector
+
         # Inner class to DeprecatedClassMethods.
         # This class exists to add abstraction and clean naming to the
         # objects that are going to be operated on.
@@ -60,20 +62,17 @@ module RuboCop
                                     replacement: :block_given?)
         ].freeze
 
+        DEPRECATED_METHODS = DEPRECATED_METHODS_OBJECT.map(&:deprecated_method).freeze
+
         def on_send(node)
+          return unless DEPRECATED_METHODS.include?(node.method_name)
+
           check(node) do |data|
             message = format(MSG, current: deprecated_method(data),
                                   prefer: replacement_method(data))
 
-            add_offense(node, location: :selector, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            check(node) do |data|
-              corrector.replace(node.loc.selector,
-                                data.replacement_method.to_s)
+            add_offense(node.loc.selector, message: message) do |corrector|
+              corrector.replace(node.loc.selector, data.replacement_method.to_s)
             end
           end
         end

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

@@ -15,7 +15,7 @@ module RuboCop
       #   OpenSSL::Cipher::AES.new(128, :GCM)
       #
       #   # good
-      #   OpenSSL::Cipher.new('AES-128-GCM')
+      #   OpenSSL::Cipher.new('aes-128-gcm')
       #
       # @example
       #
@@ -37,8 +37,9 @@ module RuboCop
       #   # good
       #   OpenSSL::Digest.digest('SHA256', 'foo')
       #
-      class DeprecatedOpenSSLConstant < Cop
+      class DeprecatedOpenSSLConstant < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)`' \
           ' instead of `%<original>s`.'
@@ -54,26 +55,29 @@ module RuboCop
 
         def on_send(node)
           return if node.arguments.any? { |arg| arg.variable? || arg.send_type? || arg.const_type? }
+          return unless algorithm_const(node)
 
-          add_offense(node) if algorithm_const(node)
+          message = message(node)
+
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           algorithm_constant, = algorithm_const(node)
 
-          lambda do |corrector|
-            corrector.remove(algorithm_constant.loc.double_colon)
-            corrector.remove(algorithm_constant.loc.name)
+          corrector.remove(algorithm_constant.loc.double_colon)
+          corrector.remove(algorithm_constant.loc.name)
 
-            corrector.replace(
-              correction_range(node),
-              "#{node.loc.selector.source}(#{replacement_args(node)})"
-            )
-          end
+          corrector.replace(
+            correction_range(node),
+            "#{node.loc.selector.source}(#{replacement_args(node)})"
+          )
         end
 
-        private
-
         def message(node)
           algorithm_constant, = algorithm_const(node)
           parent_constant = openssl_class(algorithm_constant)
@@ -127,9 +131,9 @@ module RuboCop
         end
 
         def build_cipher_arguments(node, algorithm_name)
-          algorithm_parts = algorithm_name.split('-')
-          size_and_mode = sanitize_arguments(node.arguments)
-          "'#{(algorithm_parts + size_and_mode + ['CBC']).take(3).join('-')}'"
+          algorithm_parts = algorithm_name.downcase.split('-')
+          size_and_mode = sanitize_arguments(node.arguments).map(&:downcase)
+          "'#{(algorithm_parts + size_and_mode + ['cbc']).take(3).join('-')}'"
         end
       end
     end

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

@@ -22,7 +22,9 @@ module RuboCop
       #   def initialize
       #     @x = 1
       #   end
-      class DisjunctiveAssignmentInConstructor < Cop
+      class DisjunctiveAssignmentInConstructor < Base
+        extend AutoCorrector
+
         MSG = 'Unnecessary disjunctive assignment. Use plain assignment.'
 
         def on_def(node)
@@ -73,7 +75,11 @@ module RuboCop
         # @param [Node] node a disjunctive assignment
         def check_disjunctive_assignment(node)
           lhs = node.child_nodes.first
-          add_offense(node, location: :operator) if lhs.ivasgn_type?
+          return unless lhs.ivasgn_type?
+
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '=')
+          end
         end
       end
     end

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

@@ -27,7 +27,7 @@ module RuboCop
       #   when 'second'
       #     do_something_else
       #   end
-      class DuplicateCaseCondition < Cop
+      class DuplicateCaseCondition < Base
         MSG = 'Duplicate `when` condition detected.'
 
         def on_case(case_node)

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there are no repeated conditions used in if 'elsif'.
+      #
+      # @example
+      #   # bad
+      #   if x == 1
+      #     do_something
+      #   elsif x == 1
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   if x == 1
+      #     do_something
+      #   elsif x == 2
+      #     do_something_else
+      #   end
+      #
+      class DuplicateElsifCondition < Base
+        MSG = 'Duplicate `elsif` condition detected.'
+
+        def on_if(node)
+          previous = []
+          while node.if? || node.elsif?
+            condition = node.condition
+            add_offense(condition) if previous.include?(condition)
+            previous << condition
+            node = node.else_branch
+            break unless node&.if_type?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -18,7 +18,7 @@ module RuboCop
       #   # good
       #
       #   hash = { food: 'apple', other_food: 'orange' }
-      class DuplicateHashKey < Cop
+      class DuplicateHashKey < Base
         include Duplication
 
         MSG = 'Duplicated key in hash literal.'