rubocop 0.93.1 → 1.79.2

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

@@ -3,12 +3,18 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for loops that will have at most one iteration.
+      # Checks for loops that will have at most one iteration.
       #
       # A loop that can never reach the second iteration is a possible error in the code.
       # In rare cases where only one iteration (or at most one iteration) is intended behavior,
       # the code should be refactored to use `if` conditionals.
       #
+      # NOTE: Block methods that are used with ``Enumerable``s are considered to be loops.
+      #
+      # `AllowedPatterns` can be used to match against the block receiver in order to allow
+      # code that would otherwise be registered as an offense (eg. `times` used not in an
+      # `Enumerable` context).
+      #
       # @example
       #   # bad
       #   while node
@@ -70,8 +76,18 @@ module RuboCop
       #     raise NotFoundError
       #   end
       #
+      #   # bad
+      #   2.times { raise ArgumentError }
+      #
+      # @example AllowedPatterns: ['(exactly|at_least|at_most)\(\d+\)\.times'] (default)
+      #
+      #   # good
+      #   exactly(2).times { raise StandardError }
       class UnreachableLoop < Base
+        include AllowedPattern
+
         MSG = 'This loop will have at most one iteration.'
+        CONTINUE_KEYWORDS = %i[next redo].freeze
 
         def on_while(node)
           check(node)
@@ -85,13 +101,18 @@ module RuboCop
           check(node) if loop_method?(node)
         end
 
+        alias on_numblock on_block
+        alias on_itblock on_block
+
         private
 
         def loop_method?(node)
-          return false unless node.block_type?
+          return false unless node.any_block_type?
 
           send_node = node.send_node
-          send_node.enumerable_method? || send_node.enumerator_method? || send_node.method?(:loop)
+          loopable = send_node.enumerable_method? || send_node.enumerator_method? ||
+                     send_node.method?(:loop)
+          loopable && !matches_allowed_pattern?(send_node.source)
         end
 
         def check(node)
@@ -99,7 +120,10 @@ module RuboCop
           break_statement = statements.find { |statement| break_statement?(statement) }
           return unless break_statement
 
-          add_offense(node) unless preceded_by_continue_statement?(break_statement)
+          unless preceded_by_continue_statement?(break_statement) ||
+                 conditional_continue_keyword?(break_statement)
+            add_offense(node)
+          end
         end
 
         def statements(node)
@@ -114,6 +138,7 @@ module RuboCop
           end
         end
 
+        # @!method break_command?(node)
         def_node_matcher :break_command?, <<~PATTERN
           {
             return break
@@ -134,7 +159,7 @@ module RuboCop
             break_statement && !preceded_by_continue_statement?(break_statement)
           when :if
             check_if(node)
-          when :case
+          when :case, :case_match
             check_case(node)
           else
             false
@@ -144,8 +169,7 @@ module RuboCop
         def check_if(node)
           if_branch = node.if_branch
           else_branch = node.else_branch
-          if_branch && else_branch &&
-            break_statement?(if_branch) && break_statement?(else_branch)
+          if_branch && else_branch && break_statement?(if_branch) && break_statement?(else_branch)
         end
 
         def check_case(node)
@@ -153,18 +177,31 @@ module RuboCop
           return false unless else_branch
           return false unless break_statement?(else_branch)
 
-          node.when_branches.all? do |branch|
-            branch.body && break_statement?(branch.body)
-          end
+          branches = if node.case_type?
+                       node.when_branches
+                     else
+                       node.in_pattern_branches
+                     end
+
+          branches.all? { |branch| branch.body && break_statement?(branch.body) }
         end
 
         def preceded_by_continue_statement?(break_statement)
           break_statement.left_siblings.any? do |sibling|
+            # Numblocks have the arguments count as a number or,
+            # itblocks have `:it` symbol in the AST.
+            next if sibling.is_a?(Integer) || sibling.is_a?(Symbol)
             next if sibling.loop_keyword? || loop_method?(sibling)
 
-            sibling.each_descendant(:next, :redo).any?
+            sibling.each_descendant(*CONTINUE_KEYWORDS).any?
           end
         end
+
+        def conditional_continue_keyword?(break_statement)
+          or_node = break_statement.each_descendant(:or).to_a.last
+
+          or_node && CONTINUE_KEYWORDS.include?(or_node.rhs.type)
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for unused block arguments.
+      # Checks for unused block arguments.
       #
       # @example
       #   # bad
@@ -68,19 +68,22 @@ module RuboCop
 
         def check_argument(variable)
           return if allowed_block?(variable) ||
-                    allowed_keyword_argument?(variable)
+                    allowed_keyword_argument?(variable) ||
+                    used_block_local?(variable)
 
           super
         end
 
+        def used_block_local?(variable)
+          variable.explicit_block_local_variable? && !variable.assignments.empty?
+        end
+
         def allowed_block?(variable)
-          !variable.block_argument? ||
-            (ignore_empty_blocks? && empty_block?(variable))
+          !variable.block_argument? || (ignore_empty_blocks? && empty_block?(variable))
         end
 
         def allowed_keyword_argument?(variable)
-          variable.keyword_argument? &&
-            allow_unused_keyword_arguments?
+          variable.keyword_argument? && allow_unused_keyword_arguments?
         end
 
         def message(variable)
@@ -115,8 +118,7 @@ module RuboCop
         end
 
         def message_for_normal_block(variable, all_arguments)
-          if all_arguments.none?(&:referenced?) &&
-             !define_method_call?(variable)
+          if all_arguments.none?(&:referenced?) && !define_method_call?(variable)
             if all_arguments.count > 1
               "You can omit all the arguments if you don't care about them."
             else
@@ -141,7 +143,7 @@ module RuboCop
 
         def message_for_underscore_prefix(variable)
           "If it's necessary, use `_` or `_#{variable.name}` " \
-          "as an argument name to indicate that it won't be used."
+            "as an argument name to indicate that it won't be used."
         end
 
         def define_method_call?(variable)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for unused method arguments.
+      # Checks for unused method arguments.
       #
       # @example
       #   # bad
@@ -39,6 +39,8 @@ module RuboCop
       #   end
       #
       # @example IgnoreNotImplementedMethods: true (default)
+      #   # with default value of `NotImplementedExceptions: ['NotImplementedError']`
+      #
       #   # good
       #   def do_something(unused)
       #     raise NotImplementedError
@@ -48,6 +50,14 @@ module RuboCop
       #     fail "TODO"
       #   end
       #
+      # @example IgnoreNotImplementedMethods: true
+      #   # with `NotImplementedExceptions: ['AbstractMethodError']`
+      #
+      #   # good
+      #   def do_something(unused)
+      #     raise AbstractMethodError
+      #   end
+      #
       # @example IgnoreNotImplementedMethods: false
       #   # bad
       #   def do_something(unused)
@@ -57,16 +67,20 @@ module RuboCop
       #   def do_something_else(unused)
       #     fail "TODO"
       #   end
-      #
       class UnusedMethodArgument < Base
         include UnusedArgument
         extend AutoCorrector
 
+        # @!method not_implemented?(node)
         def_node_matcher :not_implemented?, <<~PATTERN
-          {(send nil? :raise (const {nil? cbase} :NotImplementedError))
+          {(send nil? :raise #allowed_exception_class? ...)
            (send nil? :fail ...)}
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Style::ExplicitBlockArgument]
+        end
+
         def self.joining_forces
           VariableForce
         end
@@ -79,17 +93,15 @@ module RuboCop
 
         def check_argument(variable)
           return unless variable.method_argument?
-          return if variable.keyword_argument? &&
-                    cop_config['AllowUnusedKeywordArguments']
+          return if variable.keyword_argument? && cop_config['AllowUnusedKeywordArguments']
           return if ignored_method?(variable.scope.node.body)
 
           super
         end
 
         def ignored_method?(body)
-          cop_config['IgnoreEmptyMethods'] && body.nil? ||
-            cop_config['IgnoreNotImplementedMethods'] &&
-              not_implemented?(body)
+          (cop_config['IgnoreEmptyMethods'] && body.nil?) ||
+            (cop_config['IgnoreNotImplementedMethods'] && not_implemented?(body))
         end
 
         def message(variable)
@@ -97,7 +109,8 @@ module RuboCop
 
           unless variable.keyword_argument?
             message << " If it's necessary, use `_` or `_#{variable.name}` " \
-                       "as an argument name to indicate that it won't be used."
+                       "as an argument name to indicate that it won't be used. " \
+                       "If it's unnecessary, remove it."
           end
 
           scope = variable.scope
@@ -111,6 +124,13 @@ module RuboCop
 
           message
         end
+
+        def allowed_exception_class?(node)
+          return false unless node.const_type?
+
+          allowed_class_names = Array(cop_config.fetch('NotImplementedExceptions', []))
+          allowed_class_names.include?(node.const_name)
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop identifies places where `URI.escape` can be replaced by
+      # Identifies places where `URI.escape` can be replaced by
       # `CGI.escape`, `URI.encode_www_form`, or `URI.encode_www_form_component`
       # depending on your specific use case.
       # Also this cop identifies places where `URI.unescape` can be replaced by
@@ -47,6 +47,7 @@ module RuboCop
         METHOD_NAMES = %i[escape encode unescape decode].freeze
         RESTRICT_ON_SEND = METHOD_NAMES
 
+        # @!method uri_escape_unescape?(node)
         def_node_matcher :uri_escape_unescape?, <<~PATTERN
           (send
             (const ${nil? cbase} :URI) ${:#{METHOD_NAMES.join(' :')}}

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

@@ -3,29 +3,47 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop identifies places where `URI.regexp` is obsolete and should
-      # not be used. Instead, use `URI::DEFAULT_PARSER.make_regexp`.
+      # Identifies places where `URI.regexp` is obsolete and should not be used.
+      #
+      # For Ruby 3.3 or lower, use `URI::DEFAULT_PARSER.make_regexp`.
+      # For Ruby 3.4 or higher, use `URI::RFC2396_PARSER.make_regexp`.
+      #
+      # NOTE: If you need to support both Ruby 3.3 and lower as well as Ruby 3.4 and higher,
+      # consider manually changing the code as follows:
+      #
+      # [source,ruby]
+      # ----
+      # defined?(URI::RFC2396_PARSER) ? URI::RFC2396_PARSER : URI::DEFAULT_PARSER
+      # ----
       #
       # @example
       #   # bad
       #   URI.regexp('http://example.com')
       #
-      #   # good
+      #   # good - Ruby 3.3 or lower
       #   URI::DEFAULT_PARSER.make_regexp('http://example.com')
       #
+      #   # good - Ruby 3.4 or higher
+      #   URI::RFC2396_PARSER.make_regexp('http://example.com')
+      #
       class UriRegexp < Base
         extend AutoCorrector
 
         MSG = '`%<current>s` is obsolete and should not be used. Instead, use `%<preferred>s`.'
-        URI_CONSTANTS = ['URI', '::URI'].freeze
         RESTRICT_ON_SEND = %i[regexp].freeze
 
+        # @!method uri_constant?(node)
+        def_node_matcher :uri_constant?, <<~PATTERN
+          (const {cbase nil?} :URI)
+        PATTERN
+
         def on_send(node)
-          return unless node.receiver
-          return unless URI_CONSTANTS.include?(node.receiver.source)
+          return unless uri_constant?(node.receiver)
 
+          parser = target_ruby_version >= 3.4 ? 'RFC2396_PARSER' : 'DEFAULT_PARSER'
           argument = node.first_argument ? "(#{node.first_argument.source})" : ''
-          preferred_method = "#{node.receiver.source}::DEFAULT_PARSER.make_regexp#{argument}"
+
+          preferred_method = "#{node.receiver.source}::#{parser}.make_regexp#{argument}"
           message = format(MSG, current: node.source, preferred: preferred_method)
 
           add_offense(node.loc.selector, message: message) do |corrector|

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

@@ -3,11 +3,11 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for redundant access modifiers, including those with no
-      # code, those which are repeated, and leading `public` modifiers in a
-      # class or module body. Conditionally-defined methods are considered as
-      # always being defined, and thus access modifiers guarding such methods
-      # are not redundant.
+      # Checks for redundant access modifiers, including those with no
+      # code, those which are repeated, those which are on top-level, and
+      # leading `public` modifiers in a class or module body.
+      # Conditionally-defined methods are considered as always being defined,
+      # and thus access modifiers guarding such methods are not redundant.
       #
       # This cop has `ContextCreatingMethods` option. The default setting value
       # is an empty array that means no method is specified.
@@ -31,8 +31,8 @@ module RuboCop
       #   # bad
       #   class Foo
       #     # The following is redundant (methods defined on the class'
-      #     # singleton class are not affected by the public modifier)
-      #     public
+      #     # singleton class are not affected by the private modifier)
+      #     private
       #
       #     def self.method3
       #     end
@@ -58,6 +58,12 @@ module RuboCop
       #     private # this is redundant (no following methods are defined)
       #   end
       #
+      #   # bad
+      #   private # this is useless (access modifiers have no effect on top-level)
+      #
+      #   def method
+      #   end
+      #
       #   # good
       #   class Foo
       #     private # this is not redundant (a method is defined)
@@ -137,11 +143,25 @@ module RuboCop
         alias on_sclass on_class
 
         def on_block(node)
-          return unless eval_call?(node)
+          return unless eval_call?(node) || included_block?(node)
 
           check_node(node.body)
         end
 
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_begin(node)
+          return if node.parent
+
+          node.child_nodes.each do |child|
+            next unless child.send_type? && access_modifier?(child)
+
+            # This call always registers an offense for access modifier `child.method_name`
+            check_send_node(child, child.method_name, true)
+          end
+        end
+
         private
 
         def autocorrect(corrector, node)
@@ -150,20 +170,19 @@ module RuboCop
           corrector.remove(range)
         end
 
+        # @!method static_method_definition?(node)
         def_node_matcher :static_method_definition?, <<~PATTERN
           {def (send nil? {:attr :attr_reader :attr_writer :attr_accessor} ...)}
         PATTERN
 
+        # @!method dynamic_method_definition?(node)
         def_node_matcher :dynamic_method_definition?, <<~PATTERN
-          {(send nil? :define_method ...) (block (send nil? :define_method ...) ...)}
+          {(send nil? :define_method ...) (any_block (send nil? :define_method ...) ...)}
         PATTERN
 
+        # @!method class_or_instance_eval?(node)
         def_node_matcher :class_or_instance_eval?, <<~PATTERN
-          (block (send _ {:class_eval :instance_eval}) ...)
-        PATTERN
-
-        def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
-          (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
+          (any_block (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
         def check_node(node)
@@ -179,8 +198,7 @@ module RuboCop
         end
 
         def access_modifier?(node)
-          node.bare_access_modifier? ||
-            node.method?(:private_class_method)
+          node.bare_access_modifier? || node.method?(:private_class_method)
         end
 
         def check_scope(node)
@@ -192,10 +210,13 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_child_nodes(node, unused, cur_vis)
           node.child_nodes.each do |child|
             if child.send_type? && access_modifier?(child)
               cur_vis, unused = check_send_node(child, cur_vis, unused)
+            elsif child.block_type? && included_block?(child)
+              next
             elsif method_definition?(child)
               unused = nil
             elsif start_of_new_scope?(child)
@@ -207,6 +228,7 @@ module RuboCop
 
           [cur_vis, unused]
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def check_send_node(node, cur_vis, unused)
           if node.bare_access_modifier?
@@ -240,6 +262,10 @@ module RuboCop
           [new_vis, unused]
         end
 
+        def included_block?(block_node)
+          active_support_extensions_enabled? && block_node.method?(:included)
+        end
+
         def method_definition?(child)
           static_method_definition?(child) ||
             dynamic_method_definition?(child) ||
@@ -248,38 +274,45 @@ module RuboCop
 
         def any_method_definition?(child)
           cop_config.fetch('MethodCreatingMethods', []).any? do |m|
-            matcher_name = "#{m}_method?".to_sym
+            # Some users still have `"included"` in their `MethodCreatingMethods` configurations,
+            # so to prevent Ruby method redefinition warnings let's just skip this value.
+            next if m == 'included'
+
+            matcher_name = :"#{m}_method?"
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<~PATTERN
                 {def (send nil? :#{m} ...)}
               PATTERN
             end
 
-            send(matcher_name, child)
+            public_send(matcher_name, child)
           end
         end
 
         def start_of_new_scope?(child)
-          child.module_type? || child.class_type? ||
-            child.sclass_type? || eval_call?(child)
+          child.type?(:module, :class, :sclass) || eval_call?(child)
         end
 
         def eval_call?(child)
           class_or_instance_eval?(child) ||
-            class_or_module_or_struct_new_call?(child) ||
+            child.class_constructor? ||
             any_context_creating_methods?(child)
         end
 
         def any_context_creating_methods?(child)
+          # Some users still have `"included"` in their `ContextCreatingMethods` configurations,
+          # so to prevent Ruby method redefinition warnings let's just skip this value.
           cop_config.fetch('ContextCreatingMethods', []).any? do |m|
-            matcher_name = "#{m}_block?".to_sym
+            next if m == 'included'
+
+            matcher_name = :"#{m}_block?"
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<~PATTERN
-                (block (send {nil? const} {:#{m}} ...) ...)
+                (any_block (send {nil? const} {:#{m}} ...) ...)
               PATTERN
             end
 
-            send(matcher_name, child)
+            public_send(matcher_name, child)
           end
         end
       end