aws-sdk-core 2.0.0.rc1 → 2.0.0.rc2

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

@@ -16,24 +16,17 @@ module Seahorse
       #     puts Endpoint.new('foo.com')
       #     #=> 'https://foo.com'
       #
-      # You can default to a HTTP endpoint by passing `:ssl_default` as `false`:
-      #
-      #     puts Endpoint.new('foo.com', ssl_default: false)
-      #     #=> 'http://foo.com'
-      #
       class Endpoint
 
         # @param [Endpoint, String] endpoint
-        # @option options [Boolean] :ssl_default (true)
-        def initialize(endpoint, options = {})
+        def initialize(endpoint)
           endpoint = endpoint.to_s
-          unless endpoint =~ /^http/
-            endpoint = apply_scheme(endpoint, options)
-          end
+          endpoint = "https://#{endpoint}" unless endpoint =~ /^http/
           URI.parse(endpoint).tap do |uri|
             @scheme = uri.scheme
             @host = uri.host
             @port = uri.port
+            @request_uri = uri.request_uri
             @user = uri.user
             @password = uri.password
           end
@@ -48,12 +41,26 @@ module Seahorse
         # @return [Integer] Returns the endpoint port number (e.g. 443).
         attr_accessor :port
 
+        # @return [String] Returns the path and querystring,
+        #   e.g. '/path?querystring'.
+        attr_accessor :request_uri
+
         # @return [String, nil]
         attr_accessor :user
 
         # @return [String, nil]
         attr_accessor :password
 
+        # @return [String]
+        def path
+          request_uri.split('?', 2)[0]
+        end
+
+        # @return [String, nil]
+        def querystring
+          request_uri.split('?', 2)[1]
+        end
+
         # @return [Boolean]
         def http?
           @scheme == 'http'
@@ -67,7 +74,8 @@ module Seahorse
         # @return [String]
         # @api private
         def inspect
-          URI.parse("#{@scheme}://#{userpass}#{@host}:#{@port}").to_s
+          uri = "#{@scheme}://#{userpass}#{@host}:#{@port}#{@request_uri}"
+          URI.parse(uri).to_s
         end
         alias to_str inspect
         alias to_s inspect
@@ -81,10 +89,6 @@ module Seahorse
 
         private
 
-        def apply_scheme(endpoint, options)
-          "http#{options.fetch(:ssl_default, true) ? 's' : ''}://#{endpoint}"
-        end
-
         def userpass
           [@user, @password].compact.join(':') + '@' if @user
         end

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

@@ -7,13 +7,11 @@ module Seahorse
 
         # @option options [Endpoint] :endpoint (nil)
         # @option options [String] :http_method ('GET')
-        # @option options [String] :path ('/')
         # @option options [Headers] :headers (Headers.new)
         # @option options [Body] :body (StringIO.new)
         def initialize(options = {})
           self.endpoint = options[:endpoint] if options[:endpoint]
           self.http_method = options[:http_method] || 'GET'
-          self.path = options[:path] || '/'
           self.headers = Headers.new(options[:headers] || {})
           self.headers['User-Agent'] ||= ua
           self.body = options[:body]
@@ -28,9 +26,6 @@ module Seahorse
         # @return [Headers] The hash of request headers.
         attr_accessor :headers
 
-        # @return [String] The path name and querystring, e.g. `/abc?mno=xyz`.
-        attr_accessor :path
-
         # @return [IO]
         attr_reader :body
 
@@ -46,16 +41,6 @@ module Seahorse
           contents
         end
 
-        # @return [String]
-        def pathname
-          path.split('?', 2)[0]
-        end
-
-        # @return [String]
-        def querystring
-          path.split('?', 2)[1] || ''
-        end
-
         # @param [#read, #size, #rewind] io
         def body=(io)
           @body = case io

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

@@ -53,9 +53,6 @@ module Seahorse
       #
       #   * `:http_request_port` - The port number (e.g. '443' or '80').
       #
-      #   * `:http_request_path` - The full path (pathname plus querystring)
-      #     for the request, e.g., `/bucket_name/objects/key?versions`.
-      #
       #   * `:http_request_headers` - The http request headers, inspected.
       #
       #   * `:http_request_body` - The http request payload.
@@ -157,10 +154,6 @@ module Seahorse
           response.context.http_request.http_method
         end
 
-        def _http_request_path(response)
-          response.context.http_request.path
-        end
-
         def _http_request_headers(response)
           response.http_request.headers.inspect
         end

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

@@ -0,0 +1,14 @@
+module Seahorse
+  module Client
+    # This utility class is used to track files opened by Seahorse.
+    # This allows Seahorse to know what files it needs to close.
+    class ManagedFile < File
+
+      # @return [Boolean]
+      def open?
+        !closed?
+      end
+
+    end
+  end
+end

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

@@ -44,8 +44,6 @@ module Seahorse
                 response.body.write(chunk)
               end
 
-              response.body.rewind
-
             end
           end
         end
@@ -66,7 +64,7 @@ module Seahorse
         # @return [Net::HTTP::Request]
         def net_http_request(request)
           request_class = net_http_request_class(request)
-          req = request_class.new(request.path, headers(request))
+          req = request_class.new(request.endpoint.request_uri, headers(request))
           req.body_stream = request.body
           req
         end

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

@@ -14,7 +14,7 @@ module Seahorse
 
         end
 
-        handler(Handler, step: :sign, proiority: 0)
+        handler(Handler, step: :sign, priority: 0)
 
       end
     end

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

@@ -12,24 +12,95 @@ module Seahorse
       #        'http://example.com:123'
       #
       #    This must include the host.  It may also include the scheme and
-      #    port.  When the scheme is not set it defaults to `https`
-      #    or `http` based on the `:ssl_default` option.
-      #
-      # @seahorse.client.option [Boolean] :ssl_default (true)
-      #    When `true`, endpoints without a scheme are prefixed by `http://`.
-      #    When `false`, endpoints without a scheme are prefixed by `http://`.
+      #    port.  When the scheme is not set it defaults to `https`.
       #
       class Endpoint < Plugin
 
         option(:endpoint) { |config| config.api.endpoint }
 
-        option(:ssl_default, true)
+        class Handler < Client::Handler
+
+          def call(context)
+            endpoint = Http::Endpoint.new(context.config.endpoint)
+            apply_url_params(endpoint, context)
+            context.http_request.endpoint = endpoint
+            @handler.call(context)
+          end
+
+          def apply_url_params(endpoint, context)
+            prefix = endpoint.path.sub(/\/$/, '')
+            endpoint.request_uri = prefix + RequestUriBuilder.new(
+              context.operation.http_path || '/',
+              context.operation.input.uri_members,
+            ).path(context.params)
+          end
 
-        handle_request(:EndpointHandler, priority: 90) do |context|
-          context.http_request.endpoint = Http::Endpoint.new(
-            context.config.endpoint, ssl_default: context.config.ssl_default)
         end
 
+        handle(Handler, priority: 90)
+
+        # @api private
+        class RequestUriBuilder
+
+          PLACEHOLDER_REGEX = /{\w+?}/
+
+          # @param [String] path_pattern
+          # @param [Hash<Model::Shapes::Shape>] rules
+          def initialize(path_pattern, rules)
+            @pattern = path_pattern
+            @rules = rules
+          end
+
+          # @param [Hash] params
+          # @return [String<URI path>]
+          def path(params)
+            path, querystring = @pattern.split('?')
+            path = escape_path_params(path, params)
+            if querystring
+              querystring = escape_querystring_params(querystring, params)
+              path = "#{path}?#{querystring}" unless querystring.empty?
+            end
+            path
+          end
+
+          private
+
+          def escape_path_params(path, params)
+            path.gsub(PLACEHOLDER_REGEX) do |placeholder|
+              param_value = params[param_name(placeholder)]
+              path_escape(param_value)
+            end
+          end
+
+          def escape_querystring_params(querystring, params)
+            parts = []
+            querystring.split('&').each do |part|
+              if match = part.match(PLACEHOLDER_REGEX)
+                placeholder = match[0]
+                param_value = params[param_name(placeholder)]
+                unless param_value.nil?
+                  parts << part.sub(placeholder, escape(param_value.to_s))
+                end
+              else
+                parts << part # querystring param has no substitution
+              end
+            end
+            parts.join('&')
+          end
+
+          def param_name(placeholder)
+            placeholder[1..-2].to_sym
+          end
+
+          def path_escape(value)
+            escape(value).gsub('%2F', '/')
+          end
+
+          def escape(string)
+            CGI::escape(string.encode('UTF-8')).gsub('+', '%20').gsub('%7E', '~')
+          end
+
+        end
       end
     end
   end

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

@@ -19,7 +19,6 @@ module Seahorse
 
           def build_request(context)
             populate_method(context)
-            populate_path(context)
             populate_headers(context)
             populate_body(context)
           end
@@ -28,13 +27,6 @@ module Seahorse
             context.http_request.http_method = context.operation.http_method
           end
 
-          def populate_path(context)
-            builder = UriPathBuilder.new(
-              context.operation.http_path,
-              context.operation.input.uri_members)
-            context.http_request.path = builder.path(context.params)
-          end
-
           def populate_headers(context)
             context.operation.input.header_members.each do |member_name, member|
               value = context.params[member_name]
@@ -78,7 +70,7 @@ module Seahorse
 
           def parse_response(response)
             output = response.context.operation.output
-            response.data ||= Structure.new(output.members.keys)
+            response.data ||= Aws::Structure.new(output.members.keys)
             extract_headers(response)
             extract_body(response)
           end
@@ -137,68 +129,6 @@ module Seahorse
 
         handle(Handler, priority: 90)
 
-        # @api private
-        class UriPathBuilder
-
-          PLACEHOLDER_REGEX = /{\w+?}/
-
-          # @param [String] path_pattern
-          # @param [Hash<Model::Shapes::Shape>] rules
-          def initialize(path_pattern, rules)
-            @pattern = path_pattern
-            @rules = rules
-          end
-
-          # @param [Hash] params
-          # @return [String<URI path>]
-          def path(params)
-            path, querystring = @pattern.split('?')
-            path = escape_path_params(path, params)
-            if querystring
-              querystring = escape_querystring_params(querystring, params)
-              path = "#{path}?#{querystring}" unless querystring.empty?
-            end
-            path
-          end
-
-          private
-
-          def escape_path_params(path, params)
-            path.gsub(PLACEHOLDER_REGEX) do |placeholder|
-              param_value = params[param_name(placeholder)]
-              path_escape(param_value)
-            end
-          end
-
-          def escape_querystring_params(querystring, params)
-            parts = []
-            querystring.split('&').each do |part|
-              if match = part.match(PLACEHOLDER_REGEX)
-                placeholder = match[0]
-                param_value = params[param_name(placeholder)]
-                unless param_value.nil?
-                  parts << part.sub(placeholder, escape(param_value.to_s))
-                end
-              else
-                parts << part # querystring param has no substitution
-              end
-            end
-            parts.join('&')
-          end
-
-          def param_name(placeholder)
-            placeholder[1..-2].to_sym
-          end
-
-          def path_escape(value)
-            escape(value).gsub('%2F', '/')
-          end
-
-          def escape(string)
-            CGI::escape(string.encode('UTF-8')).gsub('+', '%20').gsub('%7E', '~')
-          end
-
-        end
       end
     end
   end

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

@@ -52,9 +52,32 @@ module Seahorse
       #
       # @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)
+        set_target(options, &block)
+        resp = @handlers.to_stack.call(@context)
+        close_managed_files
+        resp
+      end
+
+      private
+
+      def set_target(options, &block)
+        if target = options[:target] || block
+          @context.http_response.body =
+            case target
+            when Proc then BlockIO.new(&target)
+            when String, Pathname then ManagedFile.new(target, 'wb')
+            else target
+          end
+        end
+      end
+
+      def close_managed_files
+        [
+          @context.http_request.body,
+          @context.http_response.body,
+        ].each do |io|
+          io.close if io.is_a?(ManagedFile) && io.open?
+        end
       end
 
     end

data/vendor/seahorse/spec/seahorse/client/base_spec.rb

@@ -40,10 +40,6 @@ module Seahorse
           expect(client.config.endpoint).to eq(api['endpoint'])
         end
 
-        it 'defaults ssl_default to true' do
-          expect(client.config.ssl_default).to equal(true)
-        end
-
         it 'passes constructor args to the config' do
           expect {
             client_class.new(foo: 'bar')
@@ -63,7 +59,7 @@ module Seahorse
           client_class.add_plugin(Plugins::NetHttp)
           expect(client.handlers.to_a).to eq([
             NetHttp::Handler,
-            Plugins::Endpoint::EndpointHandler,
+            Plugins::Endpoint::Handler,
           ])
         end
 

data/vendor/seahorse/spec/seahorse/client/configuration_spec.rb

@@ -64,7 +64,7 @@ module Seahorse
         it 'returns self so it can be chained' do
           c = config.add_option(:name).add_option(:color)
           expect(c).to be(config)
-          expect(c.build!.members).to eq([:name, :color])
+          expect(c.build!.members).to eq([:color, :name])
         end
 
       end
@@ -75,15 +75,6 @@ module Seahorse
           expect(config.add_option(:opt).build!).to be_kind_of(Struct)
         end
 
-        it 'returns a frozen structure' do
-          config.add_option(:foo)
-          c = config.build!
-          expect(c).to be_frozen
-          expect {
-            c.foo = 'bar'
-          }.to raise_error(/can't modify frozen/)
-        end
-
         it 'accepts a hash of options' do
           config.add_option(:size, 'default')
           config.add_option(:color, 'default')