ciborium 0.1.0-x86_64-linux-gnu

data/sig/generated/ciborium/compat/unpacker.rbs

@@ -0,0 +1,59 @@
+# Generated from lib/ciborium/compat/unpacker.rb with RBS::Inline
+
+module Ciborium
+  module Compat
+    # CBOR::Unpacker of the cbor gem, reading through Ciborium::Decoder. Input passes through
+    # buffer, which also reads from io when more is needed.
+    class Unpacker
+      @buffer: Buffer
+
+      @decoder: Ciborium::Decoder
+
+      attr_reader buffer: Buffer
+
+      # options takes symbolize_keys, and the Buffer options.
+      #
+      # : (?untyped io, ?Hash[Symbol, untyped]? options) -> void
+      def initialize: (?untyped io, ?Hash[Symbol, untyped]? options) -> void
+
+      # : (String data) -> self
+      def feed: (String data) -> self
+
+      # : () -> untyped
+      def read: () -> untyped
+
+      # : () -> nil
+      def skip: () -> nil
+
+      # Whether the next item is null. Consumes nothing.
+      #
+      # : () -> bool
+      def skip_nil: () -> bool
+
+      # : () -> Integer
+      def read_array_header: () -> Integer
+
+      # : () -> Integer
+      def read_map_header: () -> Integer
+
+      # Yields each item until the input runs out, leaving a partial item buffered.
+      #
+      # : () { (untyped) -> void } -> nil
+      # : () -> Enumerator[untyped, nil]
+      def each: () { (untyped) -> void } -> nil
+              | () -> Enumerator[untyped, nil]
+
+      # : (String data) { (untyped) -> void } -> nil
+      def feed_each: (String data) { (untyped) -> void } -> nil
+
+      # : () -> nil
+      def reset: () -> nil
+
+      # Runs the block on the decoder, moving more input into it until the block stops raising
+      # IncompleteError or the input ends.
+      #
+      # : [T] () { () -> T } -> T
+      private def with_input: [T] () { () -> T } -> T
+    end
+  end
+end

data/sig/generated/ciborium/compat.rbs

@@ -0,0 +1,57 @@
+# Generated from lib/ciborium/compat.rb with RBS::Inline
+
+module Ciborium
+  # The interface of the cbor gem (CBOR), implemented on top of Ciborium. Tag extensions follow
+  # Compat.extensions, so a tag that is not allowlisted decodes to Tagged. require
+  # "ciborium/replace" to install it as CBOR.
+  module Compat
+    Tagged: untyped
+
+    Simple: untyped
+
+    # Nothing is allowlisted until the application opts in, as with Ciborium itself.
+    DEFAULT_EXTENSIONS: Array[extension]
+
+    self.@extensions: Array[extension]
+
+    # The extensions every Compat entry point uses, process-wide.
+    #
+    # : () -> Array[extension]
+    def self.extensions: () -> Array[extension]
+
+    # : (Array[extension] extensions) -> void
+    def self.extensions=: (Array[extension] extensions) -> void
+
+    # Options for Ciborium::Encoder that reproduce the cbor gem's encoding.
+    #
+    # : () -> Hash[Symbol, untyped]
+    def self.encode_options: () -> Hash[Symbol, untyped]
+
+    # Options for Ciborium::Decoder that reproduce the cbor gem's decoding.
+    #
+    # : () -> Hash[Symbol, untyped]
+    def self.decode_options: () -> Hash[Symbol, untyped]
+
+    # Encodes object, or writes it to io and returns nil when io is given.
+    #
+    # : (untyped object, ?untyped io) -> String?
+    def self.encode: (untyped object, ?untyped io) -> String?
+
+    # Decodes a single item from a String, or from all that an IO holds.
+    #
+    # options is {symbolize_keys: true}, or :keys_as_symbols.
+    #
+    # : (untyped source, ?(Hash[Symbol, untyped] | Symbol)? options) -> untyped
+    def self.decode: (untyped source, ?(Hash[Symbol, untyped] | Symbol)? options) -> untyped
+
+    # Encodes an object Ciborium cannot represent through its own to_cbor(packer), as the cbor
+    # gem does.
+    FALLBACK: ^(untyped) -> untyped
+
+    # to_cbor for the classes the cbor gem extends. Installed by ciborium/replace.
+    module CoreExt
+      # : (?untyped packer_or_io) -> untyped
+      def to_cbor: (?untyped packer_or_io) -> untyped
+    end
+  end
+end

data/sig/generated/ciborium/decode_options.rbs

@@ -0,0 +1,41 @@
+# Generated from lib/ciborium/decode_options.rb with RBS::Inline
+
+module Ciborium
+  DEFAULT_MAX_DEPTH: Integer
+
+  MAX_DEPTH_LIMIT: Integer
+
+  # Encoding rules a profile enforces beyond well-formedness. :ctap2 is the CTAP2 canonical CBOR
+  # encoding form that WebAuthn requires: no tags, no indefinite lengths, arguments in their
+  # shortest form, and map keys ordered without duplicates.
+  PROFILES: Array[Symbol]
+
+  # Decoding options, validated and packed into the arguments the native decoder takes.
+  class DecodeOptions < Data
+    attr_reader max_depth(): Integer
+
+    attr_reader flags(): Integer
+
+    attr_reader handlers(): Hash[Integer, ^(Integer, untyped) -> untyped]?
+
+    def self.new: (Integer max_depth, Integer flags, Hash[Integer, ^(Integer, untyped) -> untyped]? handlers) -> instance
+                | (max_depth: Integer, flags: Integer, handlers: Hash[Integer, ^(Integer, untyped) -> untyped]?) -> instance
+
+    def self.members: () -> [ :max_depth, :flags, :handlers ]
+
+    def members: () -> [ :max_depth, :flags, :handlers ]
+  end
+
+  class DecodeOptions
+    # extensions lists the allowlisted extensions (see Extensions); every other tag decodes to
+    # Tagged. profile rejects input that breaks one of PROFILES.
+    #
+    # : (?extensions: Array[extension], ?symbolize_keys: bool, ?max_depth: Integer, ?duplicate_keys: Symbol, ?profile: Symbol?) -> DecodeOptions
+    def self.build: (?extensions: Array[extension], ?symbolize_keys: bool, ?max_depth: Integer, ?duplicate_keys: Symbol, ?profile: Symbol?) -> DecodeOptions
+
+    # Returns whether profile is :ctap2.
+    #
+    # : (Symbol? profile, untyped extensions) -> bool
+    def self.check_profile: (Symbol? profile, untyped extensions) -> bool
+  end
+end

data/sig/generated/ciborium/decoder.rbs

@@ -0,0 +1,85 @@
+# Generated from lib/ciborium/decoder.rb with RBS::Inline
+
+module Ciborium
+  # Decodes data items from input that arrives in parts. Nothing is consumed until a whole item
+  # has arrived, so reads that raise IncompleteError can be retried after feeding more.
+  class Decoder
+    include Enumerable[untyped]
+
+    # Consumed bytes are dropped from the buffer once they exceed this size.
+    COMPACT_THRESHOLD: Integer
+
+    @scan_state: Native::ScanState
+
+    @pos: Integer
+
+    @buffer: String
+
+    @options: DecodeOptions
+
+    # Options are those of DecodeOptions.build.
+    #
+    # : (**untyped options) -> void
+    def initialize: (**untyped options) -> void
+
+    # : (String bytes) -> self
+    def feed: (String bytes) -> self
+
+    # Decodes the next item. Raises IncompleteError when it has not fully arrived.
+    #
+    # : () -> untyped
+    def read: () -> untyped
+
+    # Yields each item that has fully arrived, leaving a partial one buffered.
+    #
+    # : () { (untyped) -> void } -> self
+    # : () -> Enumerator[untyped, self]
+    def each: () { (untyped) -> void } -> self
+            | () -> Enumerator[untyped, self]
+
+    # Skips the next item without decoding it.
+    #
+    # : () -> self
+    def skip: () -> self
+
+    # Reads the head of a definite-length array and returns its length, leaving the elements to
+    # be read one by one.
+    #
+    # : () -> Integer
+    def read_array_header: () -> Integer
+
+    # Reads the head of a definite-length map and returns its number of pairs.
+    #
+    # : () -> Integer
+    def read_map_header: () -> Integer
+
+    # Whether the next item is null. Consumes nothing.
+    #
+    # : () -> bool
+    def next_nil?: () -> bool
+
+    # : () -> Integer
+    def buffered_bytes: () -> Integer
+
+    # Drops all buffered input.
+    #
+    # : () -> self
+    def reset: () -> self
+
+    # : () -> Integer
+    private def item_end: () -> Integer
+
+    # Moves to the next item, whose scan starts afresh.
+    #
+    # : (Integer pos) -> void
+    private def advance: (Integer pos) -> void
+
+    # : (Integer major, String name) -> Integer
+    private def read_container_head: (Integer major, String name) -> Integer
+
+    # The scan state is relative to @pos, so it stays valid.
+    #
+    # : () -> void
+    private def compact: () -> void
+  end
+end

data/sig/generated/ciborium/encode_options.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/ciborium/encode_options.rb with RBS::Inline
+
+module Ciborium
+  # Encoding options, validated into the arguments the native encoder takes.
+  class EncodeOptions < Data
+    attr_reader max_depth(): Integer
+
+    attr_reader flags(): Integer
+
+    attr_reader fallback(): Proc?
+
+    attr_reader class_handlers(): Array[[ Module, ^(untyped) -> untyped ]]?
+
+    def self.new: (Integer max_depth, Integer flags, Proc? fallback, Array[[ Module, ^(untyped) -> untyped ]]? class_handlers) -> instance
+                | (max_depth: Integer, flags: Integer, fallback: Proc?, class_handlers: Array[[ Module, ^(untyped) -> untyped ]]?) -> instance
+
+    def self.members: () -> [ :max_depth, :flags, :fallback, :class_handlers ]
+
+    def members: () -> [ :max_depth, :flags, :fallback, :class_handlers ]
+  end
+
+  class EncodeOptions
+    # extensions lists the allowlisted extensions (see Extensions). fallback is called with each
+    # object neither the encoder nor an extension can represent, and returns an object to encode
+    # in its place. profile makes the output follow one of PROFILES, sorting map keys.
+    #
+    # : (?extensions: Array[extension], ?max_depth: Integer, ?fallback: (^(untyped) -> untyped)?, ?profile: Symbol?) -> EncodeOptions
+    def self.build: (?extensions: Array[extension], ?max_depth: Integer, ?fallback: (^(untyped) -> untyped)?, ?profile: Symbol?) -> EncodeOptions
+
+    # : (^(untyped) -> untyped fallback) -> Proc
+    def self.wrap_fallback: (^(untyped) -> untyped fallback) -> Proc
+  end
+end

data/sig/generated/ciborium/encoded.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/ciborium/encoded.rb with RBS::Inline
+
+module Ciborium
+  # A data item that is already encoded, written out as-is by the encoder. The encoder checks
+  # that bytes hold exactly one well-formed item.
+  class Encoded < Data
+    attr_reader bytes(): String
+
+    def self.new: (String bytes) -> instance
+                | (bytes: String) -> instance
+
+    def self.members: () -> [ :bytes ]
+
+    def members: () -> [ :bytes ]
+  end
+end

data/sig/generated/ciborium/encoder.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/ciborium/encoder.rb with RBS::Inline
+
+module Ciborium
+  # Writes data items one after another into a buffer, for output built in parts.
+  class Encoder
+    @options: EncodeOptions
+
+    @buffer: String
+
+    # Options are those of EncodeOptions.build.
+    #
+    # : (**untyped options) -> void
+    def initialize: (**untyped options) -> void
+
+    # : (untyped object) -> self
+    def write: (untyped object) -> self
+
+    # Writes the head of an array whose length items the caller writes next.
+    #
+    # : (Integer length) -> self
+    def write_array_header: (Integer length) -> self
+
+    # Writes the head of a map whose length key-value pairs the caller writes next.
+    #
+    # : (Integer length) -> self
+    def write_map_header: (Integer length) -> self
+
+    # Writes a tag head; the caller writes the tag content next.
+    #
+    # : (Integer tag) -> self
+    def write_tag: (Integer tag) -> self
+
+    # A copy of everything written so far.
+    #
+    # : () -> String
+    def bytes: () -> String
+
+    # : () -> Integer
+    def size: () -> Integer
+
+    # : () -> bool
+    def empty?: () -> bool
+
+    # : () -> self
+    def clear: () -> self
+
+    # : (Integer major, Integer argument) -> self
+    private def write_head: (Integer major, Integer argument) -> self
+  end
+end

data/sig/generated/ciborium/errors.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/ciborium/errors.rb with RBS::Inline
+
+module Ciborium
+  class Error < StandardError
+  end
+
+  class DecodeError < Error
+  end
+
+  # The input is not well-formed CBOR, or breaks a rule the decoder enforces.
+  class MalformedError < DecodeError
+  end
+
+  # The input ends in the middle of a data item.
+  class IncompleteError < DecodeError
+  end
+
+  # Containers and tags are nested deeper than max_depth.
+  class DepthError < DecodeError
+  end
+
+  # An allowlisted extension failed to decode a tag's content. The cause holds the original error.
+  class ExtensionError < DecodeError
+  end
+
+  # A Decoder head reader found an item of another type.
+  class UnexpectedTypeError < DecodeError
+  end
+
+  class EncodeError < Error
+  end
+end

data/sig/generated/ciborium/extensions/bignum.rbs

@@ -0,0 +1,20 @@
+# Generated from lib/ciborium/extensions/bignum.rb with RBS::Inline
+
+module Ciborium
+  module Extensions
+    # Tags 2 and 3 (RFC 8949 section 3.4.3): integers outside -2**64..2**64-1 as byte strings.
+    class BigInteger
+      # : () -> Array[Integer]
+      def tags: () -> Array[Integer]
+
+      # : () -> Array[Module]
+      def classes: () -> Array[Module]
+
+      # : (Integer tag, untyped value) -> Integer
+      def decode: (Integer tag, untyped value) -> Integer
+
+      # : (Integer object) -> Tagged
+      def encode: (Integer object) -> Tagged
+    end
+  end
+end

data/sig/generated/ciborium/extensions/regexp.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/ciborium/extensions/regexp.rb with RBS::Inline
+
+module Ciborium
+  module Extensions
+    # Tag 35 as Regexp. Compiling a pattern from untrusted input risks ReDoS, so pass a timeout
+    # unless Regexp.timeout is set.
+    class Regexp
+      FLAGS: Integer
+
+      @timeout: Float?
+
+      # : (?timeout: Float?) -> void
+      def initialize: (?timeout: Float?) -> void
+
+      # : () -> Array[Integer]
+      def tags: () -> Array[Integer]
+
+      # : () -> Array[Module]
+      def classes: () -> Array[Module]
+
+      # : (Integer tag, untyped value) -> ::Regexp
+      def decode: (Integer tag, untyped value) -> ::Regexp
+
+      # Tag 35 has no place for flags, so a Regexp with any is refused rather than changed.
+      #
+      # : (::Regexp object) -> Tagged
+      def encode: (::Regexp object) -> Tagged
+    end
+  end
+end

data/sig/generated/ciborium/extensions/time.rbs

@@ -0,0 +1,22 @@
+# Generated from lib/ciborium/extensions/time.rb with RBS::Inline
+
+module Ciborium
+  module Extensions
+    # Tag 0 (RFC 3339 text) and tag 1 (seconds since the epoch) as Time.
+    class Time
+      # : () -> Array[Integer]
+      def tags: () -> Array[Integer]
+
+      # : () -> Array[Module]
+      def classes: () -> Array[Module]
+
+      # : (Integer tag, untyped value) -> ::Time
+      def decode: (Integer tag, untyped value) -> ::Time
+
+      # Whole seconds are written as an Integer, anything finer as a Float.
+      #
+      # : (::Time object) -> Tagged
+      def encode: (::Time object) -> Tagged
+    end
+  end
+end

data/sig/generated/ciborium/extensions/uri.rbs

@@ -0,0 +1,20 @@
+# Generated from lib/ciborium/extensions/uri.rb with RBS::Inline
+
+module Ciborium
+  module Extensions
+    # Tag 32 (RFC 8949 section 3.4.5.3) as URI.
+    class URI
+      # : () -> Array[Integer]
+      def tags: () -> Array[Integer]
+
+      # : () -> Array[Module]
+      def classes: () -> Array[Module]
+
+      # : (Integer tag, untyped value) -> ::URI::Generic
+      def decode: (Integer tag, untyped value) -> ::URI::Generic
+
+      # : (::URI::Generic object) -> Tagged
+      def encode: (::URI::Generic object) -> Tagged
+    end
+  end
+end

data/sig/generated/ciborium/extensions.rbs

@@ -0,0 +1,35 @@
+# Generated from lib/ciborium/extensions.rb with RBS::Inline
+
+module Ciborium
+  # Tag handling beyond Tagged, enabled per call through the extensions: option.
+  #
+  # An extension is any object that responds to:
+  #
+  # - tags: the tag numbers it decodes
+  # - classes: the classes whose instances it encodes
+  # - decode(tag, value): the object for a tag's decoded content
+  # - encode(object): an object to encode in place of object, typically a Tagged
+  #
+  # Symbols name the built-in extensions.
+  module Extensions
+    BUILTIN: Hash[Symbol, String]
+
+    # Resolves Symbols to the built-in extensions and checks every entry is an extension.
+    #
+    # : (untyped extensions) -> Array[_Extension]
+    def self.resolve: (untyped extensions) -> Array[_Extension]
+
+    # Maps each tag to a callable that wraps the extension's failures in ExtensionError.
+    #
+    # : (Array[_Extension] extensions) -> Hash[Integer, ^(Integer, untyped) -> untyped]?
+    def self.tag_handlers: (Array[_Extension] extensions) -> Hash[Integer, ^(Integer, untyped) -> untyped]?
+
+    # Pairs each class with a callable that wraps the extension's failures in EncodeError.
+    #
+    # : (Array[_Extension] extensions) -> Array[[Module, ^(untyped) -> untyped]]?
+    def self.class_handlers: (Array[_Extension] extensions) -> Array[[ Module, ^(untyped) -> untyped ]]?
+
+    # : (Symbol name) -> _Extension
+    def self.builtin: (Symbol name) -> _Extension
+  end
+end

data/sig/generated/ciborium/native.rbs

@@ -0,0 +1,10 @@
+# Generated from lib/ciborium/native.rb with RBS::Inline
+
+module Ciborium
+  module Native
+    # Called by the encoder for text in an encoding other than UTF-8 or US-ASCII.
+    #
+    # : (String string) -> String
+    def self.transcode: (String string) -> String
+  end
+end

data/sig/generated/ciborium/replace.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/ciborium/replace.rb with RBS::Inline
+
+module Ciborium
+  module Compat
+    # Classes the cbor gem gives to_cbor. URI::Generic is included when URI is loaded.
+    CORE_EXT_CLASSES: Array[Module]
+
+    # Constants of the cbor gem that CBOR carries.
+    CBOR_CONSTANTS: Array[Symbol]
+
+    # Module functions of the cbor gem that CBOR carries.
+    CBOR_FUNCTIONS: Array[Symbol]
+
+    self.@facade: Module?
+
+    # The frozen module installed as CBOR. It delegates to Compat rather than being Compat, so the
+    # cbor gem's extension, should it load anyway, fails on reopening it instead of replacing
+    # Compat's methods with its own.
+    #
+    # : () -> Module
+    def self.facade: () -> Module
+
+    # Marks every file of the installed cbor gems that require "cbor" could load as loaded.
+    #
+    # : () -> void
+    def self.block_cbor_gem: () -> void
+
+    # The cbor gem's entry point and extension: as found on the load path, and in every
+    # installed version, since RubyGems may activate any of them later.
+    #
+    # : () -> Array[String]
+    def self.cbor_gem_features: () -> Array[String]
+
+    # : () -> void
+    def self.install: () -> void
+  end
+end

data/sig/generated/ciborium/version.rbs

@@ -0,0 +1,5 @@
+# Generated from lib/ciborium/version.rb with RBS::Inline
+
+module Ciborium
+  VERSION: String
+end

data/sig/generated/ciborium.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/ciborium.rb with RBS::Inline
+
+# A CBOR (RFC 8949) encoder and decoder. Tags carry no meaning unless an extension for them is
+# allowlisted.
+module Ciborium
+  # Encodes object into a binary String.
+  #
+  # Options are those of EncodeOptions.build.
+  #
+  # : (untyped object, **untyped options) -> String
+  def self.encode: (untyped object, **untyped options) -> String
+
+  # Decodes a single data item. Raises MalformedError when bytes follow it.
+  #
+  # Options are those of DecodeOptions.build.
+  #
+  # : (String bytes, **untyped options) -> untyped
+  def self.decode: (String bytes, **untyped options) -> untyped
+
+  # Decodes the data item at the start of bytes and returns it with the number of bytes it took,
+  # leaving whatever follows unread.
+  #
+  # : (String bytes, **untyped options) -> [untyped, Integer]
+  def self.decode_prefix: (String bytes, **untyped options) -> [ untyped, Integer ]
+
+  # Decodes a CBOR sequence (RFC 8742), a concatenation of zero or more data items.
+  #
+  # : (String bytes, **untyped options) -> Array[untyped]
+  def self.decode_sequence: (String bytes, **untyped options) -> Array[untyped]
+end

data/sig/manual/ciborium/extensions.rbs

@@ -0,0 +1,12 @@
+# Hand-written because rbs-inline cannot declare interfaces or type aliases.
+module Ciborium
+  interface _Extension
+    def tags: () -> Array[Integer]
+    def classes: () -> Array[Module]
+    def decode: (Integer tag, untyped value) -> untyped
+    def encode: (untyped object) -> untyped
+    def inspect: () -> String
+  end
+
+  type extension = Symbol | _Extension
+end

data/sig/manual/ciborium/native.rbs

@@ -0,0 +1,23 @@
+# Defined by the Rust extension under ext/ciborium, which rbs-inline cannot read.
+module Ciborium
+  module Native
+    FLAG_SYMBOLIZE_KEYS: Integer
+    FLAG_LAST_WINS: Integer
+    FLAG_CTAP2: Integer
+
+    def self.decode: (String input, Integer offset, Integer max_depth, Integer flags, Hash[Integer, ^(Integer, untyped) -> untyped]? handlers) -> [untyped, Integer]
+
+    def self.encode: (untyped value, Integer max_depth, Integer flags, Proc? fallback, Array[[Module, ^(untyped) -> untyped]]? class_handlers) -> String
+
+    def self.scan: (String input, Integer offset, Integer max_depth, ScanState state) -> Integer?
+
+    # Progress of scanning one incomplete item, carried between scans.
+    class ScanState
+      def clear: () -> void
+    end
+
+    def self.read_head: (String input, Integer offset) -> [Integer, Integer?, Integer]?
+
+    def self.encode_head: (Integer major, Integer argument) -> String
+  end
+end

data/sig/manual/ciborium/tagged.rbs

@@ -0,0 +1,25 @@
+# Hand-written because Tagged and Simple override the Data constructor to validate.
+module Ciborium
+  class Tagged < Data
+    MAX_TAG: Integer
+
+    attr_reader tag: Integer
+    attr_reader value: untyped
+
+    def self.new: (Integer tag, untyped value) -> Tagged
+                | (tag: Integer, value: untyped) -> Tagged
+
+    def initialize: (tag: Integer, value: untyped) -> void
+  end
+
+  class Simple < Data
+    attr_reader value: Integer
+
+    def self.new: (Integer value) -> Simple
+                | (value: Integer) -> Simple
+
+    def initialize: (value: Integer) -> void
+  end
+
+  UNDEFINED: Simple
+end