libtmux-async 0.1.0.alpha.1

data/lib/libtmux/async/server.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module LibTmux
+  module Async
+    class Server < LibTmux::Server
+      def initialize(scope, source)
+        raise ArgumentError, "server must be a bound LibTmux::Server" unless source.is_a?(LibTmux::Server)
+
+        @scope, @source = scope, source
+        @mutex = Mutex.new
+        source.__send__(:with_bound_endpoint) { |endpoint, pin| @endpoint, @pin = endpoint, pin }
+      end
+
+      def run(argv, input: "".b, timeout: 5.0, cancel: nil)
+        ensure_owner
+        ensure_open
+        validate_argv(argv)
+        raise ArgumentError, "raw commands cannot override endpoint flags" if argv.first.start_with?("-")
+
+        @scope.__send__(:execute, @pin.command_prefix + argv, input: input, timeout: timeout, cancel: cancel)
+      end
+
+      def close
+        @scope.close
+      end
+
+      # Scope counters remain readable after this facade closes its scope.
+      def diagnostics
+        @scope.diagnostics
+      end
+
+      def open_control(session:, **options)
+        session_id = target(session, :session)
+        control = @scope.__send__(:open_control, binding: @pin, session_id: session_id, **options)
+        return control unless block_given?
+
+        failure = result = nil
+        begin
+          result = yield control
+        rescue Exception => error
+          failure = error
+        ensure
+          begin
+            control.close
+          rescue Exception => error
+            details = ["Async control close failed (#{error.class})"]
+            details.concat(error.cleanup_errors) if error.is_a?(Error)
+            Async.__send__(:attach_cleanup, failure, details) if failure
+            failure ||= error
+          end
+        end
+        raise failure if failure
+
+        result
+      end
+
+      def attach(**)
+        raise UnsupportedFeatureError.new("interactive terminal attachment requires the blocking core facade", phase: :admission)
+      end
+
+      def self.start(**)
+        raise UnsupportedFeatureError.new("create an owned core server before opening its Async scope", phase: :admission)
+      end
+
+      private
+
+      def ensure_owner
+        @scope.__send__(:ensure_owner)
+      end
+
+      def ensure_open
+        @scope.__send__(:ensure_open)
+        @source.__send__(:with_bound_endpoint) { nil }
+      end
+    end
+  end
+end

data/lib/libtmux/async/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module LibTmux
+  module Async
+    VERSION = "0.1.0.alpha.1"
+  end
+end

data/lib/libtmux/async.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "libtmux"
+require "async"
+require "libtmux/async/version"
+require "libtmux/async/server"
+require "libtmux/async/scope"
+require "libtmux/async/control"
+
+module LibTmux
+  module Async
+    module CleanupDetails
+      attr_reader :async_cleanup_errors
+    end
+    private_constant :CleanupDetails
+
+    def self.attach_cleanup(error, details)
+      return if details.empty?
+
+      if error.is_a?(Error)
+        error.__send__(:attach_cleanup_errors, details)
+      else
+        error.extend(CleanupDetails)
+        error.instance_variable_set(:@async_cleanup_errors, ((error.async_cleanup_errors || []) + details).freeze)
+      end
+    rescue FrozenError, TypeError
+      nil
+    end
+    private_class_method :attach_cleanup
+
+    def self.open(server:, parent: ::Async::Task.current, **options)
+      raise ArgumentError, "Async scope requires a block" unless block_given?
+
+      scope = Scope.new(parent: parent, server: server, **options)
+      failure = result = nil
+      begin
+        result = yield scope
+      rescue Exception => error
+        failure = error
+      ensure
+        begin
+          scope.close
+        rescue Exception => error
+          details = ["Async scope close failed (#{error.class})"]
+          details.concat(error.cleanup_errors) if error.is_a?(Error)
+          attach_cleanup(failure, details) if failure
+          failure ||= error
+        end
+      end
+      raise failure if failure
+
+      result
+    end
+  end
+end

data/sig/libtmux-async.rbs

@@ -0,0 +1,58 @@
+module LibTmux
+  module Async
+    VERSION: String
+
+    def self.open: [T] (server: LibTmux::Server, ?parent: untyped, **untyped) { (Scope) -> T } -> T
+
+    type scope_diagnostics = {
+      transport: :async_process, closed: bool, admitted_requests: Integer,
+      reserved_process_slots: Integer,
+      waiting_requests: Integer, active_process_slots: Integer,
+      reserved_request_bytes: Integer, retained_output_bytes: Integer,
+      control_connections: Integer, maps: Integer,
+      limits: {concurrency: Integer, max_requests: Integer, max_controls: Integer,
+        max_queue_bytes: Integer, max_output_bytes: Integer,
+        stdout_limit: Integer, stderr_limit: Integer, input_limit: Integer,
+        argv_limit: Integer, cleanup_timeout: Numeric, drain_timeout: Numeric,
+        close_timeout: Numeric}
+    }
+
+    class Scope
+      def initialize: (parent: untyped, server: LibTmux::Server, ?concurrency: Integer, ?max_requests: Integer,
+        ?max_controls: Integer, ?max_queue_bytes: Integer, ?max_output_bytes: Integer,
+        ?stdout_limit: Integer, ?stderr_limit: Integer, ?input_limit: Integer, ?argv_limit: Integer,
+        ?cleanup_timeout: Numeric, ?drain_timeout: Numeric) -> void
+      attr_reader server: Server
+      def map: [Input, Output] (Enumerable[Input], ?concurrency: Integer, ?max_items: Integer,
+        ?max_bytes: Integer, ?result_bytes: ^(Output) -> Integer) { (Input) -> Output } -> Array[Output]
+      def close: () -> nil
+      def closed?: () -> bool
+      def diagnostics: () -> scope_diagnostics
+    end
+
+    class Server < LibTmux::Server
+      def initialize: (Scope, LibTmux::Server) -> void
+      def run: (Array[String], ?input: String, ?timeout: Numeric, ?cancel: untyped) -> CommandResult
+      def close: () -> nil
+      def diagnostics: () -> scope_diagnostics
+      def open_control: [T] (session: EntityRef, ?reconnect: LibTmux::ControlConnection?, **Integer) { (ControlConnection) -> T } -> T
+                      | (session: EntityRef, ?reconnect: LibTmux::ControlConnection?, **Integer) -> ControlConnection
+      def attach: (**untyped) -> bot
+      def self.start: (**untyped) -> bot
+    end
+
+    class ControlConnection < LibTmux::ControlConnection
+      def initialize: (scope: Scope, binding: untyped, session_id: String, ?reconnect: LibTmux::ControlConnection?, **Integer) -> void
+      attr_reader events: ControlSubscription
+      def exchange: (String, ?timeout: Numeric, ?cancel: untyped) -> GuardedReply
+      def subscribe: (?pane_id: String?, ?mode: :reliable | :tail, ?max_bytes: Integer, ?max_events: Integer) -> ControlSubscription
+      def close: (?timeout: Numeric) -> nil
+      def closed?: () -> bool
+    end
+
+    class ControlSubscription < LibTmux::ControlSubscription
+      def initialize: (scope: Scope, **untyped) -> void
+      def next: (?timeout: Numeric?) -> ControlEvent
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: libtmux-async
+version: !ruby/object:Gem::Version
+  version: 0.1.0.alpha.1
+platform: ruby
+authors:
+- libtmux contributors
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: libtmux
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.0.alpha.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.0.alpha.1
+- !ruby/object:Gem::Dependency
+  name: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.46.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.46.0
+description: Run concurrent libtmux commands and bounded control subscriptions inside
+  application-owned Async tasks.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/libtmux/async.rb
+- lib/libtmux/async/control.rb
+- lib/libtmux/async/process.rb
+- lib/libtmux/async/scope.rb
+- lib/libtmux/async/server.rb
+- lib/libtmux/async/version.rb
+- sig/libtmux-async.rbs
+homepage: https://github.com/libtmux/libtmux-ruby
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/libtmux/libtmux-ruby
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Optional Async integration for libtmux
+test_files: []