aws-sdk-core 2.0.48 → 2.1.0

data/lib/seahorse/client/param_validator.rb

@@ -1,139 +0,0 @@
-module Seahorse
-  module Client
-    class ParamValidator
-
-      # @param [Model::Shapes::Shape] shape
-      # @param [Hash] params
-      # @return [void]
-      def self.validate!(shape, params)
-        new(shape).validate!(params)
-      end
-
-      # @param [Model::Shapes::Shape] shape
-      # @option options [Boolean] :validate_required (true)
-      def initialize(shape, options = {})
-        @shape = shape || Seahorse::Model::Shapes::Structure.new
-        @validate_required = options[:validate_required] != false
-      end
-
-      # @param [Hash] params
-      # @return [void]
-      def validate!(params)
-        errors = []
-        shape(@shape, params, errors, context = 'params')
-        raise ArgumentError, error_messages(errors) unless errors.empty?
-      end
-
-      private
-
-      def structure(structure, values, errors, context)
-        # ensure the value is hash like
-        return unless hash?(values, errors, context)
-
-        # ensure required members are present
-        if @validate_required
-          structure.required.each do |member_name|
-            if values[member_name].nil?
-              param = "#{context}[#{member_name.inspect}]"
-              errors << "missing required parameter #{param}"
-            end
-          end
-        end
-
-        # validate non-nil members
-        values.each do |name, value|
-          unless value.nil?
-            if structure.member?(name)
-              member_shape = structure.member(name)
-              shape(member_shape, value, errors, context + "[#{name.inspect}]")
-            else
-              errors << "unexpected value at #{context}[#{name.inspect}]"
-            end
-          end
-        end
-      end
-
-      def list(list, values, errors, context)
-        # ensure the value is an array
-        unless values.is_a?(Array)
-          errors << "expected #{context} to be an array"
-          return
-        end
-
-        # validate members
-        values.each.with_index do |value, index|
-          shape(list.member, value, errors, context + "[#{index}]")
-        end
-      end
-
-      def map(map, values, errors, context)
-        return unless hash?(values, errors, context)
-        values.each do |key, value|
-          shape(map.key, key, errors, "#{context} #{key.inspect} key")
-          shape(map.value, value, errors, context + "[#{key.inspect}]")
-        end
-      end
-
-      def shape(shape, value, errors, context)
-        case shape
-        when Model::Shapes::Structure
-          structure(shape, value, errors, context)
-        when Model::Shapes::List
-          list(shape, value, errors, context)
-        when Model::Shapes::Map
-          map(shape, value, errors, context)
-        when Model::Shapes::String
-          unless value.is_a?(String)
-            errors << "expected #{context} to be a string"
-          end
-        when Model::Shapes::Integer
-          unless value.is_a?(Integer)
-            errors << "expected #{context} to be an integer"
-          end
-        when Model::Shapes::Float
-          unless value.is_a?(Float)
-            errors << "expected #{context} to be a float"
-          end
-        when Model::Shapes::Timestamp
-          unless value.is_a?(Time)
-            errors << "expected #{context} to be a Time object"
-          end
-        when Model::Shapes::Boolean
-          unless [true, false].include?(value)
-            errors << "expected #{context} to be true or false"
-          end
-        when Model::Shapes::Blob
-          unless io_like?(value) or value.is_a?(String)
-            errors << "expected #{context} to be a string or IO object"
-          end
-        end
-      end
-
-      def hash?(value, errors, context)
-        if value.is_a?(Hash)
-          true
-        else
-          errors << "expected #{context} to be a hash"
-          false
-        end
-      end
-
-      def io_like?(value)
-        value.respond_to?(:read) &&
-        value.respond_to?(:rewind) &&
-        value.respond_to?(:size)
-      end
-
-      def error_messages(errors)
-        if errors.size == 1
-          errors.first
-        else
-          prefix = "\n  - "
-          "parameter validator found #{errors.size} errors:" +
-            prefix + errors.join(prefix)
-        end
-      end
-
-    end
-  end
-end

data/lib/seahorse/client/plugins/json_simple.rb

@@ -1,33 +0,0 @@
-module Seahorse
-  module Client
-    module Plugins
-
-      # This plugin performs two trivial translations:
-      #
-      # * The request parameters are serialized as JSON for the request body
-      # * The response body is deserialized as JSON for the response data
-      #
-      # No attempt is made to extract errors from the HTTP response body.
-      # Parsing the response only happens for a successful response.
-      #
-      class JsonSimple < Plugin
-
-        # @api private
-        class Handler < Client::Handler
-
-          def call(context)
-            context.http_request.body = MultiJson.dump(context.params)
-            @handler.call(context).on_success do |response|
-              response.error = nil
-              response.data = MultiJson.load(context.http_response.body_contents)
-            end
-          end
-
-        end
-
-        handler(Handler)
-
-      end
-    end
-  end
-end

data/lib/seahorse/client/plugins/param_conversion.rb

@@ -1,29 +0,0 @@
-module Seahorse
-  module Client
-    module Plugins
-
-      # @seahorse.client.option [Boolean] :convert_params (true)
-      #   When `true`, an attempt is made to coerce request parameters
-      #   into the required types.
-      class ParamConversion < Plugin
-
-        option(:convert_params, true)
-
-        def add_handlers(handlers, config)
-          handlers.add(Handler, step: :initialize) if config.convert_params
-        end
-
-        class Handler < Client::Handler
-
-          def call(context)
-            if input = context.operation.input
-              context.params = ParamConverter.convert(input, context.params)
-            end
-            @handler.call(context)
-          end
-
-        end
-      end
-    end
-  end
-end

data/lib/seahorse/client/plugins/param_validation.rb

@@ -1,30 +0,0 @@
-module Seahorse
-  module Client
-    module Plugins
-
-      # @seahorse.client.option [Boolean] :validate_params (true)
-      #   When `true`, request parameters are validated before
-      #   sending the request.
-      class ParamValidation < Plugin
-
-        option(:validate_params, true)
-
-        def add_handlers(handlers, config)
-          if config.validate_params
-            handlers.add(Handler, step: :validate, priority: 50)
-          end
-        end
-
-        class Handler < Client::Handler
-
-          def call(context)
-            ParamValidator.validate!(context.operation.input, context.params)
-            @handler.call(context)
-          end
-
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-module Seahorse
-  module Client
-    module Xml
-      class Builder
-
-        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/lib/seahorse/model/shape_map.rb

@@ -1,47 +0,0 @@
-module Seahorse
-  module Model
-    # @api private
-    class ShapeMap
-
-      # @param [Hash<String,Hash>] shape_defs ({}) A hash of shape definitions.
-      #   Hash keys should be shape names.  Hash values should be shape
-      #   definitions.
-      def initialize(shape_defs = {})
-        @definitions = shape_defs
-        @shapes = {}
-      end
-
-      # @return [Hash]
-      attr_reader :definitions
-
-      # @param [Hash] shape_ref
-      # @option shape_ref [required, String] 'shape'
-      # @return [Shapes::Shape]
-      # @raise [ArgumentError] Raised when the given shape ref can not be
-      #   resolved.
-      def shape(shape_ref)
-        @shapes[shape_ref] ||= build_shape(shape_ref)
-      end
-
-      # @return [Array<String>]
-      def shape_names
-        @definitions.keys
-      end
-
-      private
-
-      def build_shape(shape_ref)
-        Shapes::Shape.new(resolve(shape_ref), shape_map: self)
-      end
-
-      def resolve(shape_ref)
-        if definition = @definitions[shape_ref['shape']]
-          definition.merge(shape_ref)
-        else
-          raise ArgumentError, "shape not found for #{shape_ref.inspect}"
-        end
-      end
-
-    end
-  end
-end