aws-sdk-core 2.0.0.rc1

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

@@ -0,0 +1,62 @@
+module Seahorse
+  module Client
+    class Request
+
+      include HandlerBuilder
+
+      # @param [HandlerList] handlers
+      # @param [RequestContext] context
+      def initialize(handlers, context)
+        @handlers = handlers
+        @context = context
+      end
+
+      # @return [HandlerList]
+      attr_reader :handlers
+
+      # @return [RequestContext]
+      attr_reader :context
+
+      # Sends the request, returning a {Response} object.
+      #
+      #     response = request.send_request
+      #
+      # # Streaming Responses
+      #
+      # By default, HTTP responses are buffered into memory.  This can be
+      # bad if you are downloading large responses, e.g. large files.
+      # You can avoid this by streaming the response to a block or some other
+      # target.
+      #
+      # ## Streaming to a File
+      #
+      # You can stream the raw HTTP response body to a File, or any IO-like
+      # object, by passing the `:target` option.
+      #
+      #     File.open('photo.jpg', 'wb') do |file|
+      #       request.send_request(target: file)
+      #     end
+      #
+      # ## Block Streaming
+      #
+      # Pass a block to `#send_request` and the response will be yielded in
+      # chunks to the given block.
+      #
+      #     # stream the response data
+      #     request.send_request do |chunk|
+      #       file.write(chunk)
+      #     end
+      #
+      # **Please Note**: When streaming to a block, it is not possible to
+      # retry failed requests.
+      #
+      # @return [Response]
+      def send_request(options = {}, &block)
+        @context.http_response.body = BlockIO.new(&block) if block_given?
+        @context.http_response.body = options[:target] if options[:target]
+        @handlers.to_stack.call(@context)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'stringio'
+
+module Seahorse
+  module Client
+    class RequestContext
+
+      # @option options [required,String] :operation_name (nil)
+      # @option options [required,Model::Operation] :operation (nil)
+      # @option options [Hash] :params ({})
+      # @option options [Configuration] :config (nil)
+      # @option options [Http::Request] :http_request (Http::Request.new)
+      # @option options [Http::Response] :http_response (Http::Response.new)
+      #   and #rewind.
+      def initialize(options = {})
+        @operation_name = options[:operation_name]
+        @operation = options[:operation]
+        @client = options[:client]
+        @params = options[:params] || {}
+        @config = options[:config]
+        @http_request = options[:http_request] || Http::Request.new
+        @http_response = options[:http_response] || Http::Response.new
+        @retries = 0
+        @metadata = {}
+      end
+
+      # @return [String] Name of the API operation called.
+      attr_accessor :operation_name
+
+      # @return [Model::Operation]
+      attr_accessor :operation
+
+      # @return [Seahorse::Client::Base]
+      attr_accessor :client
+
+      # @return [Hash] The hash of request parameters.
+      attr_accessor :params
+
+      # @return [Configuration] The client configuration.
+      attr_accessor :config
+
+      # @return [Http::Request]
+      attr_accessor :http_request
+
+      # @return [Http::Response]
+      attr_accessor :http_response
+
+      # @return [Integer]
+      attr_accessor :retries
+
+      # Returns the metadata for the given `key`.
+      # @param [Symbol] key
+      # @return [Object]
+      def [](key)
+        @metadata[key]
+      end
+
+      # Sets the request context metadata for the given `key`.  Request metadata
+      # useful for handlers that need to keep state on the request, without
+      # sending that data with the request over HTTP.
+      # @param [Symbol] key
+      # @param [Object] value
+      def []=(key, value)
+        @metadata[key] = value
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+require 'thread'
+
+module Seahorse
+  module Client
+    class Response
+
+      # @option options [RequestContext] :context (nil)
+      # @option options [Integer] :status_code (nil)
+      # @option options [Http::Headers] :headers (Http::Headers.new)
+      # @option options [String] :body ('')
+      def initialize(options = {})
+        @context = options[:context] || RequestContext.new
+        @data = options[:data]
+        @error = options[:error]
+        @http_request = @context.http_request
+        @http_response = @context.http_response
+      end
+
+      # @return [RequestContext]
+      attr_reader :context
+
+      # @return [Http::Request]
+      attr_reader :http_request
+
+      # @return [Http::Response]
+      attr_reader :http_response
+
+      # @return The response data.  This may be `nil` if the response contains
+      #   an {#error}.
+      attr_accessor :data
+
+      # @return [StandardError, nil]
+      attr_accessor :error
+
+      # @param [Range<Integer>] status_code_range (nil) When present, the
+      #   `block` will be triggered only for responses with a status code
+      #   in the given range.
+      # @return [Response] Returns self.
+      def on_status(status_code_range = nil, &block)
+        if status_code_range.nil? || status_code_range.include?(status_code)
+          yield(self)
+        end
+        self
+      end
+
+      # Yields to the given block if the HTTP request received a response.
+      def on_complete(&block)
+        on_status(200..599, &block)
+      end
+
+      # Yields to the given block if the HTTP request received response with a
+      # ~ 200 level status code.
+      def on_success(&block)
+        on_status(200..299, &block)
+      end
+
+      # Yields to the given block if the HTTP request received response with a
+      # ~ 300 level status code.
+      def on_redirect(&block)
+        on_status(300..399, &block)
+      end
+
+      # Yields to the given block if the HTTP request received response with a
+      # ~ 400 or 500 level status code.
+      def on_error(&block)
+        on_status(400..599, &block)
+      end
+
+      # Yields to the given block if the HTTP request failed to receive any
+      # response.  This generally indicates there was a network 
+      # level status code.
+      def on_failure(&block)
+        on_status(0..0, &block)
+      end
+
+      # @api private
+      def respond_to?(*args)
+        @data.respond_to?(args.first, false) || super
+      end
+
+      # @api private
+      def inspect
+        if @data
+          @data.respond_to?(:pretty_inspect) ? @data.pretty_inspect : super
+        else
+          super
+        end
+      end
+
+      private
+
+      def status_code
+        @http_response.status_code
+      end
+
+      def method_missing(*args, &block)
+        if @data.respond_to?(args.first, false)
+          @data.send(*args, &block)
+        else
+          super
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module Seahorse
+  module Client
+    module Xml
+      class Builder
+
+        # @api private
+        class XmlDoc
+
+          # @option options [#<<] :target ('')
+          # @option options [String] :pad ('')
+          # @option options [String] :indent ('')
+          def initialize(options = {})
+            @target = options[:target] || ''
+            @indent = options[:indent] || ''
+            @pad = options[:pad] || ''
+            @end_of_line = @indent == '' ? '' : "\n"
+          end
+
+          attr_reader :target
+
+          # @overload node(name, attributes = {})
+          #   Adds a self closing element without any content.
+          #
+          # @overload node(name, value, attributes = {})
+          #   Adds an element that opens and closes on the same line with
+          #   simple text content.
+          #
+          # @overload node(name, attributes = {}, &block)
+          #   Adds a wrapping element.  Calling {#node} from inside
+          #   the yielded block creates nested elements.
+          #
+          # @return [void]
+          #
+          def node(name, *args, &block)
+            attrs = args.last.is_a?(Hash) ? args.pop : {}
+            if block_given?
+              @target << open_el(name, attrs)
+              @target << @end_of_line
+              increase_pad { yield }
+              @target << @pad
+              @target << close_el(name)
+            elsif args.empty?
+              @target << empty_element(name, attrs)
+            else
+              @target << inline_element(name, args.first, attrs)
+            end
+          end
+
+          private
+
+          def empty_element(name, attrs)
+            "#{@pad}<#{name}#{attributes(attrs)}/>#{@end_of_line}"
+          end
+
+          def inline_element(name, value, attrs)
+            "#{open_el(name, attrs)}#{escape(value)}#{close_el(name)}"
+          end
+
+          def open_el(name, attrs)
+            "#{@pad}<#{name}#{attributes(attrs)}>"
+          end
+
+          def close_el(name)
+            "</#{name}>#{@end_of_line}"
+          end
+
+          def escape(string)
+            string.to_s
+          end
+
+          def attributes(attr)
+            if attr.empty?
+              ''
+            else
+              ' ' + attr.map do |key, value|
+                "#{key}=\"#{escape(value).gsub('"', '&quot;')}\""
+              end.join(' ')
+            end
+          end
+
+          def increase_pad(&block)
+            pre_increase = @pad
+            @pad = @pad + @indent
+            yield
+            @pad = pre_increase
+          end
+
+        end
+      end
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/model.rb

@@ -0,0 +1,38 @@
+
+module Seahorse
+  module Model
+
+    autoload :Api, 'seahorse/model/api'
+    autoload :Node, 'seahorse/model/node'
+    autoload :Operation, 'seahorse/model/operation'
+    autoload :Operations, 'seahorse/model/operations'
+    autoload :OperationInput, 'seahorse/model/operation_input'
+    autoload :Property, 'seahorse/model/property'
+    autoload :PropertyError, 'seahorse/model/property'
+
+    module Shapes
+      autoload :BlobShape, 'seahorse/model/shapes/shape'
+      autoload :BooleanShape, 'seahorse/model/shapes/shape'
+      autoload :DoubleShape, 'seahorse/model/shapes/shape'
+      autoload :IntegerShape, 'seahorse/model/shapes/shape'
+      autoload :InputShape, 'seahorse/model/shapes/shape'
+      autoload :Iso8601TimestampShape, 'seahorse/model/shapes/shape'
+      autoload :FloatShape, 'seahorse/model/shapes/shape'
+      autoload :ListShape, 'seahorse/model/shapes/shape'
+      autoload :LongShape, 'seahorse/model/shapes/shape'
+      autoload :MapShape, 'seahorse/model/shapes/shape'
+      autoload :MemberHash, 'seahorse/model/shapes/shape'
+      autoload :Rfc822TimestampShape, 'seahorse/model/shapes/shape'
+      autoload :Shape, 'seahorse/model/shapes/shape'
+      autoload :StringShape, 'seahorse/model/shapes/shape'
+      autoload :StructureShape, 'seahorse/model/shapes/shape'
+      autoload :TimestampShape, 'seahorse/model/shapes/shape'
+      autoload :UnixTimestampShape, 'seahorse/model/shapes/shape'
+    end
+
+    module Types
+      autoload :Boolean, 'seahorse/model/types'
+    end
+
+  end
+end

data/vendor/seahorse/lib/seahorse/model/api.rb

@@ -0,0 +1,39 @@
+
+module Seahorse
+  module Model
+    class Api < Node
+
+      property :version, String
+      property :endpoint, String
+      property :metadata, Hash
+      property :plugins, [String]
+      property :documentation, String
+      property :operations, Operations
+
+      def initialize(*)
+        super
+        self.metadata = {}
+        self.plugins = []
+        self.operations = Operations.new
+      end
+
+      def validate!
+        operations.load!
+        true
+      end
+
+      def to_hash
+        operations.load!
+        hash = super
+        hash.delete('metadata') if hash['metadata'].empty?
+        hash.delete('plugins') if hash['plugins'].empty?
+        hash
+      end
+
+      def inspect
+        "#<#{self.class.name} version=#{version}>"
+      end
+
+    end
+  end
+end

data/vendor/seahorse/lib/seahorse/model/node.rb

@@ -0,0 +1,102 @@
+module Seahorse
+  module Model
+    class Node
+      include Types
+      include Shapes
+
+      class IndifferentHash < Hash
+        def [](k) super(k.to_s) end
+        def []=(k, v) super(k.to_s, v) end
+        def has_key?(k) super(k.to_s) end
+      end
+
+      class << self
+        # @!macro [attach] model.property
+        #   @!attribute $1
+        #     @return [$2]
+        def property(name, klass, opts = {})
+          attr_accessor(name)
+          @properties ||= IndifferentHash.new
+          @inner_properties ||= IndifferentHash.new
+
+          property = Property.new(name, klass, opts)
+          if property.serialized_location
+            @inner_properties[property.serialized_location] = true
+          end
+
+          @properties[property.serialized_name] = property
+        end
+
+        # @!attribute [r] properties
+        def properties
+          return @final_properties if @final_properties
+
+          @final_properties = IndifferentHash.new
+
+          klass = superclass
+          while klass != Node
+            @final_properties.update(klass.properties)
+            klass = klass.superclass
+          end
+
+          @final_properties.update(@properties) if @properties
+          @final_properties
+        end
+
+        # @!attribute [r] inner_properties
+        def inner_properties
+          return @final_inner_properties if @final_inner_properties
+
+          @final_inner_properties = IndifferentHash.new
+
+          klass = superclass
+          while klass != Node
+            @final_inner_properties.update(klass.inner_properties)
+            klass = klass.superclass
+          end
+
+          if @inner_properties
+            @final_inner_properties.update(@inner_properties)
+          end
+
+          @final_inner_properties
+        end
+
+        def from_hash_class(hash) self end
+
+        def from_hash(hash)
+          return unless hash
+
+          unrecognized_properties = []
+          klass = from_hash_class(hash)
+          obj = klass.new
+          hashes = [hash]
+          while hashes.size > 0
+            hashes.pop.each do |key, value|
+              next hashes.unshift(value) if inner_properties[key.to_s]
+
+              if prop = klass.properties[key.to_s]
+                obj.send("#{prop.name}=", prop.load_from(hash))
+              else
+                unrecognized_properties << key
+              end
+            end
+          end
+
+          if unrecognized_properties.size > 0
+            raise "Unrecognized properties: " +
+                  "#{unrecognized_properties.join(', ')} on #{hash}"
+          else
+            obj
+          end
+        end
+      end
+
+      def to_hash
+        self.class.properties.inject({}) do |hsh, (key, prop)|
+          prop.write_to(hsh, send(prop.name)); hsh
+        end
+      end
+    end
+  end
+end