smithy-cbor 1.0.0.pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cad452fa4f5b9fee884f71ccf900eb6e2f0a74ca6e4cd45583e9efdc618cf461
+  data.tar.gz: 3b62d399313458de8786f5b3148fa23cb2487967acaf5ce26bdbe291153abd28
+SHA512:
+  metadata.gz: 4674b1fe815460d442e3e06e1b1ac9b6b8b9d07d5a21ddc5fc807efbb65dd11ce5564f10cba95c473d5c9beafbafab264507e0b9cd7c968e7ddab15e5bae6199
+  data.tar.gz: aa410cf7523ea7f2af0524e4f23b06a1331efd4012bc5b2b9c89973239faea89c55a7b06c4fddf590f5fba52189e7dee2058334edd96f6c1b5aaaee624a383f2

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+Unreleased Changes
+------------------
+
+* Feature - Initial version of this gem.

data/VERSION

@@ -0,0 +1 @@
+1.0.0.pre1

data/lib/smithy-cbor/codec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'deserializer'
+require_relative 'serializer'
+
+module Smithy
+  module CBOR
+    # Codec that serializes and deserializes in CBOR format.
+    class Codec
+      # @param [Hash] options
+      def initialize(options = {})
+        @options = options
+      end
+
+      # @param [Shape] shape
+      # @param [Object] data
+      # @return [String, nil]
+      def serialize(shape, data)
+        Serializer.new(@options).serialize(shape, data)
+      end
+
+      # @param [Shape] shape
+      # @param [String] bytes
+      # @param [Object] target
+      # @return [Object]
+      def deserialize(shape, bytes, target = nil)
+        Deserializer.new(@options).deserialize(shape, bytes, target)
+      end
+    end
+  end
+end

data/lib/smithy-cbor/decoder.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Smithy
+  module CBOR
+    # @api private
+    class Decoder # rubocop:disable Metrics/ClassLength
+      FIVE_BIT_MASK = 0x1F
+      TAG_TYPE_EPOCH = 1
+      TAG_TYPE_BIGNUM = 2
+      TAG_TYPE_NEG_BIGNUM = 3
+      TAG_TYPE_BIGDEC = 4
+
+      def initialize(bytes)
+        @buffer = bytes
+        @pos = 0
+      end
+
+      def decode
+        return nil if @buffer.nil? || @buffer.empty?
+
+        val = decode_item
+        return val unless @pos != @buffer.size
+
+        raise ExtraBytesError.new(@pos, @buffer.size)
+      end
+
+      private
+
+      # high level, generic decode. Based on the next type.
+      # Consumes and returns the next item as a ruby object.
+      # rubocop:disable Metrics
+      def decode_item
+        case (next_type = peek_type)
+        when :array
+          read_array.times.map { decode_item }
+        when :map
+          read_map.times.to_h { [read_string, decode_item] }
+        when :indefinite_array then process_indefinite_array
+        when :indefinite_map then process_indefinite_map
+        when :indefinite_binary_string then process_indefinite_binary
+        when :indefinite_string then process_indefinite_string
+        when :tag then process_tag
+        when :break_stop_code then raise UnexpectedBreakCodeError
+        else send("read_#{next_type}")
+        end
+      end
+      # rubocop:enable Metrics
+
+      def peek(n_bytes)
+        return @buffer[@pos, n_bytes] if (@pos + n_bytes) <= @buffer.bytesize
+
+        raise OutOfBytesError.new(n_bytes, @buffer.bytesize - @pos)
+      end
+
+      # low level streaming interface
+      # rubocop:disable Metrics
+      def peek_type
+        ib = peek(1).ord
+        add_info = ib & FIVE_BIT_MASK
+        major_type = ib >> 5
+        case major_type
+        when 0, 1 then :integer
+        when 2
+          add_info == 31 ? :indefinite_binary_string : :binary_string
+        when 3
+          add_info == 31 ? :indefinite_string : :string
+        when 4
+          add_info == 31 ? :indefinite_array : :array
+        when 5
+          add_info == 31 ? :indefinite_map : :map
+        when 6 then :tag
+        when 7 then process_major_type_simple(add_info)
+        end
+      end
+
+      # simple or float
+      def process_major_type_simple(add_info)
+        case add_info
+        when 20, 21 then :boolean
+        when 22 then :nil
+        when 23 then :undefined # for smithy, this should be parsed as nil
+        when 25 then :half
+        when 26 then :float
+        when 27 then :double
+        when 31 then :break_stop_code
+        else :reserved_undefined
+        end
+      end
+      # rubocop:enable Metrics
+
+      def process_indefinite_array
+        read_start_indefinite_array
+        value = []
+        value << decode_item until peek_type == :break_stop_code
+        read_end_indefinite_collection
+        value
+      end
+
+      def process_indefinite_binary
+        read_info
+        value = String.new
+        value << read_binary_string until peek_type == :break_stop_code
+        read_end_indefinite_collection
+        value
+      end
+
+      def process_indefinite_map
+        read_start_indefinite_map
+        value = {}
+        value[read_string] = decode_item until peek_type == :break_stop_code
+        read_end_indefinite_collection
+        value
+      end
+
+      def process_indefinite_string
+        read_info
+        value = String.new
+        value << read_string until peek_type == :break_stop_code
+        read_end_indefinite_collection
+        value.force_encoding(Encoding::UTF_8)
+      end
+
+      def process_tag
+        case (tag = read_tag)
+        when TAG_TYPE_EPOCH
+          item = decode_item
+          Time.at(item)
+        when TAG_TYPE_BIGNUM, TAG_TYPE_NEG_BIGNUM
+          read_bignum(tag)
+        when TAG_TYPE_BIGDEC
+          read_big_decimal
+        else
+          Tagged.new(tag, decode_item)
+        end
+      end
+
+      # returns only the length of the array, caller must read the correct
+      # number of values after this
+      def read_array
+        _major_type, add_info = read_info
+        read_count(add_info)
+      end
+
+      # A decimal fraction or a bigfloat is represented as a tagged array
+      # that contains exactly two integer numbers:
+      # an exponent e and a mantissa m
+      # See: https://www.rfc-editor.org/rfc/rfc8949.html#name-decimal-fractions-and-bigfl
+      def read_big_decimal
+        unless (s = read_array) == 2
+          raise Error, "Expected array of length 2 but length is: #{s}"
+        end
+
+        e = read_integer
+        m = read_integer
+        BigDecimal(m) * (BigDecimal(10)**BigDecimal(e))
+      end
+
+      # tag type 2 or 3
+      def read_bignum(tag_value)
+        _major_type, add_info = read_info
+        bstr = take(read_count(add_info))
+        v = bstr.bytes.inject(0) do |sum, b|
+          sum <<= 8
+          sum + b
+        end
+        case tag_value
+        when 2 then v
+        when 3 then -1 - v
+        end
+      end
+
+      def read_boolean # rubocop:disable Naming/PredicateMethod
+        _major_type, add_info = read_info
+        case add_info
+        when 20 then false
+        when 21 then true
+        end
+      end
+
+      def read_binary_string
+        _major_type, add_info = read_info
+        take(read_count(add_info)).force_encoding(Encoding::BINARY)
+      end
+
+      def read_count(add_info)
+        case add_info
+        when 0..23 then add_info
+        when 24 then take(1).ord
+        when 25 then take(2).unpack1('n')
+        when 26 then take(4).unpack1('N')
+        when 27 then take(8).unpack1('Q>')
+        else raise UnexpectedAdditionalInformationError, add_info
+        end
+      end
+
+      def read_double
+        read_info
+        take(8).unpack1('G')
+      end
+
+      # returns nothing but consumes and checks the type/info.
+      def read_end_indefinite_collection
+        read_info
+      end
+
+      def read_float
+        read_info
+        take(4).unpack1('g')
+      end
+
+      # 16 bit IEEE 754 half-precision floats
+      # Support decoding only
+      # format:
+      # sign - 1 bit
+      # exponent - 5 bits
+      # precision - 10 bits
+      def read_half
+        read_info
+        b16 = take(2).unpack1('n')
+        exp = (b16 >> 10) & 0x1f
+        mant = b16 & 0x3ff
+        val =
+          case exp
+          when 0
+            Math.ldexp(mant, -24)
+          when 31
+            mant.zero? ? Float::INFINITY : Float::NAN
+          else
+            # exp bias is 15, but to use ldexp we divide
+            # by 1024 (2^10) to get exp-15-10
+            Math.ldexp(1024 + mant, exp - 25)
+          end
+        if b16[15].zero?
+          val
+        else
+          -val
+        end
+      end
+
+      # return a tuple of major_type, add_info
+      def read_info
+        ib = take(1).ord
+        [ib >> 5, ib & FIVE_BIT_MASK]
+      end
+
+      def read_integer
+        major_type, add_info = read_info
+
+        val = read_count(add_info)
+        case major_type
+        when 0 then val
+        when 1 then -1 - val
+        end
+      end
+
+      def read_nil
+        read_info
+        nil
+      end
+
+      # returns only the length of the array, caller must read the correct
+      # number of key value pairs after this
+      def read_map
+        _major_type, add_info = read_info
+        read_count(add_info)
+      end
+
+      # returns nothing but consumes and checks the type/info.
+      # Caller must keep reading until encountering the stop sequence
+      def read_start_indefinite_array
+        read_info
+      end
+
+      # returns nothing but consumes and checks the type/info.
+      # Caller must keep reading until encountering the stop sequence
+      def read_start_indefinite_map
+        read_info
+      end
+
+      def read_string
+        _major_type, add_info = read_info
+        take(read_count(add_info)).force_encoding(Encoding::UTF_8)
+      end
+
+      # returns only the tag, caller must interpret the tag and read another
+      # value as appropriate
+      def read_tag
+        _major_type, add_info = read_info
+        read_count(add_info)
+      end
+
+      def read_reserved_undefined
+        _major_type, add_info = read_info
+        raise Error, "Undefined reserved additional information: #{add_info}"
+      end
+
+      def read_undefined
+        read_info
+        :undefined
+      end
+
+      def take(n_bytes)
+        opos = @pos
+        @pos += n_bytes
+
+        return @buffer[opos, n_bytes] if @pos <= @buffer.bytesize
+
+        raise OutOfBytesError.new(n_bytes, @buffer.bytesize - @pos)
+      end
+    end
+  end
+end

data/lib/smithy-cbor/deserializer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Smithy
+  module CBOR
+    # @api private
+    class Deserializer
+      include Schema::Shapes
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def deserialize(shape, bytes, target)
+        return {} if bytes.empty?
+
+        ref = shape.is_a?(ShapeRef) ? shape : ShapeRef.new(shape: shape)
+        shape(ref, CBOR.decode(bytes), target)
+      end
+
+      private
+
+      def shape(ref, value, target = nil)
+        return nil if value.nil?
+
+        case ref.shape
+        when ListShape then list(ref, value, target)
+        when MapShape then map(ref, value, target)
+        when StructureShape then structure(ref, value, target)
+        when UnionShape then union(ref, value, target)
+        else value
+        end
+      end
+
+      def list(ref, values, target = nil)
+        target = [] if target.nil?
+        values.each do |value|
+          next if value.nil? && !sparse?(ref.shape)
+
+          target << shape(ref.shape.member, value)
+        end
+        target
+      end
+
+      def map(ref, values, target = nil)
+        target = {} if target.nil?
+        values.each do |key, value|
+          next if value.nil? && !sparse?(ref.shape)
+
+          target[key] = shape(ref.shape.value, value)
+        end
+        target
+      end
+
+      def structure(ref, values, target = nil)
+        target = ref.shape.type.new if target.nil?
+        ref.shape.members.each do |member_name, member_ref|
+          value = values[member_ref.member_name]
+          target[member_name] = shape(member_ref, value) unless value.nil?
+        end
+        target
+      end
+
+      def union(ref, values, target = nil) # rubocop:disable Metrics/AbcSize
+        ref.shape.members.each do |member_name, member_ref|
+          value = values[member_ref.member_name]
+          next if value.nil?
+
+          target = ref.shape.member_type(member_name) if target.nil?
+          return target.new(member_name => shape(member_ref, value))
+        end
+
+        values.delete('__type')
+        key, value = values.first
+        ref.shape.member_type(:unknown).new(unknown: { key => value })
+      end
+
+      def sparse?(shape)
+        shape.traits.key?('smithy.api#sparse')
+      end
+    end
+  end
+end

data/lib/smithy-cbor/encoder.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Smithy
+  module CBOR
+    # @api private
+    class Encoder
+      MAJOR_TYPE_UNSIGNED_INT = 0x00 # 000_00000 - Major Type 0 - unsigned int
+      MAJOR_TYPE_NEGATIVE_INT = 0x20 # 001_00000 - Major Type 1 - negative int
+      MAJOR_TYPE_BYTE_STR = 0x40 # 010_00000 - Major Type 2 (Byte String)
+      MAJOR_TYPE_STR = 0x60 # 011_00000 - Major Type 3 (Text String)
+      MAJOR_TYPE_ARRAY = 0x80 # 100_00000 - Major Type 4 (Array)
+      MAJOR_TYPE_MAP = 0xa0 # 101_00000 - Major Type 5 (Map)
+      MAJOR_TYPE_TAG = 0xc0 # 110_00000 - Major type 6 (Tag)
+      MAJOR_TYPE_SIMPLE = 0xe0 # 111_00000 - Major type 7 (111) + 5 bit 0
+
+      FLOAT_BYTES = 0xfa # 111_11010 - Major type 7 (Float) + value: 26
+      DOUBLE_BYTES = 0xfb # 111_ 11011 - Major type 7 (Float) + value: 26
+
+      # https://www.rfc-editor.org/rfc/rfc8949.html#tags
+      TAG_TYPE_EPOCH = 1
+      TAG_BIGNUM_BASE = 2
+      TAG_TYPE_BIGDEC = 4
+
+      MAX_INTEGER = 18_446_744_073_709_551_616 # 2^64
+
+      def initialize
+        @buffer = String.new
+      end
+
+      # @return the encoded bytes in CBOR format for all added data
+      def bytes
+        @buffer
+      end
+
+      # generic method for adding generic Ruby data based on its type
+      # rubocop:disable Metrics
+      def add(value)
+        case value
+        when BigDecimal then add_big_decimal(value)
+        when Integer then add_auto_integer(value)
+        when Numeric then add_auto_float(value)
+        when Symbol then add_string(value.to_s)
+        when true, false then add_boolean(value)
+        when nil then add_nil
+        when Tagged then process_tag(value)
+        when String then process_string(value)
+        when Array then add_array(value)
+        when Hash then add_hash(value)
+        when Time then add_time(value)
+        else raise UnknownTypeError, value
+        end
+        self
+      end
+      # rubocop:enable Metrics
+
+      private
+
+      def add_array(value)
+        start_array(value.size)
+        value.each { |di| add(di) }
+      end
+
+      def add_auto_float(value)
+        if value.nan?
+          @buffer << FLOAT_BYTES << [value].pack('g')
+        else
+          ss = [value].pack('g') # single-precision
+          if ss.unpack1('g') == value
+            @buffer << FLOAT_BYTES << ss
+          else
+            @buffer << [DOUBLE_BYTES, value].pack('CG') # double-precision
+          end
+        end
+      end
+
+      def add_auto_integer(value)
+        major_type =
+          if value.negative?
+            value = -1 - value
+            MAJOR_TYPE_NEGATIVE_INT
+          else
+            MAJOR_TYPE_UNSIGNED_INT
+          end
+
+        if value >= MAX_INTEGER
+          s = bignum_to_bytes(value)
+          head(MAJOR_TYPE_TAG, TAG_BIGNUM_BASE + (major_type >> 5))
+          head(MAJOR_TYPE_BYTE_STR, s.bytesize)
+          @buffer << s
+        else
+          head(major_type, value)
+        end
+      end
+
+      # A decimal fraction or a bigfloat is represented as a tagged array
+      # that contains exactly two integer numbers:
+      # an exponent e and a mantissa m
+      # decimal fractions are always represented with a base of 10
+      # See: https://www.rfc-editor.org/rfc/rfc8949.html#name-decimal-fractions-and-bigfl
+      def add_big_decimal(value)
+        if value.infinite? == 1
+          return add_float(value.infinite? * Float::INFINITY)
+        elsif value.nan?
+          return add_float(Float::NAN)
+        end
+
+        head(MAJOR_TYPE_TAG, TAG_TYPE_BIGDEC)
+        sign, digits, _base, exp = value.split
+        # Ruby BigDecimal digits of XXX are used as 0.XXX, convert
+        exp -= digits.size
+        digits = sign * digits.to_i
+        start_array(2)
+        add_auto_integer(exp)
+        add_auto_integer(digits)
+      end
+
+      def add_boolean(value)
+        value ? head(MAJOR_TYPE_SIMPLE, 21) : head(MAJOR_TYPE_SIMPLE, 20)
+      end
+
+      # Encoding MUST already be Encoding::BINARY
+      def add_byte_string(value)
+        head(MAJOR_TYPE_BYTE_STR, value.bytesize)
+        @buffer << value
+      end
+
+      def add_double(value)
+        @buffer << [DOUBLE_BYTES, value].pack('CG') # double-precision
+      end
+
+      def add_float(value)
+        @buffer << [FLOAT_BYTES, value].pack('Cg') # single-precision
+      end
+
+      def add_hash(value)
+        start_map(value.size)
+        value.each do |k, v|
+          add(k)
+          add(v)
+        end
+      end
+
+      def add_nil
+        head(MAJOR_TYPE_SIMPLE, 22)
+      end
+
+      def add_string(value)
+        value = value.encode(Encoding::UTF_8).force_encoding(Encoding::BINARY)
+        head(MAJOR_TYPE_STR, value.bytesize)
+        @buffer << value
+      end
+
+      def add_tag(tag)
+        head(MAJOR_TYPE_TAG, tag)
+      end
+
+      def add_time(value)
+        head(MAJOR_TYPE_TAG, TAG_TYPE_EPOCH)
+        epoch = value.to_f
+        add_double(epoch)
+      end
+
+      def bignum_to_bytes(value)
+        s = String.new
+        while value != 0
+          s << (value & 0xFF)
+          value >>= 8
+        end
+        s.reverse!
+      end
+
+      def head(major_type, value)
+        @buffer <<
+          case value
+          when 0...24
+            [major_type + value].pack('C') # 8-bit unsigned
+          when 0...256
+            [major_type + 24, value].pack('CC')
+          when 0...65_536
+            [major_type + 25, value].pack('Cn')
+          when 0...4_294_967_296
+            [major_type + 26, value].pack('CN')
+          when 0...MAX_INTEGER
+            [major_type + 27, value].pack('CQ>')
+          else
+            raise Error, "Value is too large to encode: #{value}"
+          end
+      end
+
+      def process_string(value)
+        if value.encoding == Encoding::BINARY
+          add_byte_string(value)
+        else
+          add_string(value)
+        end
+      end
+
+      def process_tag(value)
+        add_tag(value.tag)
+        add(value.value)
+      end
+
+      # caller is responsible for adding length values
+      def start_array(length)
+        head(MAJOR_TYPE_ARRAY, length)
+      end
+
+      # caller is responsible for adding length key/value pairs
+      def start_map(length)
+        head(MAJOR_TYPE_MAP, length)
+      end
+    end
+  end
+end

data/lib/smithy-cbor/serializer.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Smithy
+  module CBOR
+    # @api private
+    class Serializer
+      include Schema::Shapes
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def serialize(shape, data)
+        ref = shape.is_a?(ShapeRef) ? shape : ShapeRef.new(shape: shape)
+        return if ref.shape == Prelude::Unit
+
+        CBOR.encode(shape(ref, data))
+      end
+
+      private
+
+      def shape(ref, value)
+        case ref.shape
+        when BlobShape then blob(value)
+        when ListShape then list(ref, value)
+        when MapShape then map(ref, value)
+        when StructureShape then structure(ref, value)
+        when UnionShape then union(ref, value)
+        else value
+        end
+      end
+
+      def blob(value)
+        value.respond_to?(:read) ? value.read : value
+      end
+
+      def list(ref, values)
+        return if values.nil?
+
+        shape = ref.shape
+        values.collect do |value|
+          shape(shape.member, value)
+        end
+      end
+
+      def map(ref, values)
+        return if values.nil?
+
+        shape = ref.shape
+        values.each.with_object({}) do |(key, value), data|
+          data[key] = shape(shape.value, value)
+        end
+      end
+
+      def structure(ref, values)
+        return if values.nil?
+
+        ref.shape.members.each_with_object({}) do |(member_name, member_ref), data|
+          value = values[member_name]
+          next if value.nil?
+
+          data[member_ref.member_name] = shape(member_ref, value)
+        end
+      end
+
+      def union(ref, values) # rubocop:disable Metrics/AbcSize
+        return if values.nil?
+
+        data = {}
+        if values.is_a?(Schema::Union)
+          _name, member_ref = ref.shape.member_by_type(values.class)
+          data[member_ref.member_name] = shape(member_ref, values.value)
+        else
+          key, value = values.first
+          if ref.shape.member?(key)
+            member_ref = ref.shape.member(key)
+            data[member_ref.member_name] = shape(member_ref, value)
+          end
+        end
+        data
+      end
+    end
+  end
+end

data/lib/smithy-cbor.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'smithy-schema'
+
+require_relative 'smithy-cbor/codec'
+require_relative 'smithy-cbor/decoder'
+require_relative 'smithy-cbor/encoder'
+
+module Smithy
+  # Smithy::CBOR is a purpose-built set of utilities for working with CBOR.
+  # It does not support all features of generic CBOR parsing and serialization.
+  module CBOR
+    VERSION = File.read(File.expand_path('../VERSION', __dir__.to_s)).strip
+
+    # CBOR Tagged data (Major type 6).
+    # A Tag consists of a tag number and a value.
+    # In the extended generic data model, a tag number's definition
+    # describes the additional semantics conveyed with the tag number.
+    class Tagged
+      # @param [Integer] tag The tag number.
+      # @param [Object] value The tag's content.
+      def initialize(tag, value)
+        @tag = tag
+        @value = value
+      end
+
+      # The tag number.
+      # @return [Integer]
+      attr_accessor :tag
+
+      # The tag's content.
+      # @return [Object]
+      attr_accessor :value
+    end
+
+    # Generic CBOR error, super class for specific encode/decode related errors.
+    class Error < StandardError; end
+
+    # Malformed buffer, expected more bytes
+    class OutOfBytesError < Error
+      def initialize(requested_bytes, left)
+        super("Out of bytes. Trying to read #{requested_bytes} bytes but buffer contains only #{left}")
+      end
+    end
+
+    # unknown or unsupported typed
+    class UnknownTypeError < Error
+      def initialize(type)
+        super("Unable to encode #{type}")
+      end
+    end
+
+    # Malformed buffer, more bytes than expected
+    class ExtraBytesError < Error
+      def initialize(pos, size)
+        super("Extra bytes follow after decoding item. Read #{pos} / #{size} bytes")
+      end
+    end
+
+    # Malformed buffer, unexpected break code
+    class UnexpectedBreakCodeError < Error; end
+
+    # malformed buffer, unexpected additional information
+    class UnexpectedAdditionalInformationError < Error
+      def initialize(add_info)
+        super("Unexpected additional information: #{add_info}")
+      end
+    end
+
+    class << self
+      # @param [nil, BigDecimal, Time, Tagged, String, Hash, Array] data
+      # @return [String] bytes
+      def encode(data)
+        Encoder.new.add(data).bytes
+      end
+
+      # @param [String] bytes
+      # @return [nil, BigDecimal, Time, Tagged, String, Hash, Array]
+      def decode(bytes)
+        Decoder.new(bytes.force_encoding(Encoding::BINARY)).decode
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: smithy-cbor
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre1
+platform: ruby
+authors:
+- Amazon Web Services
+bindir: bin
+cert_chain: []
+date: 2025-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: smithy-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.pre1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.pre1
+description: Smithy is a code generation toolkit for creating Client and Server SDKs
+  from Smithy models.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- VERSION
+- lib/smithy-cbor.rb
+- lib/smithy-cbor/codec.rb
+- lib/smithy-cbor/decoder.rb
+- lib/smithy-cbor/deserializer.rb
+- lib/smithy-cbor/encoder.rb
+- lib/smithy-cbor/serializer.rb
+homepage: https://github.com/smithy-lang/smithy-ruby
+licenses:
+- Apache-2.0
+metadata: {}
+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: 3.6.2
+specification_version: 4
+summary: CBOR utilities and codec for Smithy generated clients and servers
+test_files: []