canopus 0.4.0 → 0.5.0

data/lib/canopus/debug/session.rb

@@ -0,0 +1,354 @@
+# frozen_string_literal: true
+
+require "socket"
+require "tempfile"
+require_relative "../error"
+
+module Canopus
+  module Debug
+    class Session
+      DEFAULT_TIMEOUT = 10
+      CONNECT_INTERVAL = 0.05
+
+      attr_reader :client
+
+      def initialize(root:, configuration:, adapter:, breakpoints:, client: nil, timeout: DEFAULT_TIMEOUT)
+        @root = File.realpath(root)
+        @configuration = configuration
+        @adapter = adapter
+        @breakpoints = breakpoints
+        @client = client
+        @timeout = timeout
+        unless timeout.is_a?(Numeric) && timeout.finite? && timeout.positive?
+          raise ArgumentError, "debug session timeout must be positive and finite"
+        end
+        @handlers = {}
+        @lock = Mutex.new
+        @closed = false
+      rescue SystemCallError, TypeError => error
+        raise Error, "invalid debug session: #{error.message}"
+      end
+
+      def on(event, &handler)
+        raise ArgumentError, "debug event handler required" unless handler
+
+        @lock.synchronize { (@handlers[event.to_sym] ||= []) << handler }
+        handler
+      end
+
+      def stopped_thread_id = @lock.synchronize { @stopped_thread_id }
+
+      def stack_frames(levels: 100)
+        client, thread_id = inspection_state
+        client.stack_trace(thread_id, start: 0, levels: levels)
+      end
+
+      def scopes(frame_id) = inspection_client.scopes(frame_id)
+      def variables(reference) = inspection_client.variables(reference)
+      def evaluate(expression, frame_id:, context: "watch") = inspection_client.evaluate(expression, frame_id: frame_id, context: context)
+
+      def start
+        deadline = monotonic_time + @timeout
+        initialized = Queue.new
+        client = @client || build_client(deadline)
+        install_client(client)
+        client.on(:initialized) { initialized << true }
+        client.on(:stopped) { |event| stopped(client, event) }
+        client.on(:continued) { clear_stopped_thread; emit(:continued) }
+        client.on(:output) { |event| emit(:output, event) }
+        client.on(:terminated) { clear_stopped_thread; emit(:terminated) }
+        client.on(:exited) { clear_stopped_thread; emit(:terminated) }
+
+        capabilities = client.start(adapter_id: adapter_id, timeout: remaining(deadline))
+        request = request_start(client)
+        wait_for_initialized(initialized, request, deadline)
+        set_breakpoints(client, capabilities, deadline)
+        if capabilities["supportsConfigurationDoneRequest"]
+          client.configuration_done.await(timeout: remaining(deadline))
+        end
+        request.await(timeout: remaining(deadline))
+        self
+      rescue StandardError => error
+        begin
+          request.await(timeout: 0) if request&.done?
+        rescue StandardError => start_error
+          error = start_error
+        end
+        begin
+          close
+        rescue StandardError
+          nil
+        end
+        raise debug_error(error)
+      end
+
+      def close
+        client, waiter, log = @lock.synchronize do
+          next if @closed
+
+          @closed = true
+          [@client, @process, @log]
+        end
+        return nil unless client || waiter || log
+
+        failure = nil
+        begin
+          client&.close
+        rescue StandardError => error
+          failure = error
+        ensure
+          begin
+            stop_process(waiter)
+          rescue StandardError => error
+            failure ||= error
+          ensure
+            begin
+              log&.close!
+            rescue StandardError => error
+              failure ||= error
+            end
+          end
+        end
+        raise debug_error(failure) if failure
+        nil
+      end
+
+      private
+
+      def inspection_state
+        @lock.synchronize do
+          raise Error, "debug session is not stopped" if @closed || !@client || !@stopped_thread_id
+
+          [@client, @stopped_thread_id]
+        end
+      end
+
+      def inspection_client = inspection_state.first
+
+      def clear_stopped_thread = @lock.synchronize { @stopped_thread_id = nil }
+
+      def build_client(deadline)
+        command = @adapter.fetch("command")
+        case @adapter.fetch("transport")
+        when "stdio"
+          Megrez::Session.stdio(command: command, env: debug_environment,
+            cwd: @configuration["cwd"] || @root)
+        when "tcp"
+          build_tcp_client(command, deadline)
+        else
+          raise Error, "unsupported debug adapter transport"
+        end
+      end
+
+      def build_tcp_client(command, deadline)
+        unless File.basename(command.first) == "rdbg"
+          raise Error, "tcp debug adapters currently require rdbg"
+        end
+        raise Error, "rdbg tcp adapters only support launch" unless @configuration["request"] == "launch"
+
+        host, port = "127.0.0.1", available_port
+        arguments = command.map { |argument| argument == "--open" ? "--open=vscode" : argument }
+        arguments << "--open=vscode" unless arguments.any? { |argument| argument.start_with?("--open=") }
+        arguments.concat(["--host", host, "--port", port.to_s])
+        if @configuration["request"] == "launch" && @configuration["program"]
+          arguments.concat(["--", @configuration.fetch("program"), *@configuration.fetch("args", [])])
+        end
+        log = Tempfile.new(["canopus-debug-", ".log"])
+        pid = Process.spawn(debug_environment, *arguments, chdir: @configuration["cwd"] || @root,
+          out: log, err: log)
+        waiter = Process.detach(pid)
+        rejected = @lock.synchronize do
+          if @closed
+            true
+          else
+            @log, @process = log, waiter
+            false
+          end
+        end
+        if rejected
+          stop_process(waiter)
+          log.close!
+          raise Error, "debug session is closed"
+        end
+        connect_tcp(host, port, deadline)
+      rescue SystemCallError => error
+        log&.close! unless defined?(@log) && @log.equal?(log)
+        raise Error, "debug adapter spawn failed: #{error.message}"
+      end
+
+      def connect_tcp(host, port, deadline)
+        loop do
+          raise Error, "debug session is closed" if closed?
+          if @process&.join(0)
+            raise Error, "debug adapter exited before accepting DAP#{adapter_log}"
+          end
+          begin
+            return Megrez::Session.tcp(host: host, port: port,
+              connect_timeout: [remaining(deadline), 0.2].min)
+          rescue Megrez::Error
+            raise if monotonic_time >= deadline
+
+            sleep([CONNECT_INTERVAL, remaining(deadline)].min)
+          end
+        end
+      end
+
+      def install_client(client)
+        rejected = @lock.synchronize do
+          if @closed
+            true
+          else
+            @client = client
+            false
+          end
+        end
+        if rejected
+          client.close
+          raise Error, "debug session is closed"
+        end
+      end
+
+      def request_start(client)
+        arguments = @configuration.reject { |key, _| %w[name type request].include?(key) }
+        if @adapter["transport"] == "tcp" && File.basename(@adapter.fetch("command").first) == "rdbg"
+          arguments = arguments.reject { |key, _| %w[program args cwd env].include?(key) }.merge("localfs" => true)
+        end
+        @configuration.fetch("request") == "launch" ? client.launch(arguments) : client.attach(arguments)
+      end
+
+      def wait_for_initialized(queue, request, deadline)
+        loop do
+          initialized = queue.pop(true)
+          request.await(timeout: 0) if request.done?
+          return initialized
+        rescue ThreadError
+          request.await(timeout: 0) if request.done?
+          raise Error, "debug adapter did not initialize" if monotonic_time >= deadline
+          raise Error, "debug session is closed" if closed?
+
+          sleep([CONNECT_INTERVAL, remaining(deadline)].min)
+        end
+      end
+
+      def set_breakpoints(client, capabilities, deadline)
+        @breakpoints.entries.select(&:enabled).group_by(&:path).sort.each do |path, entries|
+          validate_breakpoint_capabilities!(entries, capabilities)
+          source = File.join(@root, path)
+          values = entries.map do |entry|
+            Megrez::SourceBreakpoint.new(line: entry.line, column: nil,
+              condition: capabilities["supportsConditionalBreakpoints"] ? entry.condition : nil,
+              hit_condition: capabilities["supportsHitConditionalBreakpoints"] ? entry.hit_condition : nil,
+              log_message: capabilities["supportsLogPoints"] ? entry.log_message : nil)
+          end
+          client.set_breakpoints(source, values).await(timeout: remaining(deadline))
+        end
+      end
+
+      def validate_breakpoint_capabilities!(entries, capabilities)
+        requirements = {
+          condition: "supportsConditionalBreakpoints",
+          hit_condition: "supportsHitConditionalBreakpoints",
+          log_message: "supportsLogPoints"
+        }
+        requirements.each do |field, capability|
+          if !capabilities[capability] && entries.any? { |entry| !entry.public_send(field).nil? }
+            raise Error, "debug adapter does not support #{field.to_s.tr('_', ' ')}"
+          end
+        end
+      end
+
+      def stopped(client, event)
+        thread_id = event["threadId"] || event[:threadId]
+        raise Error, "debug stop event has no thread" unless thread_id.is_a?(Integer) && thread_id.positive?
+
+        generation = client.generation
+        frame = client.stack_trace(thread_id, start: 0, levels: 1).await(timeout: @timeout).first
+        raise Error, "debug stop event has no stack frame" unless frame
+        return unless client.state == :stopped && client.generation == generation
+
+        accepted = @lock.synchronize do
+          next false if @closed || client.state != :stopped || client.generation != generation
+
+          @stopped_thread_id = thread_id
+          true
+        end
+        return unless accepted
+
+        emit(:stopped, frame)
+      rescue StandardError => error
+        return if generation && (client.state != :stopped || client.generation != generation)
+
+        emit(:error, debug_error(error))
+      end
+
+      def emit(event, value = nil)
+        handlers = @lock.synchronize { @closed ? [] : (@handlers[event] || []).dup }
+        handlers.each { |handler| handler.call(value) }
+      end
+
+      def debug_environment
+        value = @configuration.fetch("env", {})
+        valid = value.is_a?(Hash) && value.all? do |key, item|
+          key.is_a?(String) && (item.nil? || item.is_a?(String))
+        end
+        raise Error, "debug environment must contain string values" unless valid
+
+        ENV.each_key.grep(/\ABUNDLE/).to_h { |key| [key, nil] }
+          .merge("RUBYOPT" => nil, "RUBYLIB" => nil)
+          .merge(value)
+      end
+
+      def adapter_id
+        File.basename(@adapter.fetch("command").first) == "rdbg" ? "rdbg" : @configuration.fetch("type")
+      end
+
+      def available_port
+        server = TCPServer.new("127.0.0.1", 0)
+        server.local_address.ip_port
+      ensure
+        server&.close
+      end
+
+      def stop_process(waiter)
+        return unless waiter
+        return if waiter.join(0)
+
+        Process.kill(Gem.win_platform? ? "KILL" : "TERM", waiter.pid)
+        return if waiter.join(1)
+
+        return if Gem.win_platform?
+
+        Process.kill("KILL", waiter.pid)
+        waiter.join(1)
+      rescue Errno::ESRCH, Errno::ECHILD
+        nil
+      end
+
+      def adapter_log
+        return "" unless @log
+
+        @log.flush
+        text = File.binread(@log.path, 2_048).force_encoding(Encoding::UTF_8).scrub.strip
+        text.empty? ? "" : ": #{text}"
+      rescue IOError, SystemCallError
+        ""
+      end
+
+      def remaining(deadline)
+        value = deadline - monotonic_time
+        raise Megrez::Timeout, "debug session timed out" unless value.positive?
+
+        value
+      end
+
+      def closed? = @lock.synchronize { @closed }
+      def monotonic_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      def debug_error(error)
+        return error if error.is_a?(Error)
+
+        Error.new("debug session failed: #{error.message}")
+      end
+    end
+  end
+end

data/lib/canopus/decoration.rb

@@ -39,7 +39,9 @@ module Canopus
         first, last = normalize_rows(row_range)
         state = [buffer.respond_to?(:version) ? buffer.version : nil,
           context&.object_id,
-          context&.respond_to?(:selections) ? context.selections : buffer.respond_to?(:selections) ? buffer.selections : nil]
+          context&.respond_to?(:selections) ? context.selections : buffer.respond_to?(:selections) ? buffer.selections : nil,
+          context&.respond_to?(:tab_size) ? context.tab_size : nil,
+          context&.respond_to?(:language_document) ? context.language_document.object_id : nil]
         suppliers = @lock.synchronize do
           @suppliers.map { |source, supplier| [source, supplier, @generations[source]] }
         end
@@ -63,7 +65,7 @@ module Canopus
           end
           supplied
         end
-        items.sort_by { |item| item.priority }.freeze
+        items.each_with_index.sort_by { |item, index| [item.priority, index] }.map!(&:first).freeze
       end
 
       def invalidate(source, buffer: nil, rows: nil)

data/lib/canopus/denebola_compat.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Canopus asks lazy ropes for a bounded line window while moving cursors. Keep
+# this small compatibility shim until that helper is part of Denebola's API.
+unless Denebola::LazyRope.method_defined?(:line_window)
+  class Denebola::LazyRope
+    def line_end(row)
+      start = line_start(row)
+      ending = row + 1 < line_count(exact: true) ? line_start(row + 1) : bytesize
+      tail_start = [ending - 3, start].max
+      tail = send(:read_bytes, tail_start, [ending - tail_start, 3].min)
+      ending - (tail.end_with?("\r\n") ? 2 : tail.end_with?("\r", "\n") ? 1 : 0)
+    end
+
+    def line_window(row, from: 0, max_bytes: 16_384)
+      start, ending = line_start(row), line_end(row)
+      offset = (start + from).clamp(start, ending)
+      offset -= 1 while offset > start && offset < ending && (send(:read_bytes, offset, 1).getbyte(0) & 0xc0) == 0x80
+      value = send(:read_bytes, offset, [max_bytes, ending - offset].min)
+      finish = value.bytesize
+      while finish.positive? && !value.byteslice(0, finish).force_encoding(Encoding::UTF_8).valid_encoding?
+        finish -= 1
+      end
+      [value.byteslice(0, finish).to_s.force_encoding(Encoding::UTF_8), offset - start]
+    end
+  end
+end

data/lib/canopus/diagnostics.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "json"
+require "sadr" unless defined?(Sadr::Protocol) && defined?(Sadr::Error)
+
+module Canopus
+  module Diagnostics
+    SOURCES = %i[lsp settings task test].freeze
+    SEVERITIES = {error: 1, warning: 2, information: 3, hint: 4}.freeze
+    URI_LIMIT = 16_384
+    MESSAGE_LIMIT = 4_096
+    PUBLICATION_LIMIT = 10_000
+    TOTAL_LIMIT = 100_000
+    TOTAL_BYTES_LIMIT = 32 << 20
+    ITEM_BYTES_LIMIT = 1 << 20
+    VALUE_DEPTH_LIMIT = 100
+
+    Entry = Data.define(:source, :uri, :diagnostic)
+
+    class Registry
+      attr_reader :version
+
+      def initialize(&on_change)
+        @entries = {}
+        @sizes = {}
+        @counts = SEVERITIES.keys.to_h { |severity| [severity, 0] }
+        @total = @bytes = 0
+        @lock = Mutex.new
+        @on_change = on_change
+        @version = 0
+      end
+
+      def publish(source, uri, diagnostics, notify: true)
+        raise ArgumentError, "invalid diagnostics notification option" unless [true, false].include?(notify)
+        source = normalize_source(source)
+        uri = normalize_uri(uri)
+        values, bytes = normalize_diagnostics(diagnostics)
+        @lock.synchronize do
+          key = [source, uri]
+          previous = @entries.fetch(key, [])
+          total = @total - previous.length + values.length
+          raise ArgumentError, "too many diagnostics" if total > TOTAL_LIMIT
+          total_bytes = @bytes - @sizes.fetch(key, 0) + bytes
+          raise ArgumentError, "diagnostics use too much memory" if total_bytes > TOTAL_BYTES_LIMIT
+
+          previous.each { |diagnostic| @counts[SEVERITIES.key(diagnostic.fetch("severity", 1))] -= 1 }
+          values.each { |diagnostic| @counts[SEVERITIES.key(diagnostic.fetch("severity", 1))] += 1 }
+          if values.empty?
+            @entries.delete(key)
+            @sizes.delete(key)
+          else
+            @entries[key] = values
+            @sizes[key] = bytes
+          end
+          @total, @bytes = total, total_bytes
+          @version += 1
+        end
+        @on_change&.call(uri) if notify
+        values
+      end
+
+      def for_uri(uri)
+        uri = normalize_uri(uri)
+        @lock.synchronize do
+          @entries.flat_map do |(source, current), diagnostics|
+            current == uri ? diagnostics.map { |diagnostic| Entry.new(source, current, diagnostic).freeze } : []
+          end.freeze
+        end
+      end
+
+      def all(severity: nil, source: nil)
+        severity = normalize_severity(severity) if severity
+        source = normalize_source(source) if source
+        @lock.synchronize do
+          @entries.flat_map do |(entry_source, uri), diagnostics|
+            next [] if source && source != entry_source
+
+            diagnostics.filter_map do |diagnostic|
+              next if severity && diagnostic.fetch("severity", 1) != severity
+              Entry.new(entry_source, uri, diagnostic).freeze
+            end
+          end.freeze
+        end
+      end
+
+      def counts
+        @lock.synchronize { @counts.dup.freeze }
+      end
+
+      private
+
+      def normalize_source(source)
+        raise ArgumentError, "invalid diagnostic source" unless SOURCES.include?(source)
+        source
+      end
+
+      def normalize_uri(uri)
+        valid = uri.is_a?(String) && uri.encoding == Encoding::UTF_8 && uri.valid_encoding? &&
+          uri.bytesize <= URI_LIMIT && !uri.include?("\0")
+        raise ArgumentError, "invalid diagnostic URI" unless valid
+        Sadr::Protocol.path(uri)
+        uri.dup.freeze
+      rescue Sadr::Error
+        raise ArgumentError, "invalid diagnostic URI"
+      end
+
+      def normalize_severity(severity)
+        severity = SEVERITIES.fetch(severity, severity) if severity.is_a?(Symbol)
+        raise ArgumentError, "invalid diagnostic severity" unless severity.is_a?(Integer) && severity.between?(1, 4)
+        severity
+      end
+
+      def normalize_diagnostics(diagnostics)
+        unless diagnostics.is_a?(Array) && diagnostics.length <= PUBLICATION_LIMIT
+          raise ArgumentError, "invalid diagnostics"
+        end
+        Sadr::Protocol.diagnostics(diagnostics)
+        bytes = 0
+        values = diagnostics.map do |diagnostic|
+          message = diagnostic.fetch("message")
+          valid = message.encoding == Encoding::UTF_8 && message.valid_encoding? &&
+            message.bytesize <= MESSAGE_LIMIT && !message.include?("\0")
+          raise ArgumentError, "invalid diagnostic message" unless valid
+
+          validate_value(diagnostic)
+          encoded = JSON.generate(diagnostic)
+          raise ArgumentError, "diagnostic exceeds 1 MiB" if encoded.bytesize > ITEM_BYTES_LIMIT
+          bytes += encoded.bytesize
+          raise ArgumentError, "diagnostics use too much memory" if bytes > TOTAL_BYTES_LIMIT
+          freeze_value(JSON.parse(encoded))
+        end.freeze
+        [values, bytes]
+      rescue JSON::GeneratorError, JSON::ParserError, JSON::NestingError, Sadr::Error, KeyError, TypeError
+        raise ArgumentError, "invalid diagnostics"
+      end
+
+      def freeze_value(value)
+        value.each { |key, child| key.freeze; freeze_value(child) } if value.is_a?(Hash)
+        value.each { |child| freeze_value(child) } if value.is_a?(Array)
+        value.freeze
+      end
+
+      def validate_value(value, depth = 0)
+        raise ArgumentError, "diagnostic is too deeply nested" if depth > VALUE_DEPTH_LIMIT
+
+        case value
+        when Hash
+          raise ArgumentError, "invalid diagnostic" unless value.length <= PUBLICATION_LIMIT
+          value.each do |key, child|
+            validate_string(key)
+            validate_value(child, depth + 1)
+          end
+        when Array
+          raise ArgumentError, "invalid diagnostic" if value.length > PUBLICATION_LIMIT
+          value.each { |child| validate_value(child, depth + 1) }
+        when String then validate_string(value)
+        when Float
+          raise ArgumentError, "invalid diagnostic" unless value.finite?
+        when NilClass, TrueClass, FalseClass, Integer
+          nil
+        else
+          raise ArgumentError, "invalid diagnostic"
+        end
+      end
+
+      def validate_string(value)
+        valid = value.is_a?(String) && value.encoding == Encoding::UTF_8 && value.valid_encoding? &&
+          value.bytesize <= MESSAGE_LIMIT && !value.include?("\0")
+        raise ArgumentError, "invalid diagnostic text" unless valid
+      end
+    end
+  end
+end

data/lib/canopus/display_map/overlay_map.rb

@@ -62,10 +62,14 @@ class Canopus::DisplayMap::OverlayMap
         blocks[row] << Block.new(item, row, height.to_f, (height.to_f / line_height).ceil, position)
       end
     end
-    inlines.each_value { |values| values.sort_by! { |value| [value.offset, value.item.priority] }.freeze }
+    inline_values = inlines.values.flatten.each_with_index
+      .sort_by { |value, index| [value.offset, value.item.priority, index] }.map!(&:first).freeze
+    inlines.each_value do |values|
+      ordered = values.each_with_index.sort_by { |value, index| [value.offset, value.item.priority, index] }.map!(&:first)
+      values.replace(ordered).freeze
+    end
     blocks.each_value { |values| values.sort_by! { |value| value.item.priority }.freeze }
     inlines, blocks = inlines.to_h.freeze, blocks.to_h.freeze
-    inline_values = inlines.values.flatten.sort_by(&:offset).freeze
     return [] if @inlines == inlines && @blocks == blocks && @line_height == line_height
 
     affected = (@inlines.keys | @blocks.keys | inlines.keys | blocks.keys).select do |row|

data/lib/canopus/editor/snippet_expandable.rb

@@ -47,12 +47,13 @@ module Canopus
     def insert_snippet(source, variables: {}, workspace_root: nil, clipboard: nil)
       raise Error, "snippet variables must be a Hash" unless variables.is_a?(Hash)
       # Parse every cursor expansion before changing text or disposing a live session.
-      snippets = @selections.each_with_index.map do |selection, index|
+      selections = merged_selections(@selections, touching: false)
+      snippets = selections.each_with_index.map do |selection, index|
         builtins = snippet_variables(workspace_root: workspace_root, clipboard: clipboard, selection: selection, cursor_index: index)
         Snippet.new(source, variables: builtins.merge(variables.transform_keys(&:to_s)))
       end
       starts, delta = [], 0
-      @selections.zip(snippets).each do |selection, snippet|
+      selections.zip(snippets).each do |selection, snippet|
         starts << selection.start + delta
         delta += snippet.text.bytesize - selection.range.size
       end