rubocop 1.35.1 → 1.37.0

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 (node.if? || node.unless?) && node.else_branch
+          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
@@ -107,13 +111,51 @@ module RuboCop
           end
         end
 
+        def require_other_branches_correction?(node)
+          return false unless node.if_type? && node.else?
+          return false if !empty_if_branch?(node) && node.elsif?
+
+          !empty_elsif_branch?(node)
+        end
+
+        def empty_if_branch?(node)
+          return false unless (parent = node.parent)
+          return true unless parent.if_type?
+          return true unless (if_branch = parent.if_branch)
+
+          if_branch.if_type? && !if_branch.body
+        end
+
+        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
+          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.loc.else.begin_pos - 1)
+          elsif all_branches_body_missing?(node)
+            if_node = node.ancestors.detect(&:if?)
+            node.source_range.with(end_pos: if_node.loc.end.end_pos)
           else
             node.source_range
           end
         end
+        # rubocop:enable Metrics/AbcSize
+
+        def all_branches_body_missing?(node)
+          return false unless node.parent&.if_type?
+
+          node.parent.branches.compact.empty?
+        end
 
         def deletion_range(range)
           # Collect a range between the start of the `if` node and the next relevant node,

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

@@ -209,7 +209,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 +232,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,22 @@ 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
+      #
+      # This cop target those features.
       #
       # @example
       #   # bad
@@ -24,21 +33,19 @@ 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)
@@ -46,6 +53,19 @@ module RuboCop
             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')
+        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

@@ -12,7 +12,7 @@ module RuboCop
       # same `rescue` statement. In both cases, the more specific rescue is
       # unnecessary because it is covered by rescuing the less specific
       # exception. (ie. `rescue Exception, StandardError` has the same behavior
-      # whether `StandardError` is included or not, because all `StandardError`s
+      # whether `StandardError` is included or not, because all ``StandardError``s
       # are rescued by `rescue Exception`).
       #
       # @example
@@ -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
       #
@@ -64,14 +67,26 @@ module RuboCop
         end
 
         def same_conditions_node_different_branch?(variable, outer_local_variable)
-          variable_node = variable.scope.node.parent
+          variable_node = variable_node(variable)
           return false unless variable_node.conditional?
 
           outer_local_variable_node =
             find_conditional_node_from_ascendant(outer_local_variable.declaration_node)
           return true unless outer_local_variable_node
 
-          outer_local_variable_node.conditional? && variable_node == outer_local_variable_node
+          outer_local_variable_node.conditional? &&
+            (variable_node == outer_local_variable_node ||
+              variable_node == outer_local_variable_node.else_branch)
+        end
+
+        def variable_node(variable)
+          parent_node = variable.scope.node.parent
+
+          if parent_node.when_type?
+            parent_node.parent
+          else
+            parent_node
+          end
         end
 
         def find_conditional_node_from_ascendant(node)

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

@@ -9,7 +9,7 @@ module RuboCop
       # 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.
+      # 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
@@ -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/lint/useless_access_modifier.rb

@@ -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

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

@@ -6,7 +6,7 @@ module RuboCop
       # Looks for `ruby2_keywords` calls for methods that do not need it.
       #
       # `ruby2_keywords` should only be called on methods that accept an argument splat
-      # (`*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
+      # (`\*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
       # a keyword splat (`**kwargs`).
       #
       # @example

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

@@ -17,16 +17,21 @@ module RuboCop
 
       # @api public
       def allowed_methods
-        deprecated_values = cop_config_deprecated_values
-        if deprecated_values.any?(Regexp)
-          cop_config.fetch('AllowedMethods', [])
+        if cop_config_deprecated_values.any?(Regexp)
+          cop_config_allowed_methods
         else
-          Array(cop_config['AllowedMethods']).concat(deprecated_values)
+          cop_config_allowed_methods + cop_config_deprecated_values
         end
       end
 
+      def cop_config_allowed_methods
+        @cop_config_allowed_methods ||= Array(cop_config.fetch('AllowedMethods', []))
+      end
+
       def cop_config_deprecated_values
-        Array(cop_config['IgnoredMethods']).concat(Array(cop_config['ExcludedMethods']))
+        @cop_config_deprecated_values ||=
+          Array(cop_config.fetch('IgnoredMethods', [])) +
+          Array(cop_config.fetch('ExcludedMethods', []))
       end
     end
     # @deprecated IgnoredMethods class has been replaced with AllowedMethods.

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

@@ -30,15 +30,23 @@ module RuboCop
       def allowed_patterns
         # Since there could be a pattern specified in the default config, merge the two
         # arrays together.
-        patterns = Array(cop_config['AllowedPatterns']).concat(Array(cop_config['IgnoredPatterns']))
-        deprecated_values = cop_config_deprecated_methods_values
-        return patterns unless deprecated_values.any?(Regexp)
+        if cop_config_deprecated_methods_values.any?(Regexp)
+          cop_config_patterns_values + cop_config_deprecated_methods_values
+        else
+          cop_config_patterns_values
+        end
+      end
 
-        Array(patterns.concat(deprecated_values))
+      def cop_config_patterns_values
+        @cop_config_patterns_values ||=
+          Array(cop_config.fetch('AllowedPatterns', [])) +
+          Array(cop_config.fetch('IgnoredPatterns', []))
       end
 
       def cop_config_deprecated_methods_values
-        Array(cop_config['IgnoredMethods']).concat(Array(cop_config['ExcludedMethods']))
+        @cop_config_deprecated_methods_values ||=
+          Array(cop_config.fetch('IgnoredMethods', [])) +
+          Array(cop_config.fetch('ExcludedMethods', []))
       end
     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? }
 

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

@@ -96,11 +96,14 @@ module RuboCop
       end
 
       def without_parentheses_call_expr_follows?(ancestor)
+        return false unless ancestor.respond_to?(:parenthesized?) && !ancestor.parenthesized?
+
         right_sibling = ancestor.right_sibling
-        right_sibling ||= ancestor.each_ancestor.find(&:assignment?)&.right_sibling
-        return false unless right_sibling
+        right_sibling ||= ancestor.each_ancestor.find do |node|
+          node.assignment? || node.send_type?
+        end&.right_sibling
 
-        ancestor.respond_to?(:parenthesized?) && !ancestor.parenthesized? && !!right_sibling
+        !!right_sibling
       end
 
       def breakdown_value_types_of_hash(hash_node)

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

@@ -68,6 +68,8 @@ module RuboCop
         # `transform_values` if value transformation uses key.
         return if captures.transformation_uses_both_args?
 
+        return unless captures.use_transformed_argname?
+
         message = "Prefer `#{new_method_name}` over `#{match_desc}`."
         add_offense(node, message: message) do |corrector|
           correction = prepare_correction(node)
@@ -113,11 +115,7 @@ module RuboCop
       end
 
       # Internal helper class to hold match data
-      Captures = Struct.new(
-        :transformed_argname,
-        :transforming_body_expr,
-        :unchanged_body_expr
-      ) do
+      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
         def noop_transformation?
           transforming_body_expr.lvar_type? &&
             transforming_body_expr.children == [transformed_argname]
@@ -126,6 +124,12 @@ module RuboCop
         def transformation_uses_both_args?
           transforming_body_expr.descendants.include?(unchanged_body_expr)
         end
+
+        def use_transformed_argname?
+          transforming_body_expr.each_descendant(:lvar).any? do |node|
+            node.source == transformed_argname.to_s
+          end
+        end
       end
 
       # Internal helper class to hold autocorrect data

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

@@ -11,7 +11,9 @@ module RuboCop
       private
 
       def rescue_modifier?(node)
-        node&.resbody_type? && @modifier_locations.include?(node.loc.keyword)
+        return false unless node.respond_to?(:resbody_type?)
+
+        node.resbody_type? && @modifier_locations.include?(node.loc.keyword)
       end
 
       # @deprecated Use ResbodyNode#exceptions instead

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

@@ -13,7 +13,7 @@ module RuboCop
 
       private
 
-      def side_space_range(range:, side:)
+      def side_space_range(range:, side:, include_newlines: false)
         buffer = processed_source.buffer
         src = buffer.source
 
@@ -21,11 +21,11 @@ module RuboCop
         end_pos = range.end_pos
         if side == :left
           end_pos = begin_pos
-          begin_pos = reposition(src, begin_pos, -1)
+          begin_pos = reposition(src, begin_pos, -1, include_newlines: include_newlines)
         end
         if side == :right
           begin_pos = end_pos
-          end_pos = reposition(src, end_pos, 1)
+          end_pos = reposition(src, end_pos, 1, include_newlines: include_newlines)
         end
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
@@ -75,9 +75,10 @@ module RuboCop
         end
       end
 
-      def reposition(src, pos, step)
+      def reposition(src, pos, step, include_newlines: false)
         offset = step == -1 ? -1 : 0
-        pos += step while SINGLE_SPACE_REGEXP.match?(src[pos + offset])
+        pos += step while SINGLE_SPACE_REGEXP.match?(src[pos + offset]) ||
+                          (include_newlines && src[pos + offset] == "\n")
         pos.negative? ? 0 : pos
       end