rubocop 1.36.0 → 1.40.0

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

@@ -51,8 +51,8 @@ module RuboCop
       #   alias bar foo
       class DuplicateMethods < Base
         MSG = 'Method `%<method>s` is defined at both %<defined>s and %<current>s.'
-
         RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer attr_accessor attr].freeze
+        DEF_TYPES = %i[def defs].freeze
 
         def initialize(config = nil, options = nil)
           super
@@ -127,13 +127,13 @@ module RuboCop
           found_method(node, "#{enclosing}.#{name}")
         end
 
-        def message_for_dup(node, method_name)
-          format(MSG, method: method_name, defined: source_location(@definitions[method_name]),
+        def message_for_dup(node, method_name, key)
+          format(MSG, method: method_name, defined: source_location(@definitions[key]),
                       current: source_location(node))
         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,19 +145,38 @@ 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
-                  when :def, :defs
+          key = method_key(node, method_name)
+
+          if @definitions.key?(key)
+            loc = if DEF_TYPES.include?(node.type)
                     node.loc.keyword.join(node.loc.name)
                   else
                     node.loc.expression
                   end
-            message = message_for_dup(node, method_name)
+            message = message_for_dup(node, method_name, key)
 
             add_offense(loc, message: message)
           else
-            @definitions[method_name] = node
+            @definitions[key] = node
+          end
+        end
+
+        def method_key(node, method_name)
+          if (ancestor_def = node.each_ancestor(*DEF_TYPES).first)
+            "#{ancestor_def.method_name}.#{method_name}"
+          else
+            method_name
           end
         end
 

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_block.rb

@@ -65,7 +65,7 @@ module RuboCop
 
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return if node.body
-          return if allow_empty_lambdas? && lambda_or_proc?(node)
+          return if allow_empty_lambdas? && node.lambda_or_proc?
           return if cop_config['AllowComments'] && allow_comment?(node)
 
           add_offense(node)
@@ -88,10 +88,6 @@ module RuboCop
           regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
           Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
         end
-
-        def lambda_or_proc?(node)
-          node.lambda? || node.proc?
-        end
       end
     end
   end

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

@@ -68,7 +68,7 @@ module RuboCop
         MSG = 'Avoid `%<keyword>s` branches without a body.'
 
         def on_if(node)
-          return if node.body
+          return if node.body || same_line?(node.loc.begin, node.loc.end)
           return if cop_config['AllowComments'] && contains_comments?(node)
 
           add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
@@ -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/interpolation_check.rb

@@ -6,9 +6,10 @@ module RuboCop
       # Checks for interpolation in a single quoted string.
       #
       # @safety
-      #   This cop is generally safe, but is marked as unsafe because
-      #   it is possible to actually intentionally have text inside
-      #   `#{...}` in a single quoted string.
+      #   This cop's autocorrection is unsafe because although it always replaces single quotes as
+      #   if it were miswritten double quotes, it is not always the case. For example,
+      #   `'#{foo} bar'` would be replaced by `"#{foo} bar"`, so the replaced code would evaluate
+      #   the expression `foo`.
       #
       # @example
       #

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

@@ -40,11 +40,16 @@ module RuboCop
           unless node.arguments.one? && first_argument_starts_with_left_parenthesis?(node)
             return true
           end
+          return true if first_argument_block_type?(node.first_argument)
 
           node.operator_method? || node.setter_method? || chained_calls?(node) ||
             valid_first_argument?(node.first_argument)
         end
 
+        def first_argument_block_type?(first_arg)
+          first_arg.block_type? || first_arg.numblock_type?
+        end
+
         def valid_first_argument?(first_arg)
           first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg)
         end

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)
@@ -130,18 +131,28 @@ module RuboCop
         def each_already_disabled(cop, line_ranges)
           line_ranges.each_cons(2) do |previous_range, range|
             next if ignore_offense?(range)
-            next unless followed_ranges?(previous_range, range)
-
             # If a cop is disabled in a range that begins on the same line as
             # the end of the previous range, it means that the cop was
             # already disabled by an earlier comment. So it's redundant
             # whether there are offenses or not.
+            next unless followed_ranges?(previous_range, range)
+
             comment = processed_source.comment_at_line(range.begin)
 
+            next unless comment
             # Comments disabling all cops don't count since it's reasonable
             # to disable a few select cops first and then all cops further
             # down in the code.
-            yield comment, cop if comment && !all_disabled?(comment)
+            next if all_disabled?(comment)
+
+            redundant =
+              if department_disabled?(cop, comment)
+                find_redundant_department(cop, range)
+              else
+                cop
+              end
+
+            yield comment, redundant
           end
         end
 
@@ -179,11 +190,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 +230,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 +253,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)