rubocop 0.82.0 → 1.18.4

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

@@ -14,28 +14,28 @@ 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.'
+        RESTRICT_ON_SEND = %i[new].freeze
 
+        # @!method big_decimal_new(node)
         def_node_matcher :big_decimal_new, <<~PATTERN
           (send
             (const ${nil? cbase} :BigDecimal) :new ...)
         PATTERN
 
         def on_send(node)
-          return unless big_decimal_new(node) do |captured_value|
+          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,55 @@
+# 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 / x
+      #   x.top >= x.top
+      #
+      #   if a.x != 0 && a.x != 0
+      #     do_something
+      #   end
+      #
+      #   def childs?
+      #     left_child || left_child
+      #   end
+      #
+      #   # good
+      #   x + x
+      #   1 << 1
+      #
+      class BinaryOperatorWithIdenticalOperands < Base
+        MSG = 'Binary operator `%<op>s` has identical operands.'
+        ALLOWED_MATH_OPERATORS = %i[+ * ** << >>].to_set.freeze
+
+        def on_send(node)
+          return unless node.binary_operation?
+
+          lhs, operation, rhs = *node
+          return if ALLOWED_MATH_OPERATORS.include?(node.method_name)
+
+          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,28 +21,36 @@ module RuboCop
       #
       #   # good
       #   false
-      class BooleanSymbol < Cop
-        MSG = 'Symbol with a boolean name - ' \
-              'you probably meant to use `%<boolean>s`.'
+      class BooleanSymbol < Base
+        extend AutoCorrector
 
+        MSG = 'Symbol with a boolean name - you probably meant to use `%<boolean>s`.'
+
+        # @!method boolean_symbol?(node)
         def_node_matcher :boolean_symbol?, '(sym {:true :false})'
 
         def on_sym(node)
           return unless boolean_symbol?(node)
 
-          add_offense(node, message: format(MSG, boolean: node.value))
+          parent = node.parent
+          return if parent&.array_type? && parent&.percent_literal?(:symbol)
+
+          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_definition_in_block.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Do not define constants within a block, since the block's scope does not
+      # isolate or namespace the constant in any way.
+      #
+      # If you are trying to define that constant once, define it outside of
+      # the block instead, or use a variable or method if defining the constant
+      # in the outer scope would be problematic.
+      #
+      # For meta-programming, use `const_set`.
+      #
+      # @example
+      #   # bad
+      #   task :lint do
+      #     FILES_TO_LINT = Dir['lib/*.rb']
+      #   end
+      #
+      #   # bad
+      #   describe 'making a request' do
+      #     class TestRequest; end
+      #   end
+      #
+      #   # bad
+      #   module M
+      #     extend ActiveSupport::Concern
+      #     included do
+      #       LIST = []
+      #     end
+      #   end
+      #
+      #   # good
+      #   task :lint do
+      #     files_to_lint = Dir['lib/*.rb']
+      #   end
+      #
+      #   # good
+      #   describe 'making a request' do
+      #     let(:test_request) { Class.new }
+      #     # see also `stub_const` for RSpec
+      #   end
+      #
+      #   # good
+      #   module M
+      #     extend ActiveSupport::Concern
+      #     included do
+      #       const_set(:LIST, [])
+      #     end
+      #   end
+      #
+      # @example AllowedMethods: ['enums'] (default)
+      #   # good
+      #
+      #   # `enums` for Typed Enums via `T::Enum` in Sorbet.
+      #   # https://sorbet.org/docs/tenum
+      #   class TestEnum < T::Enum
+      #     enums do
+      #       Foo = new("foo")
+      #     end
+      #   end
+      #
+      class ConstantDefinitionInBlock < Base
+        include AllowedMethods
+
+        MSG = 'Do not define constants this way within a block.'
+
+        # @!method constant_assigned_in_block?(node)
+        def_node_matcher :constant_assigned_in_block?, <<~PATTERN
+          ({^block_type? [^begin_type? ^^block_type?]} nil? ...)
+        PATTERN
+
+        # @!method module_defined_in_block?(node)
+        def_node_matcher :module_defined_in_block?, <<~PATTERN
+          ({^block_type? [^begin_type? ^^block_type?]} ...)
+        PATTERN
+
+        def on_casgn(node)
+          return if !constant_assigned_in_block?(node) || allowed_method?(method_name(node))
+
+          add_offense(node)
+        end
+
+        def on_class(node)
+          return if !module_defined_in_block?(node) || allowed_method?(method_name(node))
+
+          add_offense(node)
+        end
+        alias on_module on_class
+
+        private
+
+        def method_name(node)
+          node.ancestors.find(&:block_type?).send_node.method_name
+        end
+      end
+    end
+  end
+end

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.'
+
+        # @!method unqualified_const?(node)
+        def_node_matcher :unqualified_const?, <<~PATTERN
+          (const nil? #const_name?)
+        PATTERN
+
+        def on_const(node)
+          return if !unqualified_const?(node) || node.parent&.defined_module
+
+          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

@@ -3,7 +3,21 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for calls to debugger or pry.
+      # This cop checks for debug calls (such as `debugger` or `binding.pry`) that should
+      # not be kept for production code.
+      #
+      # The cop can be configured using `DebuggerMethods`. By default, a number of gems
+      # debug entrypoints are configured (`Kernel`, `Byebug`, `Capybara`, `Pry`, `Rails`,
+      # and `WebConsole`). Additional methods can be added.
+      #
+      # Specific default groups can be disabled if necessary:
+      #
+      # [source,yaml]
+      # ----
+      # Lint/Debugger:
+      #   WebConsole: ~
+      # ----
+      #
       #
       # @example
       #
@@ -32,32 +46,34 @@ module RuboCop
       #   def some_method
       #     do_something
       #   end
-      class Debugger < Cop
+      #
+      # @example DebuggerMethods: [my_debugger]
+      #
+      #   # bad (ok during development)
+      #
+      #   def some_method
+      #     my_debugger
+      #   end
+      class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
 
-        def_node_matcher :kernel?, <<~PATTERN
-          {
-            (const nil? :Kernel)
-            (const (cbase) :Kernel)
-          }
-        PATTERN
+        RESTRICT_ON_SEND = [].freeze
 
-        def_node_matcher :debugger_call?, <<~PATTERN
-          {(send {nil? #kernel?} {:debugger :byebug :remote_byebug} ...)
-           (send (send {#kernel? nil?} :binding)
-             {:pry :remote_pry :pry_remote :console} ...)
-           (send (const {nil? (cbase)} :Pry) :rescue ...)
-           (send nil? {:save_and_open_page
-                      :save_and_open_screenshot
-                      :save_screenshot} ...)}
+        # @!method kernel?(node)
+        def_node_matcher :kernel?, <<~PATTERN
+          (const {nil? cbase} :Kernel)
         PATTERN
 
-        def_node_matcher :binding_irb_call?, <<~PATTERN
-          (send (send {#kernel? nil?} :binding) :irb ...)
+        # @!method valid_receiver?(node, arg1)
+        def_node_matcher :valid_receiver?, <<~PATTERN
+          {
+            (const {nil? cbase} %1)
+            (send {nil? #kernel?} %1)
+          }
         PATTERN
 
         def on_send(node)
-          return unless debugger_call?(node) || binding_irb?(node)
+          return unless debugger_method?(node)
 
           add_offense(node)
         end
@@ -68,8 +84,32 @@ module RuboCop
           format(MSG, source: node.source)
         end
 
-        def binding_irb?(node)
-          binding_irb_call?(node)
+        def debugger_methods
+          @debugger_methods ||= begin
+            config = cop_config.fetch('DebuggerMethods', [])
+            values = config.is_a?(Array) ? config : config.values.flatten
+            values.map do |v|
+              next unless v
+
+              *receiver, method_name = v.split('.')
+              {
+                receiver: receiver.empty? ? nil : receiver.join.to_sym,
+                method_name: method_name.to_sym
+              }
+            end.compact
+          end
+        end
+
+        def debugger_method?(send_node)
+          debugger_methods.any? do |method|
+            next unless method[:method_name] == send_node.method_name
+
+            if method[:receiver].nil?
+              send_node.receiver.nil?
+            else
+              valid_receiver?(send_node.receiver, method[:receiver])
+            end
+          end
         end
       end
     end