rubocop 1.35.0 → 1.36.0

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

@@ -57,7 +57,7 @@ module RuboCop
         end
 
         if left_parenthesis && style == :special_inside_parentheses
-          return [left_parenthesis.column + 1, :first_colmn_after_left_parenthesis]
+          return [left_parenthesis.column + 1, :first_column_after_left_parenthesis]
         end
 
         [left_brace.source_line =~ /\S/, :start_of_line]

data/lib/rubocop/cop/naming/constant_name.rb

@@ -72,10 +72,10 @@ module RuboCop
         PATTERN
 
         def allowed_conditional_expression_on_rhs?(node)
-          node&.if_type? && contains_contant?(node)
+          node&.if_type? && contains_constant?(node)
         end
 
-        def contains_contant?(node)
+        def contains_constant?(node)
           node.branches.any?(&:const_type?)
         end
       end

data/lib/rubocop/cop/style/access_modifier_declarations.rb

@@ -9,6 +9,11 @@ module RuboCop
       # Applications of visibility methods to symbols can be controlled
       # using AllowModifiersOnSymbols config.
       #
+      # @safety
+      #   Autocorrection is not safe, because the visibility of dynamically
+      #   defined methods can vary depending on the state determined by
+      #   the group access modifier.
+      #
       # @example EnforcedStyle: group (default)
       #   # bad
       #   class Foo
@@ -63,7 +68,10 @@ module RuboCop
       #
       #   end
       class AccessModifierDeclarations < Base
+        extend AutoCorrector
+
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         GROUP_STYLE_MESSAGE = [
           '`%<access_modifier>s` should not be',
@@ -88,7 +96,10 @@ module RuboCop
           return if allow_modifiers_on_symbols?(node)
 
           if offense?(node)
-            add_offense(node.loc.selector) { opposite_style_detected }
+            add_offense(node.loc.selector) do |corrector|
+              autocorrect(corrector, node)
+            end
+            opposite_style_detected
           else
             correct_style_detected
           end
@@ -96,6 +107,23 @@ module RuboCop
 
         private
 
+        def autocorrect(corrector, node)
+          case style
+          when :group
+            def_node = find_corresponding_def_node(node)
+            return unless def_node
+
+            remove_node(corrector, def_node)
+            remove_node(corrector, node)
+            insert_def(corrector, node, def_node.source)
+          when :inline
+            remove_node(corrector, node)
+            select_grouped_def_nodes(node).each do |grouped_def_node|
+              insert_inline_modifier(corrector, grouped_def_node, node.method_name)
+            end
+          end
+        end
+
         def allow_modifiers_on_symbols?(node)
           cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
         end
@@ -130,6 +158,54 @@ module RuboCop
             format(INLINE_STYLE_MESSAGE, access_modifier: access_modifier)
           end
         end
+
+        def find_corresponding_def_node(node)
+          if access_modifier_with_symbol?(node)
+            method_name = node.arguments.first.value
+            node.parent.each_child_node(:def).find do |child|
+              child.method?(method_name)
+            end
+          else
+            node.arguments.first
+          end
+        end
+
+        def find_argument_less_modifier_node(node)
+          node.parent.each_child_node(:send).find do |child|
+            child.method?(node.method_name) && child.arguments.empty?
+          end
+        end
+
+        def select_grouped_def_nodes(node)
+          node.right_siblings.take_while do |sibling|
+            !(sibling.send_type? && sibling.bare_access_modifier_declaration?)
+          end.select(&:def_type?)
+        end
+
+        def insert_def(corrector, node, source)
+          argument_less_modifier_node = find_argument_less_modifier_node(node)
+          if argument_less_modifier_node
+            corrector.insert_after(argument_less_modifier_node, "\n\n#{source}")
+          else
+            corrector.insert_before(
+              node.each_ancestor(:block, :class, :module).first.location.end,
+              "#{node.method_name}\n\n#{source}\n"
+            )
+          end
+        end
+
+        def insert_inline_modifier(corrector, node, modifier_name)
+          corrector.insert_before(node, "#{modifier_name} ")
+        end
+
+        def remove_node(corrector, node)
+          corrector.remove(
+            range_by_whole_lines(
+              node.location.expression,
+              include_final_newline: true
+            )
+          )
+        end
       end
     end
   end

data/lib/rubocop/cop/style/case_equality.rb

@@ -7,6 +7,9 @@ module RuboCop
       #
       # If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of
       # the case equality operator is a constant.
+
+      # If `AllowOnSelfClass` option is enabled, the cop will ignore violations when the receiver of
+      # the case equality operator is `self.class`. Note intermediate variables are not accepted.
       #
       # @example
       #   # bad
@@ -26,6 +29,14 @@ module RuboCop
       #   # good
       #   Array === something
       #
+      # @example AllowOnSelfClass: false (default)
+      #   # bad
+      #   self.class === something
+      #
+      # @example AllowOnSelfClass: true
+      #   # good
+      #   self.class === something
+      #
       class CaseEquality < Base
         extend AutoCorrector
 
@@ -33,7 +44,10 @@ module RuboCop
         RESTRICT_ON_SEND = %i[===].freeze
 
         # @!method case_equality?(node)
-        def_node_matcher :case_equality?, '(send $#const? :=== $_)'
+        def_node_matcher :case_equality?, '(send $#offending_receiver? :=== $_)'
+
+        # @!method self_class?(node)
+        def_node_matcher :self_class?, '(send (self) :class)'
 
         def on_send(node)
           case_equality?(node) do |lhs, rhs|
@@ -48,12 +62,11 @@ module RuboCop
 
         private
 
-        def const?(node)
-          if cop_config.fetch('AllowOnConstant', false)
-            !node&.const_type?
-          else
-            true
-          end
+        def offending_receiver?(node)
+          return false if node&.const_type? && cop_config.fetch('AllowOnConstant', false)
+          return false if self_class?(node) && cop_config.fetch('AllowOnSelfClass', false)
+
+          true
         end
 
         def replacement(lhs, rhs)
@@ -66,12 +79,29 @@ module RuboCop
             #
             # So here is noop.
           when :begin
-            child = lhs.children.first
-            "#{lhs.source}.include?(#{rhs.source})" if child&.range_type?
+            begin_replacement(lhs, rhs)
           when :const
-            "#{rhs.source}.is_a?(#{lhs.source})"
+            const_replacement(lhs, rhs)
+          when :send
+            send_replacement(lhs, rhs)
           end
         end
+
+        def begin_replacement(lhs, rhs)
+          return unless lhs.children.first&.range_type?
+
+          "#{lhs.source}.include?(#{rhs.source})"
+        end
+
+        def const_replacement(lhs, rhs)
+          "#{rhs.source}.is_a?(#{lhs.source})"
+        end
+
+        def send_replacement(lhs, rhs)
+          return unless self_class?(lhs)
+
+          "#{rhs.source}.is_a?(#{lhs.source})"
+        end
       end
     end
   end

data/lib/rubocop/cop/style/each_for_simple_loop.rb

@@ -28,14 +28,14 @@ module RuboCop
         MSG = 'Use `Integer#times` for a simple loop which iterates a fixed number of times.'
 
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
-          return unless offending_each_range(node)
+          return unless offending?(node)
 
           send_node = node.send_node
 
           range = send_node.receiver.source_range.join(send_node.loc.selector)
 
           add_offense(range) do |corrector|
-            range_type, min, max = offending_each_range(node)
+            range_type, min, max = each_range(node)
 
             max += 1 if range_type == :irange
 
@@ -45,9 +45,44 @@ module RuboCop
 
         private
 
-        # @!method offending_each_range(node)
-        def_node_matcher :offending_each_range, <<~PATTERN
-          (block (send (begin (${irange erange} (int $_) (int $_))) :each) (args) ...)
+        def offending?(node)
+          each_range_with_zero_origin?(node) || each_range_without_block_argument?(node)
+        end
+
+        # @!method each_range(node)
+        def_node_matcher :each_range, <<~PATTERN
+          (block
+            (send
+              (begin
+                (${irange erange}
+                  (int $_) (int $_)))
+              :each)
+            (args ...)
+            ...)
+        PATTERN
+
+        # @!method each_range_with_zero_origin?(node)
+        def_node_matcher :each_range_with_zero_origin?, <<~PATTERN
+          (block
+            (send
+              (begin
+                ({irange erange}
+                  (int 0) (int _)))
+              :each)
+            (args ...)
+            ...)
+        PATTERN
+
+        # @!method each_range_without_block_argument?(node)
+        def_node_matcher :each_range_without_block_argument?, <<~PATTERN
+          (block
+            (send
+              (begin
+                ({irange erange}
+                  (int _) (int _)))
+              :each)
+            (args)
+            ...)
         PATTERN
       end
     end

data/lib/rubocop/cop/style/guard_clause.rb

@@ -6,6 +6,10 @@ module RuboCop
       # Use a guard clause instead of wrapping the code inside a conditional
       # expression
       #
+      # A condition with an `elsif` or `else` branch is allowed unless
+      # one of `return`, `break`, `next`, `raise`, or `fail` is used
+      # in the body of the conditional expression.
+      #
       # @example
       #   # bad
       #   def test
@@ -50,34 +54,41 @@ module RuboCop
       #
       # @example AllowConsecutiveConditionals: false (default)
       #   # bad
-      #   if foo?
-      #     work
-      #   end
+      #   def test
+      #     if foo?
+      #       work
+      #     end
       #
-      #   if bar?  # <- reports an offense
-      #     work
+      #     if bar?  # <- reports an offense
+      #       work
+      #     end
       #   end
       #
       # @example AllowConsecutiveConditionals: true
       #   # good
-      #   if foo?
-      #     work
-      #   end
+      #   def test
+      #     if foo?
+      #       work
+      #     end
       #
-      #   if bar?
-      #     work
+      #     if bar?
+      #       work
+      #     end
       #   end
       #
       #   # bad
-      #   if foo?
-      #     work
-      #   end
+      #   def test
+      #     if foo?
+      #       work
+      #     end
       #
-      #   do_something
+      #     do_something
       #
-      #   if bar?  # <- reports an offense
-      #     work
+      #     if bar?  # <- reports an offense
+      #       work
+      #     end
       #   end
+      #
       class GuardClause < Base
         include MinBodyLength
         include StatementModifier

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -130,7 +130,7 @@ module RuboCop
               call_as_argument_or_chain?(node) ||
               hash_literal_in_arguments?(node) ||
               node.descendants.any? do |n|
-                n.forwarded_args_type? || ambigious_literal?(n) || logical_operator?(n) ||
+                n.forwarded_args_type? || ambiguous_literal?(n) || logical_operator?(n) ||
                   call_with_braced_block?(n)
               end
           end
@@ -166,7 +166,7 @@ module RuboCop
             previous.parenthesized? || allowed_chained_call_with_parentheses?(previous)
           end
 
-          def ambigious_literal?(node)
+          def ambiguous_literal?(node)
             splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) || unary_literal?(node)
           end
 

data/lib/rubocop/cop/style/multiline_in_pattern_then.rb

@@ -49,7 +49,7 @@ module RuboCop
 
         # Requires `then` for write `in` and its body on the same line.
         def require_then?(in_pattern_node)
-          return true if in_pattern_node.pattern.first_line != in_pattern_node.pattern.last_line
+          return true unless in_pattern_node.pattern.single_line?
           return false unless in_pattern_node.body
 
           same_line?(in_pattern_node, in_pattern_node.body)

data/lib/rubocop/cop/style/next.rb

@@ -225,11 +225,7 @@ module RuboCop
           adjustment = delta + @reindented_lines[lineno]
           @reindented_lines[lineno] = adjustment
 
-          if adjustment.positive?
-            corrector.remove_leading(buffer.line_range(lineno), adjustment)
-          elsif adjustment.negative?
-            corrector.insert_before(buffer.line_range(lineno), ' ' * -adjustment)
-          end
+          corrector.remove_leading(buffer.line_range(lineno), adjustment) if adjustment.positive?
         end
       end
     end

data/lib/rubocop/cop/style/perl_backrefs.rb

@@ -83,10 +83,31 @@ module RuboCop
           end
         end
 
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String, nil]
+        def preferred_expression_to_node_with_constant_prefix(node)
+          expression = preferred_expression_to(node)
+          return unless expression
+
+          "#{constant_prefix(node)}#{expression}"
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String]
+        def constant_prefix(node)
+          if node.each_ancestor(:class, :module).any?
+            '::'
+          else
+            ''
+          end
+        end
+
         # @private
         # @param [RuboCop::AST::Node] node
         def on_back_ref_or_gvar_or_nth_ref(node)
-          preferred_expression = preferred_expression_to(node)
+          preferred_expression = preferred_expression_to_node_with_constant_prefix(node)
           return unless preferred_expression
 
           add_offense(

data/lib/rubocop/cop/style/redundant_parentheses.rb

@@ -29,6 +29,9 @@ module RuboCop
         # @!method rescue?(node)
         def_node_matcher :rescue?, '{^resbody ^^resbody}'
 
+        # @!method allowed_pin_operator?(node)
+        def_node_matcher :allowed_pin_operator?, '^(pin (begin !{lvar ivar cvar gvar}))'
+
         # @!method arg_in_call_with_block?(node)
         def_node_matcher :arg_in_call_with_block?, '^^(block (send _ _ equal?(%0) ...) ...)'
 
@@ -44,6 +47,7 @@ module RuboCop
           empty_parentheses?(node) ||
             first_arg_begins_with_hash_literal?(node) ||
             rescue?(node) ||
+            allowed_pin_operator?(node) ||
             allowed_expression?(node)
         end
 

data/lib/rubocop/cop/style/safe_navigation.rb

@@ -141,7 +141,7 @@ module RuboCop
 
           corrector.remove(begin_range(node, body))
           corrector.remove(end_range(node, body))
-          corrector.insert_before(method_call.loc.dot, '&')
+          corrector.insert_before(method_call.loc.dot, '&') unless method_call.safe_navigation?
           handle_comments(corrector, node, method_call)
 
           add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
@@ -250,7 +250,9 @@ module RuboCop
         end
 
         def unsafe_method?(send_node)
-          negated?(send_node) || send_node.assignment? || !send_node.dot?
+          negated?(send_node) ||
+            send_node.assignment? ||
+            (!send_node.dot? && !send_node.safe_navigation?)
         end
 
         def negated?(send_node)

data/lib/rubocop/cop/style/sole_nested_conditional.rb

@@ -173,8 +173,6 @@ module RuboCop
         end
 
         def correct_for_comment(corrector, node, if_branch)
-          return if config.for_cop('Style/IfUnlessModifier')['Enabled']
-
           comments = processed_source.ast_with_comments[if_branch]
           comment_text = comments.map(&:text).join("\n") << "\n"
 

data/lib/rubocop/cop/style/symbol_array.rb

@@ -69,7 +69,7 @@ module RuboCop
             if c.dsym_type?
               string_literal = to_string_literal(c.source)
 
-              ":#{trim_string_interporation_escape_character(string_literal)}"
+              ":#{trim_string_interpolation_escape_character(string_literal)}"
             else
               to_symbol_literal(c.value.to_s)
             end

data/lib/rubocop/cop/style/symbol_proc.rb

@@ -11,10 +11,11 @@ module RuboCop
       # These are customizable with `AllowedMethods` option.
       #
       # @safety
-      #   This cop is unsafe because `proc`s and blocks work differently
-      #   when additional arguments are passed in. A block will silently
-      #   allow additional arguments, but a `proc` will raise
-      #   an `ArgumentError`.
+      #   This cop is unsafe because there is a difference that a `Proc`
+      #   generated from `Symbol#to_proc` behaves as a lambda, while
+      #   a `Proc` generated from a block does not.
+      #   For example, a lambda will raise an `ArgumentError` if the
+      #   number of arguments is wrong, but a non-lambda `Proc` will not.
       #
       #   For example:
       #

data/lib/rubocop/cop/style/word_array.rb

@@ -87,7 +87,7 @@ module RuboCop
             if word.dstr_type?
               string_literal = to_string_literal(word.source)
 
-              trim_string_interporation_escape_character(string_literal)
+              trim_string_interpolation_escape_character(string_literal)
             else
               to_string_literal(word.children[0])
             end

data/lib/rubocop/cop/util.rb

@@ -126,7 +126,7 @@ module RuboCop
         end
       end
 
-      def trim_string_interporation_escape_character(str)
+      def trim_string_interpolation_escape_character(str)
         str.gsub(/\\\#\{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
       end
 

data/lib/rubocop/feature_loader.rb

@@ -41,7 +41,9 @@ module RuboCop
         # https://github.com/rubocop/rubocop/issues/10893
         require(namespaced_target)
       rescue ::LoadError => error_for_namespaced_target
-        raise e if error_for_namespaced_target.path == namespaced_target
+        # NOTE: This wrap is necessary due to JRuby 9.3.4.0 incompatibility:
+        # https://github.com/jruby/jruby/issues/7316
+        raise LoadError, e if error_for_namespaced_target.path == namespaced_target
 
         raise error_for_namespaced_target
       end

data/lib/rubocop/formatter/html_formatter.rb

@@ -93,12 +93,12 @@ module RuboCop
 
         def highlighted_source_line(offense)
           source_before_highlight(offense) +
-            hightlight_source_tag(offense) +
+            highlight_source_tag(offense) +
             source_after_highlight(offense) +
             possible_ellipses(offense.location)
         end
 
-        def hightlight_source_tag(offense)
+        def highlight_source_tag(offense)
           "<span class=\"highlight #{offense.severity}\">" \
             "#{escape(offense.highlighted_area.source)}" \
             '</span>'

data/lib/rubocop/runner.rb

@@ -64,6 +64,10 @@ module RuboCop
     # instances that each inspects its allotted group of files.
     def warm_cache(target_files)
       saved_options = @options.dup
+      if target_files.length <= 1
+        puts 'Skipping parallel inspection: only a single file needs inspection' if @options[:debug]
+        return
+      end
       puts 'Running parallel inspection' if @options[:debug]
       %i[autocorrect safe_autocorrect].each { |opt| @options[opt] = false }
       Parallel.each(target_files) { |target_file| file_offenses(target_file) }

data/lib/rubocop/server/cache.rb

@@ -62,17 +62,18 @@ module RuboCop
             # `RuboCop::ConfigStore` has heavy dependencies, this is a lightweight implementation
             # so that only the necessary `CacheRootDirectory` can be obtained.
             require 'yaml'
-
             config_path = ConfigFinder.find_config_path(Dir.pwd)
 
-            # Ruby 3.1+
-            config_yaml = if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('4.0.0')
-                            YAML.safe_load_file(config_path, permitted_classes: [Regexp, Symbol])
-                          else
-                            config = YAML.load_file(config_path)
+            require 'erb'
+            file_contents = File.read(config_path)
+            yaml_code = ERB.new(file_contents).result
+
+            config_yaml = YAML.safe_load(yaml_code, permitted_classes: [Regexp, Symbol])
 
-                            config == false ? nil : config
-                          end
+            # For compatibility with Ruby 3.0 or lower.
+            if Gem::Version.new(Psych::VERSION) < Gem::Version.new('4.0.0')
+              config_yaml == false ? nil : config_yaml
+            end
 
             config_yaml&.dig('AllCops', 'CacheRootDirectory')
           end

data/lib/rubocop/version.rb

@@ -3,11 +3,11 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.35.0'
+    STRING = '1.36.0'
 
     MSG = '%<version>s (using Parser %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \
-          'running on %<ruby_engine>s %<ruby_version>s %<ruby_platform>s)'
+          'running on %<ruby_engine>s %<ruby_version>s)%<server>s [%<ruby_platform>s]'
 
     CANONICAL_FEATURE_NAMES = { 'Rspec' => 'RSpec', 'Graphql' => 'GraphQL', 'Md' => 'Markdown',
                                 'Thread_safety' => 'ThreadSafety' }.freeze
@@ -19,6 +19,7 @@ module RuboCop
         verbose_version = format(MSG, version: STRING, parser_version: Parser::VERSION,
                                       rubocop_ast_version: RuboCop::AST::Version::STRING,
                                       ruby_engine: RUBY_ENGINE, ruby_version: RUBY_VERSION,
+                                      server: Server.running? ? ' +server' : '',
                                       ruby_platform: RUBY_PLATFORM)
         return verbose_version unless env
 

data/lib/rubocop.rb

@@ -703,7 +703,7 @@ require_relative 'rubocop/cli'
 require_relative 'rubocop/cli/command'
 require_relative 'rubocop/cli/environment'
 require_relative 'rubocop/cli/command/base'
-require_relative 'rubocop/cli/command/auto_genenerate_config'
+require_relative 'rubocop/cli/command/auto_generate_config'
 require_relative 'rubocop/cli/command/execute_runner'
 require_relative 'rubocop/cli/command/init_dotfile'
 require_relative 'rubocop/cli/command/show_cops'