rubocop 1.50.2 → 1.62.1

data/lib/rubocop/directive_comment.rb

@@ -6,9 +6,11 @@ module RuboCop
   # cops it contains.
   class DirectiveComment
     # @api private
-    REDUNDANT_DIRECTIVE_COP_DEPARTMENT = 'Lint'
+    LINT_DEPARTMENT = 'Lint'
     # @api private
-    REDUNDANT_DIRECTIVE_COP = "#{REDUNDANT_DIRECTIVE_COP_DEPARTMENT}/RedundantCopDisableDirective"
+    LINT_REDUNDANT_DIRECTIVE_COP = "#{LINT_DEPARTMENT}/RedundantCopDisableDirective"
+    # @api private
+    LINT_SYNTAX_COP = "#{LINT_DEPARTMENT}/Syntax"
     # @api private
     COP_NAME_PATTERN = '([A-Z]\w+/)*(?:[A-Z]\w+)'
     # @api private
@@ -118,9 +120,10 @@ module RuboCop
     end
 
     def parsed_cop_names
-      splitted_cops_string.map do |name|
+      cops = splitted_cops_string.map do |name|
         department?(name) ? cop_names_for_department(name) : name
       end.flatten
+      cops - [LINT_SYNTAX_COP]
     end
 
     def department?(name)
@@ -128,17 +131,16 @@ module RuboCop
     end
 
     def all_cop_names
-      exclude_redundant_directive_cop(cop_registry.names)
+      exclude_lint_department_cops(cop_registry.names)
     end
 
     def cop_names_for_department(department)
       names = cop_registry.names_for_department(department)
-      has_redundant_directive_cop = department == REDUNDANT_DIRECTIVE_COP_DEPARTMENT
-      has_redundant_directive_cop ? exclude_redundant_directive_cop(names) : names
+      department == LINT_DEPARTMENT ? exclude_lint_department_cops(names) : names
     end
 
-    def exclude_redundant_directive_cop(cops)
-      cops - [REDUNDANT_DIRECTIVE_COP]
+    def exclude_lint_department_cops(cops)
+      cops - [LINT_REDUNDANT_DIRECTIVE_COP, LINT_SYNTAX_COP]
     end
   end
 end

data/lib/rubocop/ext/regexp_node.rb

@@ -54,10 +54,7 @@ module RuboCop
         return enum_for(__method__, named: named) unless block_given?
 
         parsed_tree&.traverse do |event, exp, _index|
-          yield(exp) if event == :enter &&
-                        named == exp.respond_to?(:name) &&
-                        exp.respond_to?(:capturing?) &&
-                        exp.capturing?
+          yield(exp) if named_capturing?(exp, event, named)
         end
 
         self
@@ -65,6 +62,14 @@ module RuboCop
 
       private
 
+      def named_capturing?(exp, event, named)
+        event == :enter &&
+          named == exp.respond_to?(:name) &&
+          !exp.text.start_with?('(?<=') &&
+          exp.respond_to?(:capturing?) &&
+          exp.capturing?
+      end
+
       def with_interpolations_blanked
         # Ignore the trailing regopt node
         children[0...-1].map do |child|

data/lib/rubocop/ext/regexp_parser.rb

@@ -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/disabled_config_formatter.rb

@@ -30,7 +30,8 @@ module RuboCop
         @files_with_offenses ||= {}
       end
 
-      def file_started(_file, _file_info)
+      def file_started(_file, options)
+        @config_for_pwd = options[:config_store].for_pwd
         @exclude_limit_option = @options[:exclude_limit]
         @exclude_limit = Integer(@exclude_limit_option ||
           RuboCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS)
@@ -115,9 +116,13 @@ module RuboCop
       def set_max(cfg, cop_name)
         return unless cfg[:exclude_limit]
 
-        # In case auto_gen_only_exclude is set, only modify the maximum if the
-        # files are not excluded one by one.
-        if !@options[:auto_gen_only_exclude] || @files_with_offenses[cop_name].size > @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
 
@@ -192,8 +197,8 @@ module RuboCop
         # 'Enabled' option will be put into file only if exclude
         # limit is exceeded.
         rejected_keys = ['Enabled']
-        rejected_keys << 'EnforcedStyle' unless auto_gen_enforced_style?
-        cfg.reject { |key| rejected_keys.include?(key) }
+        rejected_keys << /\AEnforcedStyle\w*/ unless auto_gen_enforced_style?
+        cfg.reject { |key| include_or_match?(rejected_keys, key) }
       end
 
       def output_offending_files(output_buffer, cfg, cop_name)
@@ -262,6 +267,12 @@ module RuboCop
       def no_exclude_limit?
         @options[:no_exclude_limit] == false
       end
+
+      # Returns true if the given arr include the given elm or if any of the
+      # given arr is a regexp that matches the given elm.
+      def include_or_match?(arr, elm)
+        arr.include?(elm) || arr.any? { |x| x.is_a?(Regexp) && x.match?(elm) }
+      end
     end
   end
 end

data/lib/rubocop/formatter/html_formatter.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-require 'base64'
 require 'cgi'
 require 'erb'
-require 'ostruct'
 
 module RuboCop
   module Formatter
@@ -11,6 +9,7 @@ module RuboCop
     class HTMLFormatter < BaseFormatter
       ELLIPSES = '<span class="extra-code">...</span>'
       TEMPLATE_PATH = File.expand_path('../../../assets/output.html.erb', __dir__)
+      CSS_PATH = File.expand_path('../../../assets/output.css.erb', __dir__)
 
       Color = Struct.new(:red, :green, :blue, :alpha) do
         def to_s
@@ -52,8 +51,8 @@ module RuboCop
         context = ERBContext.new(files, summary)
 
         template = File.read(TEMPLATE_PATH, encoding: Encoding::UTF_8)
-        erb = ERB.new(template, trim_mode: '-')
-        html = erb.result(context.binding)
+        erb = ERB.new(template)
+        html = erb.result(context.binding).lines.map { (_1 =~ /^\s*$/).nil? ? _1 : "\n" }.join
 
         output.write html
       end
@@ -63,14 +62,6 @@ module RuboCop
         include PathUtil
         include TextUtil
 
-        SEVERITY_COLORS = {
-          refactor:   Color.new(0xED, 0x9C, 0x28, 1.0),
-          convention: Color.new(0xED, 0x9C, 0x28, 1.0),
-          warning:    Color.new(0x96, 0x28, 0xEF, 1.0),
-          error:      Color.new(0xD2, 0x32, 0x2D, 1.0),
-          fatal:      Color.new(0xD2, 0x32, 0x2D, 1.0)
-        }.freeze
-
         LOGO_IMAGE_PATH = File.expand_path('../../../assets/logo.png', __dir__)
 
         attr_reader :files, :summary
@@ -88,7 +79,7 @@ module RuboCop
         # rubocop:enable Lint/UselessMethodDefinition
 
         def decorated_message(offense)
-          offense.message.gsub(/`(.+?)`/) { "<code>#{Regexp.last_match(1)}</code>" }
+          offense.message.gsub(/`(.+?)`/) { "<code>#{escape(Regexp.last_match(1))}</code>" }
         end
 
         def highlighted_source_line(offense)
@@ -124,9 +115,39 @@ module RuboCop
 
         def base64_encoded_logo_image
           image = File.read(LOGO_IMAGE_PATH, binmode: true)
-          Base64.encode64(image)
+
+          # `Base64.encode64` compatible:
+          # https://github.com/ruby/base64/blob/v0.1.1/lib/base64.rb#L27-L40
+          [image].pack('m')
+        end
+
+        def render_css
+          context = CSSContext.new
+          template = File.read(CSS_PATH, encoding: Encoding::UTF_8)
+          erb = ERB.new(template, trim_mode: '-')
+          erb.result(context.binding).lines.map do |line|
+            line == "\n" ? line : "      #{line}"
+          end.join
         end
       end
+
+      # This class provides helper methods used in the ERB CSS template.
+      class CSSContext
+        SEVERITY_COLORS = {
+          refactor:   Color.new(0xED, 0x9C, 0x28, 1.0),
+          convention: Color.new(0xED, 0x9C, 0x28, 1.0),
+          warning:    Color.new(0x96, 0x28, 0xEF, 1.0),
+          error:      Color.new(0xD2, 0x32, 0x2D, 1.0),
+          fatal:      Color.new(0xD2, 0x32, 0x2D, 1.0)
+        }.freeze
+
+        # Make Kernel#binding public.
+        # rubocop:disable Lint/UselessMethodDefinition
+        def binding
+          super
+        end
+        # rubocop:enable Lint/UselessMethodDefinition
+      end
     end
   end
 end

data/lib/rubocop/formatter/json_formatter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'json'
-require 'pathname'
 
 module RuboCop
   module Formatter

data/lib/rubocop/formatter/junit_formatter.rb

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

data/lib/rubocop/formatter/offense_count_formatter.rb

@@ -61,8 +61,7 @@ module RuboCop
 
         column_width = total_count.to_s.length + 2
         per_cop_counts.each do |cop_name, count|
-          output.puts "#{count.to_s.ljust(column_width)}#{cop_name}" \
-                      "#{@style_guide_links[cop_name]}\n"
+          output.puts "#{count.to_s.ljust(column_width)}#{cop_information(cop_name)}"
         end
         output.puts '--'
         output.puts "#{total_count}  Total in #{offending_files_count} files"
@@ -78,6 +77,17 @@ module RuboCop
       def total_offense_count(offense_counts)
         offense_counts.values.sum
       end
+
+      def cop_information(cop_name)
+        cop = RuboCop::Cop::Registry.global.find_by_cop_name(cop_name).new
+
+        if cop.correctable?
+          safety = cop.safe_autocorrect? ? 'Safe' : 'Unsafe'
+          correctable = Rainbow(" [#{safety} Correctable]").yellow
+        end
+
+        "#{cop_name}#{correctable}#{@style_guide_links[cop_name]}"
+      end
     end
   end
 end

data/lib/rubocop/formatter.rb

@@ -14,7 +14,7 @@ module RuboCop
     require_relative 'formatter/emacs_style_formatter'
     require_relative 'formatter/file_list_formatter'
     require_relative 'formatter/fuubar_style_formatter'
-    require_relative 'formatter/git_hub_actions_formatter'
+    require_relative 'formatter/github_actions_formatter'
     require_relative 'formatter/html_formatter'
     require_relative 'formatter/json_formatter'
     require_relative 'formatter/junit_formatter'

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