rubocop 0.89.0 → 0.92.0

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for duplicate `require`s and `require_relative`s.
+      #
+      # @example
+      #   # bad
+      #   require 'foo'
+      #   require 'bar'
+      #   require 'foo'
+      #
+      #   # good
+      #   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(' :')}} _)
+        PATTERN
+
+        def on_new_investigation
+          # Holds the known required files for a given parent node (used as key)
+          @required = Hash.new { |h, k| h[k] = Set.new }.compare_by_identity
+          super
+        end
+
+        def on_send(node)
+          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
+      end
+    end
+  end
+end

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

@@ -33,27 +33,14 @@ 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)
             end
           end
         end
-
-        private
-
-        def rescued_exceptions(resbody)
-          rescue_group, = *resbody
-          if rescue_group
-            rescue_group.values
-          else
-            []
-          end
-        end
       end
     end
   end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop enforces that Ruby source files are not empty.
+      #
+      # @example
+      #   # bad
+      #   # Empty file
+      #
+      #   # good
+      #   # File containing non commented source lines
+      #
+      # @example AllowComments: true (default)
+      #   # good
+      #   # File consisting only of comments
+      #
+      # @example AllowComments: false
+      #   # bad
+      #   # File consisting only of comments
+      #
+      class EmptyFile < Base
+        include RangeHelp
+
+        MSG = 'Empty file detected.'
+
+        def on_new_investigation
+          add_global_offense(MSG) if offending?
+        end
+
+        private
+
+        def offending?
+          empty_file? || (!cop_config['AllowComments'] && contains_only_comments?)
+        end
+
+        def empty_file?
+          processed_source.buffer.source.empty?
+        end
+
+        def contains_only_comments?
+          processed_source.lines.all? do |line|
+            line.blank? || comment_line?(line)
+          end
+        end
+      end
+    end
+  end
+end

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/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/missing_super.rb

@@ -45,13 +45,19 @@ module RuboCop
 
         OBJECT_LIFECYCLE_CALLBACKS  = %i[method_missing respond_to_missing?].freeze
         CLASS_LIFECYCLE_CALLBACKS   = %i[inherited].freeze
-        MODULE_LIFECYCLE_CALLBACKS  = %i[included extended prepended].freeze
+        METHOD_LIFECYCLE_CALLBACKS  = %i[method_added method_removed method_undefined
+                                         singleton_method_added singleton_method_removed
+                                         singleton_method_undefined].freeze
+
+        CALLBACKS = (OBJECT_LIFECYCLE_CALLBACKS +
+                      CLASS_LIFECYCLE_CALLBACKS +
+                      METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
 
         def on_def(node)
           return unless offender?(node)
 
-          if node.method?(:initialize)
-            add_offense(node, message: CONSTRUCTOR_MSG) if inside_class_with_stateful_parent?(node)
+          if node.method?(:initialize) && inside_class_with_stateful_parent?(node)
+            add_offense(node, message: CONSTRUCTOR_MSG)
           elsif callback_method_def?(node)
             add_offense(node, message: CALLBACK_MSG)
           end
@@ -70,15 +76,9 @@ module RuboCop
         end
 
         def callback_method_def?(node)
-          method_name = node.method_name
-
-          if OBJECT_LIFECYCLE_CALLBACKS.include?(method_name) ||
-             CLASS_LIFECYCLE_CALLBACKS.include?(method_name)
+          return unless CALLBACKS.include?(node.method_name)
 
-            node.each_ancestor(:class, :sclass, :module).first
-          elsif MODULE_LIFECYCLE_CALLBACKS.include?(method_name)
-            node.each_ancestor(:module).first
-          end
+          node.each_ancestor(:class, :sclass, :module).first
         end
 
         def contains_super?(node)

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

@@ -25,44 +25,11 @@ module RuboCop
               'in a Regexp literal.'
 
         def on_regexp(node)
-          return if contain_non_literal?(node)
-
-          begin
-            tree = Regexp::Parser.parse(node.content)
-          # Returns if a regular expression that cannot be processed by regexp_parser gem.
-          # https://github.com/rubocop-hq/rubocop/issues/8083
-          rescue Regexp::Scanner::ScannerError
-            return
-          end
-
-          return unless named_capture?(tree)
-          return unless numbered_capture?(tree)
+          return if node.each_capture(named: false).none?
+          return if node.each_capture(named: true).none?
 
           add_offense(node)
         end
-
-        private
-
-        def contain_non_literal?(node)
-          if node.respond_to?(:type) && (node.variable? || node.send_type? || node.const_type?)
-            return true
-          end
-          return false unless node.respond_to?(:children)
-
-          node.children.any? { |child| contain_non_literal?(child) }
-        end
-
-        def named_capture?(tree)
-          tree.each_expression.any? do |e|
-            e.instance_of?(Regexp::Expression::Group::Capture)
-          end
-        end
-
-        def numbered_capture?(tree)
-          tree.each_expression.any? do |e|
-            e.instance_of?(Regexp::Expression::Group::Named)
-          end
-        end
       end
     end
   end

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

@@ -21,16 +21,37 @@ module RuboCop
       class OutOfRangeRegexpRef < Base
         MSG = 'Do not use out of range reference for the Regexp.'
 
+        REGEXP_RECEIVER_METHODS = %i[=~ === match].to_set.freeze
+        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
         end
 
-        def on_regexp(node)
+        def on_match_with_lvasgn(node)
+          check_regexp(node.children.first)
+        end
+
+        def on_send(node)
           @valid_ref = nil
-          return if contain_non_literal?(node)
 
-          tree = Regexp::Parser.parse(node.content)
-          @valid_ref = regexp_captures(tree)
+          if node.receiver&.regexp_type?
+            check_regexp(node.receiver)
+          elsif node.first_argument&.regexp_type? \
+            && REGEXP_ARGUMENT_METHODS.include?(node.method_name)
+            check_regexp(node.first_argument)
+          end
+        end
+
+        def on_when(node)
+          regexp_conditions = node.conditions.select(&:regexp_type?)
+
+          @valid_ref = regexp_conditions.map do |condition|
+            check_regexp(condition)
+          end.compact.max
         end
 
         def on_nth_ref(node)
@@ -42,18 +63,15 @@ module RuboCop
 
         private
 
-        def contain_non_literal?(node)
-          node.children.size != 2 || !node.children.first.str_type?
-        end
+        def check_regexp(node)
+          return if node.interpolation?
 
-        def regexp_captures(tree)
-          named_capture = numbered_capture = 0
-          tree.each_expression do |e|
-            if e.type?(:group)
-              e.respond_to?(:name) ? named_capture += 1 : numbered_capture += 1
-            end
-          end
-          named_capture.positive? ? named_capture : numbered_capture
+          named_capture = node.each_capture(named: true).count
+          @valid_ref = if named_capture.positive?
+                         named_capture
+                       else
+                         node.each_capture(named: false).count
+                       end
         end
       end
     end

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

@@ -39,23 +39,19 @@ module RuboCop
           return unless contains_quotes_or_commas?(node)
 
           add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-
-        private
+            node.each_value do |value|
+              range = value.loc.expression
 
-        def autocorrect(corrector, node)
-          node.each_value do |value|
-            range = value.loc.expression
+              match = range.source.match(TRAILING_QUOTE)
+              corrector.remove_trailing(range, match[0].length) if match
 
-            match = range.source.match(TRAILING_QUOTE)
-            corrector.remove_trailing(range, match[0].length) if match
-
-            corrector.remove_leading(range, 1) if LEADING_QUOTE.match?(range.source)
+              corrector.remove_leading(range, 1) if LEADING_QUOTE.match?(range.source)
+            end
           end
         end
 
+        private
+
         def contains_quotes_or_commas?(node)
           node.values.any? do |value|
             literal = value.children.first.to_s.scrub