rubocop 1.36.0 → 1.38.0

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for duplicated magic comments.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # encoding: ascii
+      #   # encoding: ascii
+      #
+      #   # good
+      #
+      #   # encoding: ascii
+      #
+      #   # bad
+      #
+      #   # frozen_string_literal: true
+      #   # frozen_string_literal: true
+      #
+      #   # good
+      #
+      #   # frozen_string_literal: true
+      #
+      class DuplicateMagicComment < Base
+        include FrozenStringLiteral
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Duplicate magic comment detected.'
+
+        def on_new_investigation
+          return if processed_source.buffer.source.empty?
+
+          magic_comment_lines.each_value do |comment_lines|
+            next if comment_lines.count <= 1
+
+            comment_lines[1..].each do |comment_line|
+              range = processed_source.buffer.line_range(comment_line + 1)
+
+              register_offense(range)
+            end
+          end
+        end
+
+        private
+
+        def magic_comment_lines
+          comment_lines = { encoding_magic_comments: [], frozen_string_literal_magic_comments: [] }
+
+          leading_magic_comments.each.with_index do |magic_comment, index|
+            if magic_comment.encoding_specified?
+              comment_lines[:encoding_magic_comments] << index
+            elsif magic_comment.frozen_string_literal_specified?
+              comment_lines[:frozen_string_literal_magic_comments] << index
+            end
+          end
+
+          comment_lines
+        end
+
+        def register_offense(range)
+          add_offense(range) do |corrector|
+            corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -133,7 +133,7 @@ module RuboCop
         end
 
         def found_instance_method(node, name)
-          return unless (scope = node.parent_module_name)
+          return found_sclass_method(node, name) unless (scope = node.parent_module_name)
 
           # Humanize the scope
           scope = scope.sub(
@@ -145,6 +145,16 @@ module RuboCop
           found_method(node, "#{scope}#{name}")
         end
 
+        def found_sclass_method(node, name)
+          singleton_ancestor = node.each_ancestor.find(&:sclass_type?)
+          return unless singleton_ancestor
+
+          singleton_receiver_node = singleton_ancestor.children[0]
+          return unless singleton_receiver_node.send_type?
+
+          found_method(node, "#{singleton_receiver_node.method_name}.#{name}")
+        end
+
         def found_method(node, method_name)
           if @definitions.key?(method_name)
             loc = case node.type

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

@@ -32,26 +32,40 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def each_repeated_character_class_element_loc(node)
           node.parsed_tree&.each_expression do |expr|
-            next if expr.type != :set || expr.token == :intersection
+            next if skip_expression?(expr)
 
             seen = Set.new
+            enum = expr.expressions.to_enum
+            expression_count = expr.expressions.count
 
-            expr.expressions.each do |child|
-              next if within_interpolation?(node, child)
+            expression_count.times do |current_number|
+              current_child = enum.next
+              next if within_interpolation?(node, current_child)
 
-              child_source = child.to_s
+              current_child_source = current_child.to_s
+              next_child = enum.peek if current_number + 1 < expression_count
 
-              yield child.expression if seen.include?(child_source)
+              if seen.include?(current_child_source)
+                next if start_with_escaped_zero_number?(current_child_source, next_child.to_s)
 
-              seen << child_source
+                yield current_child.expression
+              end
+
+              seen << current_child_source
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         private
 
+        def skip_expression?(expr)
+          expr.type != :set || expr.token == :intersection
+        end
+
         # Since we blank interpolations with a space for every char of the interpolation, we would
         # mark every space (except the first) as duplicate if we do not skip regexp_parser nodes
         # that are within an interpolation.
@@ -61,6 +75,11 @@ module RuboCop
           interpolation_locs(node).any? { |il| il.overlaps?(parse_tree_child_loc) }
         end
 
+        def start_with_escaped_zero_number?(current_child, next_child)
+          # Represents escaped code from `"\00"` (`"\u0000"`) to `"\07"` (`"\a"`).
+          current_child == '\\0' && next_child.match?(/[0-7]/)
+        end
+
         def interpolation_locs(node)
           @interpolation_locs ||= {}
 

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

@@ -85,7 +85,9 @@ module RuboCop
         private
 
         def body_or_allowed_comment_lines?(node)
-          node.body || (cop_config['AllowComments'] && comment_lines?(node))
+          return true if node.body
+
+          cop_config['AllowComments'] && processed_source.contains_comment?(node.source_range)
         end
       end
     end

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

@@ -92,13 +92,17 @@ module RuboCop
         end
 
         def remove_empty_branch(corrector, node)
-          corrector.remove(deletion_range(branch_range(node)))
+          if empty_if_branch?(node) && else_branch?(node)
+            corrector.remove(branch_range(node))
+          else
+            corrector.remove(deletion_range(branch_range(node)))
+          end
         end
 
         def correct_other_branches(corrector, node)
           return unless require_other_branches_correction?(node)
 
-          if node.else_branch.if_type?
+          if node.else_branch&.if_type?
             # Replace an orphaned `elsif` with `if`
             corrector.replace(node.else_branch.loc.keyword, 'if')
           else
@@ -108,10 +112,10 @@ module RuboCop
         end
 
         def require_other_branches_correction?(node)
-          return false unless node.if_type? && node.else_branch
+          return false unless node.if_type? && node.else?
           return false if !empty_if_branch?(node) && node.elsif?
 
-          !empty_else_branch?(node)
+          !empty_elsif_branch?(node)
         end
 
         def empty_if_branch?(node)
@@ -122,14 +126,22 @@ module RuboCop
           if_branch.if_type? && !if_branch.body
         end
 
-        def empty_else_branch?(node)
-          node.else_branch.if_type? && !node.else_branch.body
+        def empty_elsif_branch?(node)
+          return false unless (else_branch = node.else_branch)
+
+          else_branch.if_type? && !else_branch.body
+        end
+
+        def else_branch?(node)
+          node.else_branch && !node.else_branch.if_type?
         end
 
         # rubocop:disable Metrics/AbcSize
         def branch_range(node)
-          if node.loc.else
-            node.source_range.with(end_pos: node.loc.else.begin_pos - 1)
+          if empty_if_branch?(node) && else_branch?(node)
+            node.source_range.with(end_pos: node.loc.else.begin_pos)
+          elsif node.loc.else
+            node.source_range.with(end_pos: node.condition.loc.expression.end_pos)
           elsif all_branches_body_missing?(node)
             if_node = node.ancestors.detect(&:if?)
             node.source_range.with(end_pos: if_node.loc.end.end_pos)

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

@@ -50,9 +50,7 @@ module RuboCop
 
         def on_new_investigation
           each_missing_enable do |cop, line_range|
-            # This has to remain a strict inequality to handle
-            # the case when max_range is Float::INFINITY
-            next if line_range.max - line_range.min < max_range + 2
+            next if acceptable_range?(cop, line_range)
 
             range = source_range(processed_source.buffer, line_range.min, (0..0))
             comment = processed_source.comment_at_line(line_range.begin)
@@ -69,6 +67,23 @@ module RuboCop
           end
         end
 
+        def acceptable_range?(cop, line_range)
+          # This has to remain a strict inequality to handle
+          # the case when max_range is Float::INFINITY
+          return true if line_range.max - line_range.min < max_range + 2
+          # This cop is disabled in the config, it is not expected to be re-enabled
+          return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
+
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
+          if cop_class &&
+             !processed_source.registry.enabled?(cop_class, config) &&
+             line_range.max == Float::INFINITY
+            return true
+          end
+
+          false
+        end
+
         def max_range
           @max_range ||= cop_config['MaximumRangeSize']
         end

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

@@ -30,6 +30,9 @@ module RuboCop
       #
       #   # good
       #
+      #   # `class_eval`, `instance_eval`, `module_eval`, `class_exec`, `instance_exec`, and
+      #   # `module_exec` blocks are allowed by default.
+      #
       #   def foo
       #     self.class.class_eval do
       #       def bar
@@ -54,7 +57,47 @@ module RuboCop
       #       end
       #     end
       #   end
+      #
+      # @example AllowedMethods: [] (default)
+      #   # bad
+      #   def do_something
+      #     has_many :articles do
+      #       def find_or_create_by_name(name)
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedMethods: ['has_many']
+      #   # bad
+      #   def do_something
+      #     has_many :articles do
+      #       def find_or_create_by_name(name)
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: [] (default)
+      #   # bad
+      #   def foo(obj)
+      #     obj.do_baz do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: ['baz']
+      #   # good
+      #   def foo(obj)
+      #     obj.do_baz do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
       class NestedMethodDefinition < Base
+        include AllowedMethods
+        include AllowedPattern
+
         MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
@@ -77,7 +120,13 @@ module RuboCop
 
         def scoping_method_call?(child)
           child.sclass_type? || eval_call?(child) || exec_call?(child) ||
-            class_or_module_or_struct_new_call?(child)
+            class_or_module_or_struct_new_call?(child) || allowed_method_name?(child)
+        end
+
+        def allowed_method_name?(node)
+          name = node.method_name
+
+          allowed_method?(name) || matches_allowed_pattern?(name)
         end
 
         # @!method eval_call?(node)

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

@@ -61,7 +61,7 @@ module RuboCop
       #   # bad
       #   10.minutes.to_i
       #
-      # @example AllowedPatterns: [/min*/]
+      # @example AllowedPatterns: ['min*']
       #
       #   # good
       #   10.minutes.to_i

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

@@ -7,6 +7,9 @@ module RuboCop
       # Checks the proper ordering of magic comments and whether
       # a magic comment is not placed before a shebang.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because file encoding may change.
+      #
       # @example
       #   # bad
       #
@@ -61,7 +64,7 @@ module RuboCop
         def magic_comment_lines
           lines = [nil, nil]
 
-          magic_comments.each.with_index do |comment, index|
+          leading_magic_comments.each.with_index do |comment, index|
             if comment.encoding_specified?
               lines[0] = index
             elsif comment.frozen_string_literal_specified?
@@ -73,10 +76,6 @@ module RuboCop
 
           lines
         end
-
-        def magic_comments
-          leading_comment_lines.map { |line| MagicComment.parse(line) }
-        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cops looks for references of Regexp captures that are out of range
+      # Looks for references of Regexp captures that are out of range
       # and thus always returns nil.
       #
       # @safety

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

@@ -113,6 +113,7 @@ module RuboCop
         def each_line_range(cop, line_ranges)
           line_ranges.each_with_index do |line_range, line_range_index|
             next if ignore_offense?(line_range)
+            next if expected_final_disable?(cop, line_range)
 
             comment = processed_source.comment_at_line(line_range.begin)
             redundant = if all_disabled?(comment)
@@ -179,11 +180,21 @@ module RuboCop
         end
 
         def ignore_offense?(line_range)
+          return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
+
           disabled_ranges.any? do |range|
             range.cover?(line_range.min) && range.cover?(line_range.max)
           end
         end
 
+        def expected_final_disable?(cop, line_range)
+          # A cop which is disabled in the config is being re-disabled until end of file
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
+          cop_class &&
+            !processed_source.registry.enabled?(cop_class, config) &&
+            line_range.max == Float::INFINITY
+        end
+
         def department_disabled?(cop, comment)
           directive = DirectiveComment.new(comment)
           directive.in_directive_department?(cop) && !directive.overridden_by_department?(cop)
@@ -209,7 +220,12 @@ module RuboCop
 
           add_offense(location, message: message(cop_names)) do |corrector|
             range = comment_range_with_surrounding_space(location, comment.loc.expression)
-            corrector.remove(range)
+
+            if leave_free_comment?(comment, range)
+              corrector.replace(range, ' # ')
+            else
+              corrector.remove(range)
+            end
           end
         end
 
@@ -227,6 +243,12 @@ module RuboCop
           end
         end
 
+        def leave_free_comment?(comment, range)
+          free_comment = comment.text.gsub(range.source.strip, '')
+
+          !free_comment.empty? && !free_comment.start_with?('#')
+        end
+
         def cop_range(comment, cop)
           cop = remove_department_marker(cop)
           matching_range(comment.loc.expression, cop) ||

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

@@ -41,6 +41,7 @@ module RuboCop
           return unless (receiver = node.receiver)
           return unless receiver.receiver&.const_type? && receiver.receiver.short_name == :Dir
           return unless GLOB_METHODS.include?(receiver.method_name)
+          return if multiple_argument?(receiver)
 
           selector = node.loc.selector
 
@@ -49,6 +50,12 @@ module RuboCop
             corrector.remove(node.loc.dot)
           end
         end
+
+        private
+
+        def multiple_argument?(glob_method)
+          glob_method.arguments.count >= 2 || glob_method.first_argument&.splat_type?
+        end
       end
     end
   end

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

@@ -6,13 +6,23 @@ module RuboCop
       # Checks for unnecessary `require` statement.
       #
       # The following features are unnecessary `require` statement because
-      # they are already loaded.
+      # they are already loaded. e.g. Ruby 2.2:
       #
       #   ruby -ve 'p $LOADED_FEATURES.reject { |feature| %r|/| =~ feature }'
       #   ruby 2.2.8p477 (2017-09-14 revision 59906) [x86_64-darwin13]
       #   ["enumerator.so", "rational.so", "complex.so", "thread.rb"]
       #
-      # This cop targets Ruby 2.2 or higher containing these 4 features.
+      # Below are the features that each `TargetRubyVersion` targets.
+      #
+      #   * 2.0+ ... `enumerator`
+      #   * 2.1+ ... `thread`
+      #   * 2.2+ ... Add `rational` and `complex` above
+      #   * 2.5+ ... Add `pp` above
+      #   * 2.7+ ... Add `ruby2_keywords` above
+      #   * 3.1+ ... Add `fiber` above
+      #   * 3.2+ ... `set`
+      #
+      # This cop target those features.
       #
       # @example
       #   # bad
@@ -24,28 +34,46 @@ module RuboCop
       class RedundantRequireStatement < Base
         include RangeHelp
         extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.2
 
         MSG = 'Remove unnecessary `require` statement.'
         RESTRICT_ON_SEND = %i[require].freeze
+        RUBY_22_LOADED_FEATURES = %w[rational complex].freeze
 
-        # @!method unnecessary_require_statement?(node)
-        def_node_matcher :unnecessary_require_statement?, <<~PATTERN
+        # @!method redundant_require_statement?(node)
+        def_node_matcher :redundant_require_statement?, <<~PATTERN
           (send nil? :require
-            (str {"enumerator" "rational" "complex" "thread"}))
+            (str #redundant_feature?))
         PATTERN
 
         def on_send(node)
-          return unless unnecessary_require_statement?(node)
+          return unless redundant_require_statement?(node)
 
           add_offense(node) do |corrector|
-            range = range_with_surrounding_space(node.loc.expression, side: :right)
+            if node.parent.respond_to?(:modifier_form?) && node.parent.modifier_form?
+              corrector.insert_after(node.parent, "\nend")
+
+              range = range_with_surrounding_space(node.loc.expression, side: :right)
+            else
+              range = range_by_whole_lines(node.source_range, include_final_newline: true)
+            end
 
             corrector.remove(range)
           end
         end
+
+        private
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def redundant_feature?(feature_name)
+          feature_name == 'enumerator' ||
+            (target_ruby_version >= 2.1 && feature_name == 'thread') ||
+            (target_ruby_version >= 2.2 && RUBY_22_LOADED_FEATURES.include?(feature_name)) ||
+            (target_ruby_version >= 2.5 && feature_name == 'pp') ||
+            (target_ruby_version >= 2.7 && feature_name == 'ruby2_keywords') ||
+            (target_ruby_version >= 3.1 && feature_name == 'fiber') ||
+            (target_ruby_version >= 3.2 && feature_name == 'set')
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       end
     end
   end

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

@@ -46,7 +46,7 @@ module RuboCop
         private
 
         def check_ternary(ternary, node)
-          return unless ternary.condition.operator_keyword?
+          return if node.method?(:[]) || !ternary.condition.operator_keyword?
 
           range = range_between(node.source_range.begin_pos, ternary.condition.source_range.end_pos)
 

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

@@ -31,6 +31,7 @@ module RuboCop
         minimum_target_ruby_version 2.3
 
         MSG = 'Do not chain ordinary method call after safe navigation operator.'
+        PLUS_MINUS_METHODS = %i[+@ -@].freeze
 
         # @!method bad_method?(node)
         def_node_matcher :bad_method?, <<~PATTERN
@@ -42,7 +43,7 @@ module RuboCop
 
         def on_send(node)
           bad_method?(node) do |safe_nav, method|
-            return if nil_methods.include?(method)
+            return if nil_methods.include?(method) || PLUS_MINUS_METHODS.include?(node.method_name)
 
             method_chain = method_chain(node)
             location =
@@ -71,7 +72,7 @@ module RuboCop
             else
               offense_range.source.dup
             end
-          source.prepend('.') unless send_node.dot?
+          source.prepend('.') unless source.start_with?('.')
           source.prepend('&')
         end
 

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

@@ -155,16 +155,6 @@ module RuboCop
           end
         end
 
-        # @param [RuboCop::AST::Node] rescue_group is a node of array_type
-        def rescued_exceptions(rescue_group)
-          klasses = *rescue_group
-          klasses.map do |klass|
-            next unless klass.const_type?
-
-            klass.source
-          end.compact
-        end
-
         def find_shadowing_rescue(rescues)
           rescued_groups = rescued_groups_for(rescues)
           rescued_groups.zip(rescues).each do |group, res|

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

@@ -12,9 +12,12 @@ module RuboCop
       # because `Ractor` should not access outer variables.
       # eg. following style is encouraged:
       #
+      #   [source,ruby]
+      #   ----
       #   worker_id, pipe = env
       #   Ractor.new(worker_id, pipe) do |worker_id, pipe|
       #   end
+      #   ----
       #
       # @example
       #

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

@@ -79,7 +79,7 @@ module RuboCop
       #   # bad
       #   2.times { raise ArgumentError }
       #
-      # @example AllowedPatterns: [/(exactly|at_least|at_most)\(\d+\)\.times/] (default)
+      # @example AllowedPatterns: ['(exactly|at_least|at_most)\(\d+\)\.times'] (default)
       #
       #   # good
       #   exactly(2).times { raise StandardError }

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

@@ -68,6 +68,10 @@ module RuboCop
            (send nil? :fail ...)}
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Style::ExplicitBlockArgument]
+        end
+
         def self.joining_forces
           VariableForce
         end

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -22,6 +22,18 @@ module RuboCop
         processed_source.each_comment_in_lines(start_line...end_line)
       end
 
+      def comments_contain_disables?(node, cop_name)
+        disabled_ranges = processed_source.disabled_line_ranges[cop_name]
+
+        return unless disabled_ranges
+
+        node_range = node.source_range.line...find_end_line(node)
+
+        disabled_ranges.any? do |disable_range|
+          disable_range.cover?(node_range) || node_range.cover?(disable_range)
+        end
+      end
+
       private
 
       def end_position_for(node)

data/lib/rubocop/cop/mixin/frozen_string_literal.rb

@@ -69,6 +69,10 @@ module RuboCop
         end
       end
 
+      def leading_magic_comments
+        leading_comment_lines.map { |line| MagicComment.parse(line) }
+      end
+
       def leading_comment_lines
         first_non_comment_token = processed_source.tokens.find { |token| !token.comment? }