ciborium 0.1.0

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

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: ciborium
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sorah Fukumori
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.130
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.130
+description: A CBOR implementation backed by a Rust extension. Tags carry no meaning
+  unless an extension for them is allowlisted. Ships a compatibility layer for the
+  cbor gem's interface.
+email:
+- sorah@ivry.jp
+executables: []
+extensions:
+- ext/ciborium/extconf.rb
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- NOTICE.md
+- README.md
+- Rakefile
+- ext/ciborium/Cargo.lock
+- ext/ciborium/Cargo.toml
+- ext/ciborium/build.rs
+- ext/ciborium/extconf.rb
+- ext/ciborium/src/canonical.rs
+- ext/ciborium/src/cursor.rs
+- ext/ciborium/src/decode.rs
+- ext/ciborium/src/encode.rs
+- ext/ciborium/src/error.rs
+- ext/ciborium/src/lib.rs
+- ext/ciborium/src/scan.rs
+- lib/ciborium.rb
+- lib/ciborium/compat.rb
+- lib/ciborium/compat/buffer.rb
+- lib/ciborium/compat/errors.rb
+- lib/ciborium/compat/packer.rb
+- lib/ciborium/compat/unpacker.rb
+- lib/ciborium/decode_options.rb
+- lib/ciborium/decoder.rb
+- lib/ciborium/encode_options.rb
+- lib/ciborium/encoded.rb
+- lib/ciborium/encoder.rb
+- lib/ciborium/errors.rb
+- lib/ciborium/extensions.rb
+- lib/ciborium/extensions/bignum.rb
+- lib/ciborium/extensions/regexp.rb
+- lib/ciborium/extensions/time.rb
+- lib/ciborium/extensions/uri.rb
+- lib/ciborium/native.rb
+- lib/ciborium/replace.rb
+- lib/ciborium/simple.rb
+- lib/ciborium/tagged.rb
+- lib/ciborium/version.rb
+- sig/generated/ciborium.rbs
+- sig/generated/ciborium/compat.rbs
+- sig/generated/ciborium/compat/buffer.rbs
+- sig/generated/ciborium/compat/errors.rbs
+- sig/generated/ciborium/compat/packer.rbs
+- sig/generated/ciborium/compat/unpacker.rbs
+- sig/generated/ciborium/decode_options.rbs
+- sig/generated/ciborium/decoder.rbs
+- sig/generated/ciborium/encode_options.rbs
+- sig/generated/ciborium/encoded.rbs
+- sig/generated/ciborium/encoder.rbs
+- sig/generated/ciborium/errors.rbs
+- sig/generated/ciborium/extensions.rbs
+- sig/generated/ciborium/extensions/bignum.rbs
+- sig/generated/ciborium/extensions/regexp.rbs
+- sig/generated/ciborium/extensions/time.rbs
+- sig/generated/ciborium/extensions/uri.rbs
+- sig/generated/ciborium/native.rbs
+- sig/generated/ciborium/replace.rbs
+- sig/generated/ciborium/version.rbs
+- sig/manual/ciborium/extensions.rbs
+- sig/manual/ciborium/native.rbs
+- sig/manual/ciborium/tagged.rbs
+homepage: https://github.com/sorah/ciborium-ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/sorah/ciborium-ruby
+  source_code_uri: https://github.com/sorah/ciborium-ruby
+  changelog_uri: https://github.com/sorah/ciborium-ruby/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Memory-safe CBOR (RFC 8949) encoder and decoder with allowlisted tag extensions
+test_files: []