smithy 2.0.0.pre0 → 2.0.0.pre1

data/lib/smithy/views/client/request_response_example.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class RequestResponseExample
+        # @param [Hash] model Model
+        # @param [String] operation_name Operation name
+        # @param [Hash<String, Object>] operation Operation shape
+        def initialize(model, operation_name, operation)
+          @model = model
+          @operation_name = operation_name
+          @operation = operation
+        end
+
+        def docstrings
+          example = <<~EXAMPLE
+            @example Request syntax with placeholder values
+              params = #{request_params}
+              options = {}
+              response = client.#{@operation_name}(params, options)
+            @example Response structure with placeholder values
+              response.to_h #=>
+              #{response_hash}
+          EXAMPLE
+          example.split("\n")
+        end
+
+        private
+
+        def request_params
+          target = @operation['input']['target']
+          return '{}' if target == 'smithy.api#Unit'
+
+          input = Model.shape(@model, target)
+          return '{}' unless input['members'].any?
+
+          structure(input, '  ', Set.new)
+        end
+
+        def response_hash
+          target = @operation['output']['target']
+          return '{}' if target == 'smithy.api#Unit'
+
+          output = Model.shape(@model, target)
+          return '{}' unless output['members'].any?
+
+          structure(output, '  ', Set.new)
+        end
+
+        # rubocop:disable Metrics
+        def value(target, indent, visited)
+          if visited.include?(target)
+            shape = Model::Shape.name(target)
+            return "{\n#{indent}  # recursive #{shape}\n#{indent}}"
+          end
+
+          visited += [target]
+          shape = Model.shape(@model, target)
+
+          case shape['type']
+          when 'blob' then blob(shape)
+          when 'boolean' then 'false'
+          when 'string' then string(target)
+          when 'byte' then '97'
+          when 'short', 'integer', 'long', 'bigInteger' then '1'
+          when 'float', 'double' then '1.0'
+          when 'bigDecimal' then 'BigDecimal(1)'
+          when 'timestamp' then 'Time.now'
+          when 'document' then '""null""'
+          when 'enum' then enum(shape)
+          when 'intEnum' then enum(shape, string: false)
+          when 'list' then list(shape, indent, visited)
+          when 'map' then map(shape, indent, visited)
+          when 'structure' then structure(shape, indent, visited)
+          when 'union' then union(shape, indent, visited)
+          else raise "unsupported shape type: #{shape['type'].inspect}"
+          end
+        end
+        # rubocop:enable Metrics
+
+        def blob(shape)
+          if shape && shape['traits']&.include?('smithy.api#streaming')
+            'File.read("source_file")'
+          else
+            '"data"'
+          end
+        end
+
+        def string(target)
+          Model::Shape.name(target).inspect
+        end
+
+        def enum(shape, string: true)
+          enum_values = shape['members'].map do |_, member_shape|
+            value = member_shape['traits']['smithy.api#enumValue']
+            string ? "\"#{value}\"" : value
+          end
+          "#{enum_values.first} # One of: [#{enum_values.join(', ')}]"
+        end
+
+        def structure(structure_shape, indent, visited)
+          lines = []
+          lines << '{'
+          structure_shape['members']&.each_pair do |member_name, member_shape|
+            lines << member(member_name, member_shape, indent, visited)
+          end
+          lines.last.chomp!(',') if lines.last.end_with?(',')
+          lines << "#{indent}}"
+          lines.join("\n")
+        end
+
+        def union(union_shape, indent, visited)
+          lines = []
+          lines << '{'
+          lines << "#{indent}  # One of:"
+          union_shape['members']&.each_pair do |member_name, member_shape|
+            lines << member(member_name, member_shape, indent, visited)
+          end
+          lines.last.chomp!(',') if lines.last.end_with?(',')
+          lines << "#{indent}}"
+          lines.join("\n")
+        end
+
+        def member(member_name, member_shape, indent, visited)
+          value = value(member_shape['target'], "#{indent}  ", visited)
+          entry = "#{indent}  #{member_name.underscore}: #{value},"
+          apply_comments(member_shape, entry)
+        end
+
+        def list(list_shape, indent, visited)
+          member_shape = list_shape['member']
+          if complex?(member_shape)
+            complex_list(member_shape, indent, visited)
+          else
+            scalar_list(member_shape, indent, visited)
+          end
+        end
+
+        def complex?(member_shape)
+          shape = Model.shape(@model, member_shape['target'])
+          %w[structure list map].include?(shape['type'])
+        end
+
+        def scalar_list(member_shape, indent, visited)
+          "[#{value(member_shape['target'], indent, visited)}]"
+        end
+
+        def complex_list(member_shape, indent, visited)
+          "[\n#{indent}  #{value(member_shape['target'], "#{indent}  ", visited)}\n#{indent}]"
+        end
+
+        def map(map_shape, indent, visited)
+          key = string(map_shape['key']['target'])
+          value = value(map_shape['value']['target'], "#{indent}  ", visited)
+          "{\n#{indent}  #{key} => #{value}\n#{indent}}"
+        end
+
+        def apply_comments(shape, text)
+          lines = text.lines.to_a
+          if lines[0].match(/\n$/)
+            lines[0] = lines[0].sub(/\n$/, "#{comments(shape)}\n")
+          else
+            lines[0] += comments(shape)
+          end
+          lines.join
+        end
+
+        def comments(shape)
+          required = shape['traits']&.any? { |k, _| k == 'smithy.api#required' }
+          comments = []
+          comments << 'required' if required
+          comments == [] ? '' : " # #{comments.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/smithy/views/client/rubocop_yml.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class RubocopYml < View
+        def initialize(plan)
+          @plan = plan
+          super()
+        end
+
+        def gem_name
+          @plan.gem_name
+        end
+      end
+    end
+  end
+end

data/lib/smithy/views/client/schema.rb

@@ -0,0 +1,356 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class Schema < View
+        def initialize(plan)
+          @plan = plan
+          @model = plan.model
+          @service_id, @service = plan.service.first
+          @service_index = Model::ServiceIndex.new(@model)
+          super()
+        end
+
+        def module_name
+          @plan.module_name
+        end
+
+        def schema_gem?
+          @plan.type == :schema
+        end
+
+        def service_shape
+          @service_shape ||= ServiceShape.new(@plan.service)
+        end
+
+        def operation_shapes
+          @operation_shapes ||=
+            @service_index
+            .operations_for(@plan.service)
+            .map { |k, v| OperationShape.new(@plan.service, k, v) }
+        end
+
+        def shapes
+          @shapes ||=
+            @service_index
+            .shapes_for(@plan.service)
+            .map { |k, v| build_shape(k, v) }
+        end
+
+        private
+
+        def build_shape(id, shape)
+          args = [@plan.service, id, shape]
+          case shape['type']
+          when 'enum' then EnumShape.new(*args)
+          when 'intEnum' then IntEnumShape.new(*args)
+          when 'structure' then StructureShape.new(*args)
+          when 'list' then ListShape.new(*args)
+          when 'map' then MapShape.new(*args)
+          when 'union' then UnionShape.new(*args)
+          else Shape.new(*args)
+          end
+        end
+
+        # @api private
+        class ServiceShape
+          OMITTED_TRAITS = %w[
+            smithy.api#documentation
+            smithy.api#paginated
+            smithy.rules#endpointRuleSet
+            smithy.rules#endpointTests
+          ].freeze
+
+          def initialize(service)
+            @id, @service = service.first
+            @version = @service['version']
+            @traits = @service.fetch('traits', {}).except(*OMITTED_TRAITS)
+          end
+
+          attr_reader :id, :version, :traits
+
+          def name
+            Model::Shape.name(@id).camelize
+          end
+        end
+
+        # @api private
+        class OperationShape
+          OMITTED_TRAITS = %w[
+            smithy.api#documentation
+            smithy.api#examples
+            smithy.api#paginated
+            smithy.ruby#skipTests
+            smithy.test#httpRequestTests
+            smithy.test#httpResponseTests
+            smithy.waiters#waitable
+          ].freeze
+
+          def initialize(service, id, shape)
+            _, @service = service.first
+            @id = id
+            @input = ShapeRef.new(@service, nil, shape['input'])
+            @output = ShapeRef.new(@service, nil, shape['output'])
+            @errors = build_errors(@service['errors'] || []).concat(build_errors(shape['errors'] || []))
+            @traits = shape.fetch('traits', {})
+          end
+
+          attr_reader :id, :input, :output, :errors
+
+          def name
+            Model::Shape.name(@id)
+          end
+
+          def traits
+            @traits.except(*OMITTED_TRAITS)
+          end
+
+          def paginated?
+            @traits.key?('smithy.api#paginated')
+          end
+
+          def paginator
+            "Paginators::#{Model::Shape.name(@id)}.new"
+          end
+
+          private
+
+          def build_errors(errors)
+            errors.map { |shape_ref| ShapeRef.new(@service, nil, shape_ref) }
+          end
+        end
+
+        # @api private
+        class Shape
+          OMITTED_TRAITS = %w[
+            smithy.api#documentation
+          ].freeze
+
+          SHAPE_CLASS_MAP = {
+            'bigDecimal' => 'BigDecimalShape',
+            'bigInteger' => 'IntegerShape',
+            'blob' => 'BlobShape',
+            'boolean' => 'BooleanShape',
+            'byte' => 'IntegerShape',
+            'document' => 'DocumentShape',
+            'double' => 'FloatShape',
+            'enum' => 'EnumShape',
+            'float' => 'FloatShape',
+            'integer' => 'IntegerShape',
+            'intEnum' => 'IntEnumShape',
+            'list' => 'ListShape',
+            'long' => 'IntegerShape',
+            'map' => 'MapShape',
+            'short' => 'IntegerShape',
+            'string' => 'StringShape',
+            'structure' => 'StructureShape',
+            'timestamp' => 'TimestampShape',
+            'union' => 'UnionShape'
+          }.freeze
+
+          def initialize(service, id, shape)
+            _, @service = service.first
+            @id = id
+            @shape = shape
+            @type = shape['type']
+            @traits = shape.fetch('traits', {}).except(*OMITTED_TRAITS)
+          end
+
+          attr_reader :type, :id
+
+          def name
+            (@service.dig('rename', @id) || Model::Shape.name(@id)).camelize
+          end
+
+          def initializer
+            traits_str = ", traits: #{@traits}" unless @traits.empty?
+            "Smithy::Schema::Shapes::#{SHAPE_CLASS_MAP[@type]}.new(id: '#{@id}'#{traits_str})"
+          end
+        end
+
+        # @api private
+        class StructureShape < Shape
+          OMITTED_TRAITS = %w[
+            smithy.api#documentation
+            smithy.api#input
+            smithy.api#output
+          ].freeze
+
+          def initialize(service, id, shape)
+            super
+            @members = build_shape_refs(shape['members'])
+            @traits = shape.fetch('traits', {}).except(*OMITTED_TRAITS)
+          end
+
+          attr_reader :members
+
+          def type_class
+            "Types::#{(@service.dig('rename', @id) || Model::Shape.name(@id)).camelize}"
+          end
+
+          def http_payload?
+            @members.any?(&:http_payload?)
+          end
+
+          def http_payload
+            @members.find(&:http_payload).http_payload
+          end
+
+          private
+
+          def build_shape_refs(members)
+            members.map { |name, shape_ref| ShapeRef.new(@service, name, shape_ref) }
+          end
+        end
+
+        # @api private
+        class EnumShape < Shape
+          def initialize(service, id, shape)
+            super
+            @members = build_shape_refs(shape['members'])
+          end
+
+          attr_reader :members
+
+          private
+
+          def build_shape_refs(members)
+            members.map { |name, shape_ref| ShapeRef.new(@service, name, shape_ref) }
+          end
+        end
+
+        # @api private
+        class IntEnumShape < Shape
+          def initialize(service, id, shape)
+            super
+            @members = build_shape_refs(shape['members'])
+          end
+
+          attr_reader :members
+
+          private
+
+          def build_shape_refs(members)
+            members.map { |name, shape_ref| ShapeRef.new(@service, name, shape_ref) }
+          end
+        end
+
+        # @api private
+        class ListShape < Shape
+          def initialize(service, id, shape)
+            super
+            @member = ShapeRef.new(@service, nil, shape['member'])
+          end
+
+          attr_reader :member
+        end
+
+        # @api private
+        class MapShape < Shape
+          def initialize(service, id, shape)
+            super
+            @key = ShapeRef.new(@service, nil, shape['key'])
+            @value = ShapeRef.new(@service, nil, shape['value'])
+          end
+
+          attr_reader :key, :value
+        end
+
+        # @api private
+        class UnionShape < Shape
+          def initialize(service, id, shape)
+            super
+            @members = build_shape_refs(shape['members'])
+          end
+
+          attr_reader :members
+
+          def type_class
+            "Types::#{(@service.dig('rename', @id) || Model::Shape.name(@id)).camelize}"
+          end
+
+          def union_type(shape_ref)
+            "#{type_class}::#{shape_ref.name.camelize}"
+          end
+
+          private
+
+          def build_shape_refs(members)
+            members.map { |name, shape_ref| ShapeRef.new(@service, name, shape_ref) }
+          end
+        end
+
+        # @api private
+        class ShapeRef
+          OMITTED_TRAITS = %w[
+            smithy.api#documentation
+            smithy.api#httpPayload
+          ].freeze
+
+          PRELUDE_SHAPES_MAP = {
+            'smithy.api#BigInteger' => 'Prelude::BigInteger',
+            'smithy.api#BigDecimal' => 'Prelude::BigDecimal',
+            'smithy.api#Blob' => 'Prelude::Blob',
+            'smithy.api#Boolean' => 'Prelude::Boolean',
+            'smithy.api#Byte' => 'Prelude::Byte',
+            'smithy.api#Document' => 'Prelude::Document',
+            'smithy.api#Double' => 'Prelude::Double',
+            'smithy.api#Float' => 'Prelude::Float',
+            'smithy.api#Integer' => 'Prelude::Integer',
+            'smithy.api#Long' => 'Prelude::Long',
+            'smithy.api#PrimitiveBoolean' => 'Prelude::PrimitiveBoolean',
+            'smithy.api#PrimitiveByte' => 'Prelude::PrimitiveByte',
+            'smithy.api#PrimitiveDouble' => 'Prelude::PrimitiveDouble',
+            'smithy.api#PrimitiveFloat' => 'Prelude::PrimitiveFloat',
+            'smithy.api#PrimitiveInteger' => 'Prelude::PrimitiveInteger',
+            'smithy.api#PrimitiveLong' => 'Prelude::PrimitiveLong',
+            'smithy.api#PrimitiveShort' => 'Prelude::PrimitiveShort',
+            'smithy.api#Short' => 'Prelude::Short',
+            'smithy.api#String' => 'Prelude::String',
+            'smithy.api#Timestamp' => 'Prelude::Timestamp',
+            'smithy.api#Unit' => 'Prelude::Unit'
+          }.freeze
+
+          def initialize(service, member_name, shape_ref)
+            @service = service
+            @name = member_name.underscore if member_name
+            @member_name = member_name
+            @shape = shape(shape_ref['target'])
+            @traits = shape_ref.fetch('traits', {})
+          end
+
+          attr_reader :name
+
+          def initializer
+            options_str = "shape: #{@shape}"
+            options_str += ", member_name: '#{@member_name}'" if @member_name
+            options_str += ", traits: #{@traits}" unless @traits.empty?
+            "Smithy::Schema::Shapes::ShapeRef.new(#{options_str})"
+          end
+
+          def shape(id)
+            return "Smithy::Schema::Shapes::#{PRELUDE_SHAPES_MAP[id]}" if PRELUDE_SHAPES_MAP.key?(id)
+
+            (@service.dig('rename', id) || Model::Shape.name(id)).camelize
+          end
+
+          def traits
+            @traits.except(*OMITTED_TRAITS)
+          end
+
+          def http_payload?
+            @traits.key?('smithy.api#httpPayload')
+          end
+
+          def http_payload
+            return unless http_payload?
+
+            @name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smithy/views/client/schema_rbs.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class SchemaRbs < View
+        def initialize(plan)
+          @plan = plan
+          @service_index = Model::ServiceIndex.new(plan.model)
+          super()
+        end
+
+        def module_name
+          @plan.module_name
+        end
+
+        def shapes
+          @service_index
+            .shapes_for(@plan.service)
+            .map { |id, shape| Shape.new(@plan.service, id, shape) }
+        end
+
+        def service_shape
+          @service_shape ||= ServiceShape.new(@plan.service)
+        end
+
+        # @api private
+        class ServiceShape
+          def initialize(service)
+            @id, = service.first
+          end
+
+          def name
+            Model::Shape.name(@id).camelize
+          end
+
+          def shape_class
+            'ServiceShape'
+          end
+        end
+
+        # @api private
+        class Shape
+          SHAPE_TYPES_MAP = {
+            'bigDecimal' => 'BigDecimalShape',
+            'bigInteger' => 'IntegerShape',
+            'blob' => 'BlobShape',
+            'boolean' => 'BooleanShape',
+            'byte' => 'IntegerShape',
+            'document' => 'DocumentShape',
+            'double' => 'FloatShape',
+            'enum' => 'EnumShape',
+            'float' => 'FloatShape',
+            'integer' => 'IntegerShape',
+            'intEnum' => 'IntEnumShape',
+            'list' => 'ListShape',
+            'long' => 'IntegerShape',
+            'map' => 'MapShape',
+            'short' => 'IntegerShape',
+            'string' => 'StringShape',
+            'structure' => 'StructureShape',
+            'timestamp' => 'TimestampShape',
+            'union' => 'UnionShape'
+          }.freeze
+
+          def initialize(service, id, shape)
+            _, @service = service.first
+            @id = id
+            @shape = shape
+          end
+
+          def name
+            (@service.dig('rename', @id) || Model::Shape.name(@id)).camelize
+          end
+
+          def shape_class
+            SHAPE_TYPES_MAP[@shape['type']]
+          end
+        end
+      end
+    end
+  end
+end