smithy-schema 1.0.0.pre0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2dc2a4e23db98951101c73d858d031c3a1e2b757c49d891c448bd3e049a6917d
+  data.tar.gz: 888f46534f8c174d00f6a09470ce69ac183ab68dd9d9c43e55f9e4ec51b3cf07
+SHA512:
+  metadata.gz: 949146a02a4357e994ad85028d06cb198bb20dbb208c5d8d001762ff7653b7c9c03ca2f7aa313aa85f2b6051798184dc24b3c2547a9e034cab818c3bb6b0edef
+  data.tar.gz: f63565e8f4297c5c9e20720d89ac5f316f8ac590572f4d600196d2aa15cc82c9720496c26559a300806d1346bb1cd611ee00f7caa06047c96b60b8add5a8676c

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+Unreleased Changes
+------------------

data/VERSION

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

data/lib/smithy-schema/shapes.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Schema
+    # Represents shape types from the Smithy model.
+    module Shapes
+      # A base shape that all shapes inherits from.
+      class Shape
+        def initialize(options = {})
+          @id = options[:id]
+          @traits = options[:traits] || {}
+        end
+
+        # @return [String, nil] Absolute shape ID from model
+        attr_accessor :id
+
+        # @return [Hash<String, Object>]
+        attr_accessor :traits
+      end
+
+      # Represents an aggregate shape that has members.
+      class Structure < Shape
+        def initialize(options = {})
+          super
+          @members = {}
+          @names_by_member_name = {}
+        end
+
+        # @return [Hash<Symbol, MemberShape>]
+        attr_accessor :members
+
+        # @return [Hash<String, Symbol>]
+        attr_accessor :names_by_member_name
+
+        # @return [Class, nil]
+        attr_accessor :type
+
+        # @return [MemberShape]
+        def add_member(name, member_name, shape, traits: {})
+          @names_by_member_name[member_name] = name
+          @members[name] = MemberShape.new(member_name, shape, traits: traits)
+        end
+
+        # @param [Symbol] name
+        # @return [Boolean]
+        def member?(name)
+          @members.key?(name)
+        end
+
+        # @param [Symbol] name
+        # @return [MemberShape, nil]
+        def member(name)
+          @members[name]
+        end
+
+        # @param [String] member_name
+        # @return [Boolean]
+        def name_by_member_name?(member_name)
+          @names_by_member_name.key?(member_name)
+        end
+
+        # @param [String] member_name
+        # @return [Symbol, nil]
+        def name_by_member_name(member_name)
+          @names_by_member_name[member_name]
+        end
+      end
+
+      # Represents a slim variation of the Service shape.
+      class ServiceShape < Shape
+        include Enumerable
+
+        def initialize(options = {})
+          super
+          @name = options[:name]
+          @version = options[:version]
+          @operations = {}
+          yield self if block_given?
+        end
+
+        # @return [String, nil] Service name
+        attr_accessor :name
+
+        # @return [String, nil]
+        attr_accessor :version
+
+        # @return [Hash<Symbol, OperationShape>]
+        attr_accessor :operations
+
+        # @return [Hash<Symbol, OperationShape>]
+        def each(&)
+          @operations.each(&)
+        end
+
+        # @return [OperationShape]
+        def add_operation(name, operation)
+          @operations[name] = operation
+        end
+
+        # @param [Symbol] name
+        # @return [OperationShape] operation
+        def operation(name)
+          raise ArgumentError, "unknown operation #{name.inspect}" unless @operations.key?(name)
+
+          @operations[name]
+        end
+
+        # @return [Array<Symbol>]
+        def operation_names
+          @operations.keys
+        end
+      end
+
+      # Represents an Operation shape.
+      class OperationShape < Shape
+        def initialize(options = {})
+          super
+          @name = options[:name]
+          @input = options[:input]
+          @output = options[:output]
+          @errors = options[:errors] || []
+          yield self if block_given?
+        end
+
+        # @return [String, nil] Operation name
+        attr_accessor :name
+
+        # @return [StructureShape, nil]
+        attr_accessor :input
+
+        # @return [StructureShape, nil]
+        attr_accessor :output
+
+        # @return [Array<StructureShape>]
+        attr_accessor :errors
+      end
+
+      # Represents a BigDecimal shape.
+      class BigDecimalShape < Shape; end
+
+      # Represents both Blob and Data Stream shapes.
+      class BlobShape < Shape; end
+
+      # Represents a Boolean shape.
+      class BooleanShape < Shape; end
+
+      # Represents a Document shape.
+      class DocumentShape < Shape; end
+
+      # Represents an Enum shape.
+      class EnumShape < Structure; end
+
+      # Represents the following shapes: Byte, Short, Integer, Long, BigInteger.
+      class IntegerShape < Shape; end
+
+      # Represents an IntEnum shape.
+      class IntEnumShape < Structure; end
+
+      # Represents both Float and Double shapes.
+      class FloatShape < Shape; end
+
+      # Represents a List shape.
+      class ListShape < Shape
+        def initialize(options = {})
+          super
+          @member = nil
+        end
+
+        # @return [MemberShape, nil]
+        attr_accessor :member
+
+        def set_member(shape, traits: {})
+          @member = MemberShape.new('member', shape, traits: traits)
+        end
+      end
+
+      # Represents a Map shape.
+      class MapShape < Shape
+        def initialize(options = {})
+          super
+          @key = nil
+          @value = nil
+        end
+
+        # @return [MemberShape, nil]
+        attr_accessor :key
+
+        # @return [MemberShape, nil]
+        attr_accessor :value
+
+        def set_key(shape, traits: {})
+          @key = MemberShape.new('key', shape, traits: traits)
+        end
+
+        def set_value(shape, traits: {})
+          @value = MemberShape.new('value', shape, traits: traits)
+        end
+      end
+
+      # Represents a String shape.
+      class StringShape < Shape; end
+
+      # Represents a Structure shape.
+      class StructureShape < Structure
+      end
+
+      # Represents a Timestamp shape.
+      class TimestampShape < Shape; end
+
+      # Represents both Union and EventStream shapes.
+      class UnionShape < Structure
+        def initialize(options = {})
+          super
+          @member_types = {}
+          @members_by_type = {}
+        end
+
+        # @return [Hash<Symbol, Class>]
+        attr_accessor :member_types
+
+        # @return [Hash<Class, MemberShape>]
+        attr_accessor :members_by_type
+
+        # @return [MemberShape]
+        def add_member(name, member_name, shape, type, traits: {})
+          member = MemberShape.new(member_name, shape, traits: traits)
+          @members[name] = member
+          @names_by_member_name[member_name] = name
+          @member_types[name] = type
+          @members_by_type[type] = member
+          member
+        end
+
+        # @param [Symbol] name
+        # @return [Boolean]
+        def member_type?(name)
+          @member_types.key?(name)
+        end
+
+        # @param [Symbol] name
+        # @return [Class, nil]
+        def member_type(name)
+          @member_types[name]
+        end
+
+        # @param [Class] type
+        # @return [Boolean]
+        def member_by_type?(type)
+          @members_by_type.key?(type)
+        end
+
+        # @param [Class] type
+        # @return [MemberShape, nil]
+        def member_by_type(type)
+          @members_by_type[type]
+        end
+      end
+
+      # Represents a member shape.
+      class MemberShape
+        def initialize(name, shape, traits: {})
+          @name = name
+          @shape = shape
+          @traits = traits
+        end
+
+        # @return [String] Member name
+        attr_accessor :name
+
+        # @return [Shape] Referenced shape
+        attr_accessor :shape
+
+        # @return [Hash<String, Object>]
+        attr_accessor :traits
+      end
+
+      # Prelude shape definitions.
+      module Prelude
+        BigDecimal = BigDecimalShape.new(id: 'smithy.api#BigDecimal')
+        BigInteger = IntegerShape.new(id: 'smithy.api#BigInteger')
+        Blob = BlobShape.new(id: 'smithy.api#Blob')
+        Boolean = BooleanShape.new(id: 'smithy.api#Boolean')
+        Byte = IntegerShape.new(id: 'smithy.api#Byte')
+        Document = DocumentShape.new(id: 'smithy.api#Document')
+        Double = FloatShape.new(id: 'smithy.api#Double')
+        Float = FloatShape.new(id: 'smithy.api#Float')
+        Integer = IntegerShape.new(id: 'smithy.api#Integer')
+        Long = IntegerShape.new(id: 'smithy.api#Long')
+        PrimitiveBoolean = BooleanShape.new(
+          id: 'smithy.api#PrimitiveBoolean',
+          traits: { 'smithy.api#default' => false }
+        )
+        PrimitiveByte = IntegerShape.new(
+          id: 'smithy.api#PrimitiveByte',
+          traits: { 'smithy.api#default' => 0 }
+        )
+        PrimitiveDouble = FloatShape.new(
+          id: 'smithy.api#PrimitiveDouble',
+          traits: { 'smithy.api#default' => 0 }
+        )
+        PrimitiveFloat = FloatShape.new(
+          id: 'smithy.api#PrimitiveFloat',
+          traits: { 'smithy.api#default' => 0 }
+        )
+        PrimitiveInteger = IntegerShape.new(
+          id: 'smithy.api#PrimitiveInteger',
+          traits: { 'smithy.api#default' => 0 }
+        )
+        PrimitiveShort = IntegerShape.new(
+          id: 'smithy.api#PrimitiveShort',
+          traits: { 'smithy.api#default' => 0 }
+        )
+        PrimitiveLong = IntegerShape.new(
+          id: 'smithy.api#PrimitiveLong',
+          traits: { 'smithy.api#default' => 0 }
+        )
+        Short = IntegerShape.new(id: 'smithy.api#Short')
+        String = StringShape.new(id: 'smithy.api#String')
+        Timestamp = TimestampShape.new(id: 'smithy.api#Timestamp')
+        Unit = StructureShape.new(
+          id: 'smithy.api#Unit',
+          traits: { 'smithy.api#unitType' => {} }
+        )
+      end
+    end
+  end
+end

data/lib/smithy-schema/structure.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Schema
+    # A module mixed into Structs that provides utility methods.
+    module Structure
+      # Deeply converts the Struct into a hash. Structure members that
+      # are `nil` are omitted from the resultant hash.
+      # @return [Hash, Structure]
+      def to_h(obj = self)
+        case obj
+        when Union
+          obj.to_h
+        when Structure
+          _to_h_structure(obj)
+        when Hash
+          _to_h_hash(obj)
+        when Array
+          _to_h_array(obj)
+        else
+          obj
+        end
+      end
+      alias to_hash to_h
+
+      private
+
+      def _to_h_structure(obj)
+        obj.members.each_with_object({}) do |member, hash|
+          value = obj.send(member)
+          hash[member] = to_hash(value) unless value.nil?
+        end
+      end
+
+      def _to_h_hash(obj)
+        obj.transform_values do |value|
+          to_hash(value)
+        end
+      end
+
+      def _to_h_array(obj)
+        obj.collect { |value| to_hash(value) }
+      end
+    end
+
+    # An empty Struct that includes the {Client::Structure} module.
+    EmptyStructure = Struct.new do
+      include Smithy::Schema::Structure
+    end
+  end
+end

data/lib/smithy-schema/union.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module Smithy
+  module Schema
+    # Top level class for all generated Union types
+    class Union < ::SimpleDelegator
+      include Structure
+
+      def to_s
+        "#<#{self.class.name} #{__getobj__ || 'nil'}>"
+      end
+
+      def value
+        __getobj__
+      end
+    end
+  end
+end

data/lib/smithy-schema.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'smithy-schema/shapes'
+require_relative 'smithy-schema/structure'
+require_relative 'smithy-schema/union'
+
+module Smithy
+  # Base module for Smithy model classes.
+  module Model
+    VERSION = File.read(File.expand_path('../VERSION', __dir__.to_s)).strip
+  end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: smithy-schema
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre0
+platform: ruby
+authors:
+- Amazon Web Services
+bindir: bin
+cert_chain: []
+date: 2025-03-06 00:00:00.000000000 Z
+dependencies: []
+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-schema.rb
+- lib/smithy-schema/shapes.rb
+- lib/smithy-schema/structure.rb
+- lib/smithy-schema/union.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: Schema definitions for Smithy generated clients and servers
+test_files: []