rubocop 0.76.0 → 0.83.0

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

@@ -27,18 +27,20 @@ module RuboCop
       #
       #   # good
       #
-      #   # using while
-      #   while some_condition
+      #   # while replacement
+      #   loop do
       #     do_something
+      #     break unless some_condition
       #   end
       #
       # @example
       #
       #   # good
       #
-      #   # using until
-      #   until some_condition
+      #   # until replacement
+      #   loop do
       #     do_something
+      #     break if some_condition
       #   end
       class Loop < Cop
         MSG = 'Use `Kernel#loop` with `break` rather than ' \

data/lib/rubocop/cop/lint/{multiple_compare.rb → multiple_comparison.rb}

@@ -21,7 +21,7 @@ module RuboCop
       #
       #   x < y && y < z
       #   10 <= x && x <= 20
-      class MultipleCompare < Cop
+      class MultipleComparison < Cop
         MSG = 'Use the `&&` operator to compare multiple values.'
 
         def_node_matcher :multiple_compare?, <<~PATTERN
@@ -39,7 +39,7 @@ module RuboCop
           new_center = "#{center.source} && #{center.source}"
 
           lambda do |corrector|
-            corrector.replace(center.source_range, new_center)
+            corrector.replace(center, new_center)
           end
         end
       end

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

@@ -31,14 +31,14 @@ module RuboCop
       #   # good
       #
       #   def foo
-      #     self.class_eval do
+      #     self.class.class_eval do
       #       def bar
       #       end
       #     end
       #   end
       #
       #   def foo
-      #     self.module_exec do
+      #     self.class.module_exec do
       #       def bar
       #       end
       #     end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # `Dir[...]` and `Dir.glob(...)` do not make any guarantees about
+      # the order in which files are returned. The final order is
+      # determined by the operating system and file system.
+      # This means that using them in cases where the order matters,
+      # such as requiring files, can lead to intermittent failures
+      # that are hard to debug. To ensure this doesn't happen,
+      # always sort the list.
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir["./lib/**/*.rb"].each do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir["./lib/**/*.rb"].sort.each do |file|
+      #     require file
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')) do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')).sort.each do |file|
+      #     require file
+      #   end
+      #
+      class NonDeterministicRequireOrder < Cop
+        MSG = 'Sort files before requiring them.'
+
+        def on_block(node)
+          return unless node.body
+          return unless unsorted_dir_loop?(node.send_node)
+
+          loop_variable(node.arguments) do |var_name|
+            return unless var_is_required?(node.body, var_name)
+
+            add_offense(node.send_node)
+          end
+        end
+
+        def autocorrect(node)
+          if unsorted_dir_block?(node)
+            lambda do |corrector|
+              corrector.replace(node, "#{node.source}.sort.each")
+            end
+          else
+            lambda do |corrector|
+              source = node.receiver.source
+              corrector.replace(node, "#{source}.sort.each")
+            end
+          end
+        end
+
+        private
+
+        def unsorted_dir_loop?(node)
+          unsorted_dir_block?(node) || unsorted_dir_each?(node)
+        end
+
+        def_node_matcher :unsorted_dir_block?, <<~PATTERN
+          (send (const nil? :Dir) :glob ...)
+        PATTERN
+
+        def_node_matcher :unsorted_dir_each?, <<~PATTERN
+          (send (send (const nil? :Dir) {:[] :glob} ...) :each)
+        PATTERN
+
+        def_node_matcher :loop_variable, <<~PATTERN
+          (args (arg $_))
+        PATTERN
+
+        def_node_search :var_is_required?, <<~PATTERN
+          (send nil? :require (lvar %1))
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -55,7 +55,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.loc.expression,
+            corrector.replace(node,
                               correct_method(node, node.receiver))
           end
         end

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

@@ -9,14 +9,12 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
-      #   puts (x + y)
-      #
-      # @example
+      #   do_something (foo)
       #
       #   # good
-      #
-      #   puts(x + y)
+      #   do_something(foo)
+      #   do_something (2 + 3) * 4
+      #   do_something (foo * bar).baz
       class ParenthesesAsGroupedExpression < Cop
         include RangeHelp
 
@@ -25,20 +23,34 @@ module RuboCop
         def on_send(node)
           return unless node.arguments.one?
           return if node.operator_method? || node.setter_method?
-
-          return unless node.first_argument.source.start_with?('(')
+          return if grouped_parentheses?(node)
 
           space_length = spaces_before_left_parenthesis(node)
           return unless space_length.positive?
 
           range = space_range(node.first_argument.source_range, space_length)
 
-          add_offense(nil, location: range)
+          add_offense(node, location: range)
         end
         alias on_csend on_send
 
+        def autocorrect(node)
+          space_length = spaces_before_left_parenthesis(node)
+          range = space_range(node.first_argument.source_range, space_length)
+
+          lambda do |corrector|
+            corrector.remove(range)
+          end
+        end
+
         private
 
+        def grouped_parentheses?(node)
+          first_argument = node.first_argument
+
+          first_argument.send_type? && first_argument.receiver&.begin_type?
+        end
+
         def spaces_before_left_parenthesis(node)
           receiver = node.receiver
           receiver_length = if receiver

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

@@ -42,13 +42,13 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            node.values.each do |value|
+            node.each_value do |value|
               range = value.loc.expression
 
               match = range.source.match(TRAILING_QUOTE)
               corrector.remove_trailing(range, match[0].length) if match
 
-              if range.source =~ LEADING_QUOTE
+              if LEADING_QUOTE.match?(range.source)
                 corrector.remove_leading(range, 1)
               end
             end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for `raise` or `fail` statements which are
+      # raising `Exception` class.
+      #
+      # You can specify a module name that will be an implicit namespace
+      # using `AllowedImplicitNamespaces` option. The cop cause a false positive
+      # for namespaced `Exception` when a namespace is omitted. This option can
+      # prevent the false positive by specifying a namespace to be omitted for
+      # `Exception`. Alternatively, make `Exception` a fully qualified class
+      # name with an explicit namespace.
+      #
+      # @example
+      #   # bad
+      #   raise Exception, 'Error message here'
+      #
+      #   # good
+      #   raise StandardError, 'Error message here'
+      #
+      # @example AllowedImplicitNamespaces: ['Gem']
+      #   # good
+      #   module Gem
+      #     def self.foo
+      #       raise Exception # This exception means `Gem::Exception`.
+      #     end
+      #   end
+      class RaiseException < Cop
+        MSG = 'Use `StandardError` over `Exception`.'
+
+        def_node_matcher :exception?, <<~PATTERN
+          (send nil? {:raise :fail} (const ${cbase nil?} :Exception) ... )
+        PATTERN
+
+        def_node_matcher :exception_new_with_message?, <<~PATTERN
+          (send nil? {:raise :fail}
+            (send (const ${cbase nil?} :Exception) :new ... ))
+        PATTERN
+
+        def on_send(node)
+          exception?(node, &check(node)) ||
+            exception_new_with_message?(node, &check(node))
+        end
+
+        private
+
+        def check(node)
+          lambda do |cbase|
+            return if cbase.nil? && implicit_namespace?(node)
+
+            add_offense(node)
+          end
+        end
+
+        def implicit_namespace?(node)
+          return false unless (parent = node.parent)
+
+          if parent.module_type?
+            namespace = parent.identifier.source
+
+            return allow_implicit_namespaces.include?(namespace)
+          end
+
+          implicit_namespace?(parent)
+        end
+
+        def allow_implicit_namespaces
+          cop_config['AllowedImplicitNamespaces'] || []
+        end
+      end
+    end
+  end
+end

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

@@ -19,14 +19,13 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   # rubocop:disable Metrics/LineLength
+      #   # rubocop:disable Layout/LineLength
       #   x += 1
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:enable Layout/LineLength
       #
       #   # good
       #   x += 1
       class RedundantCopDisableDirective < Cop
-        include NameSimilarity
         include RangeHelp
 
         COP_NAME = 'Lint/RedundantCopDisableDirective'
@@ -213,7 +212,7 @@ module RuboCop
         end
 
         def matching_range(haystack, needle)
-          offset = (haystack.source =~ Regexp.new(Regexp.escape(needle)))
+          offset = haystack.source.index(needle)
           return unless offset
 
           offset += haystack.begin_pos
@@ -235,7 +234,7 @@ module RuboCop
           elsif all_cop_names.include?(cop)
             "`#{cop}`"
           else
-            similar = find_similar_name(cop, [])
+            similar = NameSimilarity.find_similar_name(cop, all_cop_names)
             if similar
               "`#{cop}` (did you mean `#{similar}`?)"
             else
@@ -244,10 +243,6 @@ module RuboCop
           end
         end
 
-        def collect_variable_like_names(scope)
-          all_cop_names.each { |name| scope << name }
-        end
-
         def all_cop_names
           @all_cop_names ||= Cop.registry.names
         end

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

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
-# The Lint/RedundantCopEnableDirective cop needs to be disabled so as
-# to be able to provide a (bad) example of an unneeded enable.
+# The Lint/RedundantCopEnableDirective and Lint/RedundantCopDisableDirective
+# cops need to be disabled so as to be able to provide a (bad) example of an
+# unneeded enable.
 
 # rubocop:disable Lint/RedundantCopEnableDirective
+# rubocop:disable Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -15,21 +17,21 @@ module RuboCop
       # @example
       #   # bad
       #   foo = 1
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:enable Layout/LineLength
       #
       #   # good
       #   foo = 1
       # @example
       #   # bad
-      #   # rubocop:disable Metrics/LineLength
-      #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:disable Style/StringLiterals
+      #   foo = "1"
+      #   # rubocop:enable Style/StringLiterals
       #   baz
       #   # rubocop:enable all
       #
       #   # good
-      #   # rubocop:disable Metrics/LineLength
-      #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
+      #   # rubocop:disable Style/StringLiterals
+      #   foo = "1"
       #   # rubocop:enable all
       #   baz
       class RedundantCopEnableDirective < Cop
@@ -112,3 +114,6 @@ module RuboCop
     end
   end
 end
+
+# rubocop:enable Lint/RedundantCopDisableDirective
+# rubocop:enable Lint/RedundantCopEnableDirective

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

@@ -146,7 +146,7 @@ module RuboCop
           grandparent = node.parent.parent
 
           parent.when_type? || parent.send_type? || part_of_an_array?(node) ||
-            (grandparent&.resbody_type?)
+            grandparent&.resbody_type?
         end
 
         def remove_brackets(array)

data/lib/rubocop/cop/lint/{string_conversion_in_interpolation.rb → redundant_string_coercion.rb}

@@ -17,7 +17,7 @@ module RuboCop
       #   # good
       #
       #   "result is #{something}"
-      class StringConversionInInterpolation < Cop
+      class RedundantStringCoercion < Cop
         include Interpolation
 
         MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'
@@ -38,7 +38,7 @@ module RuboCop
           lambda do |corrector|
             receiver = node.receiver
             corrector.replace(
-              node.source_range,
+              node,
               if receiver
                 receiver.source
               else

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

@@ -50,7 +50,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             redundant_with_index?(node) do |send|
-              if send.method_name == :each_with_index
+              if send.method?(:each_with_index)
                 corrector.replace(send.loc.selector, 'each')
               else
                 corrector.remove(with_index_range(send))
@@ -63,7 +63,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.method_name == :each_with_index
+          if node.method?(:each_with_index)
             MSG_EACH_WITH_INDEX
           else
             MSG_WITH_INDEX

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

@@ -51,7 +51,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             redundant_with_object?(node) do |send|
-              if send.method_name == :each_with_object
+              if send.method?(:each_with_object)
                 corrector.replace(with_object_range(send), 'each')
               else
                 corrector.remove(with_object_range(send))
@@ -64,7 +64,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.method_name == :each_with_object
+          if node.method?(:each_with_object)
             MSG_EACH_WITH_OBJECT
           else
             MSG_WITH_OBJECT

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

@@ -32,7 +32,7 @@ module RuboCop
         def_node_matcher :bad_method?, <<~PATTERN
           {
             (send $(csend ...) $_ ...)
-            (send $(block (csend ...) ...) $_ ...)
+            (send $({block numblock} (csend ...) ...) $_ ...)
           }
         PATTERN
 

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks unexpected overrides of the `Struct` built-in methods
+      # via `Struct.new`.
+      #
+      # @example
+      #   # bad
+      #   Bad = Struct.new(:members, :clone, :count)
+      #   b = Bad.new([], true, 1)
+      #   b.members #=> [] (overriding `Struct#members`)
+      #   b.clone #=> true (overriding `Object#clone`)
+      #   b.count #=> 1 (overriding `Enumerable#count`)
+      #
+      #   # good
+      #   Good = Struct.new(:id, :name)
+      #   g = Good.new(1, "foo")
+      #   g.members #=> [:id, :name]
+      #   g.clone #=> #<struct Good id=1, name="foo">
+      #   g.count #=> 2
+      #
+      class StructNewOverride < Cop
+        MSG = '`%<member_name>s` member overrides `Struct#%<method_name>s`' \
+              ' and it may be unexpected.'
+
+        STRUCT_METHOD_NAMES = Struct.instance_methods
+        STRUCT_MEMBER_NAME_TYPES = %i[sym str].freeze
+
+        def_node_matcher :struct_new, <<~PATTERN
+          (send
+            (const ${nil? cbase} :Struct) :new ...)
+        PATTERN
+
+        def on_send(node)
+          return unless struct_new(node) do
+            node.arguments.each_with_index do |arg, index|
+              # Ignore if the first argument is a class name
+              next if index.zero? && arg.str_type?
+
+              # Ignore if the argument is not a member name
+              next unless STRUCT_MEMBER_NAME_TYPES.include?(arg.type)
+
+              member_name = arg.value
+
+              next unless STRUCT_METHOD_NAMES.include?(member_name.to_sym)
+
+              message = format(MSG, member_name: member_name.inspect,
+                                    method_name: member_name.to_s)
+              add_offense(arg, message: message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/{handle_exceptions.rb → suppressed_exception.rb}

@@ -5,7 +5,7 @@ module RuboCop
     module Lint
       # This cop checks for *rescue* blocks with no body.
       #
-      # @example AllowComments: false (default)
+      # @example
       #
       #   # bad
       #   def some_method
@@ -14,25 +14,11 @@ module RuboCop
       #   end
       #
       #   # bad
-      #   def some_method
-      #     do_something
-      #   rescue
-      #     # do nothing
-      #   end
-      #
-      #   # bad
       #   begin
       #     do_something
       #   rescue
       #   end
       #
-      #   # bad
-      #   begin
-      #     do_something
-      #   rescue
-      #     # do nothing
-      #   end
-      #
       #   # good
       #   def some_method
       #     do_something
@@ -47,34 +33,38 @@ module RuboCop
       #     handle_exception
       #   end
       #
-      # @example AllowComments: true
+      # @example AllowComments: true (default)
       #
-      #   # bad
+      #   # good
       #   def some_method
       #     do_something
       #   rescue
+      #     # do nothing
       #   end
       #
-      #   # bad
+      #   # good
       #   begin
       #     do_something
       #   rescue
+      #     # do nothing
       #   end
       #
-      #   # good
+      # @example AllowComments: false
+      #
+      #   # bad
       #   def some_method
       #     do_something
       #   rescue
-      #     # do nothing but comment
+      #     # do nothing
       #   end
       #
-      #   # good
+      #   # bad
       #   begin
       #     do_something
       #   rescue
-      #     # do nothing but comment
+      #     # do nothing
       #   end
-      class HandleExceptions < Cop
+      class SuppressedException < Cop
         MSG = 'Do not suppress exceptions.'
 
         def on_resbody(node)
@@ -83,12 +73,6 @@ module RuboCop
 
           add_offense(node)
         end
-
-        private
-
-        def comment_lines?(node)
-          processed_source[line_range(node)].any? { |line| comment_line?(line) }
-        end
       end
     end
   end

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

@@ -33,8 +33,6 @@ module RuboCop
         end
 
         def autocorrect(node)
-          return false if target_ruby_version <= 2.3
-
           lambda do |corrector|
             corrector.replace(node.loc.name, 'Integer')
           end