rubocop 0.76.0 → 1.50.0

data/lib/rubocop/cop/style/class_equality_comparison.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of `Object#instance_of?` instead of class comparison
+      # for equality.
+      # `==`, `equal?`, and `eql?` methods are allowed by default.
+      # These are customizable with `AllowedMethods` option.
+      #
+      # @example
+      #   # bad
+      #   var.class == Date
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #   var.class.name == 'Date'
+      #
+      #   # good
+      #   var.instance_of?(Date)
+      #
+      # @example AllowedMethods: [] (default)
+      #   # good
+      #   var.instance_of?(Date)
+      #
+      #   # bad
+      #   var.class == Date
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #   var.class.name == 'Date'
+      #   var.class.to_s == 'Date'
+      #   var.class.inspect == 'Date'
+      #
+      # @example AllowedMethods: [`==`]
+      #   # good
+      #   var.instance_of?(Date)
+      #   var.class == Date
+      #   var.class.name == 'Date'
+      #   var.class.to_s == 'Date'
+      #   var.class.inspect == 'Date'
+      #
+      #   # bad
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #
+      # @example AllowedPatterns: [] (default)
+      #   # good
+      #   var.instance_of?(Date)
+      #
+      #   # bad
+      #   var.class == Date
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #   var.class.name == 'Date'
+      #   var.class.to_s == 'Date'
+      #   var.class.inspect == 'Date'
+      #
+      # @example AllowedPatterns: ['eq']
+      #   # good
+      #   var.instance_of?(Date)
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #
+      #   # bad
+      #   var.class == Date
+      #   var.class.name == 'Date'
+      #   var.class.to_s == 'Date'
+      #   var.class.inspect == 'Date'
+      #
+      class ClassEqualityComparison < Base
+        include RangeHelp
+        include AllowedMethods
+        include AllowedPattern
+        extend AutoCorrector
+
+        MSG = 'Use `instance_of?%<class_argument>s` instead of comparing classes.'
+
+        RESTRICT_ON_SEND = %i[== equal? eql?].freeze
+        CLASS_NAME_METHODS = %i[name to_s inspect].freeze
+
+        # @!method class_comparison_candidate?(node)
+        def_node_matcher :class_comparison_candidate?, <<~PATTERN
+          (send
+            {$(send _ :class) (send $(send _ :class) #class_name_method?)}
+            {:== :equal? :eql?} $_)
+        PATTERN
+
+        def on_send(node)
+          def_node = node.each_ancestor(:def, :defs).first
+          return if def_node &&
+                    (allowed_method?(def_node.method_name) ||
+                    matches_allowed_pattern?(def_node.method_name))
+
+          class_comparison_candidate?(node) do |receiver_node, class_node|
+            range = offense_range(receiver_node, node)
+            class_argument = (class_name = class_name(class_node, node)) ? "(#{class_name})" : ''
+
+            add_offense(range, message: format(MSG, class_argument: class_argument)) do |corrector|
+              next unless class_name
+
+              corrector.replace(range, "instance_of?#{class_argument}")
+            end
+          end
+        end
+
+        private
+
+        def class_name(class_node, node)
+          if class_name_method?(node.children.first.method_name)
+            if (receiver = class_node.receiver) && class_name_method?(class_node.method_name)
+              return receiver.source
+            end
+
+            if class_node.str_type?
+              value = trim_string_quotes(class_node)
+              value.prepend('::') if require_cbase?(class_node)
+              return value
+            elsif unable_to_determine_type?(class_node)
+              # When a variable or return value of a method is used, it returns nil
+              # because the type is not known and cannot be suggested.
+              return
+            end
+          end
+
+          class_node.source
+        end
+
+        def class_name_method?(method_name)
+          CLASS_NAME_METHODS.include?(method_name)
+        end
+
+        def require_cbase?(class_node)
+          class_node.each_ancestor(:class, :module).any?
+        end
+
+        def unable_to_determine_type?(class_node)
+          class_node.variable? || class_node.call_type?
+        end
+
+        def trim_string_quotes(class_node)
+          class_node.source.delete('"').delete("'")
+        end
+
+        def offense_range(receiver_node, node)
+          range_between(receiver_node.loc.selector.begin_pos, node.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/class_methods.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of the class/module name instead of
+      # Checks for uses of the class/module name instead of
       # self, when defining class/module methods.
       #
       # @example
@@ -20,7 +20,9 @@ module RuboCop
       #       # ...
       #     end
       #   end
-      class ClassMethods < Cop
+      class ClassMethods < Base
+        extend AutoCorrector
+
         MSG = 'Use `self.%<method>s` instead of `%<class>s.%<method>s`.'
 
         def on_class(node)
@@ -29,30 +31,22 @@ module RuboCop
           if node.body.defs_type?
             check_defs(node.identifier, node.body)
           elsif node.body.begin_type?
-            node.body.each_child_node(:defs) do |def_node|
-              check_defs(node.identifier, def_node)
-            end
+            node.body.each_child_node(:defs) { |def_node| check_defs(node.identifier, def_node) }
           end
         end
         alias on_module on_class
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.name, 'self') }
-        end
-
         private
 
         def check_defs(name, node)
           # check if the class/module name matches the definee for the defs node
           return unless name == node.receiver
 
-          add_offense(node.receiver, location: :name)
-        end
-
-        def message(node)
-          _, class_name = *node
+          message = format(MSG, method: node.method_name, class: name.source)
 
-          format(MSG, method: node.parent.method_name, class: class_name)
+          add_offense(node.receiver.loc.name, message: message) do |corrector|
+            corrector.replace(node.receiver, 'self')
+          end
         end
       end
     end

data/lib/rubocop/cop/style/class_methods_definitions.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces using `def self.method_name` or `class << self` to define class methods.
+      #
+      # @example EnforcedStyle: def_self (default)
+      #   # bad
+      #   class SomeClass
+      #     class << self
+      #       attr_accessor :class_accessor
+      #
+      #       def class_method
+      #         # ...
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeClass
+      #     def self.class_method
+      #       # ...
+      #     end
+      #
+      #     class << self
+      #       attr_accessor :class_accessor
+      #     end
+      #   end
+      #
+      #   # good - contains private method
+      #   class SomeClass
+      #     class << self
+      #       attr_accessor :class_accessor
+      #
+      #       private
+      #
+      #       def private_class_method
+      #         # ...
+      #       end
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: self_class
+      #   # bad
+      #   class SomeClass
+      #     def self.class_method
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeClass
+      #     class << self
+      #       def class_method
+      #         # ...
+      #       end
+      #     end
+      #   end
+      #
+      class ClassMethodsDefinitions < Base
+        include ConfigurableEnforcedStyle
+        include CommentsHelp
+        include VisibilityHelp
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<preferred>s` to define a class method.'
+        MSG_SCLASS = 'Do not define public methods within class << self.'
+
+        def on_sclass(node)
+          return unless def_self_style?
+          return unless node.identifier.self_type?
+          return unless all_methods_public?(node)
+
+          add_offense(node, message: MSG_SCLASS) do |corrector|
+            autocorrect_sclass(node, corrector)
+          end
+        end
+
+        def on_defs(node)
+          return if def_self_style?
+          return unless node.receiver.self_type?
+
+          message = format(MSG, preferred: 'class << self')
+          add_offense(node, message: message)
+        end
+
+        private
+
+        def def_self_style?
+          style == :def_self
+        end
+
+        def all_methods_public?(sclass_node)
+          def_nodes = def_nodes(sclass_node)
+          return false if def_nodes.empty?
+
+          def_nodes.all? { |def_node| node_visibility(def_node) == :public }
+        end
+
+        def def_nodes(sclass_node)
+          sclass_def = sclass_node.body
+          return [] unless sclass_def
+
+          if sclass_def.def_type?
+            [sclass_def]
+          elsif sclass_def.begin_type?
+            sclass_def.each_child_node(:def).to_a
+          else
+            []
+          end
+        end
+
+        def autocorrect_sclass(node, corrector)
+          rewritten_defs = []
+
+          def_nodes(node).each do |def_node|
+            next unless node_visibility(def_node) == :public
+
+            range, source = extract_def_from_sclass(def_node, node)
+
+            corrector.remove(range)
+            rewritten_defs << source
+          end
+
+          if sclass_only_has_methods?(node)
+            corrector.remove(node)
+            rewritten_defs.first&.strip!
+          else
+            corrector.insert_after(node, "\n")
+          end
+
+          corrector.insert_after(node, rewritten_defs.join("\n"))
+        end
+
+        def sclass_only_has_methods?(node)
+          node.body.def_type? || node.body.each_child_node.all?(&:def_type?)
+        end
+
+        def extract_def_from_sclass(def_node, sclass_node)
+          range = source_range_with_comment(def_node)
+          source = range.source.sub!(
+            "def #{def_node.method_name}",
+            "def self.#{def_node.method_name}"
+          )
+
+          source = source.gsub(/^ {#{indentation_diff(def_node, sclass_node)}}/, '')
+          [range, source.chomp]
+        end
+
+        def indentation_diff(node1, node2)
+          node1.loc.column - node2.loc.column
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/class_vars.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of class variables. Offenses
+      # Checks for uses of class variables. Offenses
       # are signaled only on assignment to class variables to
       # reduce the number of offenses that would be reported.
       #
@@ -19,6 +19,15 @@ module RuboCop
       #     @@test = 10
       #   end
       #
+      #   class A
+      #     def self.test(name, value)
+      #       class_variable_set("@@#{name}", value)
+      #     end
+      #   end
+      #
+      #   class A; end
+      #   A.class_variable_set(:@@test, 10)
+      #
       #   # good
       #   class A
       #     @test = 10
@@ -30,17 +39,24 @@ module RuboCop
       #     end
       #   end
       #
-      class ClassVars < Cop
-        MSG = 'Replace class var %<class_var>s with a class ' \
-              'instance var.'
+      #   class A
+      #     def self.test(name)
+      #       class_variable_get("@@#{name}") # you can access without offense
+      #     end
+      #   end
+      #
+      class ClassVars < Base
+        MSG = 'Replace class var %<class_var>s with a class instance var.'
+        RESTRICT_ON_SEND = %i[class_variable_set].freeze
 
         def on_cvasgn(node)
-          add_offense(node, location: :name)
+          add_offense(node.loc.name, message: format(MSG, class_var: node.children.first))
         end
 
-        def message(node)
-          class_var, = *node
-          format(MSG, class_var: class_var)
+        def on_send(node)
+          add_offense(
+            node.first_argument, message: format(MSG, class_var: node.first_argument.source)
+          )
         end
       end
     end

data/lib/rubocop/cop/style/collection_compact.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for places where custom logic on rejection nils from arrays
+      # and hashes can be replaced with `{Array,Hash}#{compact,compact!}`.
+      #
+      # @safety
+      #   It is unsafe by default because false positives may occur in the
+      #   `nil` check of block arguments to the receiver object. Additionally,
+      #    we can't know the type of the receiver object for sure, which may
+      #    result in false positives as well.
+      #
+      #   For example, `[[1, 2], [3, nil]].reject { |first, second| second.nil? }`
+      #   and `[[1, 2], [3, nil]].compact` are not compatible. This will work fine
+      #   when the receiver is a hash object.
+      #
+      # @example
+      #   # bad
+      #   array.reject(&:nil?)
+      #   array.reject { |e| e.nil? }
+      #   array.select { |e| !e.nil? }
+      #
+      #   # good
+      #   array.compact
+      #
+      #   # bad
+      #   hash.reject!(&:nil?)
+      #   hash.reject! { |k, v| v.nil? }
+      #   hash.select! { |k, v| !v.nil? }
+      #
+      #   # good
+      #   hash.compact!
+      #
+      class CollectionCompact < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+        RESTRICT_ON_SEND = %i[reject reject! select select!].freeze
+        TO_ENUM_METHODS = %i[to_enum lazy].freeze
+
+        # @!method reject_method_with_block_pass?(node)
+        def_node_matcher :reject_method_with_block_pass?, <<~PATTERN
+          (send !nil? {:reject :reject!}
+            (block_pass
+              (sym :nil?)))
+        PATTERN
+
+        # @!method reject_method?(node)
+        def_node_matcher :reject_method?, <<~PATTERN
+          (block
+            (send
+              !nil? {:reject :reject!})
+            $(args ...)
+            (send
+              $(lvar _) :nil?))
+        PATTERN
+
+        # @!method select_method?(node)
+        def_node_matcher :select_method?, <<~PATTERN
+          (block
+            (send
+              !nil? {:select :select!})
+            $(args ...)
+            (send
+              (send
+                $(lvar _) :nil?) :!))
+        PATTERN
+
+        def on_send(node)
+          return unless (range = offense_range(node))
+          return if target_ruby_version <= 3.0 && to_enum_method?(node)
+
+          good = good_method_name(node)
+          message = format(MSG, good: good, bad: range.source)
+
+          add_offense(range, message: message) { |corrector| corrector.replace(range, good) }
+        end
+
+        private
+
+        def offense_range(node)
+          if reject_method_with_block_pass?(node)
+            range(node, node)
+          else
+            block_node = node.parent
+
+            return unless block_node&.block_type?
+            unless (args, receiver = reject_method?(block_node) || select_method?(block_node))
+              return
+            end
+            return unless args.last.source == receiver.source
+
+            range(node, block_node)
+          end
+        end
+
+        def to_enum_method?(node)
+          return false unless node.receiver.send_type?
+
+          TO_ENUM_METHODS.include?(node.receiver.method_name)
+        end
+
+        def good_method_name(node)
+          if node.bang_method?
+            'compact!'
+          else
+            'compact'
+          end
+        end
+
+        def range(begin_pos_node, end_pos_node)
+          range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/collection_methods.rb

@@ -3,13 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of consistent method names
+      # Enforces the use of consistent method names
       # from the Enumerable module.
       #
-      # Unfortunately we cannot actually know if a method is from
-      # Enumerable or not (static analysis limitation), so this cop
-      # can yield some false positives.
-      #
       # You can customize the mapping from undesired method to desired method.
       #
       # e.g. to use `detect` over `find`:
@@ -18,15 +14,21 @@ module RuboCop
       #     PreferredMethods:
       #       find: detect
       #
-      # The default mapping for `PreferredMethods` behaves as follows.
+      # @safety
+      #   This cop is unsafe because it finds methods by name, without actually
+      #   being able to determine if the receiver is an Enumerable or not, so
+      #   this cop may register false positives.
       #
       # @example
+      #   # These examples are based on the default mapping for `PreferredMethods`.
+      #
       #   # bad
       #   items.collect
       #   items.collect!
       #   items.inject
       #   items.detect
       #   items.find_all
+      #   items.member?
       #
       #   # good
       #   items.map
@@ -34,9 +36,11 @@ module RuboCop
       #   items.reduce
       #   items.find
       #   items.select
+      #   items.include?
       #
-      class CollectionMethods < Cop
+      class CollectionMethods < Base
         include MethodPreference
+        extend AutoCorrector
 
         MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 
@@ -44,32 +48,41 @@ module RuboCop
           check_method_node(node.send_node)
         end
 
+        alias on_numblock on_block
+
         def on_send(node)
-          return unless node.arguments.one? &&
-                        node.first_argument.block_pass_type?
+          return unless implicit_block?(node)
 
           check_method_node(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              preferred_method(node.loc.selector.source))
+        private
+
+        def check_method_node(node)
+          return unless preferred_methods[node.method_name]
+
+          message = message(node)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, preferred_method(node.loc.selector.source))
           end
         end
 
-        private
+        def implicit_block?(node)
+          return false unless node.arguments.any?
 
-        def message(node)
-          format(MSG,
-                 prefer: preferred_method(node.method_name),
-                 current: node.method_name)
+          node.last_argument.block_pass_type? ||
+            (node.last_argument.sym_type? &&
+            methods_accepting_symbol.include?(node.method_name.to_s))
         end
 
-        def check_method_node(node)
-          return unless preferred_methods[node.method_name]
+        def message(node)
+          format(MSG, prefer: preferred_method(node.method_name), current: node.method_name)
+        end
 
-          add_offense(node, location: :selector)
+        # Some enumerable methods accept a bare symbol (ie. _not_ Symbol#to_proc) instead
+        # of a block.
+        def methods_accepting_symbol
+          Array(cop_config['MethodsAcceptingSymbol'])
         end
       end
     end

data/lib/rubocop/cop/style/colon_method_call.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for methods invoked via the :: operator instead
+      # Checks for methods invoked via the :: operator instead
       # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
       #
       # @example
@@ -17,9 +17,12 @@ module RuboCop
       #   FileUtils.rmdir(dir)
       #   Marshal.dump(obj)
       #
-      class ColonMethodCall < Cop
+      class ColonMethodCall < Base
+        extend AutoCorrector
+
         MSG = 'Do not use `::` for method calls.'
 
+        # @!method java_type_node?(node)
         def_node_matcher :java_type_node?, <<~PATTERN
           (send
             (const nil? :Java) _)
@@ -30,17 +33,12 @@ module RuboCop
         end
 
         def on_send(node)
-          # ignore Java interop code like Java::int
-          return if java_type_node?(node)
-
           return unless node.receiver && node.double_colon?
           return if node.camel_case_method?
+          # ignore Java interop code like Java::int
+          return if java_type_node?(node)
 
-          add_offense(node, location: :dot)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.dot, '.') }
+          add_offense(node.loc.dot) { |corrector| corrector.replace(node.loc.dot, '.') }
         end
       end
     end