rubocop 0.90.0 → 0.93.1

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

@@ -53,8 +53,8 @@ module RuboCop
         MSG = 'Method `%<method>s` is defined at both %<defined>s and ' \
               '%<current>s.'
 
-        METHOD_DEF_METHODS = %i[alias_method attr_reader attr_writer
-                                attr_accessor attr].to_set.freeze
+        RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer
+                              attr_accessor attr].freeze
 
         def initialize(config = nil, options = nil)
           super
@@ -100,8 +100,6 @@ module RuboCop
 
         def_node_matcher :sym_name, '(sym $_name)'
         def on_send(node)
-          return unless METHOD_DEF_METHODS.include?(node.method_name)
-
           if (name = alias_method?(node))
             return if node.ancestors.any?(&:if_type?)
             return if possible_dsl?(node)

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

@@ -15,9 +15,14 @@ module RuboCop
       #   require 'foo'
       #   require 'bar'
       #
+      #   # good
+      #   require 'foo'
+      #   require_relative 'foo'
+      #
       class DuplicateRequire < Base
         MSG = 'Duplicate `%<method>s` detected.'
         REQUIRE_METHODS = %i[require require_relative].freeze
+        RESTRICT_ON_SEND = REQUIRE_METHODS
 
         def_node_matcher :require_call?, <<~PATTERN
           (send {nil? (const _ :Kernel)} {:#{REQUIRE_METHODS.join(' :')}} _)
@@ -30,8 +35,8 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless REQUIRE_METHODS.include?(node.method_name) && require_call?(node)
-          return if @required[node.parent].add?(node.first_argument)
+          return unless require_call?(node)
+          return if @required[node.parent].add?("#{node.method_name}#{node.first_argument}")
 
           add_offense(node, message: format(MSG, method: node.method_name))
         end

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

@@ -33,10 +33,8 @@ module RuboCop
         def on_rescue(node)
           return if rescue_modifier?(node)
 
-          _body, *resbodies, _else = *node
-
-          resbodies.each_with_object(Set.new) do |resbody, previous|
-            rescued_exceptions = rescued_exceptions(resbody)
+          node.resbody_branches.each_with_object(Set.new) do |resbody, previous|
+            rescued_exceptions = resbody.exceptions
 
             rescued_exceptions.each do |exception|
               add_offense(exception) unless previous.add?(exception)

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

@@ -23,6 +23,7 @@ module RuboCop
       #   sum = numbers.each_with_object(num) { |e, a| a += e }
       class EachWithObjectArgument < Base
         MSG = 'The argument to each_with_object cannot be immutable.'
+        RESTRICT_ON_SEND = %i[each_with_object].freeze
 
         def_node_matcher :each_with_object?, <<~PATTERN
           ({send csend} _ :each_with_object $_)

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

@@ -26,10 +26,7 @@ module RuboCop
         MSG = 'Empty file detected.'
 
         def on_new_investigation
-          return unless offending?
-
-          range = source_range(processed_source.buffer, 1, 0)
-          add_offense(range)
+          add_global_offense(MSG) if offending?
         end
 
         private

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

@@ -78,6 +78,8 @@ module RuboCop
           '`ERB.new(str, eoutvar: %<arg_value>s)` instead.'
         ].freeze
 
+        RESTRICT_ON_SEND = %i[new].freeze
+
         def_node_matcher :erb_new_with_non_keyword_arguments, <<~PATTERN
           (send
             (const {nil? cbase} :ERB) :new $...)

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

@@ -35,9 +35,9 @@ module RuboCop
         FLOAT_RETURNING_METHODS = %i[to_f Float fdiv].freeze
         FLOAT_INSTANCE_METHODS = %i[@- abs magnitude modulo next_float prev_float quo].to_set.freeze
 
-        def on_send(node)
-          return unless EQUALITY_METHODS.include?(node.method_name)
+        RESTRICT_ON_SEND = EQUALITY_METHODS
 
+        def on_send(node)
           lhs, _method, rhs = *node
           add_offense(node) if float?(lhs) || float?(rhs)
         end

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

@@ -44,10 +44,10 @@ module RuboCop
         KERNEL = 'Kernel'
         SHOVEL = '<<'
         STRING_TYPES = %i[str dstr].freeze
-        FORMAT_METHODS = %i[format sprintf %].freeze
+        RESTRICT_ON_SEND = %i[format sprintf %].freeze
 
         def on_send(node)
-          return unless FORMAT_METHODS.include?(node.method_name) && format_string?(node)
+          return unless format_string?(node)
 
           if invalid_format_string?(node)
             add_offense(node.loc.selector, message: MSG_INVALID)

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Prefer using `Hash#compare_by_identity` than using `object_id` for hash keys.
+      #
+      # This cop is marked as unsafe as a hash possibly can contain other keys
+      # besides `object_id`s.
+      #
+      # @example
+      #   # bad
+      #   hash = {}
+      #   hash[foo.object_id] = :bar
+      #   hash.key?(baz.object_id)
+      #
+      #   # good
+      #   hash = {}.compare_by_identity
+      #   hash[foo] = :bar
+      #   hash.key?(baz)
+      #
+      class HashCompareByIdentity < Base
+        RESTRICT_ON_SEND = %i[key? has_key? fetch [] []=].freeze
+
+        MSG = 'Use `Hash#compare_by_identity` instead of using `object_id` for keys.'
+
+        def_node_matcher :id_as_hash_key?, <<~PATTERN
+          (send _ {:key? :has_key? :fetch :[] :[]=} (send _ :object_id) ...)
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if id_as_hash_key?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      #
+      # Prefer `equal?` over `==` when comparing `object_id`.
+      #
+      # `Object#equal?` is provided to compare objects for identity, and in contrast
+      # `Object#==` is provided for the purpose of doing value comparison.
+      #
+      # @example
+      #   # bad
+      #   foo.object_id == bar.object_id
+      #
+      #   # good
+      #   foo.equal?(bar)
+      #
+      class IdentityComparison < Base
+        extend AutoCorrector
+
+        MSG = 'Use `equal?` instead `==` when comparing `object_id`.'
+        RESTRICT_ON_SEND = %i[==].freeze
+
+        def on_send(node)
+          return unless compare_between_object_id_by_double_equal?(node)
+
+          add_offense(node) do |corrector|
+            receiver = node.receiver.receiver
+            argument = node.first_argument.receiver
+            return unless receiver && argument
+
+            replacement = "#{receiver.source}.equal?(#{argument.source})"
+
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def compare_between_object_id_by_double_equal?(node)
+          object_id_method?(node.receiver) && object_id_method?(node.first_argument)
+        end
+
+        def object_id_method?(node)
+          node.send_type? && node.method?(:object_id)
+        end
+      end
+    end
+  end
+end

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

@@ -58,12 +58,9 @@ module RuboCop
         PATTERN
 
         def on_class(node)
-          check_node(node.children[2]) # class body
-        end
-
-        def on_module(node)
-          check_node(node.children[1]) # module body
+          check_node(node.body)
         end
+        alias on_module on_class
 
         private
 

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

@@ -56,6 +56,8 @@ module RuboCop
           SystemExit
         ].freeze
 
+        RESTRICT_ON_SEND = %i[new].freeze
+
         def_node_matcher :class_new_call?, <<~PATTERN
           (send
             (const {cbase nil?} :Class) :new
@@ -74,8 +76,6 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless node.method?(:new)
-
           constant = class_new_call?(node)
           return unless constant && illegal_class_name?(constant)
 

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

@@ -25,6 +25,7 @@ module RuboCop
               'in a Regexp literal.'
 
         def on_regexp(node)
+          return if node.interpolation?
           return if node.each_capture(named: false).none?
           return if node.each_capture(named: true).none?
 

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

@@ -25,9 +25,11 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use the `&&` operator to compare multiple values.'
+        COMPARISON_METHODS = %i[< > <= >=].freeze
+        RESTRICT_ON_SEND = COMPARISON_METHODS
 
         def_node_matcher :multiple_compare?, <<~PATTERN
-          (send (send _ {:< :> :<= :>=} $_) {:< :> :<= :>=} _)
+          (send (send _ {:< :> :<= :>=} $_) {:#{COMPARISON_METHODS.join(' :')}} _)
         PATTERN
 
         def on_send(node)

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

@@ -32,6 +32,7 @@ module RuboCop
               'class parsing, instead of using '\
               '%<number_object>s.%<to_method>s, use stricter '\
               '%<corrected_method>s.'
+        RESTRICT_ON_SEND = CONVERSION_METHOD_CLASS_MAPPING.keys.freeze
 
         def_node_matcher :to_method, <<~PATTERN
           (send $_ ${:to_i :to_f :to_c})

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

@@ -25,6 +25,7 @@ module RuboCop
         REGEXP_ARGUMENT_METHODS = %i[=~ match grep gsub gsub! sub sub! [] slice slice! index rindex
                                      scan partition rpartition start_with? end_with?].to_set.freeze
         REGEXP_CAPTURE_METHODS = (REGEXP_RECEIVER_METHODS + REGEXP_ARGUMENT_METHODS).freeze
+        RESTRICT_ON_SEND = REGEXP_CAPTURE_METHODS
 
         def on_new_investigation
           @valid_ref = 0
@@ -35,8 +36,6 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless REGEXP_CAPTURE_METHODS.include?(node.method_name)
-
           @valid_ref = nil
 
           if node.receiver&.regexp_type?

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

@@ -43,7 +43,7 @@ module RuboCop
           end
 
           node.operator_method? || node.setter_method? || chained_calls?(node) ||
-            operator_keyword?(node)
+            operator_keyword?(node) || node.first_argument.hash_type?
         end
 
         def first_argument_starts_with_left_parenthesis?(node)

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

@@ -31,6 +31,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `StandardError` over `Exception`.'
+        RESTRICT_ON_SEND = %i[raise fail].freeze
 
         def_node_matcher :exception?, <<~PATTERN
           (send nil? {:raise :fail} $(const ${cbase nil?} :Exception) ... )

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

@@ -23,13 +23,14 @@ module RuboCop
       class RandOne < Base
         MSG = '`%<method>s` always returns `0`. ' \
               'Perhaps you meant `rand(2)` or `rand`?'
+        RESTRICT_ON_SEND = %i[rand].freeze
 
         def_node_matcher :rand_one?, <<~PATTERN
           (send {(const {nil? cbase} :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
         PATTERN
 
         def on_send(node)
-          return unless node.method?(:rand) && rand_one?(node)
+          return unless rand_one?(node)
 
           add_offense(node)
         end

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

@@ -56,19 +56,29 @@ module RuboCop
 
         private
 
+        def previous_line_blank?(range)
+          processed_source.buffer.source_line(range.line - 1).blank?
+        end
+
         def comment_range_with_surrounding_space(range)
-          # Eat the entire comment, the preceding space, and the preceding
-          # newline if there is one.
-          original_begin = range.begin_pos
-          range = range_with_surrounding_space(range: range,
-                                               side: :left,
-                                               newlines: true)
-          range_with_surrounding_space(range: range,
-                                       side: :right,
-                                       # Special for a comment that
-                                       # begins the file: remove
-                                       # the newline at the end.
-                                       newlines: original_begin.zero?)
+          if previous_line_blank?(range)
+            # When the previous line is blank, it should be retained
+            range_with_surrounding_space(range: range, side: :right)
+          else
+            # Eat the entire comment, the preceding space, and the preceding
+            # newline if there is one.
+            original_begin = range.begin_pos
+            range = range_with_surrounding_space(range: range,
+                                                 side: :left,
+                                                 newlines: true)
+
+            range_with_surrounding_space(range: range,
+                                         side: :right,
+                                         # Special for a comment that
+                                         # begins the file: remove
+                                         # the newline at the end.
+                                         newlines: original_begin.zero?)
+          end
         end
 
         def directive_range_in_list(range, ranges)

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

@@ -45,18 +45,28 @@ module RuboCop
           return if processed_source.blank?
 
           offenses = processed_source.comment_config.extra_enabled_comments
-          offenses.each do |comment, name|
+          offenses.each { |comment, cop_names| register_offense(comment, cop_names) }
+        end
+
+        private
+
+        def register_offense(comment, cop_names)
+          directive = DirectiveComment.new(comment)
+
+          cop_names.each do |name|
             add_offense(
               range_of_offense(comment, name),
               message: format(MSG, cop: all_or_name(name))
             ) do |corrector|
-              corrector.remove(range_with_comma(comment, name))
+              if directive.match?(cop_names)
+                corrector.remove(range_with_surrounding_space(range: directive.range, side: :right))
+              else
+                corrector.remove(range_with_comma(comment, name))
+              end
             end
           end
         end
 
-        private
-
         def range_of_offense(comment, name)
           start_pos = comment_start(comment) + cop_name_indention(comment, name)
           range_between(start_pos, start_pos + name.size)

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

@@ -26,6 +26,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Remove unnecessary `require` statement.'
+        RESTRICT_ON_SEND = %i[require].freeze
 
         def_node_matcher :unnecessary_require_statement?, <<~PATTERN
           (send nil? :require

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for redundant safe navigation calls.
+      # `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`, and `equal?` methods
+      # are checked by default. These are customizable with `AllowedMethods` option.
+      #
+      # This cop is marked as unsafe, because auto-correction can change the
+      # return type of the expression. An offending expression that previously
+      # could return `nil` will be auto-corrected to never return `nil`.
+      #
+      # In the example below, the safe navigation operator (`&.`) is unnecessary
+      # because `NilClass` has methods like `respond_to?` and `is_a?`.
+      #
+      # @example
+      #   # bad
+      #   do_something if attrs&.respond_to?(:[])
+      #
+      #   # good
+      #   do_something if attrs.respond_to?(:[])
+      #
+      #   # bad
+      #   while node&.is_a?(BeginNode)
+      #     node = node.parent
+      #   end
+      #
+      #   # good
+      #   while node.is_a?(BeginNode)
+      #     node = node.parent
+      #   end
+      #
+      #   # good - without `&.` this will always return `true`
+      #   foo&.respond_to?(:to_a)
+      #
+      class RedundantSafeNavigation < Base
+        include AllowedMethods
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant safe navigation detected.'
+
+        NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
+
+        def_node_matcher :respond_to_nil_specific_method?, <<~PATTERN
+          (csend _ :respond_to? (sym %NIL_SPECIFIC_METHODS))
+        PATTERN
+
+        def on_csend(node)
+          return unless check?(node) && allowed_method?(node.method_name)
+          return if respond_to_nil_specific_method?(node)
+
+          range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
+          add_offense(range) do |corrector|
+            corrector.replace(node.loc.dot, '.')
+          end
+        end
+
+        private
+
+        def check?(node)
+          parent = node.parent
+          return false unless parent
+
+          condition?(parent, node) ||
+            parent.and_type? ||
+            parent.or_type? ||
+            (parent.send_type? && parent.negation_method?)
+        end
+
+        def condition?(parent, node)
+          (parent.conditional? || parent.post_condition_loop?) && parent.condition == node
+        end
+      end
+    end
+  end
+end