steep-relaxed 1.9.3.3

data/lib/steep/drivers/watch.rb

@@ -0,0 +1,194 @@
+module Steep
+  module Drivers
+    class Watch
+      attr_reader :dirs
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :queue
+      attr_accessor :severity_level
+      attr_reader :jobs_option
+
+      include Utils::DriverHelper
+
+      LSP = LanguageServer::Protocol
+
+      def initialize(stdout:, stderr:)
+        @dirs = []
+        @stdout = stdout
+        @stderr = stderr
+        @queue = Thread::Queue.new
+        @severity_level = :warning
+        @jobs_option = Utils::JobsOption.new()
+      end
+
+      def watching?(changed_path, files:, dirs:)
+        files.empty? || files.include?(changed_path) || dirs.intersect?(changed_path.ascend.to_set)
+      end
+
+      def run()
+        if dirs.empty?
+          stdout.puts "Specify directories to watch"
+          return 1
+        end
+
+        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)
+
+        typecheck_workers = Server::WorkerProcess.start_typecheck_workers(steepfile: project.steepfile_path, args: dirs.map(&:to_s), 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(*dirs.map(&:to_s))
+
+        main_thread = Thread.start do
+          master.start()
+        end
+
+        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)
+
+        Steep.logger.info "Watching #{dirs.join(", ")}..."
+
+        watch_paths = dirs.map do |dir|
+          case
+          when dir.directory?
+            dir.realpath
+          when dir.file?
+            dir.parent.realpath
+          else
+            dir
+          end
+        end
+
+        dir_paths = Set.new(dirs.select(&:directory?).map(&:realpath))
+        file_paths = Set.new(dirs.select(&:file?).map(&:realpath))
+
+        listener = Listen.to(*watch_paths.map(&:to_s)) do |modified, added, removed|
+          stdout.print Rainbow("🔬 Type checking updated files...").bold
+
+          version = Time.now.to_i
+          Steep.logger.tagged "watch" do
+            Steep.logger.info "Received file system updates: modified=[#{modified.join(",")}], added=[#{added.join(",")}], removed=[#{removed.join(",")}]"
+
+            (modified + added).each do |path|
+              p = Pathname(path)
+              if watching?(p, files: file_paths, dirs: dir_paths)
+                client_writer.write(
+                  method: "textDocument/didChange",
+                  params: {
+                    textDocument: { uri: "file://#{path}", version: version },
+                    contentChanges: [{ text: p.read }]
+                  }
+                )
+              end
+            end
+
+            removed.each do |path|
+              p = Pathname(path)
+              if watching?(p, files: file_paths, dirs: dir_paths)
+                client_writer.write(
+                  method: "textDocument/didChange",
+                  params: {
+                    textDocument: { uri: "file://#{path}", version: version },
+                    contentChanges: [{ text: "" }]
+                  }
+                )
+              end
+            end
+          end
+
+          params = { library_paths: [], signature_paths: [], code_paths: [] } #: Server::CustomMethods::TypeCheck::params
+
+          (modified + added).each do |path|
+            path = Pathname(path)
+            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
+
+          client_writer.write(Server::CustomMethods::TypeCheck.request(SecureRandom.uuid, params))
+
+          stdout.puts Rainbow("done!").bold
+        end.tap(&:start)
+
+        begin
+          stdout.puts Rainbow("👀 Watching directories, Ctrl-C to stop.").bold
+
+          params = { library_paths: [], signature_paths: [], code_paths: [] } #: Server::CustomMethods::TypeCheck::params
+          file_loader = Services::FileLoader.new(base_dir: project.base_dir)
+          project.targets.each do |target|
+            file_loader.each_path_in_patterns(target.source_pattern, dirs.map(&:to_s)) do |path|
+              params[:code_paths] << [target.name.to_s, project.absolute_path(path).to_s]
+            end
+            file_loader.each_path_in_patterns(target.signature_pattern, dirs.map(&:to_s)) do |path|
+              params[:signature_paths] << [target.name.to_s, project.absolute_path(path).to_s]
+            end
+          end
+          client_writer.write(Server::CustomMethods::TypeCheck.request(SecureRandom.uuid, params))
+
+          client_reader.read do |response|
+            case response[:method]
+            when "textDocument/publishDiagnostics"
+              path = PathHelper.to_pathname(response[:params][:uri]) or break
+              buffer = RBS::Buffer.new(content: path.read, name: path)
+              printer = DiagnosticPrinter.new(stdout: stdout, buffer: buffer)
+
+              diagnostics = response[:params][:diagnostics]
+              diagnostics.filter! {|d| keep_diagnostic?(d, severity_level: severity_level) }
+
+              unless diagnostics.empty?
+                diagnostics.each do |diagnostic|
+                  printer.print(diagnostic)
+                  stdout.flush
+                end
+              end
+            when "window/showMessage"
+              # Assuming ERROR message means unrecoverable error.
+              message = response[:params]
+              if message[:type] == LSP::Constant::MessageType::ERROR
+                stdout.puts "Unexpected error reported... 🚨"
+              end
+            end
+          end
+        rescue Interrupt
+          stdout.puts "Shutting down workers..."
+          shutdown_exit(reader: client_reader, writer: client_writer)
+        end
+
+        listener.stop
+        begin
+          main_thread.join
+        rescue Interrupt
+          master.kill
+          begin
+            main_thread.join
+          rescue
+            master.each_worker do |worker|
+              worker.kill(force: true)
+            end
+          end
+        end
+
+        0
+      end
+    end
+  end
+end

data/lib/steep/drivers/worker.rb

@@ -0,0 +1,58 @@
+module Steep
+  module Drivers
+    class Worker
+      attr_reader :stdout, :stderr, :stdin
+
+      attr_accessor :worker_type
+      attr_accessor :worker_name
+      attr_accessor :delay_shutdown
+      attr_accessor :max_index
+      attr_accessor :index
+      attr_accessor :commandline_args
+
+      include Utils::DriverHelper
+
+      def initialize(stdout:, stderr:, stdin:)
+        @stdout = stdout
+        @stderr = stderr
+        @stdin = stdin
+        @commandline_args = []
+      end
+
+      def run()
+        Steep.logger.tagged("#{worker_type}:#{worker_name}") do
+          project = load_config()
+
+          reader = LanguageServer::Protocol::Transport::Io::Reader.new(stdin)
+          writer = LanguageServer::Protocol::Transport::Io::Writer.new(stdout)
+
+          worker = case worker_type
+                   when :typecheck
+                     assignment = Services::PathAssignment.new(max_index: max_index, index: index)
+                     Server::TypeCheckWorker.new(project: project,
+                                                 reader: reader,
+                                                 writer: writer,
+                                                 assignment: assignment,
+                                                 commandline_args: commandline_args)
+                   when :interaction
+                     Server::InteractionWorker.new(project: project, reader: reader, writer: writer)
+                   else
+                     raise "Unknown worker type: #{worker_type}"
+                   end
+
+          unless delay_shutdown
+            worker.skip_jobs_after_shutdown!
+          end
+
+          Steep.logger.info "Starting #{worker_type} worker..."
+
+          worker.run()
+        rescue Interrupt
+          Steep.logger.info "Shutting down by interrupt..."
+        end
+
+        0
+      end
+    end
+  end
+end

data/lib/steep/equatable.rb

@@ -0,0 +1,23 @@
+module Steep
+  module Equatable
+    def ==(other)
+      if other.class == self.class
+        instance_variables.all? do |name|
+          other.instance_variable_get(name) == instance_variable_get(name)
+        end
+      else
+        false
+      end
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      instance_variables.inject(self.class.hash) do |hash, name|
+        hash ^ instance_variable_get(name).hash
+      end
+    end
+  end
+end

data/lib/steep/expectations.rb

@@ -0,0 +1,228 @@
+module Steep
+  class Expectations
+    class Diagnostic < Struct.new(:start_position, :end_position, :severity, :message, :code, keyword_init: true)
+      DiagnosticSeverity = LanguageServer::Protocol::Constant::DiagnosticSeverity
+
+      def self.from_hash(hash)
+        start_position = {
+          line: hash.dig("range", "start", "line") - 1,
+          character: hash.dig("range", "start", "character")
+        } #: position
+        end_position = {
+          line: hash.dig("range", "end", "line") - 1,
+          character: hash.dig("range", "end", "character")
+        } #: position
+
+        severity =
+          case hash["severity"] || "ERROR"
+          when "ERROR"
+            :error
+          when "WARNING"
+            :warning
+          when "INFORMATION"
+            :information
+          when "HINT"
+            :hint
+          end #: Steep::Diagnostic::LSPFormatter::severity
+
+        Diagnostic.new(
+          start_position: start_position,
+          end_position: end_position,
+          severity: severity,
+          message: hash["message"],
+          code: hash["code"]
+        )
+      end
+
+      def self.from_lsp(diagnostic)
+        start_position = {
+          line: diagnostic.dig(:range, :start, :line),
+          character: diagnostic.dig(:range, :start, :character)
+        } #: position
+        end_position = {
+          line: diagnostic.dig(:range, :end, :line),
+          character: diagnostic.dig(:range, :end, :character)
+        } #: position
+
+        severity =
+          case diagnostic[:severity]
+          when DiagnosticSeverity::ERROR
+            :error
+          when DiagnosticSeverity::WARNING
+            :warning
+          when DiagnosticSeverity::INFORMATION
+            :information
+          when DiagnosticSeverity::HINT
+            :hint
+          else
+            :error
+          end #: Steep::Diagnostic::LSPFormatter::severity
+
+        Diagnostic.new(
+          start_position: start_position,
+          end_position: end_position,
+          severity: severity,
+          message: diagnostic[:message],
+          code: diagnostic[:code]
+        )
+      end
+
+      def to_hash
+        {
+          "range" => {
+            "start" => {
+              "line" => start_position[:line] + 1,
+              "character" => start_position[:character]
+            },
+            "end" => {
+              "line" => end_position[:line] + 1,
+              "character" => end_position[:character]
+            }
+          },
+          "severity" => severity.to_s.upcase,
+          "message" => message,
+          "code" => code
+        }
+      end
+
+      def lsp_severity
+        case severity
+        when :error
+          DiagnosticSeverity::ERROR
+        when :warning
+          DiagnosticSeverity::WARNING
+        when :information
+          DiagnosticSeverity::INFORMATION
+        when :hint
+          DiagnosticSeverity::HINT
+        else
+          raise
+        end
+      end
+
+      def to_lsp
+        {
+          range: {
+            start: {
+              line: start_position[:line],
+              character: start_position[:character]
+            },
+            end: {
+              line: end_position[:line],
+              character: end_position[:character]
+            }
+          },
+          severity: lsp_severity,
+          message: message,
+          code: code
+        }
+      end
+
+      def sort_key
+        [
+          start_position[:line],
+          start_position[:character],
+          end_position[:line],
+          end_position[:character],
+          code,
+          severity,
+          message
+        ]
+      end
+    end
+
+    class TestResult
+      attr_reader :path
+      attr_reader :expectation
+      attr_reader :actual
+
+      def initialize(path:, expectation:, actual:)
+        @path = path
+        @expectation = expectation
+        @actual = actual
+      end
+
+      def empty?
+        actual.empty?
+      end
+
+      def satisfied?
+        unexpected_diagnostics.empty? && missing_diagnostics.empty?
+      end
+
+      def each_diagnostics
+        if block_given?
+          expected_set = Set.new(expectation) #: Set[Diagnostic]
+          actual_set = Set.new(actual) #: Set[Diagnostic]
+
+          (expected_set + actual_set).sort_by(&:sort_key).each do |diagnostic|
+            case
+            when expected_set.include?(diagnostic) && actual_set.include?(diagnostic)
+              yield [:expected, diagnostic]
+            when expected_set.include?(diagnostic)
+              yield [:missing, diagnostic]
+            when actual_set.include?(diagnostic)
+              yield [:unexpected, diagnostic]
+            end
+          end
+        else
+          enum_for :each_diagnostics
+        end
+      end
+
+      def expected_diagnostics
+        each_diagnostics.select {|type, _| type == :expected }.map {|_, diag| diag }
+      end
+
+      def unexpected_diagnostics
+        each_diagnostics.select {|type, _| type == :unexpected }.map {|_, diag| diag }
+      end
+
+      def missing_diagnostics
+        each_diagnostics.select {|type, _| type == :missing }.map {|_, diag| diag }
+      end
+    end
+
+    LSP = LanguageServer::Protocol
+
+    attr_reader :diagnostics
+
+    def initialize()
+      @diagnostics = {}
+    end
+
+    def test(path:, diagnostics:)
+      TestResult.new(path: path, expectation: self.diagnostics[path] || [], actual: diagnostics)
+    end
+
+    def self.empty
+      new()
+    end
+
+    def to_yaml
+      array = [] #: Array[{ "file" => String, "diagnostics" => Array[untyped] }]
+
+      diagnostics.each_key.sort.each do |key|
+        ds = diagnostics.fetch(key)
+        array << {
+          "file" => key.to_s,
+          'diagnostics' => ds.sort_by(&:sort_key).map(&:to_hash)
+        }
+      end
+
+      YAML.dump(array)
+    end
+
+    def self.load(path:, content:)
+      expectations = new()
+
+      YAML.load(content, filename: path.to_s).each do |entry|
+        file = Pathname(entry["file"])
+        expectations.diagnostics[file] =
+          entry["diagnostics"].map {|hash| Diagnostic.from_hash(hash) }.sort_by!(&:sort_key)
+      end
+
+      expectations
+    end
+  end
+end