aws-sdk-core 2.0.0.rc1

data/vendor/seahorse/lib/seahorse.rb

@@ -0,0 +1,6 @@
+require 'seahorse/model'
+require 'seahorse/client'
+
+module Seahorse
+  autoload :VERSION, 'seahorse/version'
+end

data/vendor/seahorse/lib/seahorse/client.rb

@@ -0,0 +1,61 @@
+module Seahorse
+  module Client
+
+    autoload :Base, 'seahorse/client/base'
+    autoload :BlockIO, 'seahorse/client/block_io'
+    autoload :Configuration, 'seahorse/client/configuration'
+    autoload :Handler, 'seahorse/client/handler'
+    autoload :HandlerBuilder, 'seahorse/client/handler_builder'
+    autoload :HandlerList, 'seahorse/client/handler_list'
+    autoload :ParamConverter, 'seahorse/client/param_converter'
+    autoload :ParamValidator, 'seahorse/client/param_validator'
+    autoload :Plugin, 'seahorse/client/plugin'
+    autoload :PluginList, 'seahorse/client/plugin_list'
+    autoload :Request, 'seahorse/client/request'
+    autoload :RequestContext, 'seahorse/client/request_context'
+    autoload :Response, 'seahorse/client/response'
+
+    module Http
+      autoload :Endpoint, 'seahorse/client/http/endpoint'
+      autoload :Headers, 'seahorse/client/http/headers'
+      autoload :PlainStringIO, 'seahorse/client/http/plain_string_io'
+      autoload :Request, 'seahorse/client/http/request'
+      autoload :Response, 'seahorse/client/http/response'
+    end
+
+    module Logging
+      autoload :Handler, 'seahorse/client/logging/handler'
+      autoload :Formatter, 'seahorse/client/logging/formatter'
+    end
+
+    module NetHttp
+      autoload :ConnectionPool, 'seahorse/client/net_http/connection_pool'
+      autoload :Handler, 'seahorse/client/net_http/handler'
+    end
+
+    module Plugins
+      autoload :Api, 'seahorse/client/plugins/api'
+      autoload :ContentLength, 'seahorse/client/plugins/content_length'
+      autoload :Endpoint, 'seahorse/client/plugins/endpoint'
+      autoload :JsonSimple, 'seahorse/client/plugins/json_simple'
+      autoload :Logging, 'seahorse/client/plugins/logging'
+      autoload :NetHttp, 'seahorse/client/plugins/net_http'
+      autoload :OperationMethods, 'seahorse/client/plugins/operation_methods'
+      autoload :ParamConversion, 'seahorse/client/plugins/param_conversion'
+      autoload :ParamValidation, 'seahorse/client/plugins/param_validation'
+      autoload :RaiseResponseErrors, 'seahorse/client/plugins/raise_response_errors'
+      autoload :RestfulBindings, 'seahorse/client/plugins/restful_bindings'
+    end
+
+    module Xml
+      autoload :Builder, 'seahorse/client/xml/builder'
+    end
+
+    # @param (see Base.define)
+    # @return (see Base.define)
+    def self.define(options = {})
+      Base.define(options)
+    end
+
+  end
+end

data/vendor/seahorse/lib/seahorse/client/base.rb

@@ -0,0 +1,239 @@
+module Seahorse
+  module Client
+    class Base
+
+      include HandlerBuilder
+
+      # These plugins are applied to every client and can not be removed.
+      # @api private
+      REQUIRED_PLUGINS = [
+        Plugins::Api,
+        Plugins::Endpoint,
+      ]
+
+      # default plugins
+      @plugins = PluginList.new([
+        Plugins::NetHttp,
+        Plugins::OperationMethods,
+        Plugins::ParamConversion,
+        Plugins::ParamValidation,
+        Plugins::RaiseResponseErrors,
+      ])
+
+      # @api private
+      def initialize(plugins, options)
+        @config = build_config(plugins, options)
+        @handlers = handler_list(plugins)
+        after_initialize(plugins)
+      end
+
+      # @return [Configuration<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, String] operation_name
+      # @return [Request]
+      def build_request(operation_name, params = {})
+        Request.new(
+          @handlers.for(operation_name),
+          context_for(operation_name, params))
+      end
+
+      # @param [String] name
+      # @return [Model::Operation]
+      def operation(name)
+        config.api.operations[name] || raise("unknown operation `#{name}'")
+      end
+
+      # @api private
+      def inspect
+        "#<#{self.class.name}>"
+      end
+
+      private
+
+      # Constructs a {Configuration} object and gives each plugin the
+      # opportunity to register options with default values.
+      def build_config(plugins, options)
+        options = options.merge(api: self.class.api) unless options[:api]
+        config = Configuration.new
+        plugins.each do |plugin|
+          plugin.add_options(config) if plugin.respond_to?(:add_options)
+        end
+        config.build!(options)
+      end
+
+      # Gives each plugin the opportunity to register handlers for this client.
+      def handler_list(plugins)
+        handlers = HandlerList.new
+        plugins.each do |plugin|
+          if plugin.respond_to?(:add_handlers)
+            plugin.add_handlers(handlers, @config)
+          end
+        end
+        handlers
+      end
+
+      # Gives each plugin the opportunity to modify this client.
+      def after_initialize(plugins)
+        plugins.each do |plugin|
+          plugin.after_initialize(self) if plugin.respond_to?(:after_initialize)
+        end
+      end
+
+      # @return [RequestContext]
+      def context_for(operation_name, params)
+        RequestContext.new(
+          operation_name: operation_name.to_s,
+          operation: operation(operation_name),
+          client: self,
+          params: params,
+          config: config)
+      end
+
+      class << self
+
+        # @option options [String] :endpoint
+        #   Endpoints specify the http scheme, hostname and port to connect
+        #   to.  You must specify at a minimum the hostname.  Endpoints without
+        #   a uri scheme will default to https on port 443.
+        #
+        #       # defaults to https on port 443
+        #       hostname: 'domain.com'
+        #
+        #       # defaults to http on port 80
+        #       hostname: 'domain.com', ssl_default: false
+        #
+        #       # defaults are ignored, as scheme and port are present
+        #       hostname: 'http://domain.com:123'
+        #
+        # @option options [Boolean] :ssl_default (true) Specifies the default
+        #   scheme for the #endpoint when not specified.  Defaults to `true`
+        #   which creates https endpoints.
+        #
+        def new(options = {})
+          plugins = build_plugins
+          options = options.dup
+          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 by name
+        #
+        #   ClientClass.add_plugin('gem-name.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 set_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
+          (REQUIRED_PLUGINS + Array(@plugins)).freeze
+        end
+
+        # @return [Model::Api]
+        def api
+          @api ||= Model::Api.new
+        end
+
+        # @param [Model::Api, Hash] api
+        # @return [Model::Api]
+        def set_api(api)
+          api = Model::Api.from_hash(api) if api.is_a?(Hash)
+          Array(api.plugins).each do |plugin|
+            add_plugin(plugin)
+          end
+          @api = api
+        end
+
+        # @option options [Model::Api, Hash] :api ({})
+        # @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.set_api(options[:api] || api)
+          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)
+          subclass.instance_variable_set('@plugins', PluginList.new(@plugins))
+        end
+
+      end
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/client/block_io.rb

@@ -0,0 +1,39 @@
+module Seahorse
+  module Client
+    class BlockIO
+
+      def initialize(&block)
+        @block = block
+        @size = 0
+      end
+
+      # @param [String] chunk
+      # @return [Integer]
+      def write(chunk)
+        @block.call(chunk)
+        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
+
+      # @return [Integer]
+      def size
+        @size
+      end
+
+      # It is not possible to rewind a {BlockIO} object as the data has
+      # already been yielded.
+      # @return [NotImplementedError]
+      def rewind
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/client/configuration.rb

@@ -0,0 +1,197 @@
+require 'set'
+
+module Seahorse
+  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
+      def initialize
+        @defaults = {}
+      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 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)
+        @defaults[name.to_sym] = block_given? ?
+          UnresolvedOption.new(Proc.new) :
+          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 = default_struct
+        options.each do |opt, value|
+          begin
+            struct[opt] = value
+          rescue NameError
+            msg = "invalid configuration option `#{opt.inspect}'"
+            raise ArgumentError, msg
+          end
+        end
+        OptionBlockResolver.new(struct).struct.freeze
+      end
+
+      private
+
+      def default_struct
+        Struct.new(*@defaults.keys).new(*@defaults.values_at(*@defaults.keys))
+      end
+
+      # @api private
+      class UnresolvedOption
+
+        def initialize(block)
+          @block = block
+        end
+
+        attr_reader :block
+
+      end
+
+      # @api private
+      class OptionBlockResolver
+
+        def initialize(struct)
+          @struct = struct
+          @members = Set.new(@struct.members)
+          @struct.members.each do |opt|
+            if struct[opt].is_a?(UnresolvedOption)
+              struct[opt] = struct[opt].block.call(self)
+            end
+          end
+        end
+
+        attr_reader :struct
+
+        def respond_to?(method_name)
+          @members.include?(method_name.to_sym) || super
+        end
+
+        private
+
+        def method_missing(method_name, *args)
+          if @members.include?(method_name)
+            resolve_blocks(method_name)
+          else
+            super
+          end
+        end
+
+        def resolve_blocks(member)
+          if @struct[member].is_a?(UnresolvedOption)
+            @struct[member] = @struct[member].block.call(self)
+          end
+          @struct[member]
+        end
+
+      end
+    end
+  end
+end