smithy 2.0.0.pre0 → 2.0.0.pre1

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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class OperationExamples
+        # @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
+          @examples = operation.fetch('traits', {}).fetch('smithy.api#examples', [])
+        end
+
+        def docstrings
+          examples = ''
+          @examples.each do |example|
+            examples += example(example)
+          rescue ArgumentError => e
+            puts "Error processing example for #{@operation_name}: #{e}"
+            next
+          end
+          examples.split("\n")
+        end
+
+        private
+
+        def example(example)
+          if example['error']
+            error_example(example)
+          else
+            output_example(example)
+          end
+        end
+
+        def output_example(example)
+          <<~EXAMPLE
+            @example #{example['title']}
+              #{documentation(example)}
+              params = #{params(example['input'], @operation['input']['target'])}
+              options = {}
+              response = client.#{@operation_name}(params, options)
+              response.to_h #=>
+              #{params(example['output'], @operation['output']['target'])}
+          EXAMPLE
+        end
+
+        def error_example(example)
+          error = example['error']
+          <<~EXAMPLE
+            @example #{example['title']}
+              #{documentation(example)}
+              params = #{params(example['input'], @operation['input']['target'])}
+              options = {}
+              begin
+                response = client.#{@operation_name}(params, options)
+              rescue Smithy::Client::ServiceError => e
+                puts e.class #=> #{Model::Shape.name(error['shapeId'])}
+                puts e.data.to_h #=>
+                #{error_data(error['content'], error['shapeId'])}
+              end
+          EXAMPLE
+        end
+
+        def params(document, target, indent = '  ')
+          return '{}' if document.nil? || document.empty?
+
+          shape = Model.shape(@model, target)
+          structure(document, shape, indent).join("\n")
+        end
+
+        def error_data(document, shape_id, indent = '    ')
+          shape = Model.shape(@model, shape_id)
+          structure(document, shape, indent).join("\n")
+        end
+
+        def documentation(example)
+          documentation = example.fetch('documentation', "Example operation for #{@operation_name}")
+          documentation.split("\n").map { |line| "# #{line}" }.join("\n")
+        end
+
+        def value(json, shape, indent)
+          case shape['type']
+          when 'structure' then structure(json, shape, indent)
+          when 'map' then map(json, shape, indent)
+          when 'list' then list(json, shape, indent)
+          when 'timestamp' then "Time.parse(#{json.inspect})"
+          when 'string', 'blob' then json.inspect
+          else json
+          end
+        end
+
+        def structure(json, shape, indent)
+          lines = []
+          lines << '{'
+          json.each_pair do |key, value|
+            member_shape = Model.shape(@model, shape['members'][key]['target'])
+            entry = value(value, member_shape, "#{indent}  ")
+            lines << "#{indent}  #{key.underscore}: #{format(entry)},"
+          end
+          lines.last.chomp!(',') if lines.last.end_with?(',')
+          lines << "#{indent}}"
+          lines
+        end
+
+        def map(json, shape, indent)
+          lines = []
+          lines << '{'
+          json.each do |key, value|
+            member_shape = Model.shape(@model, shape['value']['target'])
+            entry = value(value, member_shape, "#{indent}  ")
+            lines << "#{indent}  \"#{key}\" => #{format(entry)},"
+          end
+          lines.last.chomp!(',') if lines.last.end_with?(',')
+          lines << "#{indent}}"
+          lines
+        end
+
+        def list(json, shape, indent)
+          lines = []
+          lines << '['
+          json.each do |element|
+            member_shape = Model.shape(@model, shape['member']['target'])
+            entry = value(element, member_shape, "#{indent}  ")
+            lines << "#{indent}  #{format(entry)},"
+          end
+          lines.last.chomp!(',') if lines.last.end_with?(',')
+          lines << "#{indent}]"
+          lines
+        end
+
+        def format(shape_val)
+          formatted = []
+          if shape_val.is_a?(Array)
+            hashes = shape_val.map do |v|
+              (v.is_a?(Hash) ? format_hash(v, '  ') : v)
+            end
+            hashes.join(',')
+            formatted << hashes
+          elsif shape_val.is_a?(Hash)
+            formatted << format_hash(shape_val, '  ')
+          else
+            formatted << shape_val
+          end
+          formatted.join("\n")
+        end
+
+        def format_hash(value, indent)
+          Util::HashFormatter.new(indent: indent).format(value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class Paginators < View
+        def initialize(plan)
+          @plan = plan
+          @model = plan.model
+          _, service = plan.service.first
+          @service_trait = paginated_trait(service)
+          super()
+        end
+
+        def module_name
+          @plan.module_name
+        end
+
+        def paginators
+          Model::ServiceIndex
+            .new(@model)
+            .operations_for(@plan.service)
+            .map do |id, operation|
+              operation_trait = paginated_trait(operation)
+              next if operation_trait.empty?
+
+              resolved_trait = @service_trait.merge(operation_trait)
+              Paginator.new(Model::Shape.name(id), resolved_trait)
+            end
+            .compact
+        end
+
+        private
+
+        def paginated_trait(shape)
+          shape.fetch('traits', {}).fetch('smithy.api#paginated', {})
+        end
+
+        # @api private
+        class Paginator
+          def initialize(name, trait)
+            @name = name
+            @input_token = trait['inputToken']
+            @output_token = trait['outputToken']
+            @items = trait['items']
+          end
+
+          attr_reader :name
+
+          def next_tokens_code
+            next_token_getter = output_getter(@output_token)
+            code = ["next_token = #{next_token_getter}"]
+            code << 'return {} if next_token.nil? || next_token.empty?'
+            code << ''
+            code << 'tokens = Hash.new { |h, k| h[k] = {} }'
+            next_token_setter = input_getter(@input_token, 'tokens')
+            code << "#{next_token_setter} = next_token"
+            code << 'tokens'
+            code
+          end
+
+          def prev_tokens_code
+            prev_token_getter = input_getter(@input_token)
+            code = ["prev_token = #{prev_token_getter}"]
+            code << 'return {} if prev_token.nil? || prev_token.empty?'
+            code << ''
+            code << 'tokens = Hash.new { |h, k| h[k] = {} }'
+            prev_token_setter = input_getter(@input_token, 'tokens')
+            code << "#{prev_token_setter} = prev_token"
+            code << 'tokens'
+            code
+          end
+
+          def items_code
+            return ["raise NotImplementedError, 'item iteration is not implemented for this operation'"] unless items?
+
+            [output_getter(@items)]
+          end
+
+          def items?
+            !!@items
+          end
+
+          # Builds a getter using the output shape and a path.
+          # This is used to get the value of the output token or items.
+          def output_getter(path)
+            getter = String.new('data')
+            path.split('.').each do |member|
+              getter << ".#{member.underscore}"
+            end
+            getter
+          end
+
+          # Builds a getter using the input shape and a path.
+          # This is used to set the value of the input token or fetch the previous token.
+          def input_getter(path, context = 'params')
+            getter = String.new(context)
+            path.split('.').each do |member|
+              getter << "[:#{member.underscore}]"
+            end
+            getter
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class Plugin
+        def initialize(options = {})
+          @class_name = options[:class_name]
+          @require_path = options[:require_path]
+          @require_relative = options.fetch(:require_relative, false)
+          @source = options[:source]
+        end
+
+        attr_accessor :class_name, :require_path, :source
+
+        def options
+          klass = @class_name
+          klass = Object.const_get(@class_name) if @class_name.is_a?(String)
+          klass.options
+        end
+
+        def require_relative?
+          @require_relative
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class PluginList
+        include Enumerable
+
+        def initialize(plan, code_generated_plugins)
+          @plan = plan
+          @plugins = plugins(plan, code_generated_plugins)
+        end
+
+        def each(&)
+          @plugins.each(&)
+        end
+
+        private
+
+        def plugins(plan, code_generated_plugins)
+          plugins = []
+          code_generated_plugins(plugins, code_generated_plugins)
+          weld_plugins(plugins, plan.welds)
+          plugins
+        end
+
+        def code_generated_plugins(plugins, code_generated_plugins)
+          define_module_names
+          code_generated_plugins.each do |_, plugin| # rubocop:disable Style/HashEachMethods
+            Object.module_eval(plugin.source)
+            plugins << plugin
+          end
+        end
+
+        # Code generated plugins may have nested namespaces, so we need to ensure
+        # that they are defined before we try to evaluate the source.
+        def define_module_names
+          parent = Object
+          @plan.module_name.split('::') do |mod|
+            child = mod
+            parent.const_set(child, ::Module.new) unless parent.const_defined?(child)
+            parent = parent.const_get(child)
+          end
+        end
+
+        def weld_plugins(plugins, welds)
+          weld_plugins = welds.map(&:add_plugins).reduce({}, :merge)
+          weld_plugins = weld_plugins.except(*welds.map(&:remove_plugins).reduce([], :+))
+          weld_plugins.each do |class_name, options|
+            plugins << Plugin.new(class_name: class_name, **options)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class ProtocolSpec < View
+        PROTOCOL_TEST_TRAITS = %w[smithy.test#httpRequestTests smithy.test#httpResponseTests].freeze
+
+        def initialize(plan)
+          @plan = plan
+          @model = plan.model
+          @all_operation_tests =
+            Model::ServiceIndex
+            .new(@model)
+            .operations_for(@plan.service)
+            .map { |id, o| OperationTests.new(@model, id, o) }
+            .reject(&:empty?)
+          super()
+        end
+
+        attr_reader :all_operation_tests
+
+        def module_name
+          @plan.module_name
+        end
+
+        def additional_requires
+          Set.new(@all_operation_tests.map(&:additional_requires).flatten)
+        end
+
+        # @api private
+        class OperationTests
+          def initialize(model, id, operation)
+            @model = model
+            @id = id
+            @operation = operation
+            @request_tests = build_request_tests
+            @response_tests = build_response_tests
+            @error_tests = build_error_tests
+          end
+
+          attr_reader :request_tests, :response_tests, :error_tests
+
+          def name
+            Model::Shape.name(@id).underscore
+          end
+
+          def additional_requires
+            @request_tests.map(&:additional_requires) + @response_tests.map(&:additional_requires)
+          end
+
+          def empty?
+            request_tests.empty? && response_tests.empty? && error_tests.empty?
+          end
+
+          private
+
+          def build_response_tests
+            @operation
+              .fetch('traits', {})
+              .fetch('smithy.test#httpResponseTests', [])
+              .select { |t| t.fetch('appliesTo', 'client') == 'client' }
+              .map { |t| ResponseTest.new(@model, @operation, t) }
+          end
+
+          def build_request_tests
+            @operation
+              .fetch('traits', {})
+              .fetch('smithy.test#httpRequestTests', [])
+              .select { |t| t.fetch('appliesTo', 'client') == 'client' }
+              .map { |t| RequestTest.new(@model, @operation, t) }
+          end
+
+          def build_error_tests
+            @operation
+              .fetch('errors', [])
+              .map { |e| tests_for_error(e) }
+              .flatten
+          end
+
+          def tests_for_error(error)
+            error_shape = Model.shape(@model, error['target'])
+            # NOTE: error tests do not have a appliesTo that should be checked
+            error_shape
+              .fetch('traits', {})
+              .fetch('smithy.test#httpResponseTests', [])
+              .map { |t| ErrorTest.new(@model, @operation, error['target'], t) }
+          end
+        end
+
+        # @api private
+        class TestCase
+          def initialize(model, operation, test_case)
+            @model = model
+            @operation = operation
+            @test_case = test_case
+            @input_shape = Model.shape(@model, @operation['input']['target'])
+            @output_shape = Model.shape(@model, @operation['output']['target'])
+          end
+
+          attr_reader :test_case
+
+          def [](key)
+            test_case[key]
+          end
+
+          def comments
+            test_case.fetch('documentation', '').split("\n")
+          end
+
+          def id
+            test_case['id']
+          end
+
+          def additional_requires
+            requires = []
+            if test_case['bodyMediaType']
+              requires +=
+                case test_case['bodyMediaType']
+                when 'application/cbor'
+                  %w[base64]
+                when 'application/json'
+                  %w[json]
+                else
+                  []
+                end
+            end
+            requires
+          end
+
+          def skip?
+            @operation
+              .fetch('traits', {})
+              .fetch('smithy.ruby#skipTests', [])
+              .any? { |skip| skip['id'] == id }
+          end
+
+          def skip_reason
+            @operation
+              .fetch('traits', {})
+              .fetch('smithy.ruby#skipTests', [])
+              .find { |skip| skip['id'] == id }
+              &.fetch('reason', 'skipped')
+          end
+        end
+
+        # @api private
+        class RequestTest < TestCase
+          def params
+            ShapeToHash.transform_value(@model, test_case.fetch('params', {}), @input_shape)
+          end
+
+          def endpoint
+            "https://#{test_case.fetch('host', '127.0.0.1')}"
+          end
+
+          def body_expect
+            return nil unless test_case['body']
+
+            case test_case['bodyMediaType']
+            when 'application/cbor'
+              'expect(Smithy::CBOR.decode(request.body.read)).' \
+              "to match_data(Smithy::CBOR.decode(::Base64.decode64('#{test_case['body']}')))"
+            when 'application/json'
+              "expect(JSON.parse(request.body.read)).to eq(JSON.parse('#{test_case['body']}'))"
+            else
+              "expect(request.body.read).to eq('#{test_case['body']}')"
+            end
+          end
+
+          def query_expect?
+            test_case['queryParams'] || test_case['forbidQueryParams'] || test_case['requireQueryParams']
+          end
+
+          def idempotency_token_trait?
+            @input_shape.fetch('members', {})
+                        .any? { |_name, shape| shape.fetch('traits', {}).key?('smithy.api#idempotencyToken') }
+          end
+        end
+
+        # @api private
+        class ResponseTest < TestCase
+          def params
+            # Finds all required members to pass operation validation
+            ShapeToHash.transform_value(@model, structure(@input_shape, {}), @input_shape)
+          end
+
+          def shape(shape, value)
+            case shape['type']
+            when 'structure' then structure(shape, value)
+            else value
+            end
+          end
+
+          def structure(shape, values)
+            shape['members'].each_with_object({}) do |(member_name, member_shape), data|
+              next unless required?(member_shape.fetch('traits', {}))
+
+              target = Model.shape(@model, member_shape['target'])
+              data[member_name] = shape(target, values)
+            end
+          end
+
+          def required?(traits)
+            traits.key?('smithy.api#required') && !traits.key?('smithy.api#clientOptional')
+          end
+
+          def stub_body
+            case test_case['bodyMediaType']
+            when 'application/cbor'
+              "::Base64.decode64('#{test_case['body']}')"
+            else
+              "'#{test_case['body']}'"
+            end
+          end
+
+          def data_expect
+            output = ShapeToHash.transform_value(@model, test_case.fetch('params', {}), @output_shape)
+            "expect(response.data.to_h).to match_data(#{output})"
+          end
+
+          def streaming_member
+            @output_shape
+              .fetch('members', {})
+              .map { |name, member| [name, Model.shape(@model, member['target'])] }
+              .find { |_name, shape| shape.fetch('traits', {}).key?('smithy.api#streaming') }
+          end
+        end
+
+        # @api private
+        class ErrorTest < ResponseTest
+          def initialize(model, operation, error_id, test_case)
+            super(model, operation, test_case)
+            @error_id = error_id
+            @error_shape = Model.shape(@model, error_id)
+          end
+
+          def error_name
+            Model::Shape.name(@error_id)
+          end
+
+          def params
+            ShapeToHash.transform_value(@model, test_case.fetch('params', {}), @error_shape)
+          end
+
+          def data_expect
+            "expect(e.data.to_h).to match_data(#{params})"
+          end
+        end
+      end
+    end
+  end
+end