sorbet_view 0.1.0

data/lib/sorbet_view/lsp/sorbet_process.rb

@@ -0,0 +1,164 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module Lsp
+    # Manages Sorbet LSP as a child process
+    class SorbetProcess
+      extend T::Sig
+
+      sig { returns(T.nilable(Transport)) }
+      attr_reader :transport
+
+      sig { params(config: Configuration, logger: Logger).void }
+      def initialize(config:, logger:)
+        @config = config
+        @logger = logger
+        @process = T.let(nil, T.nilable(IO))
+        @pid = T.let(nil, T.nilable(Integer))
+        @transport = T.let(nil, T.nilable(Transport))
+        @read_thread = T.let(nil, T.nilable(Thread))
+        @notification_handlers = T.let({}, T::Hash[String, T.proc.params(msg: T::Hash[String, T.untyped]).void])
+        @pending_requests = T.let({}, T::Hash[T.untyped, Thread::Queue])
+        @pending_mutex = T.let(Mutex.new, Mutex)
+        @next_id = T.let(1, Integer)
+      end
+
+      sig { void }
+      def start
+        cmd = [
+          @config.sorbet_path,
+          'tc',
+          '--lsp',
+          '--enable-all-experimental-lsp-features'
+        ]
+
+        @logger.info("Starting Sorbet: #{cmd.join(' ')}")
+
+        stdin_r, stdin_w = IO.pipe
+        stdout_r, stdout_w = IO.pipe
+        err_r, err_w = IO.pipe
+
+        @pid = Process.spawn(
+          *cmd,
+          in: stdin_r,
+          out: stdout_w,
+          err: err_w
+        )
+
+        stdin_r.close
+        stdout_w.close
+        err_w.close
+
+        @process = stdin_w
+        @transport = Transport.new(input: stdout_r, output: stdin_w)
+
+        @read_thread = Thread.new { read_loop(stdout_r) }
+
+        # Log stderr from Sorbet in background
+        Thread.new do
+          err_r.each_line { |line| @logger.info("Sorbet stderr: #{line.chomp}") }
+          err_r.close
+        end
+      end
+
+      sig { params(method_name: String, params: T.untyped).returns(T.untyped) }
+      def send_request(method_name, params)
+        transport = @transport
+        raise 'Sorbet process not started' unless transport
+
+        id = @pending_mutex.synchronize do
+          current = @next_id
+          @next_id += 1
+          current
+        end
+
+        queue = Thread::Queue.new
+        @pending_mutex.synchronize { @pending_requests[id] = queue }
+
+        transport.send_request(id, method_name, params)
+
+        # Wait for response with timeout
+        result = nil
+        deadline = Time.now + 30
+        loop do
+          break unless result.nil?
+          break if Time.now > deadline
+
+          begin
+            result = queue.pop(true) # non-blocking
+          rescue ThreadError
+            sleep 0.05
+          end
+        end
+
+        @pending_mutex.synchronize { @pending_requests.delete(id) }
+
+        if result.nil?
+          @logger.error("Sorbet request '#{method_name}' timed out (30s)")
+        end
+
+        result
+      end
+
+      sig { params(method_name: String, params: T.untyped).void }
+      def send_notification(method_name, params)
+        transport = @transport
+        raise 'Sorbet process not started' unless transport
+
+        transport.send_notification(method_name, params)
+      end
+
+      # Forward a raw message (request or notification) to Sorbet
+      sig { params(message: T::Hash[String, T.untyped]).void }
+      def forward(message)
+        transport = @transport
+        raise 'Sorbet process not started' unless transport
+
+        transport.write_message(message)
+      end
+
+      sig { params(method_name: String, block: T.proc.params(msg: T::Hash[String, T.untyped]).void).void }
+      def on_notification(method_name, &block)
+        @notification_handlers[method_name] = block
+      end
+
+      sig { void }
+      def stop
+        if @pid
+          Process.kill('TERM', @pid)
+          Process.wait(@pid)
+          @pid = nil
+        end
+        @read_thread&.kill
+      rescue Errno::ESRCH, Errno::ECHILD
+        # Process already gone
+      end
+
+      private
+
+      sig { params(stdout: IO).void }
+      def read_loop(stdout)
+        reader = Transport.new(input: stdout, output: File.open(File::NULL, 'w'))
+        loop do
+          message = reader.read_message
+          break if message.nil?
+
+          if message['id'] && !message.key?('method')
+            # Response to our request
+            @pending_mutex.synchronize do
+              queue = @pending_requests[message['id']]
+              queue&.push(message)
+            end
+          elsif message.key?('method')
+            # Notification from Sorbet
+            handler = @notification_handlers[message['method']]
+            handler&.call(message)
+          end
+        end
+      rescue IOError
+        @logger.info('Sorbet process stdout closed')
+      end
+    end
+  end
+end

data/lib/sorbet_view/lsp/transport.rb

@@ -0,0 +1,89 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'json'
+require 'stringio'
+
+module SorbetView
+  module Lsp
+    # JSON-RPC over stdio transport for LSP
+    class Transport
+      extend T::Sig
+
+      sig { params(input: T.any(IO, StringIO), output: T.any(IO, StringIO)).void }
+      def initialize(input: $stdin, output: $stdout)
+        @input = T.let(input, T.any(IO, StringIO))
+        @output = T.let(output, T.any(IO, StringIO))
+        @mutex = T.let(Mutex.new, Mutex)
+      end
+
+      # Read a single JSON-RPC message from the input stream.
+      # Returns nil on EOF.
+      sig { returns(T.nilable(T::Hash[String, T.untyped])) }
+      def read_message
+        # Read headers
+        content_length = nil
+        loop do
+          line = @input.gets
+          return nil if line.nil? # EOF
+
+          line = line.strip
+          break if line.empty? # End of headers
+
+          if line.start_with?('Content-Length:')
+            content_length = line.split(':').last&.strip&.to_i
+          end
+        end
+
+        return nil unless content_length
+
+        # Read body
+        body = @input.read(content_length)
+        return nil if body.nil?
+
+        JSON.parse(body)
+      end
+
+      # Write a JSON-RPC message to the output stream (thread-safe).
+      sig { params(message: T::Hash[String, T.untyped]).void }
+      def write_message(message)
+        body = JSON.generate(message)
+        header = "Content-Length: #{body.bytesize}\r\n\r\n"
+
+        @mutex.synchronize do
+          @output.write(header)
+          @output.write(body)
+          @output.flush
+        end
+      end
+
+      # Convenience: send a JSON-RPC response
+      sig { params(id: T.untyped, result: T.untyped).void }
+      def send_response(id, result)
+        write_message({ 'jsonrpc' => '2.0', 'id' => id, 'result' => result })
+      end
+
+      # Convenience: send a JSON-RPC error response
+      sig { params(id: T.untyped, code: Integer, message: String).void }
+      def send_error(id, code, message)
+        write_message({
+          'jsonrpc' => '2.0',
+          'id' => id,
+          'error' => { 'code' => code, 'message' => message }
+        })
+      end
+
+      # Convenience: send a JSON-RPC notification (no id)
+      sig { params(method_name: String, params: T.untyped).void }
+      def send_notification(method_name, params)
+        write_message({ 'jsonrpc' => '2.0', 'method' => method_name, 'params' => params })
+      end
+
+      # Convenience: send a JSON-RPC request
+      sig { params(id: T.untyped, method_name: String, params: T.untyped).void }
+      def send_request(id, method_name, params)
+        write_message({ 'jsonrpc' => '2.0', 'id' => id, 'method' => method_name, 'params' => params })
+      end
+    end
+  end
+end

data/lib/sorbet_view/lsp/uri_mapper.rb

@@ -0,0 +1,105 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'uri'
+
+module SorbetView
+  module Lsp
+    # Maps between template file URIs and generated Ruby file URIs
+    class UriMapper
+      extend T::Sig
+
+      TEMPLATE_EXTENSIONS = T.let(%w[.erb .haml .slim].freeze, T::Array[String])
+
+      sig { params(config: Configuration).void }
+      def initialize(config:)
+        @output_dir = config.output_dir
+        # path_mapping: { "/host/path" => "/container/path" }
+        @path_mapping = T.let(config.path_mapping, T::Hash[String, String])
+      end
+
+      sig { params(uri: String).returns(T::Boolean) }
+      def template_uri?(uri)
+        path = uri_to_path(uri)
+        TEMPLATE_EXTENSIONS.any? { |ext| path.end_with?(ext) }
+      end
+
+      sig { params(uri: String).returns(T::Boolean) }
+      def generated_ruby_uri?(uri)
+        path = uri_to_path(uri)
+        path.start_with?(@output_dir) || path.include?("/#{@output_dir}/")
+      end
+
+      # template URI -> generated ruby URI
+      sig { params(template_uri: String).returns(String) }
+      def template_to_ruby_uri(template_uri)
+        path = uri_to_path(template_uri)
+        ruby_path = File.join(@output_dir, "#{path}.rb")
+        path_to_uri(ruby_path)
+      end
+
+      # component .rb URI -> generated __erb_template.rb URI
+      sig { params(component_uri: String).returns(String) }
+      def component_to_ruby_uri(component_uri)
+        path = uri_to_path(component_uri)
+        ruby_path = File.join(@output_dir, "#{path}__erb_template.rb")
+        path_to_uri(ruby_path)
+      end
+
+      # generated ruby URI -> template URI
+      sig { params(ruby_uri: String).returns(T.nilable(String)) }
+      def ruby_to_template_uri(ruby_uri)
+        path = uri_to_path(ruby_uri)
+
+        # Remove output_dir prefix and .rb suffix
+        relative = path.sub(%r{^.*/#{Regexp.escape(@output_dir)}/}, '')
+                       .sub(%r{^#{Regexp.escape(@output_dir)}/}, '')
+        return nil unless relative.end_with?('.rb')
+
+        # Component heredoc: output is foo.rb__erb_template.rb → source is foo.rb
+        if relative.end_with?('__erb_template.rb')
+          template_path = relative.chomp('__erb_template.rb')
+          return path_to_uri(template_path)
+        end
+
+        template_path = relative.chomp('.rb')
+        path_to_uri(template_path)
+      end
+
+      sig { params(uri: String).returns(String) }
+      def uri_to_path(uri)
+        path = if uri.start_with?('file://')
+          URI.decode_www_form_component(URI.parse(uri).path || '')
+        else
+          uri
+        end
+        # Map host path -> local (container) path
+        @path_mapping.each do |from, to|
+          if path.start_with?(from)
+            path = path.sub(from, to)
+            break
+          end
+        end
+        # Make relative to CWD
+        cwd = Dir.pwd
+        if path.start_with?("#{cwd}/")
+          path = path.delete_prefix("#{cwd}/")
+        end
+        path
+      end
+
+      sig { params(path: String).returns(String) }
+      def path_to_uri(path)
+        absolute = File.expand_path(path)
+        # Map local (container) path -> host path
+        @path_mapping.each do |from, to|
+          if absolute.start_with?(to)
+            absolute = absolute.sub(to, from)
+            break
+          end
+        end
+        "file://#{URI.encode_www_form_component(absolute).gsub('%2F', '/')}"
+      end
+    end
+  end
+end

data/lib/sorbet_view/perf.rb

@@ -0,0 +1,92 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module Perf
+    extend T::Sig
+
+    class Metric < T::Struct
+      prop :count, Integer, default: 0
+      prop :total_ms, Float, default: 0.0
+      prop :min_ms, Float, default: Float::INFINITY
+      prop :max_ms, Float, default: 0.0
+    end
+
+    @metrics = T.let({}, T::Hash[String, Metric])
+    @enabled = T.let(true, T::Boolean)
+
+    class << self
+      extend T::Sig
+
+      sig { returns(T::Boolean) }
+      attr_accessor :enabled
+
+      sig { returns(T::Hash[String, Metric]) }
+      attr_reader :metrics
+
+      sig do
+        type_parameters(:R)
+          .params(label: String, blk: T.proc.returns(T.type_parameter(:R)))
+          .returns(T.type_parameter(:R))
+      end
+      def measure(label, &blk)
+        unless @enabled
+          return yield
+        end
+
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result = yield
+        elapsed_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000.0
+
+        metric = @metrics[label] ||= Metric.new
+        metric.count += 1
+        metric.total_ms += elapsed_ms
+        metric.min_ms = elapsed_ms if elapsed_ms < metric.min_ms
+        metric.max_ms = elapsed_ms if elapsed_ms > metric.max_ms
+
+        result
+      end
+
+      sig { void }
+      def reset!
+        @metrics = {}
+      end
+
+      sig { params(io: IO).void }
+      def report(io: $stderr)
+        return if @metrics.empty?
+
+        io.puts "\n=== SorbetView Performance Report ==="
+        io.puts format('%-35s %8s %10s %10s %10s %10s', 'Label', 'Count', 'Total(ms)', 'Avg(ms)', 'Min(ms)', 'Max(ms)')
+        io.puts '-' * 90
+
+        @metrics.sort_by { |_, m| -m.total_ms }.each do |label, m|
+          avg = m.count > 0 ? m.total_ms / m.count : 0.0
+          min_val = m.min_ms == Float::INFINITY ? 0.0 : m.min_ms
+          io.puts format('%-35s %8d %10.2f %10.2f %10.2f %10.2f', label, m.count, m.total_ms, avg, min_val, m.max_ms)
+        end
+
+        io.puts '=' * 90
+        io.puts ''
+      end
+
+      sig { params(logger: Logger).void }
+      def report_to_logger(logger)
+        return if @metrics.empty?
+
+        lines = ["\n=== SorbetView Performance Report ==="]
+        lines << format('%-35s %8s %10s %10s %10s %10s', 'Label', 'Count', 'Total(ms)', 'Avg(ms)', 'Min(ms)', 'Max(ms)')
+        lines << '-' * 90
+
+        @metrics.sort_by { |_, m| -m.total_ms }.each do |label, m|
+          avg = m.count > 0 ? m.total_ms / m.count : 0.0
+          min_val = m.min_ms == Float::INFINITY ? 0.0 : m.min_ms
+          lines << format('%-35s %8d %10.2f %10.2f %10.2f %10.2f', label, m.count, m.total_ms, avg, min_val, m.max_ms)
+        end
+
+        lines << '=' * 90
+        logger.info(lines.join("\n"))
+      end
+    end
+  end
+end

data/lib/sorbet_view/source_map/mapping_entry.rb

@@ -0,0 +1,12 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module SourceMap
+    class MappingEntry < T::Struct
+      const :template_range, Range  # position in the template file
+      const :ruby_range, Range      # position in the generated .rb file
+      const :type, Symbol           # :code, :expression, :boilerplate
+    end
+  end
+end

data/lib/sorbet_view/source_map/position.rb

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module SourceMap
+    class Position < T::Struct
+      const :line, Integer   # 0-based
+      const :column, Integer # 0-based
+
+      extend T::Sig
+
+      sig { returns(T::Hash[Symbol, Integer]) }
+      def to_lsp
+        { line: line, character: column }
+      end
+
+      sig { params(lsp_hash: T::Hash[String, Integer]).returns(Position) }
+      def self.from_lsp(lsp_hash)
+        new(line: lsp_hash['line'] || lsp_hash[:line], column: lsp_hash['character'] || lsp_hash[:character])
+      end
+    end
+  end
+end

data/lib/sorbet_view/source_map/range.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module SourceMap
+    class Range < T::Struct
+      const :start, Position
+      const :end_, Position
+
+      extend T::Sig
+
+      sig { returns(T::Hash[Symbol, T::Hash[Symbol, Integer]]) }
+      def to_lsp
+        { start: start.to_lsp, end: end_.to_lsp }
+      end
+
+      sig { params(lsp_hash: T::Hash[String, T.untyped]).returns(Range) }
+      def self.from_lsp(lsp_hash)
+        new(
+          start: Position.from_lsp(lsp_hash['start'] || lsp_hash[:start]),
+          end_: Position.from_lsp(lsp_hash['end'] || lsp_hash[:end])
+        )
+      end
+
+      sig { params(position: Position).returns(T::Boolean) }
+      def contains?(position)
+        return false if position.line < start.line || position.line > end_.line
+        return false if position.line == start.line && position.column < start.column
+        return false if position.line == end_.line && position.column > end_.column
+
+        true
+      end
+    end
+  end
+end

data/lib/sorbet_view/source_map/source_map.rb

@@ -0,0 +1,103 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  module SourceMap
+    class SourceMap
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :template_path
+
+      sig { returns(String) }
+      attr_reader :ruby_path
+
+      sig { returns(T::Array[MappingEntry]) }
+      attr_reader :entries
+
+      sig do
+        params(
+          template_path: String,
+          ruby_path: String,
+          entries: T::Array[MappingEntry]
+        ).void
+      end
+      def initialize(template_path:, ruby_path:, entries:)
+        @template_path = template_path
+        @ruby_path = ruby_path
+        @entries = entries
+      end
+
+      sig { params(position: Position).returns(T.nilable(Position)) }
+      def template_to_ruby(position)
+        Perf.measure('sourcemap.template_to_ruby') do
+          entry = find_entry_by_template(position)
+          next nil unless entry
+          next nil if entry.type == :boilerplate
+
+          translate(position, entry.template_range, entry.ruby_range)
+        end
+      end
+
+      sig { params(position: Position).returns(T.nilable(Position)) }
+      def ruby_to_template(position)
+        Perf.measure('sourcemap.ruby_to_template') do
+          entry = find_entry_by_ruby(position)
+          next nil unless entry
+          next nil if entry.type == :boilerplate
+
+          translate(position, entry.ruby_range, entry.template_range)
+        end
+      end
+
+      sig { params(ruby_range: Range).returns(T.nilable(Range)) }
+      def ruby_range_to_template(ruby_range)
+        start_pos = ruby_to_template(ruby_range.start)
+        end_pos = ruby_to_template(ruby_range.end_)
+        return nil unless start_pos && end_pos
+
+        Range.new(start: start_pos, end_: end_pos)
+      end
+
+      sig { params(template_path: String, ruby_path: String).returns(SourceMap) }
+      def self.empty(template_path, ruby_path)
+        new(template_path: template_path, ruby_path: ruby_path, entries: [])
+      end
+
+      private
+
+      sig { params(position: Position).returns(T.nilable(MappingEntry)) }
+      def find_entry_by_template(position)
+        @entries.find { |e| e.template_range.contains?(position) }
+      end
+
+      sig { params(position: Position).returns(T.nilable(MappingEntry)) }
+      def find_entry_by_ruby(position)
+        # First try exact match, then fall back to line-only match
+        @entries.find { |e| e.ruby_range.contains?(position) } ||
+          @entries.find { |e| position.line >= e.ruby_range.start.line && position.line <= e.ruby_range.end_.line }
+      end
+
+      sig do
+        params(
+          position: Position,
+          from_range: Range,
+          to_range: Range
+        ).returns(Position)
+      end
+      def translate(position, from_range, to_range)
+        delta_line = position.line - from_range.start.line
+        delta_col = if delta_line == 0
+          position.column - from_range.start.column
+        else
+          position.column
+        end
+
+        Position.new(
+          line: to_range.start.line + delta_line,
+          column: (delta_line == 0 ? to_range.start.column : 0) + delta_col
+        )
+      end
+    end
+  end
+end

data/lib/sorbet_view/version.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetView
+  VERSION = '0.1.0'
+end

data/lib/sorbet_view.rb

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+require_relative 'sorbet_view/version'
+require_relative 'sorbet_view/perf'
+require_relative 'sorbet_view/configuration'
+require_relative 'sorbet_view/source_map/position'
+require_relative 'sorbet_view/source_map/range'
+require_relative 'sorbet_view/source_map/mapping_entry'
+require_relative 'sorbet_view/source_map/source_map'
+require_relative 'sorbet_view/compiler/ruby_segment'
+require_relative 'sorbet_view/compiler/parser_adapter'
+require_relative 'sorbet_view/compiler/adapters/erb_adapter'
+require_relative 'sorbet_view/compiler/template_context'
+require_relative 'sorbet_view/compiler/ruby_generator'
+require_relative 'sorbet_view/compiler/template_compiler'
+require_relative 'sorbet_view/compiler/heredoc_extractor'
+require_relative 'sorbet_view/compiler/component_compiler'
+require_relative 'sorbet_view/file_system/output_manager'
+require_relative 'sorbet_view/file_system/project_scanner'
+require_relative 'sorbet_view/file_system/file_watcher'
+require_relative 'sorbet_view/lsp/transport'
+require_relative 'sorbet_view/lsp/uri_mapper'
+require_relative 'sorbet_view/lsp/document_store'
+require_relative 'sorbet_view/lsp/position_translator'
+require_relative 'sorbet_view/lsp/sorbet_process'
+require_relative 'sorbet_view/lsp/server'
+require_relative 'sorbet_view/cli/runner'
+
+module SorbetView
+  extend T::Sig
+
+  CONFIG_FILE_NAME = '.sorbet_view.yml'
+end