rubocop 1.63.0 → 1.64.1

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant argument forwarding when calling super
+      # with arguments identical to the method definition.
+      #
+      # @example
+      #   # bad
+      #   def method(*args, **kwargs)
+      #     super(*args, **kwargs)
+      #   end
+      #
+      #   # good - implicitly passing all arguments
+      #   def method(*args, **kwargs)
+      #     super
+      #   end
+      #
+      #   # good - forwarding a subset of the arguments
+      #   def method(*args, **kwargs)
+      #     super(*args)
+      #   end
+      #
+      #   # good - forwarding no arguments
+      #   def method(*args, **kwargs)
+      #     super()
+      #   end
+      #
+      #   # good - assigning to the block variable before calling super
+      #   def method(&block)
+      #     # Assigning to the block variable would pass the old value to super,
+      #     # under this circumstance the block must be referenced explicitly.
+      #     block ||= proc { 'fallback behavior' }
+      #     super(&block)
+      #   end
+      class SuperArguments < Base
+        extend AutoCorrector
+
+        DEF_TYPES = %i[def defs].freeze
+        ASSIGN_TYPES = %i[or_asgn lvasgn].freeze
+
+        MSG = 'Call `super` without arguments and parentheses when the signature is identical.'
+
+        def on_super(super_node)
+          def_node = super_node.ancestors.find do |node|
+            # You can't implicitly call super when dynamically defining methods
+            break if define_method?(node)
+
+            break node if DEF_TYPES.include?(node.type)
+          end
+          return unless def_node
+          return unless arguments_identical?(def_node, def_node.arguments.argument_list,
+                                             super_node.arguments)
+
+          add_offense(super_node) { |corrector| corrector.replace(super_node, 'super') }
+        end
+
+        private
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def arguments_identical?(def_node, def_args, super_args)
+          super_args = preprocess_super_args(super_args)
+          return false if def_args.size != super_args.size
+
+          def_args.zip(super_args).each do |def_arg, super_arg|
+            next if positional_arg_same?(def_arg, super_arg)
+            next if positional_rest_arg_same(def_arg, super_arg)
+            next if keyword_arg_same?(def_arg, super_arg)
+            next if keyword_rest_arg_same?(def_arg, super_arg)
+            next if block_arg_same?(def_node, def_arg, super_arg)
+            next if forward_arg_same?(def_arg, super_arg)
+
+            return false
+          end
+          true
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def positional_arg_same?(def_arg, super_arg)
+          return false unless def_arg.arg_type? || def_arg.optarg_type?
+          return false unless super_arg.lvar_type?
+
+          def_arg.name == super_arg.children.first
+        end
+
+        def positional_rest_arg_same(def_arg, super_arg)
+          return false unless def_arg.restarg_type?
+          # anonymous forwarding
+          return true if def_arg.name.nil? && super_arg.forwarded_restarg_type?
+          return false unless super_arg.splat_type?
+          return false unless (lvar_node = super_arg.children.first).lvar_type?
+
+          def_arg.name == lvar_node.children.first
+        end
+
+        def keyword_arg_same?(def_arg, super_arg)
+          return false unless def_arg.kwarg_type? || def_arg.kwoptarg_type?
+          return false unless (pair_node = super_arg).pair_type?
+          return false unless (sym_node = pair_node.key).sym_type?
+          return false unless (lvar_node = pair_node.value).lvar_type?
+          return false unless sym_node.source == lvar_node.source
+
+          def_arg.name == sym_node.value
+        end
+
+        def keyword_rest_arg_same?(def_arg, super_arg)
+          return false unless def_arg.kwrestarg_type?
+          # anonymous forwarding
+          return true if def_arg.name.nil? && super_arg.forwarded_kwrestarg_type?
+          return false unless super_arg.kwsplat_type?
+          return false unless (lvar_node = super_arg.children.first).lvar_type?
+
+          def_arg.name == lvar_node.children.first
+        end
+
+        def block_arg_same?(def_node, def_arg, super_arg)
+          return false unless def_arg.blockarg_type? && super_arg.block_pass_type?
+          # anonymous forwarding
+          return true if (block_pass_child = super_arg.children.first).nil? && def_arg.name.nil?
+
+          block_arg_name = block_pass_child.children.first
+          def_arg.name == block_arg_name && !block_reassigned?(def_node, block_arg_name)
+        end
+
+        # Reassigning the block argument will still pass along the original block to super
+        # https://bugs.ruby-lang.org/issues/20505
+        def block_reassigned?(def_node, block_arg_name)
+          def_node.each_node(*ASSIGN_TYPES).any? do |assign_node|
+            assign_node.name == block_arg_name
+          end
+        end
+
+        def forward_arg_same?(def_arg, super_arg)
+          def_arg.forward_arg_type? && super_arg.forwarded_args_type?
+        end
+
+        def define_method?(node)
+          return false unless node.block_type?
+
+          node.method?(:define_method) || node.method?(:define_singleton_method)
+        end
+
+        def preprocess_super_args(super_args)
+          super_args.flat_map do |node|
+            if node.hash_type? && !node.braces?
+              node.children
+            else
+              node
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -120,6 +120,23 @@ module RuboCop
       #   # good
       #   something.map { |s| s.upcase }
       #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #   # bad
+      #   ->(x) { x.foo }
+      #   proc { |x| x.foo }
+      #   Proc.new { |x| x.foo }
+      #
+      #   # good
+      #   lambda(&:foo)
+      #   proc(&:foo)
+      #   Proc.new(&:foo)
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #   # good
+      #   ->(x) { x.foo }
+      #   proc { |x| x.foo }
+      #   Proc.new { |x| x.foo }
+      #
       class SymbolProc < Base
         include CommentsHelp
         include RangeHelp
@@ -129,6 +146,7 @@ module RuboCop
 
         MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` instead of a block.'
         SUPER_TYPES = %i[super zsuper].freeze
+        LAMBDA_OR_PROC = %i[lambda proc].freeze
 
         # @!method proc_node?(node)
         def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
@@ -151,13 +169,12 @@ module RuboCop
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_block(node)
           symbol_proc?(node) do |dispatch_node, arguments_node, method_name|
-            # TODO: Rails-specific handling that we should probably make
-            # configurable - https://github.com/rubocop/rubocop/issues/1485
-            # we should allow lambdas & procs
-            return if proc_node?(dispatch_node)
+            if active_support_extensions_enabled?
+              return if proc_node?(dispatch_node)
+              return if LAMBDA_OR_PROC.include?(dispatch_node.method_name)
+            end
             return if unsafe_hash_usage?(dispatch_node)
             return if unsafe_array_usage?(dispatch_node)
-            return if %i[lambda proc].include?(dispatch_node.method_name)
             return if allowed_method_name?(dispatch_node.method_name)
             return if allow_if_method_has_argument?(node.send_node)
             return if node.block_type? && destructuring_block_argument?(arguments_node)
@@ -206,6 +223,8 @@ module RuboCop
         end
 
         def autocorrect_without_args(corrector, node)
+          autocorrect_lambda_block(corrector, node) if node.send_node.lambda_literal?
+
           corrector.replace(block_range_with_space(node), "(&:#{node.body.method_name})")
         end
 
@@ -218,6 +237,14 @@ module RuboCop
           corrector.remove(block_range_with_space(node))
         end
 
+        def autocorrect_lambda_block(corrector, node)
+          send_node_loc = node.send_node.loc
+          corrector.replace(send_node_loc.selector, 'lambda')
+
+          range = range_between(send_node_loc.selector.end_pos, node.loc.begin.end_pos - 2)
+          corrector.remove(range)
+        end
+
         def block_range_with_space(node)
           block_range = range_between(begin_pos_for_replacement(node), node.loc.end.end_pos)
           range_with_surrounding_space(block_range, side: :left)

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

@@ -77,7 +77,7 @@ module RuboCop
 
         # @!method define_method_block?(node)
         def_node_matcher :define_method_block?, <<~PATTERN
-          ({block numblock} (send _ {:define_method} _) ...)
+          ({block numblock} (send _ :define_method _) ...)
         PATTERN
       end
     end

data/lib/rubocop/cop/team.rb

@@ -240,6 +240,8 @@ module RuboCop
 
           if cause.is_a?(Warning)
             handle_warning(cause, location)
+          elsif cause.is_a?(Force::HookError)
+            handle_error(cause.cause, location, cause.joining_cop)
           else
             handle_error(cause, location, error.cop)
           end

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -116,20 +116,24 @@ module RuboCop
       def set_max(cfg, cop_name)
         return unless cfg[:exclude_limit]
 
-        max_set_in_user_config =
-          @config_for_pwd.for_cop(cop_name)['Max'] != default_config(cop_name)['Max']
-        if !max_set_in_user_config &&
-           # In case auto_gen_only_exclude is set, only modify the maximum if the files are not
-           # excluded one by one.
-           (!@options[:auto_gen_only_exclude] ||
-            @files_with_offenses[cop_name].size > @exclude_limit)
-          cfg.merge!(cfg[:exclude_limit])
-        end
+        cfg.merge!(cfg[:exclude_limit]) if should_set_max?(cop_name)
 
         # Remove already used exclude_limit.
         cfg.reject! { |key| key == :exclude_limit }
       end
 
+      def should_set_max?(cop_name)
+        max_set_in_user_config =
+          @config_for_pwd.for_cop(cop_name)['Max'] != default_config(cop_name)['Max']
+
+        max_allowed = !max_set_in_user_config && !no_exclude_limit?
+        return false unless max_allowed
+
+        # In case auto_gen_only_exclude is set, only modify the maximum if the files are not
+        # excluded one by one.
+        !@options[:auto_gen_only_exclude] || @files_with_offenses[cop_name].size > @exclude_limit
+      end
+
       def output_cop_comments(output_buffer, cfg, cop_name, offense_count)
         output_buffer.puts "# Offense count: #{offense_count}" if show_offense_counts?
 

data/lib/rubocop/formatter/formatter_set.rb

@@ -27,6 +27,7 @@ module RuboCop
         '[t]ap'         => 'TapFormatter',
         '[w]orst'       => 'WorstOffendersFormatter'
       }.freeze
+      BUILTIN_FORMATTER_NAMES = BUILTIN_FORMATTERS_FOR_KEYS.keys.map { |key| key.delete('[]') }
 
       FORMATTER_APIS = %i[started finished].freeze
 
@@ -88,7 +89,12 @@ module RuboCop
           /^\[#{specified_key}\]/.match?(key) || specified_key == key.delete('[]')
         end
 
-        raise %(No formatter for "#{specified_key}") if matching_keys.empty?
+        if matching_keys.empty?
+          similar_name = NameSimilarity.find_similar_name(specified_key, BUILTIN_FORMATTER_NAMES)
+          suggestion = %( Did you mean? "#{similar_name}") if similar_name
+
+          raise Rainbow(%(Formatter "#{specified_key}" not found.#{suggestion})).red
+        end
 
         raise %(Cannot determine formatter for "#{specified_key}") if matching_keys.size > 1
 

data/lib/rubocop/lockfile.rb

@@ -1,5 +1,13 @@
 # frozen_string_literal: true
 
+begin
+  # We might not be running with `bundle exec`, so we need to pull in Bundler ourselves,
+  # in order to use `Bundler::LockfileParser`.
+  require 'bundler'
+rescue LoadError
+  nil
+end
+
 module RuboCop
   # Encapsulation of a lockfile for use when checking for gems.
   # Does not actually resolve gems, just parses the lockfile.
@@ -7,7 +15,11 @@ module RuboCop
   class Lockfile
     # @param [String, Pathname, nil] lockfile_path
     def initialize(lockfile_path = nil)
-      lockfile_path ||= defined?(Bundler) ? Bundler.default_lockfile : nil
+      lockfile_path ||= begin
+        ::Bundler.default_lockfile if bundler_lock_parser_defined?
+      rescue ::Bundler::GemfileNotFound
+        nil # We might not be a folder with a Gemfile, but that's okay.
+      end
 
       @lockfile_path = lockfile_path
     end
@@ -59,12 +71,19 @@ module RuboCop
     # @return [Bundler::LockfileParser, nil]
     def parser
       return @parser if defined?(@parser)
-      return unless @lockfile_path
 
-      lockfile = Bundler.read_file(@lockfile_path)
-      @parser = lockfile ? Bundler::LockfileParser.new(lockfile) : nil
-    rescue Bundler::BundlerError
-      nil
+      @parser = if @lockfile_path && File.exist?(@lockfile_path) && bundler_lock_parser_defined?
+                  begin
+                    lockfile = ::Bundler.read_file(@lockfile_path)
+                    ::Bundler::LockfileParser.new(lockfile) if lockfile
+                  rescue ::Bundler::BundlerError
+                    nil
+                  end
+                end
+    end
+
+    def bundler_lock_parser_defined?
+      Object.const_defined?(:Bundler) && Bundler.const_defined?(:LockfileParser)
     end
   end
 end

data/lib/rubocop/lsp/routes.rb

@@ -45,10 +45,6 @@ module RuboCop
           result: LanguageServer::Protocol::Interface::InitializeResult.new(
             capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
               document_formatting_provider: true,
-              diagnostic_provider: LanguageServer::Protocol::Interface::DiagnosticOptions.new(
-                inter_file_dependencies: false,
-                workspace_diagnostics: false
-              ),
               text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
                 change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL,
                 open_close: true
@@ -60,8 +56,9 @@ module RuboCop
 
       handle 'initialized' do |_request|
         version = RuboCop::Version::STRING
+        yjit = Object.const_defined?('RubyVM::YJIT') && RubyVM::YJIT.enabled? ? ' +YJIT' : ''
 
-        Logger.log("RuboCop #{version} language server initialized, PID #{Process.pid}")
+        Logger.log("RuboCop #{version} language server#{yjit} initialized, PID #{Process.pid}")
       end
 
       handle 'shutdown' do |request|
@@ -72,12 +69,6 @@ module RuboCop
         end
       end
 
-      handle 'textDocument/diagnostic' do |request|
-        doc = request[:params][:textDocument]
-        result = diagnostic(doc[:uri], doc[:text])
-        @server.write(result)
-      end
-
       handle 'textDocument/didChange' do |request|
         params = request[:params]
         result = diagnostic(params[:textDocument][:uri], params[:contentChanges][0][:text])
@@ -126,6 +117,12 @@ module RuboCop
         end
 
         uri = request[:params][:arguments][0][:uri]
+        formatted = nil
+
+        # The `workspace/executeCommand` is an LSP method triggered by intentional user actions,
+        # so the user's intention for autocorrection is respected.
+        LSP.disable { formatted = format_file(uri, command: command) }
+
         @server.write(
           id: request[:id],
           method: 'workspace/applyEdit',
@@ -133,7 +130,7 @@ module RuboCop
             label: label,
             edit: {
               changes: {
-                uri => format_file(uri, command: command)
+                uri => formatted
               }
             }
           }
@@ -238,7 +235,7 @@ module RuboCop
       def to_range(location)
         {
           start: { character: location[:start_column] - 1, line: location[:start_line] - 1 },
-          end: { character: location[:last_column] - 1, line: location[:last_line] - 1 }
+          end: { character: location[:last_column], line: location[:last_line] - 1 }
         }
       end
     end

data/lib/rubocop/lsp/server.rb

@@ -21,6 +21,8 @@ module RuboCop
     # @api private
     class Server
       def initialize(config_store)
+        $PROGRAM_NAME = "rubocop --lsp #{ConfigFinder.project_root}"
+
         RuboCop::LSP.enable
 
         @reader = LanguageServer::Protocol::Transport::Io::Reader.new($stdin)

data/lib/rubocop/lsp.rb

@@ -22,8 +22,15 @@ module RuboCop
     # Disable LSP.
     #
     # @return [void]
-    def disable
-      @enabled = false
+    def disable(&block)
+      if block
+        original = @enabled
+        @enabled = false
+        yield
+        @enabled = original
+      else
+        @enabled = false
+      end
     end
   end
 end

data/lib/rubocop/options.rb

@@ -573,7 +573,7 @@ module RuboCop
                                          'cops. Only valid for --format junit.'],
       display_only_fail_level_offenses:
                                         ['Only output offense messages at',
-                                         'the specified --fail-level or above'],
+                                         'the specified --fail-level or above.'],
       display_only_correctable:         ['Only output correctable offense messages.'],
       display_only_safe_correctable:    ['Only output safe-correctable offense messages',
                                          'when combined with --display-only-correctable.'],
@@ -636,8 +636,8 @@ module RuboCop
       raise_cop_error:                  ['Raise cop-related errors with cause and location.',
                                          'This is used to prevent cops from failing silently.',
                                          'Default is false.'],
-      profile:                          'Profile rubocop',
-      memory:                           'Profile rubocop memory usage'
+      profile:                          'Profile rubocop.',
+      memory:                           'Profile rubocop memory usage.'
     }.freeze
   end
   # rubocop:enable Metrics/ModuleLength

data/lib/rubocop/rake_task.rb

@@ -44,7 +44,7 @@ module RuboCop
     def run_cli(verbose, options)
       # We lazy-load RuboCop so that the task doesn't dramatically impact the
       # load time of your Rakefile.
-      require 'rubocop'
+      require_relative '../rubocop'
 
       cli = CLI.new
       puts 'Running RuboCop...' if verbose

data/lib/rubocop/runner.rb

@@ -20,10 +20,11 @@ module RuboCop
         message = 'Infinite loop detected'
         message += " in #{path}" if path
         message += " and caused by #{root_cause}" if root_cause
-        message += ' Hint: Please update to the latest RuboCop version if not already in use,'
-        message += ' and report a bug if the issue still occurs on this version.'
-        message += ' Please check the latest version at https://rubygems.org/gems/rubocop'
-        super(message)
+        message += "\n"
+        hint = 'Hint: Please update to the latest RuboCop version if not already in use, ' \
+               "and report a bug if the issue still occurs on this version.\n" \
+               'Please check the latest version at https://rubygems.org/gems/rubocop.'
+        super(Rainbow(message).red + Rainbow(hint).yellow)
       end
     end
 

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.63.0'
+    STRING = '1.64.1'
 
     MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \
@@ -42,9 +42,9 @@ module RuboCop
     # @api private
     def self.parser_version
       config_path = ConfigFinder.find_config_path(Dir.pwd)
-      yaml = YAML.safe_load(
-        File.read(config_path), permitted_classes: [Regexp, Symbol], aliases: true
-      )
+      yaml = Util.silence_warnings do
+        ConfigLoader.load_yaml_configuration(config_path)
+      end
 
       if yaml.dig('AllCops', 'ParserEngine') == 'parser_prism'
         require 'prism'

data/lib/rubocop.rb

@@ -666,6 +666,7 @@ require_relative 'rubocop/cop/style/select_by_regexp'
 require_relative 'rubocop/cop/style/self_assignment'
 require_relative 'rubocop/cop/style/semicolon'
 require_relative 'rubocop/cop/style/send'
+require_relative 'rubocop/cop/style/send_with_literal_method_name'
 require_relative 'rubocop/cop/style/signal_exception'
 require_relative 'rubocop/cop/style/single_argument_dig'
 require_relative 'rubocop/cop/style/single_line_block_params'
@@ -682,6 +683,7 @@ require_relative 'rubocop/cop/style/string_literals_in_interpolation'
 require_relative 'rubocop/cop/style/string_methods'
 require_relative 'rubocop/cop/style/strip'
 require_relative 'rubocop/cop/style/struct_inheritance'
+require_relative 'rubocop/cop/style/super_arguments'
 require_relative 'rubocop/cop/style/super_with_args_parentheses'
 require_relative 'rubocop/cop/style/swap_values'
 require_relative 'rubocop/cop/style/symbol_array'

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 1.63.0
+  version: 1.64.1
 platform: ruby
 authors:
 - Bozhidar Batsov
 - Jonas Arvidsson
 - Yuji Nakayama
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-08 00:00:00.000000000 Z
+date: 2024-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -885,6 +885,7 @@ files:
 - lib/rubocop/cop/style/self_assignment.rb
 - lib/rubocop/cop/style/semicolon.rb
 - lib/rubocop/cop/style/send.rb
+- lib/rubocop/cop/style/send_with_literal_method_name.rb
 - lib/rubocop/cop/style/signal_exception.rb
 - lib/rubocop/cop/style/single_argument_dig.rb
 - lib/rubocop/cop/style/single_line_block_params.rb
@@ -904,6 +905,7 @@ files:
 - lib/rubocop/cop/style/string_methods.rb
 - lib/rubocop/cop/style/strip.rb
 - lib/rubocop/cop/style/struct_inheritance.rb
+- lib/rubocop/cop/style/super_arguments.rb
 - lib/rubocop/cop/style/super_with_args_parentheses.rb
 - lib/rubocop/cop/style/swap_values.rb
 - lib/rubocop/cop/style/symbol_array.rb
@@ -1032,12 +1034,12 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://rubocop.org/
-  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.63.0
+  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.64.1
   source_code_uri: https://github.com/rubocop/rubocop/
-  documentation_uri: https://docs.rubocop.org/rubocop/1.63/
+  documentation_uri: https://docs.rubocop.org/rubocop/1.64/
   bug_tracker_uri: https://github.com/rubocop/rubocop/issues
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -1052,8 +1054,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Automatic Ruby code style checking tool.
 test_files: []