rubocop 1.41.1 → 1.57.1

data/lib/rubocop/cop/variable_force/variable_table.rb

@@ -97,8 +97,10 @@ module RuboCop
           scope_stack.reverse_each do |scope|
             variable = scope.variables[name]
             return variable if variable
+
             # Only block scope allows referencing outer scope variables.
-            return nil unless scope.node.block_type?
+            node = scope.node
+            return nil unless node.block_type? || node.numblock_type?
           end
 
           nil
@@ -111,14 +113,14 @@ module RuboCop
         def accessible_variables
           scope_stack.reverse_each.with_object([]) do |scope, variables|
             variables.concat(scope.variables.values)
-            break variables unless scope.node.block_type?
+            break variables unless scope.node.block_type? || scope.node.numblock_type?
           end
         end
 
         private
 
         def mark_variable_as_captured_by_block_if_so(variable)
-          return unless current_scope.node.block_type?
+          return unless current_scope.node.block_type? || current_scope.node.numblock_type?
           return if variable.scope == current_scope
 
           variable.capture_with_block!

data/lib/rubocop/cop/variable_force.rb

@@ -40,6 +40,7 @@ module RuboCop
       OPERATOR_ASSIGNMENT_TYPES = (LOGICAL_OPERATOR_ASSIGNMENT_TYPES + [:op_asgn]).freeze
 
       MULTIPLE_ASSIGNMENT_TYPE = :masgn
+      REST_ASSIGNMENT_TYPE = :splat
 
       VARIABLE_REFERENCE_TYPE = :lvar
 
@@ -50,7 +51,7 @@ module RuboCop
 
       ZERO_ARITY_SUPER_TYPE = :zsuper
 
-      TWISTED_SCOPE_TYPES = %i[block class sclass defs module].freeze
+      TWISTED_SCOPE_TYPES = %i[block numblock class sclass defs module].freeze
       SCOPE_TYPES = (TWISTED_SCOPE_TYPES + [:def]).freeze
 
       SEND_TYPE = :send
@@ -108,7 +109,6 @@ module RuboCop
         :skip_children
       end
 
-      # rubocop:disable Layout/ClassStructure
       NODE_HANDLER_METHOD_NAMES = [
         [VARIABLE_ASSIGNMENT_TYPE, :process_variable_assignment],
         [REGEXP_NAMED_CAPTURE_TYPE, :process_regexp_named_captures],
@@ -123,8 +123,6 @@ module RuboCop
         *SCOPE_TYPES.product([:process_scope])
       ].to_h.freeze
       private_constant :NODE_HANDLER_METHOD_NAMES
-      # rubocop:enable Layout/ClassStructure
-
       def node_handler_method_name(node)
         NODE_HANDLER_METHOD_NAMES[node.type]
       end

data/lib/rubocop/cops_documentation_generator.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'fileutils'
+
 # Class for generating documentation of all cops departments
 # @api private
 class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
@@ -14,6 +16,8 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     @departments = departments.map(&:to_sym).sort!
     @cops = RuboCop::Cop::Registry.global
     @config = RuboCop::ConfigLoader.default_configuration
+    @docs_path = "#{Dir.pwd}/docs/modules/ROOT/pages/"
+    FileUtils.mkdir_p(@docs_path)
   end
 
   def call
@@ -27,7 +31,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
 
   private
 
-  attr_reader :departments, :cops, :config
+  attr_reader :departments, :cops, :config, :docs_path
 
   def cops_of_department(department)
     cops.with_department(department).sort!
@@ -194,7 +198,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     table = ['|===', "| #{header.join(' | ')}\n\n"].join("\n")
     marked_contents = content.map do |plain_content|
       # Escape `|` with backslash to prevent the regexp `|` is not used as a table separator.
-      plain_content.map { |c| "| #{c.gsub(/\|/, '\|')}" }.join("\n")
+      plain_content.map { |c| "| #{c.gsub('|', '\|')}" }.join("\n")
     end
     table << marked_contents.join("\n\n")
     table << "\n|===\n"
@@ -252,7 +256,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     content = +"= #{department}\n"
     selected_cops.each { |cop| content << print_cop_with_doc(cop) }
     content << footer_for_department(department)
-    file_name = "#{Dir.pwd}/docs/modules/ROOT/pages/#{department_to_basename(department)}.adoc"
+    file_name = "#{docs_path}/#{department_to_basename(department)}.adoc"
     File.open(file_name, 'w') do |file|
       puts "* generated #{file_name}"
       file.write("#{content.strip}\n")
@@ -298,7 +302,10 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   end
 
   def print_table_of_contents
-    path = "#{Dir.pwd}/docs/modules/ROOT/pages/cops.adoc"
+    path = "#{docs_path}/cops.adoc"
+
+    File.write(path, table_contents) and return unless File.exist?(path)
+
     original = File.read(path)
     content = +"// START_COP_LIST\n\n"
 

data/lib/rubocop/directive_comment.rb

@@ -45,9 +45,9 @@ module RuboCop
 
     def range
       match = comment.text.match(DIRECTIVE_COMMENT_REGEXP)
-      begin_pos = comment.loc.expression.begin_pos
+      begin_pos = comment.source_range.begin_pos
       Parser::Source::Range.new(
-        comment.loc.expression.source_buffer, begin_pos + match.begin(0), begin_pos + match.end(0)
+        comment.source_range.source_buffer, begin_pos + match.begin(0), begin_pos + match.end(0)
       )
     end
 
@@ -108,7 +108,7 @@ module RuboCop
 
     # Returns line number for directive
     def line_number
-      comment.loc.expression.line
+      comment.source_range.line
     end
 
     private

data/lib/rubocop/ext/comment.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Ext
+    # Extensions to `Parser::Source::Comment`.
+    module Comment
+      def source
+        loc.expression.source
+      end
+
+      def source_range
+        loc.expression
+      end
+    end
+  end
+end
+
+Parser::Source::Comment.include RuboCop::Ext::Comment

data/lib/rubocop/ext/regexp_node.rb

@@ -29,7 +29,7 @@ module RuboCop
           @parsed_tree&.each_expression(true) { |e| e.origin = origin }
         end
       # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped.
-      # It's for compatibility with regexp_arser 1.8 and will never be maintained.
+      # It's for compatibility with regexp_parser 1.8 and will never be maintained.
       else
         def assign_properties(*)
           super

data/lib/rubocop/ext/regexp_parser.rb

@@ -28,7 +28,7 @@ module RuboCop
               @expression ||= origin.adjust(begin_pos: ts, end_pos: ts + full_length)
             end
           # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped.
-          # It's for compatibility with regexp_arser 1.8 and will never be maintained.
+          # It's for compatibility with regexp_parser 1.8 and will never be maintained.
           else
             attr_accessor :source
 
@@ -68,7 +68,9 @@ module RuboCop
             return { body: expression } unless (q = quantifier)
 
             body = expression.adjust(end_pos: -q.text.length)
-            q_loc = expression.with(begin_pos: body.end_pos)
+            q.origin = origin
+            q.source = source if q.respond_to?(:source=) # for regexp_parser 1.8
+            q_loc = q.expression
             { body: body, quantifier: q_loc }
           end
         end
@@ -86,6 +88,7 @@ module RuboCop
         end
       end
       ::Regexp::Expression::Base.include Expression::Base
+      ::Regexp::Expression::Quantifier.include Expression::Base
       ::Regexp::Expression::CharacterSet.include Expression::CharacterSet
     end
   end

data/lib/rubocop/file_finder.rb

@@ -6,12 +6,8 @@ module RuboCop
   # Common methods for finding files.
   # @api private
   module FileFinder
-    def self.root_level=(level)
-      @root_level = level
-    end
-
-    def self.root_level?(path, stop_dir)
-      (@root_level || stop_dir) == path.to_s
+    class << self
+      attr_accessor :root_level
     end
 
     def find_file_upwards(filename, start_dir, stop_dir = nil)
@@ -34,7 +30,8 @@ module RuboCop
         file = dir + filename
         yield(file.to_s) if file.exist?
 
-        break if FileFinder.root_level?(dir, stop_dir)
+        dir = dir.to_s
+        break if dir == stop_dir || dir == FileFinder.root_level
       end
     end
   end

data/lib/rubocop/formatter/junit_formatter.rb

@@ -62,7 +62,10 @@ module RuboCop
       end
 
       def classname_attribute_value(file)
-        file.gsub(/\.rb\Z/, '').gsub("#{Dir.pwd}/", '').tr('/', '.')
+        @classname_attribute_value_cache ||= Hash.new do |hash, key|
+          hash[key] = key.delete_suffix('.rb').gsub("#{Dir.pwd}/", '').tr('/', '.')
+        end
+        @classname_attribute_value_cache[file]
       end
 
       def finished(_inspected_files)

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -61,7 +61,7 @@ module RuboCop
                             correctable_count,
                             rainbow,
                             # :safe_autocorrect is a derived option based on several command-line
-                            # arguments - see Rubocop::Options#add_autocorrection_options
+                            # arguments - see RuboCop::Options#add_autocorrection_options
                             safe_autocorrect: @options[:safe_autocorrect])
 
         output.puts

data/lib/rubocop/formatter.rb

@@ -2,7 +2,6 @@
 
 module RuboCop
   # The bootstrap module for formatter.
-  # @api private
   module Formatter
     require_relative 'formatter/text_util'
 

data/lib/rubocop/lsp/logger.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module Lsp
+    # Log for Language Server Protocol of RuboCop.
+    # @api private
+    class Logger
+      def self.log(message)
+        warn("[server] #{message}")
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/routes.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require_relative 'severity'
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module Lsp
+    # Routes for Language Server Protocol of RuboCop.
+    # @api private
+    class Routes
+      def self.handle(name, &block)
+        define_method("handle_#{name}", &block)
+      end
+
+      private_class_method :handle
+
+      def initialize(server)
+        @server = server
+
+        @text_cache = {}
+      end
+
+      def for(name)
+        name = "handle_#{name}"
+        return unless respond_to?(name)
+
+        method(name)
+      end
+
+      handle 'initialize' do |request|
+        initialization_options = extract_initialization_options_from(request)
+
+        @server.configure(initialization_options)
+
+        @server.write(
+          id: request[:id],
+          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
+              )
+            )
+          )
+        )
+      end
+
+      handle 'initialized' do |_request|
+        version = RuboCop::Version::STRING
+
+        Logger.log("RuboCop #{version} language server initialized, PID #{Process.pid}")
+      end
+
+      handle 'shutdown' do |request|
+        Logger.log('Client asked to shutdown RuboCop language server.')
+        @server.stop do
+          @server.write(id: request[:id], result: nil)
+          Logger.log('Exiting...')
+        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])
+        @server.write(result)
+      end
+
+      handle 'textDocument/didOpen' do |request|
+        doc = request[:params][:textDocument]
+        result = diagnostic(doc[:uri], doc[:text])
+        @server.write(result)
+      end
+
+      handle 'textDocument/didClose' do |request|
+        @text_cache.delete(request.dig(:params, :textDocument, :uri))
+      end
+
+      handle 'textDocument/formatting' do |request|
+        uri = request[:params][:textDocument][:uri]
+        @server.write(id: request[:id], result: format_file(uri))
+      end
+
+      handle 'workspace/didChangeConfiguration' do |_request|
+        Logger.log('Ignoring workspace/didChangeConfiguration')
+      end
+
+      handle 'workspace/didChangeWatchedFiles' do |request|
+        changed = request[:params][:changes].any? do |change|
+          change[:uri].end_with?(RuboCop::ConfigFinder::DOTFILE)
+        end
+
+        if changed
+          Logger.log('Configuration file changed; restart required')
+          @server.stop
+        end
+      end
+
+      handle 'workspace/executeCommand' do |request|
+        case (command = request[:params][:command])
+        when 'rubocop.formatAutocorrects'
+          label = 'Format with RuboCop autocorrects'
+        when 'rubocop.formatAutocorrectsAll'
+          label = 'Format all with RuboCop autocorrects'
+        else
+          handle_unsupported_method(request, command)
+          return
+        end
+
+        uri = request[:params][:arguments][0][:uri]
+        @server.write(
+          id: request[:id],
+          method: 'workspace/applyEdit',
+          params: {
+            label: label,
+            edit: {
+              changes: {
+                uri => format_file(uri, command: command)
+              }
+            }
+          }
+        )
+      end
+
+      handle 'textDocument/willSave' do |_request|
+        # Nothing to do
+      end
+
+      handle 'textDocument/didSave' do |_request|
+        # Nothing to do
+      end
+
+      handle '$/cancelRequest' do |_request|
+        # Can't cancel anything because single-threaded
+      end
+
+      handle '$/setTrace' do |_request|
+        # No-op, we log everything
+      end
+
+      def handle_unsupported_method(request, method = request[:method])
+        @server.write(
+          id: request[:id],
+          error: LanguageServer::Protocol::Interface::ResponseError.new(
+            code: LanguageServer::Protocol::Constant::ErrorCodes::METHOD_NOT_FOUND,
+            message: "Unsupported Method: #{method}"
+          )
+        )
+        Logger.log("Unsupported Method: #{method}")
+      end
+
+      def handle_method_missing(request)
+        return unless request.key?(:id)
+
+        @server.write(id: request[:id], result: nil)
+      end
+
+      private
+
+      def extract_initialization_options_from(request)
+        safe_autocorrect = request.dig(:params, :initializationOptions, :safeAutocorrect)
+
+        {
+          safe_autocorrect: safe_autocorrect.nil? || safe_autocorrect == true,
+          lint_mode: request.dig(:params, :initializationOptions, :lintMode) == true,
+          layout_mode: request.dig(:params, :initializationOptions, :layoutMode) == true
+        }
+      end
+
+      def format_file(file_uri, command: nil)
+        unless (text = @text_cache[file_uri])
+          Logger.log("Format request arrived before text synchronized; skipping: `#{file_uri}'")
+
+          return []
+        end
+
+        new_text = @server.format(remove_file_protocol_from(file_uri), text, command: command)
+
+        return [] if new_text == text
+
+        [
+          newText: new_text,
+          range: {
+            start: { line: 0, character: 0 },
+            end: { line: text.count("\n") + 1, character: 0 }
+          }
+        ]
+      end
+
+      def diagnostic(file_uri, text)
+        @text_cache[file_uri] = text
+        offenses = @server.offenses(remove_file_protocol_from(file_uri), text)
+        diagnostics = offenses.map { |offense| to_diagnostic(offense) }
+
+        {
+          method: 'textDocument/publishDiagnostics',
+          params: {
+            uri: file_uri,
+            diagnostics: diagnostics
+          }
+        }
+      end
+
+      def remove_file_protocol_from(uri)
+        uri.delete_prefix('file://')
+      end
+
+      def to_diagnostic(offense)
+        code = offense[:cop_name]
+        message = offense[:message]
+        loc = offense[:location]
+        rubocop_severity = offense[:severity]
+        severity = Severity.find_by(rubocop_severity)
+
+        {
+          code: code, message: message, range: to_range(loc), severity: severity, source: 'rubocop'
+        }
+      end
+
+      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
+    end
+  end
+end

data/lib/rubocop/lsp/runtime.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module Lsp
+    # Runtime for Language Server Protocol of RuboCop.
+    # @api private
+    class Runtime
+      attr_writer :safe_autocorrect, :lint_mode, :layout_mode
+
+      def initialize(config_store)
+        @config_store = config_store
+        @logged_paths = []
+        @safe_autocorrect = true
+        @lint_mode = false
+        @layout_mode = false
+      end
+
+      # This abuses the `--stdin` option of rubocop and reads the formatted text
+      # from the `options[:stdin]` that rubocop mutates. This depends on
+      # `parallel: false` as well as the fact that RuboCop doesn't otherwise dup
+      # or reassign that options object. Risky business!
+      #
+      # Reassigning `options[:stdin]` is done here:
+      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cop/team.rb#L131
+      # Printing `options[:stdin]`
+      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cli/command/execute_runner.rb#L95
+      # Setting `parallel: true` would break this here:
+      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/runner.rb#L72
+      def format(path, text, command:)
+        safe_autocorrect = if command
+                             command == 'rubocop.formatAutocorrects'
+                           else
+                             @safe_autocorrect
+                           end
+
+        formatting_options = {
+          stdin: text, force_exclusion: true, autocorrect: true, safe_autocorrect: safe_autocorrect
+        }
+        formatting_options[:only] = config_only_options if @lint_mode || @layout_mode
+
+        redirect_stdout { run_rubocop(formatting_options, path) }
+
+        formatting_options[:stdin]
+      end
+
+      def offenses(path, text)
+        diagnostic_options = {
+          stdin: text, force_exclusion: true, formatters: ['json'], format: 'json'
+        }
+        diagnostic_options[:only] = config_only_options if @lint_mode || @layout_mode
+
+        json = redirect_stdout { run_rubocop(diagnostic_options, path) }
+        results = JSON.parse(json, symbolize_names: true)
+
+        if results[:files].empty?
+          unless @logged_paths.include?(path)
+            Logger.log "Ignoring file, per configuration: #{path}"
+            @logged_paths << path
+          end
+          return []
+        end
+
+        results.dig(:files, 0, :offenses)
+      end
+
+      private
+
+      def config_only_options
+        only_options = []
+        only_options << 'Lint' if @lint_mode
+        only_options << 'Layout' if @layout_mode
+        only_options
+      end
+
+      def redirect_stdout(&block)
+        stdout = StringIO.new
+
+        RuboCop::Server::Helper.redirect(stdout: stdout, &block)
+
+        stdout.string
+      end
+
+      def run_rubocop(options, path)
+        runner = RuboCop::Runner.new(options, @config_store)
+
+        runner.run([path])
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/server.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'language_server-protocol'
+require_relative 'logger'
+require_relative 'routes'
+require_relative 'runtime'
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module Lsp
+    # Language Server Protocol of RuboCop.
+    # @api private
+    class Server
+      def initialize(config_store)
+        @reader = LanguageServer::Protocol::Transport::Io::Reader.new($stdin)
+        @writer = LanguageServer::Protocol::Transport::Io::Writer.new($stdout)
+        @runtime = RuboCop::Lsp::Runtime.new(config_store)
+        @routes = Routes.new(self)
+      end
+
+      def start
+        @reader.read do |request|
+          if !request.key?(:method)
+            @routes.handle_method_missing(request)
+          elsif (route = @routes.for(request[:method]))
+            route.call(request)
+          else
+            @routes.handle_unsupported_method(request)
+          end
+        rescue StandardError => e
+          Logger.log("Error #{e.class} #{e.message[0..100]}")
+          Logger.log(e.backtrace.inspect)
+        end
+      end
+
+      def write(response)
+        @writer.write(response)
+      end
+
+      def format(path, text, command:)
+        @runtime.format(path, text, command: command)
+      end
+
+      def offenses(path, text)
+        @runtime.offenses(path, text)
+      end
+
+      def configure(options)
+        @runtime.safe_autocorrect = options[:safe_autocorrect]
+        @runtime.lint_mode = options[:lint_mode]
+        @runtime.layout_mode = options[:layout_mode]
+      end
+
+      def stop(&block)
+        at_exit(&block) if block
+        exit
+      end
+    end
+  end
+end