steep-relaxed 1.9.3.3

data/lib/steep/rake_task.rb

@@ -0,0 +1,132 @@
+require "rake"
+require "rake/tasklib"
+require "steep/cli"
+
+module Steep
+  # Provides Rake tasks for running Steep commands.
+  #
+  # require "steep/rake_task"
+  # Steep::RakeTask.new do |t|
+  #   t.check.severity_level = :error
+  #   t.watch.verbose
+  #   t.stats << "--format=table"
+  # end
+  class RakeTask < Rake::TaskLib # steep:ignore UnknownConstant
+    attr_accessor :name
+
+    def self.available_commands
+      %i(init check stats binstub project watch)
+    end
+
+    def initialize(name = :steep, cli_runner = default_cli_runner)
+      super()
+
+      @name = name
+
+      configuration = TaskConfiguration.new
+
+      yield configuration if block_given?
+
+      define_tasks(configuration, cli_runner)
+    end
+
+    private
+
+    # :nodoc:
+    class TaskConfiguration
+      def initialize
+        @commands = {}
+      end
+
+      def method_missing(command)
+        if respond_to?(command)
+          @commands[command] ||= CommandConfiguration.new
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        RakeTask.available_commands.include?(name) || super
+      end
+
+      def options(command)
+        @commands[command]&.to_a || []
+      end
+    end
+
+    # :nodoc:
+    class CommandConfiguration
+      def initialize
+        @options = []
+      end
+
+      def method_missing(name, value = nil)
+        option = "--#{name.to_s.gsub(/_/, '-').gsub(/=/, '')}"
+        option << "=#{value}" if value
+
+        self << option
+      end
+
+      def respond_to_missing?(_name)
+        true
+      end
+
+      def <<(value)
+        @options << value
+        self
+      end
+
+      def to_a
+        @options
+      end
+    end
+
+    def default_cli_runner
+      lambda do |arguments|
+        require "steep"
+
+        cli = Steep::CLI.new(
+          stdout: $stdout,
+          stdin: $stdin,
+          stderr: $stderr,
+          argv: arguments
+        )
+
+        cli.run
+      end
+    end
+
+    def define_tasks(configuration, cli_runner)
+      namespace name do
+        RakeTask.available_commands.each do |command|
+          desc "Run steep #{command}"
+          task command do |_, args|
+            configured_options = configuration.options(command)
+
+            argv = [
+              command.to_s,
+              *configured_options,
+              *args.extras
+            ]
+
+            result = cli_runner[argv]
+
+            raise "Steep failed" if result.nonzero?
+          end
+        end
+
+        desc "Run steep help"
+        task "help" do
+          arguments = ["--help"]
+
+          cli_runner[arguments]
+        end
+      end
+
+      # Default steep task to steep:check
+      desc "Run steep check" unless ::Rake.application.last_description # steep:ignore UnknownConstant
+      task name => ["#{name}:check"]
+    end
+  end
+end

data/lib/steep/range_extension.rb

@@ -0,0 +1,29 @@
+class RBS::Location
+  def as_lsp_range
+    {
+      start: {
+          line: start_line - 1,
+          character: start_column
+      },
+      end: {
+        line: end_line - 1,
+        character: end_column
+      }
+    }
+  end
+end
+
+class Parser::Source::Range
+  def as_lsp_range
+    {
+      start: {
+        line: line - 1,
+        character: column
+      },
+      end: {
+        line: last_line - 1,
+        character: last_column
+      }
+    }
+  end
+end

data/lib/steep/server/base_worker.rb

@@ -0,0 +1,97 @@
+module Steep
+  module Server
+    class BaseWorker
+      LSP = LanguageServer::Protocol
+
+      attr_reader :project
+      attr_reader :reader, :writer, :queue
+
+      ShutdownJob = _ = Struct.new(:id, keyword_init: true)
+
+      def initialize(project:, reader:, writer:)
+        @project = project
+        @reader = reader
+        @writer = writer
+        @skip_job = false
+        @shutdown = false
+        @skip_jobs_after_shutdown = false
+      end
+
+      def skip_jobs_after_shutdown!(flag = true)
+        @skip_jobs_after_shutdown = flag
+      end
+
+      def skip_jobs_after_shutdown?
+        @skip_jobs_after_shutdown
+      end
+
+      def skip_job?
+        @skip_job
+      end
+
+      def handle_request(request)
+        # process request
+      end
+
+      def handle_job(job)
+        # process async job
+      end
+
+      def run
+        tags = Steep.logger.formatter.current_tags.dup
+        thread = Thread.new do
+          Thread.current.abort_on_exception = true
+
+          Steep.logger.formatter.push_tags(*tags)
+          Steep.logger.tagged "background" do
+            while job = queue.pop
+              case job
+              when ShutdownJob
+                writer.write(id: job.id, result: nil)
+              else
+                if skip_job?
+                  Steep.logger.info "Skipping job..."
+                else
+                  begin
+                    handle_job(job)
+                  rescue => exn
+                    Steep.log_error exn
+                    writer.write(
+                      {
+                        method: "window/showMessage",
+                        params: {
+                          type: LSP::Constant::MessageType::ERROR,
+                          message: "Unexpected error: #{exn.message} (#{exn.class})"
+                        }
+                      }
+                    )
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        Steep.logger.tagged "frontend" do
+          begin
+            reader.read do |request|
+              Steep.logger.info "Received message from master: #{request[:method]}(#{request[:id]})"
+              case request[:method]
+              when "shutdown"
+                queue << ShutdownJob.new(id: request[:id])
+                @skip_job = skip_jobs_after_shutdown?
+                queue.close
+              when "exit"
+                break
+              else
+                handle_request(request) unless @shutdown
+              end
+            end
+          ensure
+            thread.join
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/server/change_buffer.rb

@@ -0,0 +1,73 @@
+module Steep
+  module Server
+    module ChangeBuffer
+      attr_reader :mutex
+      attr_reader :buffered_changes
+
+      def push_buffer
+        mutex.synchronize do
+          yield buffered_changes
+        end
+      end
+
+      def pop_buffer
+        changes = mutex.synchronize do
+          copy = buffered_changes.dup
+          buffered_changes.clear
+          copy
+        end
+
+        if block_given?
+          yield changes
+        else
+          changes
+        end
+      end
+
+      def load_files(input)
+        Steep.logger.tagged "#load_files" do
+          push_buffer do |changes|
+            input.each do |filename, content|
+              if content.is_a?(Hash)
+                content = Base64.decode64(content[:text]).force_encoding(Encoding::UTF_8)
+              end
+              changes[Pathname(filename.to_s)] = [Services::ContentChange.new(text: content)]
+            end
+          end
+        end
+      end
+
+      def collect_changes(request)
+        push_buffer do |changes|
+          if path = Steep::PathHelper.to_pathname(request[:params][:textDocument][:uri])
+            path = project.relative_path(path)
+            version = request[:params][:textDocument][:version]
+            Steep.logger.info { "Updating source: path=#{path}, version=#{version}..." }
+
+            changes[path] ||= []
+            request[:params][:contentChanges].each do |change|
+              changes.fetch(path) << Services::ContentChange.new(
+                range: change[:range]&.yield_self {|range|
+                  [
+                    range[:start].yield_self {|pos| Services::ContentChange::Position.new(line: pos[:line] + 1, column: pos[:character]) },
+                    range[:end].yield_self {|pos| Services::ContentChange::Position.new(line: pos[:line] + 1, column: pos[:character]) }
+                  ]
+                },
+                text: change[:text]
+              )
+            end
+          end
+        end
+      end
+
+      def reset_change(uri:, text:)
+        push_buffer do |changes|
+          if path = Steep::PathHelper.to_pathname(uri)
+            path = project.relative_path(path)
+            changes[path] = [Services::ContentChange.new(text: text)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/server/custom_methods.rb

@@ -0,0 +1,77 @@
+module Steep
+  module Server
+    module CustomMethods
+      module FileLoad
+        METHOD = "$/steep/file/load"
+
+        def self.notification(params)
+          { method: METHOD, params: params }
+        end
+      end
+
+      module FileReset
+        METHOD = "$/steep/file/reset"
+
+        def self.notification(params)
+          { method: METHOD, params: params }
+        end
+      end
+
+      module TypeCheck
+        METHOD = "$/steep/typecheck"
+
+        def self.request(id, params)
+          { method: METHOD, id: id, params: params }
+        end
+
+        def self.response(id, result)
+          { id: id, result: result }
+        end
+      end
+
+      module TypeCheckGroups
+        METHOD = "$/steep/typecheck/groups"
+
+        def self.notification(params)
+          { method: METHOD, params: params }
+        end
+      end
+
+      module TypeCheck__Start
+        METHOD = "$/steep/typecheck/start"
+
+        def self.notification(params)
+          { method: METHOD, params: params }
+        end
+      end
+
+      module TypeCheck__Progress
+        METHOD = "$/steep/typecheck/progress"
+
+        def self.notification(params)
+          { method: METHOD, params: params }
+        end
+      end
+
+      module Stats
+        METHOD = "$/steep/stats"
+
+        def self.request(id)
+          { method: METHOD, id: id, params: nil }
+        end
+
+        def self.response(id, result)
+          { id: id, result: result }
+        end
+      end
+
+      module Groups
+        METHOD = "$/steep/groups"
+
+        def self.response(id, result)
+          { id: id, result: result }
+        end
+      end
+    end
+  end
+end

data/lib/steep/server/delay_queue.rb

@@ -0,0 +1,45 @@
+module Steep
+  module Server
+    class DelayQueue
+      attr_reader :delay, :thread, :queue, :last_task
+
+      def initialize(delay:)
+        @delay = delay
+
+        @queue = Thread::Queue.new
+
+        @thread = Thread.new do
+          while (scheduled_at, proc = queue.pop)
+            diff = scheduled_at - Time.now
+            case
+            when diff > 0.1
+              sleep diff
+            when diff > 0
+              while Time.now < scheduled_at
+                # nop
+                sleep 0
+              end
+            end
+
+            if proc.equal?(last_task)
+              unless @cancelled
+                proc[]
+              end
+            end
+          end
+        end
+      end
+
+      def cancel
+        @cancelled = true
+        queue.clear()
+      end
+
+      def execute(&block)
+        @last_task = block
+        scheduled_at = Time.now + delay
+        queue << [scheduled_at, block]
+      end
+    end
+  end
+end