aws-sdk-core 2.0.48 → 2.1.0

data/lib/aws-sdk-core/paging/null_provider.rb

@@ -1,13 +0,0 @@
-module Aws
-  module Paging
-    class NullProvider
-
-      # @param [String] operation_name
-      # @return [NullPager]
-      def pager(operation_name)
-        NullPager.new
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-core/paging/pager.rb

@@ -1,70 +0,0 @@
-module Aws
-  module Paging
-    class Pager
-
-      def initialize(rules)
-        if rules['more_results']
-          @more_results = underscore(rules['more_results'])
-        end
-        if rules['limit_key']
-          @limit_key = underscore(rules['limit_key']).to_sym
-        end
-        map_tokens(rules)
-      end
-
-      # @return [Symbol, nil]
-      attr_reader :limit_key
-
-      # @param [Seahorse::Client::Response] response
-      # @return [Hash]
-      def next_tokens(response)
-        @tokens.each.with_object({}) do |(source, target), next_tokens|
-          value = JMESPath.search(source, response.data)
-          next_tokens[target.to_sym] = value unless empty_value?(value)
-        end
-      end
-
-      # @api private
-      def prev_tokens(response)
-        @tokens.each.with_object({}) do |(_, target), tokens|
-          value = JMESPath.search(target, response.context.params)
-          tokens[target.to_sym] = value unless empty_value?(value)
-        end
-      end
-
-      # @param [Seahorse::Client::Response] response
-      # @return [Boolean]
-      def truncated?(response)
-        if @more_results
-          JMESPath.search(@more_results, response.data)
-        else
-          next_tokens = self.next_tokens(response)
-          prev_tokens = self.prev_tokens(response)
-          !(next_tokens.empty? || next_tokens == prev_tokens)
-        end
-      end
-
-      private
-
-      def map_tokens(rules)
-        input = Array(rules['input_token'])
-        output = Array(rules['output_token'])
-        @tokens = {}
-        input.each.with_index do |key, n|
-          @tokens[underscore(output[n])] = underscore(key)
-        end
-      end
-
-      def underscore(str)
-        str.
-          gsub(' or ', '||').
-          gsub(/\w+/) { |part| Seahorse::Util.underscore(part) }
-      end
-
-      def empty_value?(value)
-        value.nil? || value == '' || value == [] || value == {}
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-core/paging/provider.rb

@@ -1,22 +0,0 @@
-module Aws
-  module Paging
-    class Provider
-
-      # @param [Hash] rules
-      def initialize(rules)
-        @operations = rules['pagination'].select { |k,v| v.key?('input_token') }
-      end
-
-      # @param [String] operation_name
-      # @return [Pager]
-      def pager(operation_name)
-        if rules = @operations[operation_name]
-          Pager.new(rules)
-        else
-          NullPager.new
-        end
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-core/rest_body_handler.rb

@@ -1,111 +0,0 @@
-module Aws
-  # @api private
-  class RestBodyHandler < Seahorse::Client::Handler
-
-    # @param [Seahorse::Client::RequestContext] context
-    # @return [Seahorse::Client::Response]
-    def call(context)
-      context.http_request.body = build_body(context)
-      @handler.call(context).on_success do |response|
-        response.data = extract_data(response.context) unless response.data
-      end.on(200..599) do |respson|
-        context[:request_id] = extract_request_id(context)
-      end
-    end
-
-    private
-
-    def extract_request_id(context)
-      headers = context.http_response.headers
-      headers['x-amz-request-id'] || headers['x-amzn-requestid']
-    end
-
-    def build_body(context)
-      input = context.operation.input
-      case
-      when input.nil?
-        nil
-      when streaming?(input)
-        context.params[input.payload]
-      when input.payload
-        if params = context.params[input.payload]
-          serialize_params(input.payload_member, params)
-        end
-      else
-        params = body_params(input, context.params)
-        serialize_params(input, params) unless params.empty?
-      end
-    end
-
-    def extract_data(context)
-      if output = context.operation.output
-        data = Structure.new(output.member_names)
-        if streaming?(output)
-          data[output.payload] = context.http_response.body
-        elsif output.payload
-          data[output.payload] = parse(context, output.payload_member)
-        else
-          parse(context, output, data)
-        end
-        data
-      else
-        EmptyStructure.new
-      end
-    end
-
-    def body_members_shape(shape)
-      if shape.payload
-        shape.payload_member
-      else
-        members = shape.members.each.with_object({}) do |(name, member), hash|
-          if member.location == 'body'
-            hash[name.to_s] = member.definition
-          end
-        end
-        definition = shape.definition.merge('members' => members)
-        options = { shape_map: shape.shape_map }
-        Seahorse::Model::Shapes::Shape.new(definition, options)
-      end
-    end
-
-    def body_params(shape, params)
-      shape.members.each.with_object({}) do |(member_name, member_shape), hash|
-        if member_shape.location == 'body'
-          hash[member_name] = params[member_name] if params.key?(member_name)
-        end
-      end
-    end
-
-    def streaming?(shape)
-      shape.payload && (
-        Seahorse::Model::Shapes::Blob === shape.payload_member ||
-        Seahorse::Model::Shapes::String === shape.payload_member
-      )
-    end
-
-    def serialize_params(shape, params)
-      raise NotImplementedError, 'must be defiend in sublcasses'
-    end
-
-    def body_contents(context)
-      context.http_response.body_contents
-    end
-
-    def parse(context, shape, target = nil)
-      body = context.http_response.body_contents
-      if body.bytesize == 0
-        nil
-      else
-        parse_body(body, shape, target)
-      end
-    end
-
-    # @param [String] body
-    # @param [Seahorse::Model::Shapes::Structure] shape
-    # @param [Structure] target
-    def parse_body(body, shape, target)
-      raise NotImplementedError, 'must be defiend in sublcasses'
-    end
-
-  end
-end

data/lib/aws-sdk-core/signers/handler.rb

@@ -1,18 +0,0 @@
-module Aws
-  module Signers
-    class Handler
-
-      def initialize(signer)
-        @signer = signer
-      end
-
-      attr_accessor :handler
-
-      def call(context)
-        @signer.sign(context)
-        @handler.call(context)
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-core/xml/rest_handler.rb

@@ -1,20 +0,0 @@
-module Aws
-  module Xml
-    class RestHandler < RestBodyHandler
-
-      # @param [Seahorse::Model::Shapes::Structure] shape
-      # @param [Hash] params
-      def serialize_params(shape, params)
-        Builder.new(shape).to_xml(params)
-      end
-
-      # @param [String] xml
-      # @param [Seahorse::Model::Shapes::Structure] shape
-      # @param [Structure, nil] target
-      def parse_body(xml, shape, target)
-        Parser.new(shape).parse(xml, target)
-      end
-
-    end
-  end
-end

data/lib/seahorse/client/param_converter.rb

@@ -1,207 +0,0 @@
-require 'stringio'
-require 'date'
-require 'time'
-require 'tempfile'
-require 'thread'
-
-module Seahorse
-  module Client
-    class ParamConverter
-
-      @mutex = Mutex.new
-      @converters = Hash.new { |h,k| h[k] = {} }
-
-      # @param [Model::Shapes::Shape] shape
-      def initialize(shape)
-        @shape = shape
-      end
-
-      # @param [Hash] params
-      # @return [Hash]
-      def convert(params)
-        structure(@shape, params)
-      end
-
-      private
-
-      def structure(structure, values)
-        values = c(structure, values)
-        if values.is_a?(Hash)
-          values.each do |k, v|
-            unless v.nil?
-              if structure.member?(k)
-                values[k] = member(structure.member(k), v)
-              end
-            end
-          end
-        end
-        values
-      end
-
-      def list(list, values)
-        values = c(list, values)
-        if values.is_a?(Array)
-          values.map { |v| member(list.member, v) }
-        else
-          values
-        end
-      end
-
-      def map(map, values)
-        values = c(map, values)
-        if values.is_a?(Hash)
-          values.each.with_object({}) do |(key, value), hash|
-            hash[member(map.key, key)] = member(map.value, value)
-          end
-        else
-          values
-        end
-      end
-
-      def member(shape, value)
-        case shape
-        when Model::Shapes::Structure then structure(shape, value)
-        when Model::Shapes::List then list(shape, value)
-        when Model::Shapes::Map then map(shape, value)
-        else c(shape, value)
-        end
-      end
-
-      def c(shape, value)
-        self.class.c(shape.class, value)
-      end
-
-      class << self
-
-        # @param [Model::Shapes::InputShape] shape
-        # @param [Hash] params
-        # @return [Hash]
-        def convert(shape, params)
-          new(shape).convert(params)
-        end
-
-        # Registers a new value converter.  Converters run in the context
-        # of a shape and value class.
-        #
-        #     # add a converter that stringifies integers
-        #     shape_class = Seahorse::Model::Shapes::StringShape
-        #     ParamConverter.add(shape_class, Integer) { |i| i.to_s }
-        #
-        # @param [Class<Model::Shapes::Shape>] shape_class
-        # @param [Class] value_class
-        # @param [#call] converter (nil) An object that responds to `#call`
-        #    accepting a single argument.  This function should perform
-        #    the value conversion if possible, returning the result.
-        #    If the conversion is not possible, the original value should
-        #    be returned.
-        # @return [void]
-        def add(shape_class, value_class, converter = nil, &block)
-          @converters[shape_class][value_class] = converter || block
-        end
-
-        # @api private
-        def c(shape, value)
-          if converter = converter_for(shape, value)
-            converter.call(value)
-          else
-            value
-          end
-        end
-
-        private
-
-        def converter_for(shape_class, value)
-          unless @converters[shape_class].key?(value.class)
-            @mutex.synchronize {
-              unless @converters[shape_class].key?(value.class)
-                @converters[shape_class][value.class] = find(shape_class, value)
-              end
-            }
-          end
-          @converters[shape_class][value.class]
-        end
-
-        def find(shape_class, value)
-          converter = nil
-          each_base_class(shape_class) do |klass|
-            @converters[klass].each do |value_class, block|
-              if value_class === value
-                converter = block
-                break
-              end
-            end
-            break if converter
-          end
-          converter
-        end
-
-        def each_base_class(shape_class, &block)
-          shape_class.ancestors.each do |ancestor|
-            yield(ancestor) if @converters.key?(ancestor)
-          end
-        end
-
-      end
-
-      add(Model::Shapes::Structure, Hash) { |h| h.dup }
-      add(Model::Shapes::Structure, Struct) do |s|
-        s.members.each.with_object({}) {|k,h| h[k] = s[k] }
-      end
-
-      add(Model::Shapes::Map, Hash) { |h| h.dup }
-      add(Model::Shapes::Map, Struct) do |s|
-        s.members.each.with_object({}) {|k,h| h[k] = s[k] }
-      end
-
-      add(Model::Shapes::List, Array) { |a| a.dup }
-      add(Model::Shapes::List, Enumerable) { |value| value.to_a }
-
-      add(Model::Shapes::String, String)
-      add(Model::Shapes::String, Symbol) { |sym| sym.to_s }
-
-      add(Model::Shapes::Integer, Integer)
-      add(Model::Shapes::Integer, Float) { |f| f.to_i }
-      add(Model::Shapes::Integer, String) do |str|
-        begin
-          Integer(str)
-        rescue ArgumentError
-          str
-        end
-      end
-
-      add(Model::Shapes::Float, Float)
-      add(Model::Shapes::Float, Integer) { |i| i.to_f }
-      add(Model::Shapes::Float, String) do |str|
-        begin
-          Float(str)
-        rescue ArgumentError
-          str
-        end
-      end
-
-      add(Model::Shapes::Timestamp, Time)
-      add(Model::Shapes::Timestamp, Date) { |d| d.to_time }
-      add(Model::Shapes::Timestamp, DateTime) { |dt| dt.to_time }
-      add(Model::Shapes::Timestamp, Integer) { |i| Time.at(i) }
-      add(Model::Shapes::Timestamp, String) do |str|
-        begin
-          Time.parse(str)
-        rescue ArgumentError
-          str
-        end
-      end
-
-      add(Model::Shapes::Boolean, TrueClass)
-      add(Model::Shapes::Boolean, FalseClass)
-      add(Model::Shapes::Boolean, String) do |str|
-        { 'true' => true, 'false' => false }[str]
-      end
-
-      add(Model::Shapes::Blob, IO)
-      add(Model::Shapes::Blob, Tempfile)
-      add(Model::Shapes::Blob, StringIO)
-      add(Model::Shapes::Blob, String) { |str| StringIO.new(str) }
-
-    end
-  end
-end