smithy-json 1.0.0.pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7d10d334459b5725b2db3bff1f85606f48557787d60c130b850e1aef10c77b3d
+  data.tar.gz: 43dde2a55c584ebfb576489bd654a03d8c92e36f13fddc7acabcf1ca313009bc
+SHA512:
+  metadata.gz: 15f40462768f4e294e86b382ca91adfbab7f038c335f65a2df76a60fd143434d64a64d4daadf574bc294bd5f37b338988ff216983289d87566bc4ed4d85e1e97
+  data.tar.gz: 2e85d7bfa40a407212592cf6df0404188b2e83ca751781f6e4873ebbf99750e063f457746b9942e1f5ada9a6ddb8a3077bd8394b16c23370025b09e77000b805

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-json/codec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'deserializer'
+require_relative 'serializer'
+
+module Smithy
+  module JSON
+    # @api private
+    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 [Struct] target
+      # @return [Object, nil]
+      def deserialize(shape, bytes, target = nil)
+        Deserializer.new(@options).deserialize(shape, bytes, target)
+      end
+    end
+  end
+end

data/lib/smithy-json/deserializer.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Smithy
+  module JSON
+    # @api private
+    class Deserializer
+      include Smithy::Schema::Shapes
+
+      def initialize(options = {})
+        @json_name = options[:json_name] || false
+      end
+
+      def deserialize(shape, bytes, target)
+        return {} if bytes.empty?
+
+        ref = shape.is_a?(ShapeRef) ? shape : ShapeRef.new(shape: shape)
+        shape(ref, Smithy::JSON.load(bytes), target)
+      end
+
+      private
+
+      def shape(ref, value, target = nil) # rubocop:disable Metrics/CyclomaticComplexity
+        case ref.shape
+        when BlobShape then Base64.decode64(value)
+        when FloatShape then float(value)
+        when ListShape then list(ref, value, target)
+        when MapShape then map(ref, value, target)
+        when StructureShape then structure(ref, value, target)
+        when TimestampShape then timestamp(value)
+        when UnionShape then union(ref, value, target)
+        else value
+        end
+      end
+
+      def float(value)
+        case value
+        when 'Infinity' then ::Float::INFINITY
+        when '-Infinity' then -::Float::INFINITY
+        when 'NaN' then ::Float::NAN
+        when nil then nil
+        else value.to_f
+        end
+      end
+
+      def list(ref, values, target = nil)
+        return if values.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)
+        return if values.nil?
+
+        target = ref.shape.type.new if target.nil?
+        ref.shape.members.each do |member_name, member_ref|
+          value = values[location_name(member_ref)]
+          target[member_name] = shape(member_ref, value) unless value.nil?
+        end
+        target
+      end
+
+      def timestamp(value)
+        case value
+        when nil then nil
+        when Numeric then Time.at(value)
+        when /^[\d.]+$/ then Time.at(value.to_f)
+        else
+          begin
+            fractional_time = Time.parse(value).to_f
+            Time.at(fractional_time).utc
+          rescue ArgumentError
+            raise "unhandled timestamp format: #{value}"
+          end
+        end
+      end
+
+      def union(ref, values, target = nil) # rubocop:disable Metrics/AbcSize
+        ref.shape.members.each do |member_name, member_ref|
+          value = values[location_name(member_ref)]
+          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 location_name(ref)
+        return ref.member_name unless @json_name
+
+        ref.traits['smithy.api#jsonName'] || ref.member_name
+      end
+
+      def sparse?(shape)
+        shape.traits.key?('smithy.api#sparse')
+      end
+    end
+  end
+end

data/lib/smithy-json/json_engine.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Smithy
+  module JSON
+    # @api private
+    module JsonEngine
+      class << self
+        def load(json)
+          ::JSON.parse(json)
+        rescue ::JSON::ParserError => e
+          raise ParseError, e
+        end
+
+        def dump(value)
+          ::JSON.dump(value)
+        end
+      end
+    end
+  end
+end

data/lib/smithy-json/oj_engine.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'oj'
+
+module Smithy
+  module JSON
+    # @api private
+    module OjEngine
+      class << self
+        def load(json)
+          Oj.load(json, mode: :compat, symbol_keys: false)
+        rescue Oj::ParseError, EncodingError => e
+          raise ParseError, e
+        end
+
+        def dump(value)
+          Oj.dump(value, mode: :compat)
+        end
+      end
+    end
+  end
+end

data/lib/smithy-json/serializer.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Smithy
+  module JSON
+    # @api private
+    class Serializer
+      include Smithy::Schema::Shapes
+
+      def initialize(options = {})
+        @json_name = options[:json_name] || false
+      end
+
+      def serialize(shape, data)
+        ref = shape.is_a?(ShapeRef) ? shape : ShapeRef.new(shape: shape)
+        Smithy::JSON.dump(shape(ref, data))
+      end
+
+      private
+
+      def shape(ref, value) # rubocop:disable Metrics/CyclomaticComplexity
+        shape = ref.shape
+        case shape
+        when BlobShape then blob(value)
+        when FloatShape then float(value)
+        when ListShape then list(ref, value)
+        when MapShape then map(ref, value)
+        when StructureShape then structure(ref, value)
+        when TimestampShape then timestamp(ref, value)
+        when UnionShape then union(ref, value)
+        else value
+        end
+      end
+
+      def blob(value)
+        Base64.strict_encode64(value.respond_to?(:read) ? value.read : value)
+      end
+
+      def float(value)
+        if value == ::Float::INFINITY
+          'Infinity'
+        elsif value == -::Float::INFINITY
+          '-Infinity'
+        elsif value.nan?
+          'NaN'
+        else
+          value
+        end
+      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]
+          data[location_name(member_ref)] = shape(member_ref, value) unless value.nil?
+        end
+      end
+
+      def timestamp(ref, value)
+        trait = 'smithy.api#timestampFormat'
+        case ref.traits[trait] || ref.shape.traits[trait]
+        when 'date-time' then value.utc.iso8601
+        when 'http-date' then value.utc.httpdate
+        else
+          # default to epoch-seconds
+          value.to_i
+        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[location_name(member_ref)] = shape(member_ref, values.value)
+        else
+          key, value = values.first
+          if ref.shape.member?(key)
+            member_ref = ref.shape.member(key)
+            data[location_name(member_ref)] = shape(member_ref, value)
+          end
+        end
+        data
+      end
+
+      def location_name(ref)
+        return ref.member_name unless @json_name
+
+        ref.traits['smithy.api#jsonName'] || ref.member_name
+      end
+    end
+  end
+end

data/lib/smithy-json.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'smithy-schema'
+
+require_relative 'smithy-json/codec'
+
+module Smithy
+  # Smithy::JSON is a purpose-built set of utilities for working with JSON.
+  module JSON
+    VERSION = File.read(File.expand_path('../VERSION', __dir__.to_s)).strip
+
+    # Raised when a JSON parsing error occurs.
+    class ParseError < StandardError
+      def initialize(error)
+        @error = error
+        super(error.message)
+      end
+
+      attr_reader :error
+    end
+
+    class << self
+      # @param [Symbol,Class] engine
+      #   Must be one of the following values:
+      #
+      #   * :oj
+      #   * :json
+      #
+      def engine=(engine)
+        @engine = engine.is_a?(Class) ? engine : load_engine(engine)
+      end
+
+      # @return [Class] Returns the default engine.
+      #   One of:
+      #
+      #   * {OjEngine}
+      #   * {JsonEngine}
+      #
+      def engine
+        set_default_engine unless @engine
+        @engine
+      end
+
+      def load(json)
+        @engine.load(json)
+      end
+
+      def dump(value)
+        @engine.dump(value)
+      end
+
+      def set_default_engine
+        %i[oj json].each do |name|
+          @engine ||= try_load_engine(name)
+        end
+        return if @engine
+
+        raise 'Unable to find a compatible json library. ' \
+              'Ensure that you have installed or added to your Gemfile one of: oj or json'
+      end
+
+      private
+
+      def try_load_engine(name)
+        load_engine(name)
+      rescue LoadError
+        nil
+      end
+
+      def load_engine(name)
+        require "smithy-json/#{name}_engine"
+        const_name = "#{name[0].upcase}#{name[1..]}Engine"
+        const_get(const_name)
+      end
+    end
+
+    set_default_engine
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: smithy-json
+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: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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-json.rb
+- lib/smithy-json/codec.rb
+- lib/smithy-json/deserializer.rb
+- lib/smithy-json/json_engine.rb
+- lib/smithy-json/oj_engine.rb
+- lib/smithy-json/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: JSON utilities and codec for Smithy generated clients and servers
+test_files: []