smithy-client 1.0.0.pre0 → 1.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbcc7c50be767042e3eae29206ceb174f523f1d5421c4ec90d0457c24acd9b10
-  data.tar.gz: 5ef14301b0132b7018a9782f01b2a6b4a8c62fbcb6f74a614bebb19fe16ea86d
+  metadata.gz: fe9f255b34cb45c0052d24be6f0f8415d129311b369e3a801b2a8945bb43ef47
+  data.tar.gz: 6ee595a5adb44533dddc82fa08e80d40aa944ec82dfd76b71216c556d54d0396
 SHA512:
-  metadata.gz: 4a6471db9b9a88bdc41546e9b004e6e7871611ba00eeb499cfbee9d28f750aff842a360786a2111add5bfc57c009fef074f494900f814cf0eb6d3c7c6a4f7d43
-  data.tar.gz: 184ac4c3e36023db7b7212aecf825535d1b5bae6701f3c63a2ebf5afdf5ddd5e1a5d15e34db8a314144a9a296fa6ce7298899514849a47d051b5b595da1bc8f8
+  metadata.gz: b8b6968ff630c4178da4f630fe3977a7112a88b84d6aeecccc515ed68566f4dbcb9ed1b0a0ec4bfa03a2f6d9b3430962d488327e902d597d58be8b569645302a
+  data.tar.gz: '0298dcc75712c68d05ce931f582e0873340e7059d7a238dfbc6f14877868040cf6401b7bb75c1874d4b1e24feb5f37468d20a80e7b8ae18a133ca81476c29f9c'

data/CHANGELOG.md

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

data/VERSION

@@ -1 +1 @@
-1.0.0.pre0
+1.0.0.pre1

data/lib/smithy-client/anonymous_provider.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # @api private
+    class AnonymousProvider
+      def identity(_properties)
+        Identities::Anonymous.new
+      end
+    end
+  end
+end

data/lib/smithy-client/auth_option.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # Object that represents an auth option, returned by Auth Resolvers.
+    class AuthOption
+      def initialize(scheme_id:, identity_properties: {}, signer_properties: {})
+        @scheme_id = scheme_id
+        @identity_properties = identity_properties
+        @signer_properties = signer_properties
+      end
+
+      # @return [String]
+      attr_reader :scheme_id
+
+      # @return [Hash]
+      attr_reader :identity_properties
+
+      # @return [Hash]
+      attr_reader :signer_properties
+    end
+  end
+end

data/lib/smithy-client/auth_scheme.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # Base class for all AuthScheme classes.
+    class AuthScheme
+      def initialize(scheme_id:, signer:, identity_type:)
+        @scheme_id = scheme_id
+        @signer = signer
+        @identity_type = identity_type
+      end
+
+      # @return [String]
+      attr_reader :scheme_id
+
+      # @return [IdentityProvider, nil]
+      def identity_provider(identity_provider = {})
+        identity_provider[@identity_type]
+      end
+
+      # @return [Signer]
+      attr_reader :signer
+    end
+  end
+end

data/lib/smithy-client/auth_schemes/anonymous.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module AuthSchemes
+      # Auth scheme for no authentication.
+      class Anonymous < AuthScheme
+        def initialize(options = {})
+          super(
+            scheme_id: 'smithy.api#noAuth',
+            signer: options.fetch(:signer, Signers::Anonymous.new),
+            identity_type: Identities::Anonymous
+          )
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/auth_schemes/http_api_key.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module AuthSchemes
+      # Auth scheme for HTTP API keys.
+      class HttpApiKey < AuthScheme
+        def initialize(options = {})
+          super(
+            scheme_id: 'smithy.api#httpApiKeyAuth',
+            signer: options.fetch(:signer, Signers::HttpApiKey.new),
+            identity_type: Identities::HttpApiKey
+          )
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/auth_schemes/http_basic.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module AuthSchemes
+      # Auth scheme for HTTP Basic.
+      class HttpBasic < AuthScheme
+        def initialize(options = {})
+          super(
+            scheme_id: 'smithy.api#httpBasicAuth',
+            signer: options.fetch(:signer, Signers::HttpBasic.new),
+            identity_type: Identities::HttpLogin
+          )
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/auth_schemes/http_bearer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module AuthSchemes
+      # Auth scheme for HTTP Bearer tokens.
+      class HttpBearer < AuthScheme
+        def initialize(options = {})
+          super(
+            scheme_id: 'smithy.api#httpBearerAuth',
+            signer: options.fetch(:signer, Signers::HttpBearer.new),
+            identity_type: Identities::HttpBearer
+          )
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/auth_schemes/http_digest.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module AuthSchemes
+      # Auth scheme for HTTP Digest.
+      class HttpDigest < AuthScheme
+        def initialize(options = {})
+          super(
+            scheme_id: 'smithy.api#httpDigestAuth',
+            signer: options.fetch(:signer, Signers::HttpDigest.new),
+            identity_type: Identities::HttpLogin
+          )
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/base.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # Base class for all service clients.
+    class Base
+      include HandlerBuilder
+
+      def initialize(plugins, options)
+        @config = build_config(plugins, options)
+        @handlers = build_handler_list(plugins)
+        after_initialize(plugins)
+      end
+
+      # @return [Struct]
+      attr_reader :config
+
+      # @return [HandlerList]
+      attr_reader :handlers
+
+      # Builds and returns a {Request} for the named operation. The request will not have been sent.
+      # @param [Symbol] operation_name
+      # @return [Request]
+      def build_request(operation_name, params = {})
+        Request.new(
+          handlers: @handlers.for(operation_name),
+          context: context_for(operation_name, params)
+        )
+      end
+
+      # @return [Array<Symbol>] Returns a list of valid request operation
+      #  names. These are valid arguments to {#build_input} and are also
+      #  valid methods.
+      def operation_names
+        self.class.service.operation_names
+      end
+
+      # @api private
+      def inspect
+        "#<#{self.class.name || 'Smithy::Client::Base'}>"
+      end
+
+      private
+
+      # Constructs a {Configuration} object and gives each plugin the
+      #  opportunity to register options with default values.
+      def build_config(plugins, options)
+        config = Configuration.new
+        config.add_option(:service)
+        plugins.each do |plugin|
+          plugin.add_options(config) if plugin.respond_to?(:add_options)
+        end
+        config.build!(options.merge(service: self.class.service))
+      end
+
+      # Gives each plugin the opportunity to register handlers for this client.
+      def build_handler_list(plugins)
+        plugins.each_with_object(HandlerList.new) do |plugin, handlers|
+          plugin.add_handlers(handlers, @config) if plugin.respond_to?(:add_handlers)
+        end
+      end
+
+      # Gives each plugin the opportunity to modify this client.
+      def after_initialize(plugins)
+        plugins.reverse.each do |plugin|
+          plugin.after_initialize(self) if plugin.respond_to?(:after_initialize)
+        end
+      end
+
+      # @return [HandlerContext]
+      def context_for(operation_name, params)
+        HandlerContext.new(
+          operation_name: operation_name,
+          operation: config.service.operation(operation_name),
+          client: self,
+          params: params,
+          config: config
+        )
+      end
+
+      def waiter(waiter_name, options = {})
+        waiter_class = waiters[waiter_name]
+        raise Waiters::NoSuchWaiterError.new(waiter_name, waiters.keys) unless waiter_class
+
+        waiter_class.new(options.merge(client: self))
+      end
+
+      class << self
+        def new(options = {})
+          plugins = build_plugins
+          options = options.dup
+          options[:plugins]&.freeze
+          before_initialize(plugins, options)
+          client = allocate
+          client.send(:initialize, plugins, options)
+          client
+        end
+
+        # Registers a plugin with this client.
+        #
+        # @example Register a plugin
+        #
+        #   ClientClass.add_plugin(PluginClass)
+        #
+        # @example Register a plugin with an object
+        #
+        #   plugin = MyPluginClass.new(options)
+        #   ClientClass.add_plugin(plugin)
+        #
+        # @param [Class, Symbol, String, Object] plugin
+        # @see .clear_plugins
+        # @see .set_plugins
+        # @see .remove_plugin
+        # @see .plugins
+        # @return [void]
+        def add_plugin(plugin)
+          @plugins.add(plugin)
+        end
+
+        # @see .clear_plugins
+        # @see .set_plugins
+        # @see .add_plugin
+        # @see .plugins
+        # @return [void]
+        def remove_plugin(plugin)
+          @plugins.remove(plugin)
+        end
+
+        # @see .set_plugins
+        # @see .add_plugin
+        # @see .remove_plugin
+        # @see .plugins
+        # @return [void]
+        def clear_plugins
+          @plugins.set([])
+        end
+
+        # @param [Array<Plugin>] plugins
+        # @see .clear_plugins
+        # @see .add_plugin
+        # @see .remove_plugin
+        # @see .plugins
+        # @return [void]
+        def plugins=(plugins)
+          @plugins.set(plugins)
+        end
+
+        # Returns the list of registered plugins for this Client. Plugins are
+        #  inherited from the client super class when the client is defined.
+        # @see .clear_plugins
+        # @see .set_plugins
+        # @see .add_plugin
+        # @see .remove_plugin
+        # @return [Array<Plugin>]
+        def plugins
+          Array(@plugins).freeze
+        end
+
+        # @return [Schema::Shapes::ServiceShape]
+        def service
+          @service ||= Schema::Shapes::ServiceShape.new
+        end
+
+        # @param [ServiceShape] service
+        attr_writer :service
+
+        # @option options [ServiceShape] :service (ServiceShape.new)
+        # @option options [Array<Plugin>] :plugins ([]) A list of plugins to
+        #  add to the client class created.
+        # @return [Class<Client::Base>]
+        def define(options = {})
+          subclass = Class.new(self)
+          subclass.service = options[:service] || service
+          Array(options[:plugins]).each do |plugin|
+            subclass.add_plugin(plugin)
+          end
+          subclass
+        end
+        alias extend define
+
+        private
+
+        def build_plugins
+          plugins.map { |plugin| plugin.is_a?(Class) ? plugin.new : plugin }
+        end
+
+        def before_initialize(plugins, options)
+          plugins.each do |plugin|
+            plugin.before_initialize(self, options) if plugin.respond_to?(:before_initialize)
+          end
+        end
+
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set('@plugins', PluginList.new)
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/block_io.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # IO object for response targets.
+    class BlockIO
+      # @param [Hash] headers (nil)
+      # @param [Proc] block
+      def initialize(headers = nil, &block)
+        @headers = headers
+        @block = block
+        @size = 0
+      end
+
+      # @return [Integer]
+      attr_reader :size
+
+      # @param [String] chunk
+      # @return [Integer]
+      def write(chunk)
+        @block.call(chunk, @headers)
+        chunk.bytesize
+      ensure
+        chunk.bytesize.tap { |chunk_size| @size += chunk_size }
+      end
+
+      # @param [Integer] bytes (nil)
+      # @param [String] output_buffer (nil)
+      # @return [String, nil]
+      def read(bytes = nil, output_buffer = nil)
+        data = bytes ? nil : ''
+        output_buffer ? output_buffer.replace(data || '') : data
+      end
+    end
+  end
+end

data/lib/smithy-client/configuration.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # Configuration is used to define possible configuration options and
+    # then build read-only structures with user-supplied data.
+    #
+    # ## Adding Configuration Options
+    #
+    # Add configuration options with optional default values.  These are used
+    # when building configuration objects.
+    #
+    #     configuration = Configuration.new
+    #
+    #     configuration.add_option(:max_retries, 3)
+    #     configuration.add_option(:use_ssl, true)
+    #
+    #     cfg = configuration.build!
+    #     #=> #<struct max_retires=3 use_ssl=true>
+    #
+    # ## Building Configuration Objects
+    #
+    # Calling {#build!} on a {Configuration} object causes it to return
+    # a read-only (frozen) struct. Options passed to {#build!} are merged
+    # on top of any default options.
+    #
+    #     configuration = Configuration.new
+    #     configuration.add_option(:color, 'red')
+    #
+    #     # default
+    #     cfg1 = configuration.build!
+    #     cfg1.color #=> 'red'
+    #
+    #     # supplied color
+    #     cfg2 = configuration.build!(color: 'blue')
+    #     cfg2.color #=> 'blue'
+    #
+    # ## Accepted Options
+    #
+    # If you try to {#build!} a {Configuration} object with an unknown
+    # option, an `ArgumentError` is raised.
+    #
+    #     configuration = Configuration.new
+    #     configuration.add_option(:color)
+    #     configuration.add_option(:size)
+    #     configuration.add_option(:category)
+    #
+    #     configuration.build!(price: 100)
+    #     #=> raises an ArgumentError, :price was not added as an option
+    #
+    class Configuration
+      # @api private
+      Defaults = Class.new(Array) do
+        def each(&block)
+          reverse.to_a.each(&block)
+        end
+      end
+
+      def initialize
+        @defaults = Hash.new { |h, k| h[k] = Defaults.new }
+      end
+
+      # Adds a getter method that returns the named option or a default
+      # value. Default values can be passed as a static positional argument
+      # or via a block.
+      #
+      #    # defaults to nil
+      #    configuration.add_option(:name)
+      #
+      #    # with a string default
+      #    configuration.add_option(:name, 'John Doe')
+      #
+      #    # with a dynamic default value, evaluated once when calling #build!
+      #    configuration.add_option(:name, 'John Doe')
+      #    configuration.add_option(:username) do |config|
+      #       config.name.gsub(/\W+/, '').downcase
+      #    end
+      #    cfg = configuration.build!
+      #    cfg.name #=> 'John Doe'
+      #    cfg.username #=> 'johndoe'
+      #
+      # @param [Symbol] name The name of the configuration option. This will
+      #  be used to define a getter by the same name.
+      #
+      # @param [Object] default The default value for this option. You can specify
+      #  a default by passing a value, a `Proc` object or a block argument.
+      #  Procs and blocks are evaluated when {#build!} is called.
+      #
+      # @return [self]
+      def add_option(name, default = nil, &block)
+        default = DynamicDefault.new(block) if block_given?
+        @defaults[name.to_sym] << default
+        self
+      end
+
+      # Constructs and returns a configuration structure.
+      # Values not present in `options` will default to those supplied via
+      # add option.
+      #
+      #     configuration = Configuration.new
+      #     configuration.add_option(:enabled, true)
+      #
+      #     cfg1 = configuration.build!
+      #     cfg1.enabled #=> true
+      #
+      #     cfg2 = configuration.build!(enabled: false)
+      #     cfg2.enabled #=> false
+      #
+      # If you pass in options to `#build!` that have not been defined,
+      # then an `ArgumentError` will be raised.
+      #
+      #     configuration = Configuration.new
+      #     configuration.add_option(:enabled, true)
+      #
+      #     # oops, spelling error for :enabled
+      #     cfg = configuration.build!(enabld: true)
+      #     #=> raises ArgumentError
+      #
+      # The object returned is a frozen `Struct`.
+      #
+      #     configuration = Configuration.new
+      #     configuration.add_option(:enabled, true)
+      #
+      #     cfg = configuration.build!
+      #     cfg.enabled #=> true
+      #     cfg[:enabled] #=> true
+      #     cfg['enabled'] #=> true
+      #
+      # @param [Hash] options ({}) A hash of configuration options.
+      # @return [Struct] Returns a frozen configuration `Struct`.
+      def build!(options = {})
+        struct = empty_struct
+        apply_options(struct, options)
+        apply_defaults(struct, options)
+        struct
+      end
+
+      private
+
+      def empty_struct
+        Struct.new(*@defaults.keys.sort).new
+      end
+
+      def apply_options(struct, options)
+        options.each do |opt, value|
+          struct[opt] = value
+        rescue NameError
+          msg = "invalid configuration option `#{opt.inspect}'"
+          raise ArgumentError, msg
+        end
+      end
+
+      def apply_defaults(struct, options)
+        @defaults.each do |opt_name, defaults|
+          struct[opt_name] = defaults unless options.key?(opt_name)
+        end
+        DefaultResolver.new(struct).resolve
+      end
+
+      # @api private
+      class DynamicDefault
+        attr_accessor :block
+
+        def initialize(block = nil)
+          @block = block
+        end
+
+        def call(*)
+          @block.call(*)
+        end
+      end
+
+      # @api private
+      class DefaultResolver
+        def initialize(struct)
+          @struct = struct
+          @members = Set.new(@struct.members)
+        end
+
+        def resolve
+          @members.each { |opt_name| value_at(opt_name) }
+        end
+
+        def respond_to?(method_name, *args)
+          @members.include?(method_name) or super
+        end
+
+        private
+
+        def value_at(opt_name)
+          value = @struct[opt_name]
+          if value.is_a?(Defaults)
+            resolve_defaults(opt_name, value)
+          else
+            value
+          end
+        end
+
+        def resolve_defaults(opt_name, defaults)
+          defaults.each do |default|
+            default = default.call(self) if default.is_a?(DynamicDefault)
+            @struct[opt_name] = default
+            break unless default.nil?
+          end
+          @struct[opt_name]
+        end
+
+        def respond_to_missing?(method_name, *args)
+          @members.include?(method_name) || super
+        end
+
+        def method_missing(method_name, *args)
+          if @members.include?(method_name)
+            value_at(method_name)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end