steep-relaxed 1.9.3.3

data/lib/steep/drivers/check.rb

@@ -0,0 +1,339 @@
+module Steep
+  module Drivers
+    class Check
+      LSP = LanguageServer::Protocol
+
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :command_line_patterns
+      attr_accessor :with_expectations_path
+      attr_accessor :save_expectations_path
+      attr_accessor :severity_level
+      attr_reader :jobs_option
+      attr_reader :targets
+      attr_reader :active_group_names
+      attr_accessor :type_check_code
+      attr_accessor :validate_group_signatures
+      attr_accessor :validate_project_signatures
+      attr_accessor :validate_library_signatures
+
+      include Utils::DriverHelper
+
+      def initialize(stdout:, stderr:)
+        @stdout = stdout
+        @stderr = stderr
+        @command_line_patterns = []
+        @severity_level = :warning
+        @jobs_option = Utils::JobsOption.new()
+        @active_group_names = []
+        @type_check_code = true
+        @validate_group_signatures = true
+        @validate_project_signatures = false
+        @validate_library_signatures = false
+      end
+
+      def active_group?(group)
+        return true if active_group_names.empty?
+
+        case group
+        when Project::Target
+          active_group_names.any? {|target_name, group_name|
+            target_name == group.name && (group_name == nil || group_name == true)
+          }
+        when Project::Group
+          active_group_names.any? {|target_name, group_name|
+            target_name == group.target.name &&
+              (group_name == group.name || group_name == true)
+          }
+        end
+      end
+
+      def run
+        project = load_config()
+
+        stdout.puts Rainbow("# Type checking files:").bold
+        stdout.puts
+
+        client_read, server_write = IO.pipe
+        server_read, client_write = IO.pipe
+
+        client_reader = LSP::Transport::Io::Reader.new(client_read)
+        client_writer = LSP::Transport::Io::Writer.new(client_write)
+
+        server_reader = LSP::Transport::Io::Reader.new(server_read)
+        server_writer = LSP::Transport::Io::Writer.new(server_write)
+
+        typecheck_workers = Server::WorkerProcess.start_typecheck_workers(
+          steepfile: project.steepfile_path,
+          args: command_line_patterns,
+          delay_shutdown: true,
+          steep_command: jobs_option.steep_command,
+          count: jobs_option.jobs_count_value
+        )
+
+        master = Server::Master.new(
+          project: project,
+          reader: server_reader,
+          writer: server_writer,
+          interaction_worker: nil,
+          typecheck_workers: typecheck_workers
+        )
+        master.typecheck_automatically = false
+        master.commandline_args.push(*command_line_patterns)
+
+        main_thread = Thread.start do
+          Thread.current.abort_on_exception = true
+          master.start()
+        end
+
+        Steep.logger.info { "Initializing server" }
+        initialize_id = request_id()
+        client_writer.write({ method: :initialize, id: initialize_id, params: DEFAULT_CLI_LSP_INITIALIZE_PARAMS })
+        wait_for_response_id(reader: client_reader, id: initialize_id)
+
+        params = { library_paths: [], signature_paths: [], code_paths: [] } #: Server::CustomMethods::TypeCheck::params
+
+        if command_line_patterns.empty?
+          files = Server::TargetGroupFiles.new(project)
+          loader = Services::FileLoader.new(base_dir: project.base_dir)
+
+          project.targets.each do |target|
+            target.new_env_loader.each_dir do |_, dir|
+              RBS::FileFinder.each_file(dir, skip_hidden: true) do |path|
+                files.add_library_path(target, path)
+              end
+            end
+
+            loader.each_path_in_target(target) do |path|
+              files.add_path(path)
+            end
+          end
+
+          project.targets.each do |target|
+            target.groups.each do |group|
+              if active_group?(group)
+                load_files(files, group.target, group, params: params)
+              end
+            end
+            if active_group?(target)
+              load_files(files, target, target, params: params)
+            end
+          end
+        else
+          command_line_patterns.each do |pattern|
+            path = Pathname(pattern)
+            path = project.absolute_path(path)
+            next unless path.file?
+            if target = project.target_for_source_path(path)
+              params[:code_paths] << [target.name.to_s, path.to_s]
+            end
+            if target = project.target_for_signature_path(path)
+              params[:signature_paths] << [target.name.to_s, path.to_s]
+            end
+          end
+        end
+
+        Steep.logger.info { "Starting type check with #{params[:code_paths].size} Ruby files and #{params[:signature_paths].size} RBS signatures..." }
+        Steep.logger.debug { params.inspect }
+
+        request_guid = SecureRandom.uuid
+        Steep.logger.info { "Starting type checking: #{request_guid}" }
+        client_writer.write(Server::CustomMethods::TypeCheck.request(request_guid, params))
+
+        diagnostic_notifications = [] #: Array[LanguageServer::Protocol::Interface::PublishDiagnosticsParams]
+        error_messages = [] #: Array[String]
+
+        response = wait_for_response_id(reader: client_reader, id: request_guid) do |message|
+          case
+          when message[:method] == "textDocument/publishDiagnostics"
+            ds = message[:params][:diagnostics]
+            ds.select! {|d| keep_diagnostic?(d, severity_level: severity_level) }
+            if ds.empty?
+              stdout.print "."
+            else
+              stdout.print "F"
+            end
+            diagnostic_notifications << message[:params]
+            stdout.flush
+          when message[:method] == "window/showMessage"
+            # Assuming ERROR message means unrecoverable error.
+            message = message[:params]
+            if message[:type] == LSP::Constant::MessageType::ERROR
+              error_messages << message[:message]
+            end
+          end
+        end
+
+        Steep.logger.info { "Finished type checking: #{response.inspect}" }
+
+        Steep.logger.info { "Shutting down..." }
+
+        shutdown_exit(reader: client_reader, writer: client_writer)
+        main_thread.join()
+
+        stdout.puts
+        stdout.puts
+
+        if error_messages.empty?
+          loader = Services::FileLoader.new(base_dir: project.base_dir)
+          all_files = project.targets.each.with_object(Set[]) do |target, set|
+            set.merge(loader.load_changes(target.source_pattern, command_line_patterns, changes: {}).each_key)
+            set.merge(loader.load_changes(target.signature_pattern, changes: {}).each_key)
+          end.to_a
+
+          case
+          when with_expectations_path
+            print_expectations(project: project,
+                               all_files: all_files,
+                               expectations_path: with_expectations_path,
+                               notifications: diagnostic_notifications)
+          when save_expectations_path
+            save_expectations(project: project,
+                              all_files: all_files,
+                              expectations_path: save_expectations_path,
+                              notifications: diagnostic_notifications)
+          else
+            print_result(project: project, notifications: diagnostic_notifications)
+          end
+        else
+          stdout.puts Rainbow("Unexpected error reported. 🚨").red.bold
+          1
+        end
+      rescue Errno::EPIPE => error
+        stdout.puts Rainbow("Steep shutdown with an error: #{error.inspect}").red.bold
+        return 1
+      end
+
+      def load_files(files, target, group, params:)
+        if type_check_code
+          files.each_group_source_path(group, true) do |path|
+            params[:code_paths] << [target.name.to_s, target.project.absolute_path(path).to_s]
+          end
+        end
+        if validate_group_signatures
+          files.each_group_signature_path(group) do |path|
+            params[:signature_paths] << [target.name.to_s, target.project.absolute_path(path).to_s]
+          end
+        end
+        if validate_project_signatures
+          files.each_project_signature_path(target) do |path|
+            if path_target = files.signature_path_target(path)
+              params[:signature_paths] << [path_target.name.to_s, target.project.absolute_path(path).to_s]
+            end
+          end
+          if group.is_a?(Project::Group)
+            files.each_target_signature_path(target, group) do |path|
+              params[:signature_paths] << [target.name.to_s, target.project.absolute_path(path).to_s]
+            end
+          end
+        end
+        if validate_library_signatures
+          files.each_library_path(target) do |path|
+            params[:library_paths] << [target.name.to_s, path.to_s]
+          end
+        end
+      end
+
+      def print_expectations(project:, all_files:, expectations_path:, notifications:)
+        expectations = Expectations.load(path: expectations_path, content: expectations_path.read)
+
+        expected_count = 0
+        unexpected_count = 0
+        missing_count = 0
+
+        ns = notifications.each.with_object({}) do |notification, hash| #$ Hash[Pathname, Array[Expectations::Diagnostic]]
+          path = project.relative_path(Steep::PathHelper.to_pathname(notification[:uri]) || raise)
+          hash[path] = notification[:diagnostics].map do |diagnostic|
+            Expectations::Diagnostic.from_lsp(diagnostic)
+          end
+        end
+
+        all_files.sort.each do |path|
+          test = expectations.test(path: path, diagnostics: ns[path] || [])
+
+          buffer = RBS::Buffer.new(name: path, content: path.read)
+          printer = DiagnosticPrinter.new(buffer: buffer, stdout: stdout)
+
+          test.each_diagnostics.each do |type, diag|
+            case type
+            when :expected
+              expected_count += 1
+            when :unexpected
+              unexpected_count += 1
+              printer.print(diag.to_lsp, prefix: Rainbow("+ ").green)
+            when :missing
+              missing_count += 1
+              printer.print(diag.to_lsp, prefix: Rainbow("- ").red, source: false)
+            end
+          end
+        end
+
+        if unexpected_count > 0 || missing_count > 0
+          stdout.puts
+
+          stdout.puts Rainbow("Expectations unsatisfied:").bold.red
+          stdout.puts "  #{expected_count} expected #{"diagnostic".pluralize(expected_count)}"
+          stdout.puts Rainbow("  + #{unexpected_count} unexpected #{"diagnostic".pluralize(unexpected_count)}").green
+          stdout.puts Rainbow("  - #{missing_count} missing #{"diagnostic".pluralize(missing_count)}").red
+          1
+        else
+          stdout.puts Rainbow("Expectations satisfied:").bold.green
+          stdout.puts "  #{expected_count} expected #{"diagnostic".pluralize(expected_count)}"
+          0
+        end
+      end
+
+      def save_expectations(project:, all_files:, expectations_path:, notifications:)
+        expectations = if expectations_path.file?
+                         Expectations.load(path: expectations_path, content: expectations_path.read)
+                       else
+                         Expectations.empty()
+                       end
+
+        ns = notifications.each.with_object({}) do |notification, hash| #$ Hash[Pathname, Array[Expectations::Diagnostic]]
+          path = project.relative_path(Steep::PathHelper.to_pathname(notification[:uri]) || raise)
+          hash[path] = notification[:diagnostics].map {|diagnostic| Expectations::Diagnostic.from_lsp(diagnostic) }
+        end
+
+        all_files.sort.each do |path|
+          ds = ns[path] || []
+
+          if ds.empty?
+            expectations.diagnostics.delete(path)
+          else
+            expectations.diagnostics[path] = ds
+          end
+        end
+
+        expectations_path.write(expectations.to_yaml)
+        stdout.puts Rainbow("Saved expectations in #{expectations_path}...").bold
+        0
+      end
+
+      def print_result(project:, notifications:)
+        if notifications.all? {|notification| notification[:diagnostics].empty? }
+          emoji = %w(🫖 🫖 🫖 🫖 🫖 🫖 🫖 🫖 🍵 🧋 🧉).sample
+          stdout.puts Rainbow("No type error detected. #{emoji}").green.bold
+          0
+        else
+          errors = notifications.reject {|notification| notification[:diagnostics].empty? }
+          total = errors.sum {|notification| notification[:diagnostics].size }
+
+          errors.each do |notification|
+            path = Steep::PathHelper.to_pathname(notification[:uri]) or raise
+            buffer = RBS::Buffer.new(name: project.relative_path(path), content: path.read)
+            printer = DiagnosticPrinter.new(buffer: buffer, stdout: stdout)
+
+            notification[:diagnostics].each do |diag|
+              printer.print(diag)
+              stdout.puts
+            end
+          end
+
+          stdout.puts Rainbow("Detected #{total} #{"problem".pluralize(total)} from #{errors.size} #{"file".pluralize(errors.size)}").red.bold
+          1
+        end
+      end
+    end
+  end
+end

data/lib/steep/drivers/checkfile.rb

@@ -0,0 +1,210 @@
+module Steep
+  module Drivers
+    class Checkfile
+      LSP = LanguageServer::Protocol
+
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :command_line_args
+      attr_accessor :all_ruby, :all_rbs
+      attr_reader :stdin_input
+      attr_reader :jobs_option
+
+      include Utils::DriverHelper
+
+      def initialize(stdout:, stderr:)
+        @stdout = stdout
+        @stderr = stderr
+        @command_line_args = []
+
+        @all_rbs = false
+        @all_ruby = false
+        @stdin_input = {}
+
+        @jobs_option = Utils::JobsOption.new()
+      end
+
+      def run
+        return 0 if command_line_args.empty? && !all_rbs && !all_ruby && stdin_input.empty?
+
+        project = load_config()
+
+        client_read, server_write = IO.pipe
+        server_read, client_write = IO.pipe
+
+        client_reader = LanguageServer::Protocol::Transport::Io::Reader.new(client_read)
+        client_writer = LanguageServer::Protocol::Transport::Io::Writer.new(client_write)
+
+        server_reader = LanguageServer::Protocol::Transport::Io::Reader.new(server_read)
+        server_writer = LanguageServer::Protocol::Transport::Io::Writer.new(server_write)
+
+        # @type var target_paths: Set[Pathname]
+        target_paths = Set[]
+        # @type var signature_paths: Set[Pathname]
+        signature_paths = Set[]
+
+        loader = Services::FileLoader.new(base_dir: project.base_dir)
+        project.targets.each do |target|
+          ruby_patterns =
+            case
+            when all_ruby
+              []
+            when command_line_args.empty?
+              nil
+            else
+              command_line_args
+            end #: Array[String]?
+
+          if ruby_patterns
+            loader.each_path_in_patterns(target.source_pattern, ruby_patterns) do |path|
+              target_paths << path
+            end
+          end
+
+          rbs_patterns =
+            case
+            when all_rbs
+              []
+            when command_line_args.empty?
+              nil
+            else
+              command_line_args
+            end #: Array[String]
+
+          if rbs_patterns
+            loader.each_path_in_patterns(target.signature_pattern, rbs_patterns) do |path|
+              signature_paths << path
+            end
+          end
+        end
+
+        stdin_input.each_key do |path|
+          case
+          when project.target_for_signature_path(path)
+            signature_paths << path
+          when project.target_for_source_path(path)
+            target_paths << path
+          end
+        end
+
+        files = target_paths + signature_paths
+
+        count =
+          if jobs_option.jobs_count
+            jobs_option.jobs_count
+          else
+            [
+              files.size + 2,
+              jobs_option.default_jobs_count
+            ].min || raise
+          end
+
+        Steep.logger.info { "Starting #{count} workers for #{files.size} files..." }
+
+        typecheck_workers = Server::WorkerProcess.start_typecheck_workers(
+          steepfile: project.steepfile_path,
+          args: [],
+          delay_shutdown: true,
+          steep_command: jobs_option.steep_command,
+          count: count
+        )
+
+        master = Server::Master.new(
+          project: project,
+          reader: server_reader,
+          writer: server_writer,
+          interaction_worker: nil,
+          typecheck_workers: typecheck_workers
+        )
+        master.typecheck_automatically = false
+
+        main_thread = Thread.start do
+          Thread.current.abort_on_exception = true
+          master.start()
+        end
+
+        Steep.logger.info { "Initializing server" }
+        initialize_id = request_id()
+        client_writer.write({ method: :initialize, id: initialize_id, params: DEFAULT_CLI_LSP_INITIALIZE_PARAMS })
+        wait_for_response_id(reader: client_reader, id: initialize_id)
+
+        stdin_input.each do |path, content|
+          uri = PathHelper.to_uri(project.absolute_path(path))
+
+          master.broadcast_notification(
+            {
+              method: "textDocument/didChange",
+              params: {
+              textDocument: { uri: uri, version: 0 },
+              contentChanges: [{ text: content }]
+              }
+            }
+          )
+          master.broadcast_notification(
+            {
+              method: "textDocument/didSave",
+              params: {
+                textDocument: { uri: uri }
+              }
+            }
+          )
+        end
+
+        ping_guid = master.fresh_request_id()
+        client_writer.write({ method: "$/ping", id: ping_guid, params: {}})
+        wait_for_response_id(reader: client_reader, id: ping_guid)
+
+        request_guid = master.fresh_request_id()
+        progress = master.work_done_progress(request_guid)
+        request = Server::TypeCheckController::Request.new(guid: request_guid, progress: progress)
+
+        target_paths.each do |path|
+          target = project.target_for_source_path(path) or next
+          request.code_paths << [target.name, project.absolute_path(path)]
+        end
+        signature_paths.each do |path|
+          target = project.target_for_signature_path(path) or next
+          request.signature_paths << [target.name, project.absolute_path(path)]
+        end
+
+        request.needs_response = true
+        master.start_type_check(request: request, last_request: nil, report_progress_threshold: 0)
+
+        Steep.logger.info { "Starting type checking: #{request_guid}" }
+
+        error_messages = [] #: Array[String]
+        client_reader.read do |response|
+          Steep.logger.info { response.inspect }
+          case
+          when response[:method] == "textDocument/publishDiagnostics"
+            params = response[:params]
+
+            if path = PathHelper.to_pathname(params[:uri])
+              stdout.puts(
+                {
+                  path: project.relative_path(path).to_s,
+                  diagnostics: params[:diagnostics]
+                }.to_json
+              )
+            end
+          when response[:method] == "window/showMessage"
+            # Assuming ERROR message means unrecoverable error.
+            message = response[:params]
+            if message[:type] == LSP::Constant::MessageType::ERROR
+              error_messages << message[:message]
+            end
+          when response[:id] == request_guid
+            break
+          end
+        end
+
+        Steep.logger.info { "Shutting down..." }
+
+        shutdown_exit(reader: client_reader, writer: client_writer)
+        main_thread.join()
+
+        0
+      end
+    end
+  end
+end

data/lib/steep/drivers/diagnostic_printer.rb

@@ -0,0 +1,105 @@
+module Steep
+  module Drivers
+    class DiagnosticPrinter
+      LSP = LanguageServer::Protocol
+
+      attr_reader :stdout
+      attr_reader :buffer
+
+      def initialize(stdout:, buffer:)
+        @stdout = stdout
+        @buffer = buffer
+      end
+
+      def path
+        Pathname(buffer.name)
+      end
+
+      def color_severity(string, severity:)
+        s = Rainbow(string)
+
+        case severity
+        when LSP::Constant::DiagnosticSeverity::ERROR
+          s.red
+        when LSP::Constant::DiagnosticSeverity::WARNING
+          s.yellow
+        when LSP::Constant::DiagnosticSeverity::INFORMATION
+          s.blue
+        else
+          s
+        end
+      end
+
+      def severity_message(severity)
+        string = case severity
+                 when LSP::Constant::DiagnosticSeverity::ERROR
+                   "error"
+                 when LSP::Constant::DiagnosticSeverity::WARNING
+                   "warning"
+                 when LSP::Constant::DiagnosticSeverity::INFORMATION
+                   "information"
+                 when LSP::Constant::DiagnosticSeverity::HINT
+                   "hint"
+                 else
+                  raise
+                 end
+
+        color_severity(string, severity: severity)
+      end
+
+      def location(diagnostic)
+        start = diagnostic[:range][:start]
+        Rainbow("#{path}:#{start[:line]+1}:#{start[:character]}").magenta
+      end
+
+      def print(diagnostic, prefix: "", source: true)
+        header, *rest = diagnostic[:message].split(/\n/)
+
+        stdout.puts "#{prefix}#{location(diagnostic)}: [#{severity_message(diagnostic[:severity])}] #{Rainbow(header).underline}"
+
+        unless rest.empty?
+          rest.each do |message|
+            stdout.puts "#{prefix}│ #{message}"
+          end
+        end
+
+        if diagnostic[:code]
+          stdout.puts "#{prefix}│" unless rest.empty?
+          stdout.puts "#{prefix}│ Diagnostic ID: #{diagnostic[:code]}"
+        end
+
+        stdout.puts "#{prefix}│"
+
+        if source
+          print_source_line(diagnostic, prefix: prefix)
+        else
+          stdout.puts "#{prefix}└ (no source code available)"
+          stdout.puts "#{prefix}"
+        end
+      end
+
+      def print_source_line(diagnostic, prefix: "")
+        start_pos = diagnostic[:range][:start]
+        end_pos = diagnostic[:range][:end]
+
+        line = buffer.lines.fetch(start_pos[:line])
+
+        leading = line[0...start_pos[:character]] || ""
+        if start_pos[:line] == end_pos[:line]
+          subject = line[start_pos[:character]...end_pos[:character]] || ""
+          trailing = (line[end_pos[:character]...] || "").chomp
+        else
+          subject = (line[start_pos[:character]...] || "").chomp
+          trailing = ""
+        end
+
+        unless subject.valid_encoding?
+          subject.scrub!
+        end
+
+        stdout.puts "#{prefix}└ #{leading}#{color_severity(subject, severity: diagnostic[:severity])}#{trailing}"
+        stdout.puts "#{prefix}  #{" " * leading.size}#{"~" * subject.size}"
+      end
+    end
+  end
+end