rubocop 0.78.0 → 1.13.0

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Do not mix named captures and numbered captures in a Regexp literal
+      # because numbered capture is ignored if they're mixed.
+      # Replace numbered captures with non-capturing groupings or
+      # named captures.
+      #
+      #   # bad
+      #   /(?<foo>FOO)(BAR)/
+      #
+      #   # good
+      #   /(?<foo>FOO)(?<bar>BAR)/
+      #
+      #   # good
+      #   /(?<foo>FOO)(?:BAR)/
+      #
+      #   # good
+      #   /(FOO)(BAR)/
+      #
+      class MixedRegexpCaptureTypes < Base
+        MSG = 'Do not mix named captures and numbered captures 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?
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -11,35 +11,35 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   x < y < z
       #   10 <= x <= 20
       #
-      # @example
-      #
       #   # good
-      #
       #   x < y && y < z
       #   10 <= x && x <= 20
-      class MultipleComparison < Cop
+      class MultipleComparison < Base
+        extend AutoCorrector
+
         MSG = 'Use the `&&` operator to compare multiple values.'
+        COMPARISON_METHODS = %i[< > <= >=].freeze
+        SET_OPERATION_OPERATORS = %i[& | ^].freeze
+        RESTRICT_ON_SEND = COMPARISON_METHODS
 
+        # @!method multiple_compare?(node)
         def_node_matcher :multiple_compare?, <<~PATTERN
-          (send (send _ {:< :> :<= :>=} $_) {:< :> :<= :>=} _)
+          (send (send _ {:< :> :<= :>=} $_) {:#{COMPARISON_METHODS.join(' :')}} _)
         PATTERN
 
         def on_send(node)
-          return unless multiple_compare?(node)
-
-          add_offense(node)
-        end
+          return unless (center = multiple_compare?(node))
+          # It allows multiple comparison using `&`, `|`, and `^` set operation operators.
+          # e.g. `x >= y & y < z`
+          return if center.send_type? && SET_OPERATION_OPERATORS.include?(center.method_name)
 
-        def autocorrect(node)
-          center = multiple_compare?(node)
-          new_center = "#{center.source} && #{center.source}"
+          add_offense(node) do |corrector|
+            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
@@ -54,49 +54,45 @@ module RuboCop
       #       end
       #     end
       #   end
-      class NestedMethodDefinition < Cop
-        MSG = 'Method definitions must not be nested. ' \
-              'Use `lambda` instead.'
+      class NestedMethodDefinition < Base
+        MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
-          find_nested_defs(node) do |nested_def_node|
-            add_offense(nested_def_node)
-          end
-        end
-        alias on_defs on_def
-
-        private
+          subject, = *node
+          return if node.defs_type? && subject.lvar_type?
 
-        def find_nested_defs(node, &block)
-          node.each_child_node do |child|
-            if child.def_type?
-              yield child
-            elsif child.defs_type?
-              subject, = *child
-              next if subject.lvar_type?
+          def_ancestor = node.each_ancestor(:def, :defs).first
+          return unless def_ancestor
 
-              yield child
-            elsif !scoping_method_call?(child)
-              find_nested_defs(child, &block)
+          within_scoping_def =
+            node.each_ancestor(:block, :sclass).any? do |ancestor|
+              scoping_method_call?(ancestor)
             end
-          end
+
+          add_offense(node) if def_ancestor && !within_scoping_def
         end
+        alias on_defs on_def
+
+        private
 
         def scoping_method_call?(child)
-          eval_call?(child) || exec_call?(child) || child.sclass_type? ||
+          child.sclass_type? || eval_call?(child) || exec_call?(child) ||
             class_or_module_or_struct_new_call?(child)
         end
 
+        # @!method eval_call?(node)
         def_node_matcher :eval_call?, <<~PATTERN
           (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
+        # @!method exec_call?(node)
         def_node_matcher :exec_call?, <<~PATTERN
           (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
 
+        # @!method class_or_module_or_struct_new_call?(node)
         def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
-          (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
+          (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
         PATTERN
       end
     end

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

@@ -15,7 +15,21 @@ module RuboCop
       #     valid_attributes: %i[name content],
       #     nested_attributes: %i[name content %i[incorrectly nested]]
       #   }
-      class NestedPercentLiteral < Cop
+      #
+      #   # good
+      #
+      #   # Neither is incompatible with the bad case, but probably the intended code.
+      #   attributes = {
+      #     valid_attributes: %i[name content],
+      #     nested_attributes: [:name, :content, %i[incorrectly nested]]
+      #   }
+      #
+      #   attributes = {
+      #     valid_attributes: %i[name content],
+      #     nested_attributes: [:name, :content, [:incorrectly, :nested]]
+      #   }
+      #
+      class NestedPercentLiteral < Base
         include PercentLiteral
 
         MSG = 'Within percent literals, nested percent literals do not ' \
@@ -25,9 +39,7 @@ module RuboCop
         # if found within a percent literal expression, will cause a
         # NestedPercentLiteral violation to be emitted.
         PERCENT_LITERAL_TYPES = PreferredDelimiters::PERCENT_LITERAL_TYPES
-        REGEXES = PERCENT_LITERAL_TYPES.map do |percent_literal|
-          /\A#{percent_literal}\W/
-        end.freeze
+        REGEXES = PERCENT_LITERAL_TYPES.map { |percent_literal| /\A#{percent_literal}\W/ }.freeze
 
         def on_array(node)
           process(node, *PERCENT_LITERAL_TYPES)
@@ -42,7 +54,7 @@ module RuboCop
         def contains_percent_literals?(node)
           node.each_child_node.any? do |child|
             literal = child.children.first.to_s.scrub
-            REGEXES.any? { |regex| literal.match(regex) }
+            REGEXES.any? { |regex| literal.match?(regex) }
           end
         end
       end

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

@@ -22,9 +22,10 @@ module RuboCop
       #     next acc if i.odd?
       #     acc + i
       #   end
-      class NextWithoutAccumulator < Cop
+      class NextWithoutAccumulator < Base
         MSG = 'Use `next` with an accumulator argument in a `reduce`.'
 
+        # @!method on_body_of_reduce(node)
         def_node_matcher :on_body_of_reduce, <<~PATTERN
           (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
         PATTERN

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for the presence of a `return` inside a `begin..end` block
+      # in assignment contexts.
+      # In this situation, the `return` will result in an exit from the current
+      # method, possibly leading to unexpected behavior.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   @some_variable ||= begin
+      #     return some_value if some_condition_is_met
+      #
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   @some_variable ||= begin
+      #     if some_condition_is_met
+      #       some_value
+      #     else
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #
+      #   some_variable = if some_condition_is_met
+      #                     return if another_condition_is_met
+      #
+      #                     some_value
+      #                   else
+      #                     do_something
+      #                   end
+      #
+      class NoReturnInBeginEndBlocks < Base
+        MSG = 'Do not `return` in `begin..end` blocks in assignment contexts.'
+
+        def on_lvasgn(node)
+          node.each_node(:kwbegin) do |kwbegin_node|
+            kwbegin_node.each_node(:return) do |return_node|
+              add_offense(return_node)
+            end
+          end
+        end
+        alias on_or_asgn    on_lvasgn
+        alias on_op_asgn    on_lvasgn
+      end
+    end
+  end
+end

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

@@ -11,6 +11,11 @@ module RuboCop
       # that are hard to debug. To ensure this doesn't happen,
       # always sort the list.
       #
+      # `Dir.glob` and `Dir[]` sort globbed results by default in Ruby 3.0.
+      # So all bad cases are acceptable when Ruby 3.0 or higher are used.
+      #
+      # This cop will be deprecated and removed when supporting only Ruby 3.0 and higher.
+      #
       # @example
       #
       #   # bad
@@ -23,8 +28,6 @@ module RuboCop
       #     require file
       #   end
       #
-      # @example
-      #
       #   # bad
       #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')) do |file|
       #     require file
@@ -35,51 +38,128 @@ module RuboCop
       #     require file
       #   end
       #
-      class NonDeterministicRequireOrder < Cop
+      #   # bad
+      #   Dir['./lib/**/*.rb'].each(&method(:require))
+      #
+      #   # good
+      #   Dir['./lib/**/*.rb'].sort.each(&method(:require))
+      #
+      #   # bad
+      #   Dir.glob(Rails.root.join('test', '*.rb'), &method(:require))
+      #
+      #   # good
+      #   Dir.glob(Rails.root.join('test', '*.rb')).sort.each(&method(:require))
+      #
+      #   # good - Respect intent if `sort` keyword option is specified in Ruby 3.0 or higher.
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb'), sort: false).each(&method(:require))
+      #
+      class NonDeterministicRequireOrder < Base
+        extend AutoCorrector
+
         MSG = 'Sort files before requiring them.'
 
         def on_block(node)
+          return if target_ruby_version >= 3.0
           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)
+            add_offense(node.send_node) { |corrector| correct_block(corrector, node.send_node) }
           end
         end
 
-        def autocorrect(node)
-          if unsorted_dir_block?(node)
-            lambda do |corrector|
-              corrector.replace(node.loc.expression, "#{node.source}.sort.each")
-            end
-          else
-            lambda do |corrector|
-              source = node.receiver.source
-              corrector.replace(node.loc.expression, "#{source}.sort.each")
+        def on_block_pass(node)
+          return if target_ruby_version >= 3.0
+          return unless method_require?(node)
+          return unless unsorted_dir_pass?(node.parent)
+
+          parent_node = node.parent
+
+          add_offense(parent_node) do |corrector|
+            if parent_node.arguments.last&.block_pass_type?
+              correct_block_pass(corrector, parent_node)
+            else
+              correct_block(corrector, parent_node)
             end
           end
         end
 
         private
 
+        def correct_block(corrector, node)
+          if unsorted_dir_block?(node)
+            corrector.replace(node, "#{node.source}.sort.each")
+          else
+            source = node.receiver.source
+
+            corrector.replace(node, "#{source}.sort.each")
+          end
+        end
+
+        def correct_block_pass(corrector, node)
+          if unsorted_dir_glob_pass?(node)
+            block_arg = node.arguments.last
+
+            corrector.remove(last_arg_range(node))
+            corrector.insert_after(node, ".sort.each(#{block_arg.source})")
+          else
+            corrector.replace(node.loc.selector, 'sort.each')
+          end
+        end
+
+        # Returns range of last argument including comma and whitespace.
+        #
+        # @return [Parser::Source::Range]
+        #
+        def last_arg_range(node)
+          node.arguments.last.source_range.with(
+            begin_pos: node.arguments[-2].source_range.end_pos
+          )
+        end
+
         def unsorted_dir_loop?(node)
           unsorted_dir_block?(node) || unsorted_dir_each?(node)
         end
 
+        def unsorted_dir_pass?(node)
+          unsorted_dir_glob_pass?(node) || unsorted_dir_each_pass?(node)
+        end
+
+        # @!method unsorted_dir_block?(node)
         def_node_matcher :unsorted_dir_block?, <<~PATTERN
-          (send (const nil? :Dir) :glob ...)
+          (send (const {nil? cbase} :Dir) :glob ...)
         PATTERN
 
+        # @!method unsorted_dir_each?(node)
         def_node_matcher :unsorted_dir_each?, <<~PATTERN
-          (send (send (const nil? :Dir) {:[] :glob} ...) :each)
+          (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each)
+        PATTERN
+
+        # @!method method_require?(node)
+        def_node_matcher :method_require?, <<~PATTERN
+          (block-pass (send nil? :method (sym :require)))
+        PATTERN
+
+        # @!method unsorted_dir_glob_pass?(node)
+        def_node_matcher :unsorted_dir_glob_pass?, <<~PATTERN
+          (send (const {nil? cbase} :Dir) :glob ...
+            (block-pass (send nil? :method (sym :require))))
+        PATTERN
+
+        # @!method unsorted_dir_each_pass?(node)
+        def_node_matcher :unsorted_dir_each_pass?, <<~PATTERN
+          (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each
+            (block-pass (send nil? :method (sym :require))))
         PATTERN
 
+        # @!method loop_variable(node)
         def_node_matcher :loop_variable, <<~PATTERN
           (args (arg $_))
         PATTERN
 
+        # @!method var_is_required?(node, name)
         def_node_search :var_is_required?, <<~PATTERN
           (send nil? :require (lvar %1))
         PATTERN