nl 0.3.0 → 0.4.1

data/sig/generated/nl/async/driver.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/nl/async/driver.rb with RBS::Inline
+
+module Nl
+  module Async
+    module Drivers
+      class Thread
+        def start: () ?{ (?) -> untyped } -> untyped
+
+        def stop: (untyped task) -> untyped
+      end
+
+      class Fiber
+        def start: () ?{ (?) -> untyped } -> untyped
+
+        def stop: (untyped _task) -> untyped
+      end
+    end
+
+    def self.driver: (untyped name) -> untyped
+  end
+end

data/sig/generated/nl/async/mailbox.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/nl/async/mailbox.rb with RBS::Inline
+
+module Nl
+  module Async
+    # A thread-safe, scheduler-aware, single-consumer mailbox.
+    class Mailbox
+      class FullError < StandardError
+      end
+
+      def initialize: (?capacity: untyped) -> untyped
+
+      # Adds a value without executing consumer code.
+      # @rbs (untyped) -> bool
+      def push: (untyped) -> bool
+
+      # Adds a completion/error event even when the value capacity is full.
+      def push_terminal: (untyped value) -> untyped
+
+      private def push_value: (untyped value, enforce_capacity: untyped) -> untyped
+
+      # Removes the next value, suspending through the current thread or Fiber scheduler if empty.
+      # @rbs (?timeout: Numeric?) -> untyped
+      def pop: (?timeout: Numeric?) -> untyped
+
+      def close: () -> untyped
+
+      def closed?: () -> untyped
+
+      def empty?: () -> untyped
+    end
+  end
+end

data/sig/generated/nl/async/operation.rbs

@@ -0,0 +1,123 @@
+# Generated from lib/nl/async/operation.rb with RBS::Inline
+
+module Nl
+  module Async
+    module Events
+      class Item < Data
+        attr_reader value(): untyped
+
+        def self.new: (untyped value) -> instance
+                    | (value: untyped) -> instance
+
+        def self.members: () -> [ :value ]
+
+        def members: () -> [ :value ]
+      end
+
+      class Done < Data
+        def self.new: () -> instance
+                    | () -> instance
+
+        def self.members: () -> [ ]
+
+        def members: () -> [ ]
+      end
+
+      class Error < Data
+        attr_reader exception(): untyped
+
+        def self.new: (untyped exception) -> instance
+                    | (exception: untyped) -> instance
+
+        def self.members: () -> [ :exception ]
+
+        def members: () -> [ :exception ]
+      end
+    end
+
+    class ConcurrentConsumptionError < StandardError
+    end
+
+    class StreamOverflowError < StandardError
+    end
+
+    # Future for the result of an already-started, single-reply operation.
+    # @rbs generic out Result
+    class Future[out Result]
+      def self.build: (?mailbox: untyped, ?on_close: untyped) -> untyped
+
+      def initialize: (mailbox: untyped, on_close: untyped) -> untyped
+
+      # @rbs (?timeout: Numeric?) -> Result
+      def await: (?timeout: Numeric?) -> Result
+
+      alias value await
+
+      def ready?: () -> bool
+
+      # Stops local delivery. The dispatcher still drains the Netlink exchange.
+      def close: () -> nil
+
+      private def settle_done: (untyped value) -> untyped
+
+      private def settle_failed: (untyped error) -> untyped
+
+      private def terminal_result: () -> untyped
+
+      class Sink
+        def initialize: (untyped mailbox) -> untyped
+
+        def succeed: (untyped value) -> untyped
+
+        def finish: () -> untyped
+
+        def fail: (untyped exception) -> untyped
+      end
+    end
+
+    # Single-pass consumer handle for a multipart Netlink operation.
+    # @rbs generic out Item
+    class Stream[out Item]
+      include Enumerable[Item]
+
+      def self.build: (?mailbox: untyped, ?on_close: untyped) -> untyped
+
+      def initialize: (mailbox: untyped, on_close: untyped) -> untyped
+
+      # @rbs () { (Item) -> void } -> self
+      #    | () -> Enumerator[Item, self]
+      def each: () { (Item) -> void } -> self
+              | () -> Enumerator[Item, self]
+
+      # @rbs (?timeout: Numeric?) -> Item
+      def next: (?timeout: Numeric?) -> Item
+
+      # Stops local delivery. The dispatcher still drains the Netlink exchange.
+      def close: () -> nil
+
+      def closed?: () -> bool
+
+      private def current_state: () -> untyped
+
+      private def open?: () -> untyped
+
+      private def claim_consumer!: () -> untyped
+
+      private def mark_completed: () -> untyped
+
+      private def mark_failed: (untyped error) -> untyped
+
+      private def terminal_result: (?next_item: untyped) -> untyped
+
+      class Sink
+        def initialize: (untyped mailbox) -> untyped
+
+        def push: (untyped value) -> untyped
+
+        def finish: () -> untyped
+
+        def fail: (untyped exception) -> untyped
+      end
+    end
+  end
+end

data/sig/generated/nl/async.rbs

@@ -0,0 +1,9 @@
+# Generated from lib/nl/async.rb with RBS::Inline
+
+module Nl
+  # Asynchronous request handling support.
+  module Async
+    class UnavailableError < StandardError
+    end
+  end
+end

data/sig/generated/nl/attribute_set.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/nl/attribute_set.rb with RBS::Inline
+
+module Nl
+  class AttributeSet
+    class Attribute < Struct[untyped]
+      attr_accessor value(): untyped
+
+      def self.new: (?untyped value) -> instance
+                  | (?value: untyped) -> instance
+    end
+
+    class Attribute
+      MULTI: bool
+
+      ORDER: untyped
+
+      SELECTOR_SLOT: untyped
+
+      def self.multi?: () -> untyped
+
+      def self.decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+
+      def encode: (untyped encoder, ?context: untyped) -> untyped
+    end
+
+    def initialize: (untyped attributes) -> untyped
+
+    def []: (untyped type) -> untyped
+
+    def <<: (untyped attr) -> untyped
+
+    SELECTOR_NAMES: untyped
+
+    private def encode1: (untyped encoder, untyped attr, untyped context) -> untyped
+
+    def encode: (untyped encoder, ?external_selectors: untyped) -> untyped
+
+    private def selector_name: (untyped error) -> untyped
+
+    private def self.decode1: (untyped decoder, untyped context) -> untyped
+
+    def self.decode: (untyped decoder, ?external_selectors: untyped) -> untyped
+
+    def self.build_attributes: (?untyped params, ?external_selectors: untyped, **untyped keywords) -> untyped
+
+    private def self.coerce: (untyped datatype, untyped value, untyped context) -> untyped
+
+    private def self.selector_name: (untyped error) -> untyped
+  end
+end

data/sig/generated/nl/bitfield32.rbs

@@ -0,0 +1,41 @@
+# Generated from lib/nl/bitfield32.rb with RBS::Inline
+
+module Nl
+  # A 32-bit value paired with a mask selecting the meaningful bits.
+  class Bitfield32
+    UINT32_RANGE: untyped
+
+    # A 32-bit flags
+    # @return [Integer]
+    attr_reader value: Integer
+
+    # A 32-bit mask selecting the meaningful bits
+    # @return [Integer]
+    attr_reader selector: Integer
+
+    # @param [Integer] value
+    # @param [Integer] selector
+    # @rbs (Integer value, Integer selector) -> void
+    def initialize: (Integer value, Integer selector) -> void
+
+    # Returns 1 or 0 for a selected bit, or nil for an unselected bit.
+    # @param [Integer] index Bits are indexed from the least significant bit, starting at zero.
+    # @return [0, 1, nil]
+    # @rbs (Integer index) -> (0 | 1 | nil)
+    def []: (Integer index) -> (0 | 1 | nil)
+
+    # Selects and sets or clears a bit. Assigning nil unselects it.
+    # @param [Integer] index Bits are indexed from the least significant bit, starting at zero.
+    # @param [0, 1, nil] state
+    # @rbs (Integer index, (0 | 1 | nil) state) -> (0 | 1 | nil)
+    def []=: (Integer index, 0 | 1 | nil state) -> (0 | 1 | nil)
+
+    # Converts a bit index to a bit mask
+    # @rbs (Integer index) -> Integer
+    private def bit_mask: (Integer index) -> Integer
+
+    # Validates if an Integer fits in uint32
+    # @rbs (Integer integer, Symbol name) -> void
+    private def validate_uint32: (Integer integer, Symbol name) -> void
+  end
+end

data/sig/generated/nl/blocking_transport.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/nl/blocking_transport.rb with RBS::Inline
+
+module Nl
+  # Drives one exchange at a time with blocking socket operations.
+  class BlockingTransport
+    class ConcurrentOperationError < StandardError
+    end
+
+    class UnexpectedSequenceError < StandardError
+      attr_reader expected: untyped
+
+      attr_reader actual: untyped
+
+      def initialize: (untyped expected, untyped actual) -> untyped
+    end
+
+    def initialize: (untyped socket, protocol: untyped, notifications: untyped) -> untyped
+
+    def exchange: (untyped endpoint, untyped kind, untyped request_class, untyped reply_class, untyped args) -> untyped
+
+    def async_capable?: () -> false
+
+    def receive_notification: (untyped endpoint, ?timeout: untyped) -> untyped
+
+    def close: () -> void
+
+    private def receive: (untyped endpoint, untyped expected_key, untyped reply_class) -> untyped
+
+    private def receive_notifications: () -> untyped
+
+    private def receive_datagram: () -> untyped
+  end
+end

data/sig/generated/nl/connection.rbs

@@ -0,0 +1,26 @@
+# Generated from lib/nl/connection.rb with RBS::Inline
+
+module Nl
+  # Owns one Netlink socket and the facilities shared by families using it.
+  class Connection
+    DEFAULT_NOTIFICATION_CAPACITY: ::Integer
+
+    def initialize: (protocol: untyped, ?executor: untyped, ?notification_capacity: untyped) -> untyped
+
+    def exchange: () -> untyped
+
+    def exchange_async: () -> untyped
+
+    def async_capable?: () -> untyped
+
+    def register_notifications: (untyped endpoint, untyped classes) -> untyped
+
+    def add_memberships: (untyped group_ids) -> untyped
+
+    def drop_memberships: (untyped group_ids) -> untyped
+
+    def receive_notification: (untyped endpoint, ?timeout: untyped) -> untyped
+
+    def close: () -> untyped
+  end
+end

data/sig/generated/nl/datagram.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/nl/datagram.rb with RBS::Inline
+
+module Nl
+  # Splits Netlink datagrams into aligned header/payload frames.
+  module Datagram
+    # @rbs (IO::Buffer buffer) { (Raw::NlMsgHdr, IO::Buffer) -> void } -> nil
+    #    | (IO::Buffer buffer) -> Enumerator[[Raw::NlMsgHdr, IO::Buffer], nil]
+    def self.each_frame: (IO::Buffer buffer) { (Raw::NlMsgHdr, IO::Buffer) -> void } -> nil
+                       | (IO::Buffer buffer) -> Enumerator[[ Raw::NlMsgHdr, IO::Buffer ], nil]
+  end
+end

data/sig/generated/nl/datatypes.rbs

@@ -0,0 +1,181 @@
+# Generated from lib/nl/datatypes.rb with RBS::Inline
+
+module Nl
+  interface _DataType
+    def encode: (Encoder, untyped, ?context: untyped) -> void
+
+    def decode: (Decoder, ?context: untyped, ?nlattr_type_flags: Integer) -> untyped
+
+    def nlattr_type_flags: (?untyped, ?context: untyped) -> Integer
+
+    def coerce: (untyped, ?context: untyped) -> untyped
+  end
+
+  module DataTypes
+    class Base
+      def initialize: (?check: untyped) -> untyped
+
+      def nlattr_type_flags: (?untyped _value, ?context: untyped) -> untyped
+
+      def coerce: (untyped value, ?context: untyped) -> untyped
+
+      private def checked: (untyped value) -> untyped
+    end
+
+    class Scalar < Base
+      def initialize: (untyped type, check: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class VariableInteger < Base
+      UINT32_RANGE: untyped
+
+      UINT64_RANGE: untyped
+
+      SINT32_RANGE: untyped
+
+      SINT64_RANGE: untyped
+
+      def initialize: (untyped byte_order, signed: untyped, check: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class String < Base
+      def initialize: (check: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class Binary < Base
+      def initialize: (check: untyped, ?length: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    # An array whose elements are packed consecutively without per-element
+    # headers or alignment padding.
+    class PackedArray < Base
+      def initialize: (untyped sub_type, ?check: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped values, ?context: untyped) -> untyped
+
+      def coerce: (untyped values, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class Struct < Base
+      def initialize: (untyped type, ?check: untyped, ?consume_remaining: untyped) -> untyped
+
+      def coerce: (untyped value, ?context: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class Flag < Base
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class Bitfield32 < Base
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class Pad < Base
+      def initialize: (?untyped length) -> untyped
+
+      def encode: (untyped encoder, untyped _value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+
+    class NestedAttributes < Base
+      def initialize: (untyped attribute_set, ?selector_bindings: untyped) -> untyped
+
+      def nlattr_type_flags: (?untyped _value, ?context: untyped) -> untyped
+
+      def coerce: (untyped value, ?context: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+
+      private def selectors: (untyped context) -> untyped
+    end
+
+    class SubMessage < Base
+      class Format < Data
+        attr_reader type(): untyped
+
+        attr_reader selector_bindings(): untyped
+
+        attr_reader nested(): untyped
+
+        def self.new: (untyped type, untyped selector_bindings, untyped nested) -> instance
+                    | (type: untyped, selector_bindings: untyped, nested: untyped) -> instance
+
+        def self.members: () -> [ :type, :selector_bindings, :nested ]
+
+        def members: () -> [ :type, :selector_bindings, :nested ]
+      end
+
+      def initialize: (untyped selector, untyped formats) -> untyped
+
+      def nlattr_type_flags: (?untyped value, context: untyped) -> untyped
+
+      def coerce: (untyped value, context: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, context: untyped, ?nlattr_type_flags: untyped) -> untyped
+
+      private def selectors: (untyped format, untyped context) -> untyped
+    end
+
+    # Nested attributes whose type numbers are keys rather than members of
+    # an attribute set. Each level is returned as an Integer-keyed Hash;
+    # values at the innermost level are decoded as @attribute_set.
+    class NestTypeValue < Base
+      def initialize: (untyped attribute_set, untyped levels, ?selector_bindings: untyped) -> untyped
+
+      def encode: (untyped encoder, untyped value, ?context: untyped) -> untyped
+
+      def coerce: (?untyped value, ?context: untyped, **untyped keywords) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+
+      private def encode_level: (untyped encoder, untyped values, untyped levels, untyped external_selectors) -> untyped
+
+      private def coerce_level: (untyped values, untyped levels, untyped external_selectors) -> untyped
+
+      private def decode_level: (untyped decoder, untyped levels, untyped external_selectors) -> untyped
+
+      private def selectors: (untyped context) -> untyped
+    end
+
+    class IndexedArray < Base
+      def initialize: (untyped sub_type) -> untyped
+
+      def encode: (untyped encoder, untyped values, ?context: untyped) -> untyped
+
+      def coerce: (untyped values, ?context: untyped) -> untyped
+
+      def decode: (untyped decoder, ?context: untyped, ?nlattr_type_flags: untyped) -> untyped
+    end
+  end
+end

data/sig/generated/nl/decoder.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/nl/decoder.rb with RBS::Inline
+
+module Nl
+  class Decoder
+    class Error < StandardError
+    end
+
+    class OutOfBounds < Error
+      def initialize: (?untyped message) -> untyped
+    end
+
+    class Unterminated < Error
+      def initialize: (?untyped message) -> untyped
+    end
+
+    def initialize: (untyped buffer, ?untyped offset, ?untyped length) -> untyped
+
+    def available?: (?untyped size) -> untyped
+
+    def remaining: () -> untyped
+
+    def limit: (untyped size) -> untyped
+
+    def skip: (?untyped length) -> untyped
+
+    def get_string: (?untyped length) -> untyped
+
+    def get_buffer: (?untyped length) -> untyped
+
+    def get_zstring: (?unterminated_ok: untyped) -> untyped
+
+    def get_value: (untyped type) -> untyped
+
+    def get_values: (untyped types) -> untyped
+
+    def align_to: (untyped alignment) -> untyped
+  end
+end

data/sig/generated/nl/encoder.rbs

@@ -0,0 +1,29 @@
+# Generated from lib/nl/encoder.rb with RBS::Inline
+
+module Nl
+  class Encoder
+    attr_reader position: untyped
+
+    def initialize: (?untyped capacity) -> untyped
+
+    def reserve: (untyped size) -> untyped
+
+    def put_string: (untyped value) -> untyped
+
+    def put_zstring: (untyped value) -> untyped
+
+    def put_value: (untyped type, untyped value) -> untyped
+
+    def put_values: (untyped types, untyped values) -> untyped
+
+    def align_to: (untyped alignment) -> untyped
+
+    def put_value_at: (untyped offset, untyped type, untyped value) -> untyped
+
+    def put_values_at: (untyped offset, untyped types, untyped values) -> untyped
+
+    def buffer: () -> untyped
+
+    def measure: (untyped type, ?untyped offset) -> untyped
+  end
+end

data/sig/generated/nl/endian.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/nl/endian.rb with RBS::Inline
+
+module Nl
+  module Endian
+    # sizeof(int)
+    SIZEOF_INT: untyped
+
+    # sizeof(long)
+    SIZEOF_LONG: untyped
+
+    # sizeof(long long)
+    SIZEOF_LLONG: untyped
+
+    # Little-endian scalar types.
+    module Little
+    end
+
+    # Big-endian scalar types.
+    module Big
+    end
+
+    # Host-endian scalar types.
+    #
+    # This module includes either {Little} or {Big} depending on the host's native byte order.
+    module Host
+    end
+  end
+end

data/sig/generated/nl/error.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/nl/error.rb with RBS::Inline
+
+module Nl
+  class Error < StandardError
+  end
+
+  class ProtocolViolation < Error
+  end
+
+  class ExhaustedSequenceNumber < Error
+  end
+
+  class TimeoutError < Error
+  end
+
+  class ClosedError < Error
+  end
+
+  class NotificationLossError < Error
+  end
+
+  class UnknownMulticastGroupError < Error
+  end
+
+  class UnresolvedMulticastGroupError < Error
+  end
+end