kapusta 0.5.0 → 0.8.0

data/lib/kapusta/lsp/workspace_index.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'uri'
+require_relative '../reader'
+require_relative 'scope_walker'
+
+module Kapusta
+  class LSP
+    class WorkspaceIndex
+      Entry = Struct.new(:uri, :text, :forms, :walker, keyword_init: true)
+
+      MACRO_MODULE_EXTENSIONS = %w[kapm kap].freeze
+      SCAN_EXTENSIONS = %w[kap kapm].freeze
+
+      def initialize(roots: [])
+        @roots = Array(roots)
+        @entries = {}
+      end
+
+      def scan!
+        @roots.each do |root|
+          SCAN_EXTENSIONS.each do |ext|
+            Dir.glob(File.join(root, '**', "*.#{ext}")).each do |path|
+              uri = path_to_uri(path)
+              text = File.read(path)
+              store(uri, text)
+            end
+          end
+        end
+        self
+      end
+
+      def refresh(uri, text)
+        store(uri, text)
+      end
+
+      def remove(uri)
+        path = uri_to_path(uri)
+        if path && File.file?(path)
+          store(uri, File.read(path))
+        else
+          @entries.delete(uri)
+        end
+      end
+
+      def entry(uri)
+        @entries[uri]
+      end
+
+      def entry_count
+        @entries.length
+      end
+
+      def toplevel_fn_definitions(name)
+        result = []
+        @entries.each do |uri, entry|
+          entry.walker.bindings.each do |b|
+            result << [uri, b] if b.kind == :toplevel_fn && b.name == name
+          end
+        end
+        result
+      end
+
+      def constant_definitions_with_prefix(prefix)
+        result = []
+        @entries.each do |uri, entry|
+          entry.walker.bindings.each do |b|
+            next unless %i[module class].include?(b.kind)
+
+            segs = b.sym.dotted? ? b.sym.segments : [b.sym.name]
+            result << [uri, b] if segs == prefix
+          end
+        end
+        result
+      end
+
+      def toplevel_fn_occurrences(name)
+        result = {}
+        @entries.each do |uri, entry|
+          occs = entry.walker.bindings.select do |b|
+            b.kind == :toplevel_fn && b.name == name
+          end
+          occs += entry.walker.references.select do |r|
+            next false unless r.sym.is_a?(Sym) && !r.sym.dotted? && r.name == name
+
+            r.target.nil? || (r.target.kind == :toplevel_fn && r.target.name == name)
+          end
+          result[uri] = occs unless occs.empty?
+        end
+        result
+      end
+
+      def toplevel_definition?(name, except_name: nil)
+        @entries.any? do |_uri, entry|
+          entry.walker.bindings.any? do |b|
+            next false unless file_toplevel_binding?(b)
+            next false if except_name && b.name == except_name
+
+            b.name == name
+          end
+        end
+      end
+
+      def constant_definition_with_prefix?(prefix, except_prefix: nil)
+        @entries.any? do |_uri, entry|
+          entry.walker.bindings.any? do |b|
+            next false unless %i[module class].include?(b.kind)
+            next false if except_prefix && matches_prefix?(b.sym, except_prefix)
+
+            matches_prefix?(b.sym, prefix)
+          end
+        end
+      end
+
+      def each_entry(&)
+        @entries.each(&)
+      end
+
+      def find_macro_definition(importing_uri, module_label, import_key)
+        target_name = import_key.to_s.tr('_', '-')
+        resolve_module_uris(importing_uri, module_label).each do |uri|
+          entry = @entries[uri]
+          next unless entry
+
+          binding = entry.walker.bindings.find do |b|
+            %i[macro toplevel_fn].include?(b.kind) && b.name == target_name
+          end
+          return [uri, binding] if binding
+        end
+        nil
+      end
+
+      def import_resolves_to?(importing_uri, module_label, target_uri)
+        resolve_module_uris(importing_uri, module_label).include?(target_uri)
+      end
+
+      def macro_definition_anywhere?(name, except_uri: nil)
+        @entries.any? do |uri, entry|
+          next false if except_uri && uri == except_uri
+
+          entry.walker.bindings.any? { |b| b.kind == :macro && b.name == name }
+        end
+      end
+
+      def constant_occurrences(prefix)
+        result = {}
+        @entries.each do |uri, entry|
+          occs = []
+          entry.walker.bindings.each do |b|
+            next unless %i[module class].include?(b.kind)
+
+            occs << b if matches_prefix?(b.sym, prefix)
+          end
+          entry.walker.references.each do |r|
+            sym = r.sym
+            next unless sym.is_a?(Sym)
+            next unless r.target.nil?
+            next unless first_segment_capitalized?(sym)
+
+            occs << r if matches_prefix?(sym, prefix)
+          end
+          result[uri] = occs unless occs.empty?
+        end
+        result
+      end
+
+      private
+
+      def file_toplevel_binding?(binding)
+        binding.scope.kind == :file && %i[toplevel_fn local var].include?(binding.kind)
+      end
+
+      def matches_prefix?(sym, prefix)
+        segs = sym.dotted? ? sym.segments : [sym.name]
+        return false if segs.length < prefix.length
+
+        segs[0...prefix.length] == prefix
+      end
+
+      def resolve_module_uris(importing_uri, module_label)
+        importing_path = uri_to_path(importing_uri)
+        return [] unless importing_path
+
+        base_dir = File.dirname(importing_path)
+        snake_stem = module_label.to_s.tr('-', '_')
+        kebab_stem = module_label.to_s.tr('_', '-')
+        uris = []
+        [kebab_stem, snake_stem].uniq.each do |stem|
+          MACRO_MODULE_EXTENSIONS.each do |ext|
+            uris << path_to_uri(File.expand_path("#{stem}.#{ext}", base_dir))
+          end
+        end
+        uris
+      end
+
+      def first_segment_capitalized?(sym)
+        first = sym.dotted? ? sym.segments.first : sym.name
+        first.match?(/\A[A-Z]/)
+      end
+
+      def store(uri, text)
+        forms = Reader.read_all(text)
+        walker = ScopeWalker.analyze(forms)
+        @entries[uri] = Entry.new(uri:, text:, forms:, walker:)
+      rescue Kapusta::Error
+        @entries[uri] = Entry.new(uri:, text:, forms: [], walker: ScopeWalker.analyze([]))
+      end
+
+      def path_to_uri(path)
+        "file://#{URI::DEFAULT_PARSER.escape(File.expand_path(path))}"
+      end
+
+      def uri_to_path(uri)
+        return unless uri.is_a?(String)
+
+        parsed = URI.parse(uri)
+        return URI::DEFAULT_PARSER.unescape(parsed.path) if parsed.scheme == 'file'
+
+        uri
+      rescue URI::InvalidURIError
+        nil
+      end
+    end
+  end
+end

data/lib/kapusta/lsp.rb

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'uri'
+require_relative '../kapusta'
+require_relative 'lsp/definition'
+require_relative 'lsp/diagnostics'
+require_relative 'lsp/formatting'
+require_relative 'lsp/rename'
+require_relative 'lsp/workspace_index'
+
+module Kapusta
+  class LSP
+    NOT_INITIALIZED = -32_002
+    METHOD_NOT_FOUND = -32_601
+    FULL_SYNC = 1
+
+    def self.start(input: $stdin, output: $stdout, log: $stderr)
+      new(input:, output:, log:).run
+    end
+
+    def initialize(input:, output:, log:)
+      @input = input.binmode
+      @output = output.binmode
+      @log = log
+      @debug = %w[1 true yes on].include?(ENV['KAPUSTA_LS_DEBUG'].to_s.downcase)
+      @sources = {}
+      @workspace_index = WorkspaceIndex.new
+      @initialized = false
+      @shutdown = false
+    end
+
+    def run
+      until (message = read_message).nil?
+        handle(message)
+      end
+    end
+
+    private
+
+    def read_message
+      headers = read_headers
+      return if headers.nil?
+
+      raw_length = headers['Content-Length']
+      return if raw_length.nil?
+
+      length = Integer(raw_length, 10, exception: false)
+      return if length.nil? || length.negative?
+
+      body = @input.read(length)
+      return if body.nil?
+
+      JSON.parse(body.force_encoding(Encoding::UTF_8))
+    rescue JSON::ParserError => e
+      log("parse error: #{e.message}")
+      nil
+    end
+
+    def read_headers
+      headers = {}
+      loop do
+        line = @input.gets
+        return if line.nil?
+        break if line.chomp.empty?
+
+        name, value = line.chomp.split(': ', 2)
+        headers[name] = value if name && value
+      end
+      headers
+    end
+
+    def write_message(payload)
+      body = JSON.generate(payload)
+      @output.write("Content-Length: #{body.bytesize}\r\n\r\n#{body}")
+      @output.flush
+    end
+
+    def handle(message)
+      method = message['method']
+      id = message['id']
+      params = message['params'] || {}
+
+      return handle_pre_init(method, id, params) unless @initialized || method == 'initialize' || method == 'exit'
+
+      dispatch(method, id, params)
+    rescue StandardError => e
+      log("#{e.class}: #{e.message}")
+      log(e.backtrace.first(5).join("\n"))
+      reply_error(id, METHOD_NOT_FOUND, e.message)
+    end
+
+    def handle_pre_init(method, id, _params)
+      return if id.nil?
+
+      reply_error(id, NOT_INITIALIZED, "received #{method} before initialize")
+    end
+
+    def dispatch(method, id, params)
+      case method
+      when 'initialize'
+        on_initialize(params)
+        @initialized = true
+        reply(id, initialize_result)
+      when 'initialized' then nil
+      when 'shutdown'
+        @shutdown = true
+        reply(id, nil)
+      when 'exit' then exit(@shutdown ? 0 : 1)
+      when 'textDocument/didOpen' then on_did_open(params)
+      when 'textDocument/didChange' then on_did_change(params)
+      when 'textDocument/didSave' then on_did_save(params)
+      when 'textDocument/didClose' then on_did_close(params)
+      when 'textDocument/formatting' then reply(id, formatting(params))
+      when 'textDocument/definition' then reply(id, definition(params))
+      when 'textDocument/prepareRename' then reply(id, prepare_rename(params))
+      when 'textDocument/rename' then handle_rename(id, params)
+      else
+        reply_error(id, METHOD_NOT_FOUND, "method not found: #{method}")
+      end
+    end
+
+    def reply(id, result)
+      return if id.nil?
+
+      write_message(jsonrpc: '2.0', id:, result:)
+    end
+
+    def reply_error(id, code, message)
+      return if id.nil?
+
+      write_message(jsonrpc: '2.0', id:, error: { code:, message: })
+    end
+
+    def notify(method, params)
+      write_message(jsonrpc: '2.0', method:, params:)
+    end
+
+    def initialize_result
+      {
+        capabilities: {
+          textDocumentSync: { openClose: true, change: FULL_SYNC, save: { includeText: false } },
+          documentFormattingProvider: true,
+          definitionProvider: true,
+          renameProvider: { prepareProvider: true }
+        },
+        serverInfo: { name: 'kapusta-ls', version: Kapusta::VERSION }
+      }
+    end
+
+    def on_initialize(params)
+      folders = params['workspaceFolders'] || []
+      roots = folders.filter_map { |f| uri_to_path(f['uri']) }
+      roots << uri_to_path(params['rootUri']) if params['rootUri']
+      roots.compact!
+      roots.uniq!
+      debug("initialize: roots=#{roots.inspect}")
+      @workspace_index = WorkspaceIndex.new(roots:)
+      @workspace_index.scan!
+      debug("workspace scan complete: #{@workspace_index.entry_count} files")
+    rescue StandardError => e
+      log("workspace scan failed: #{e.class}: #{e.message}")
+    end
+
+    def on_did_open(params)
+      doc = params['textDocument'] || {}
+      uri = doc['uri']
+      return unless uri
+
+      version = doc['version']
+      text = doc['text'] || ''
+      debug("didOpen: uri=#{uri} version=#{version} bytes=#{text.bytesize}")
+      store(uri, text, version)
+      @workspace_index.refresh(uri, text)
+      publish_diagnostics(uri, text, version)
+    end
+
+    def on_did_change(params)
+      uri = params.dig('textDocument', 'uri')
+      version = params.dig('textDocument', 'version')
+      changes = params['contentChanges'] || []
+      return if uri.nil? || changes.empty?
+
+      text = changes.last['text']
+      debug("didChange: uri=#{uri} version=#{version} bytes=#{text.bytesize}")
+      store(uri, text, version)
+      @workspace_index.refresh(uri, text)
+      publish_diagnostics(uri, text, version)
+    end
+
+    def on_did_save(params)
+      uri = params.dig('textDocument', 'uri')
+      entry = @sources[uri]
+      return unless entry
+
+      debug("didSave: uri=#{uri}")
+      @workspace_index.refresh(uri, entry[:text])
+      publish_diagnostics(uri, entry[:text], entry[:version])
+    end
+
+    def on_did_close(params)
+      uri = params.dig('textDocument', 'uri')
+      return unless uri
+
+      debug("didClose: uri=#{uri}")
+      @sources.delete(uri)
+      @workspace_index.remove(uri)
+      notify('textDocument/publishDiagnostics', { uri:, diagnostics: [] })
+    end
+
+    def formatting(params)
+      uri = params.dig('textDocument', 'uri')
+      entry = @sources[uri]
+      return [] unless entry
+
+      Formatting.text_edits(entry[:text], uri_to_path(uri))
+    end
+
+    def definition(params)
+      uri = params.dig('textDocument', 'uri')
+      pos = params['position'] || {}
+      entry = @sources[uri]
+      return unless entry
+
+      result = Definition.find(uri, entry[:text], pos['line'] || 0, pos['character'] || 0,
+                               workspace_index: @workspace_index)
+      debug("definition: uri=#{uri} pos=#{pos.inspect} result=#{result.inspect}")
+      result
+    end
+
+    def prepare_rename(params)
+      uri = params.dig('textDocument', 'uri')
+      pos = params['position'] || {}
+      entry = @sources[uri]
+      unless entry
+        debug("prepareRename: no source for uri=#{uri.inspect}; tracked=#{@sources.keys.inspect}")
+        return
+      end
+
+      result = Rename.prepare(entry[:text], pos['line'] || 0, pos['character'] || 0)
+      debug("prepareRename: uri=#{uri} pos=#{pos.inspect} result=#{result.inspect}")
+      result
+    end
+
+    def handle_rename(id, params)
+      uri = params.dig('textDocument', 'uri')
+      pos = params['position'] || {}
+      new_name = params['newName']
+      entry = @sources[uri]
+      unless entry
+        debug("rename: no source for uri=#{uri.inspect}; tracked=#{@sources.keys.inspect}")
+        return reply(id, nil)
+      end
+
+      debug("rename: uri=#{uri} pos=#{pos.inspect} newName=#{new_name.inspect}")
+      result = Rename.perform(uri, entry[:text], pos['line'] || 0, pos['character'] || 0,
+                              new_name, workspace_index: @workspace_index)
+      if result[:error]
+        debug("rename error: #{result[:error].inspect}")
+        reply_error(id, result[:error][:code], result[:error][:message])
+      else
+        edit = build_workspace_edit(result[:changes])
+        debug("rename ok: files=#{result[:changes].keys.length} edits=#{result[:changes].values.sum(&:length)}")
+        reply(id, edit)
+      end
+    end
+
+    def build_workspace_edit(changes_by_uri)
+      document_changes = changes_by_uri.map do |uri, edits|
+        sorted = edits.sort_by { |e| [-e[:range][:start][:line], -e[:range][:start][:character]] }
+        version = @sources.dig(uri, :version)
+        {
+          textDocument: { uri:, version: },
+          edits: sorted
+        }
+      end
+      { documentChanges: document_changes }
+    end
+
+    def store(uri, text, version)
+      @sources[uri] = { text:, version: }
+    end
+
+    def publish_diagnostics(uri, text, version)
+      diagnostics = Diagnostics.collect(text, uri_to_path(uri))
+      params = { uri:, diagnostics: }
+      params[:version] = version unless version.nil?
+      notify('textDocument/publishDiagnostics', params)
+    end
+
+    def uri_to_path(uri)
+      return unless uri
+
+      parsed = URI.parse(uri)
+      return URI::DEFAULT_PARSER.unescape(parsed.path) if parsed.scheme == 'file'
+
+      uri
+    rescue URI::InvalidURIError
+      uri
+    end
+
+    def log(message)
+      @log.puts "kapusta-ls: #{message}"
+    end
+
+    def debug(message)
+      return unless @debug
+
+      @log.puts "kapusta-ls[debug]: #{message}"
+    end
+  end
+end

data/lib/kapusta/reader.rb

@@ -270,8 +270,6 @@ module Kapusta
       start = @pos
       advance until delim?(peek)
       token = @src[start...@pos]
-      raise reader_error(:empty_token, position) if token.empty?
-
       parse_atom(token, position)
     end
 

data/lib/kapusta/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kapusta
-  VERSION = '0.5.0'
+  VERSION = '0.8.0'
 end