aws-sdk-core 2.0.0.rc1

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

@@ -0,0 +1,202 @@
+require 'stringio'
+require 'date'
+require 'time'
+require 'tempfile'
+
+module Seahorse
+  module Client
+    class ParamConverter
+
+      include Model::Shapes
+
+      @converters = Hash.new { |h,k| h[k] = {} }
+
+      # @param [Model::Shapes::InputShape] rules
+      def initialize(rules)
+        @rules = rules
+      end
+
+      # @param [Hash] params
+      # @return [Hash]
+      def convert(params)
+        structure(@rules, params)
+      end
+
+      private
+
+      def structure(rules, values)
+        values = c(rules, values)
+        if values.is_a?(Hash)
+          values.each do |k, v|
+            unless v.nil?
+              if member_shape = rules.members[k]
+                values[k] = member(member_shape, v)
+              end
+            end
+          end
+        end
+        values
+      end
+
+      def list(rules, values)
+        values = c(rules, values)
+        if values.is_a?(Array)
+          values.map { |v| c(rules.members, v) }
+        else
+          values
+        end
+      end
+
+      def map(rules, values)
+        values = c(rules, values)
+        if values.is_a?(Hash)
+          values.inject({}) do |hash, (k, v)|
+            hash[c(rules.keys, k)] = c(rules.members, v)
+            hash
+          end
+        else
+          values
+        end
+      end
+
+      def member(rules, value)
+        case rules
+        when StructureShape then structure(rules, value)
+        when ListShape then list(rules, value)
+        when MapShape then map(rules, value)
+        else c(rules, value)
+        end
+      end
+
+      def c(shape, value)
+        self.class.c(shape.class, value)
+      end
+
+      class << self
+
+        # @param [Model::Shapes::InputShape] rules
+        # @param [Hash] params
+        # @return [Hash]
+        def convert(rules, params)
+          new(rules).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)
+            @converters[shape_class][value.class] = find(shape_class, value)
+          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(StructureShape, Hash) { |h| h.dup }
+      add(StructureShape, Struct) do |s|
+        s.members.inject({}) {|h,k| h[k] = s[k]; h }
+      end
+
+      add(MapShape, Hash) { |h| h.dup }
+      add(MapShape, Struct) do |s|
+        s.members.inject({}) {|h,k| h[k] = s[k]; h }
+      end
+
+      add(ListShape, Array) { |a| a.dup }
+      add(ListShape, Enumerable) { |value| value.to_a }
+
+      add(StringShape, String)
+      add(StringShape, Symbol) { |sym| sym.to_s }
+
+      add(IntegerShape, Integer)
+      add(IntegerShape, Float) { |f| f.to_i }
+      add(IntegerShape, String) do |str|
+        begin
+          Integer(str)
+        rescue ArgumentError
+          str
+        end
+      end
+
+      add(FloatShape, Float)
+      add(FloatShape, Integer) { |i| i.to_f }
+      add(FloatShape, String) do |str|
+        begin
+          Float(str)
+        rescue ArgumentError
+          str
+        end
+      end
+
+      add(TimestampShape, Time)
+      add(TimestampShape, Date) { |d| d.to_time }
+      add(TimestampShape, DateTime) { |dt| dt.to_time }
+      add(TimestampShape, Integer) { |i| Time.at(i) }
+      add(TimestampShape, String) do |str|
+        begin
+          Time.parse(str)
+        rescue ArgumentError
+          str
+        end
+      end
+
+      add(BooleanShape, TrueClass)
+      add(BooleanShape, FalseClass)
+      add(BooleanShape, String) { |str| { 'true' => true, 'false' => false }[str] }
+
+      add(BlobShape, IO)
+      add(BlobShape, Tempfile)
+      add(BlobShape, StringIO)
+      add(BlobShape, String)
+
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+module Seahorse
+  module Client
+    class ParamValidator
+
+      # @param [Model::Shapes::InputShape] rules
+      # @param [Hash] params
+      # @return [void]
+      def self.validate!(rules, params)
+        new(rules).validate!(params)
+      end
+
+      # @param [Model::Shapes::InputShape] rules
+      def initialize(rules)
+        @rules = rules
+      end
+
+      # @param [Hash] params
+      # @return [void]
+      def validate!(params)
+        errors = []
+        structure(@rules, params, errors, context = 'params')
+        raise ArgumentError, error_messages(errors) unless errors.empty?
+      end
+
+      private
+
+      def structure(rules, values, errors, context)
+        # ensure the value is hash like
+        return unless hash?(values, errors, context)
+
+        # ensure required members are present
+        rules.members.each do |member_name, member_shape|
+          if member_shape.required? and values[member_name].nil?
+            param = "#{context}[#{member_name.inspect}]"
+            errors << "missing required parameter #{param}"
+          end
+        end
+
+        # validate non-nil members
+        values.each do |name, value|
+          unless value.nil?
+            if member_shape = rules.members[name]
+              payload = rules.is_a?(Model::Shapes::InputShape) &&
+                rules.payload == name
+              member(member_shape, value, errors, context + "[#{name.inspect}]",
+                payload)
+            else
+              errors << "unexpected value at #{context}[#{name.inspect}]"
+            end
+          end
+        end
+      end
+
+      def list(rules, 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
+        offset = 0
+        values.each do |value|
+          member(rules.members, value, errors, context + "[#{offset}]")
+          offset += 1
+        end
+      end
+
+      def map(rules, values, errors, context)
+        return unless hash?(values, errors, context)
+        values.each do |key, value|
+          member(rules.keys, key, errors, "#{context} #{key.inspect} key")
+          member(rules.members, value, errors, context + "[#{key.inspect}]")
+        end
+      end
+
+      def member(rules, value, errors, context, payload = false)
+        case rules
+        when Model::Shapes::StructureShape
+          structure(rules, value, errors, context)
+        when Model::Shapes::ListShape
+          list(rules, value, errors, context)
+        when Model::Shapes::MapShape
+          map(rules, value, errors, context)
+        when Model::Shapes::StringShape
+          unless value.is_a?(String)
+            errors << "expected #{context} to be a string"
+          end
+        when Model::Shapes::IntegerShape
+          unless value.is_a?(Integer)
+            errors << "expected #{context} to be an integer"
+          end
+        when Model::Shapes::FloatShape
+          unless value.is_a?(Float)
+            errors << "expected #{context} to be a float"
+          end
+        when Model::Shapes::TimestampShape
+          unless value.is_a?(Time)
+            errors << "expected #{context} to be a Time object"
+          end
+        when Model::Shapes::BooleanShape
+          unless [true, false].include?(value)
+            errors << "expected #{context} to be true or false"
+          end
+        when Model::Shapes::BlobShape
+          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/vendor/seahorse/lib/seahorse/client/plugin.rb

@@ -0,0 +1,80 @@
+module Seahorse
+  module Client
+    class Plugin
+
+      extend HandlerBuilder
+
+      # @param [Configuration] config
+      # @return [void]
+      def add_options(config)
+        self.class.options.each do |args, block|
+          config.add_option(*args, &block)
+        end
+      end
+
+      # @param [HandlerList] handlers
+      # @param [Configuration] config
+      # @return [void]
+      def add_handlers(handlers, config)
+        handlers.copy_from(self.class.handlers)
+      end
+
+      # @param [Class<Client::Base>] client_class
+      # @param [Hash] options
+      # @return [void]
+      def before_initialize(client_class, options)
+        self.class.before_initialize_hooks.each do |block|
+          block.call(client_class, options)
+        end
+      end
+
+      # @param [Client::Base] client
+      # @return [void]
+      def after_initialize(client)
+        self.class.after_initialize_hooks.each do |block|
+          block.call(client)
+        end
+      end
+
+      class << self
+
+        def option(name, default = nil, &block)
+          if block_given?
+            options << [[name], Proc.new]
+          else
+            options << [[name, default]]
+          end
+        end
+
+        def before_initialize(&block)
+          before_initialize_hooks << block
+        end
+
+        def after_initialize(&block)
+          after_initialize_hooks << block
+        end
+
+        # @api private
+        def options
+          @options ||= []
+        end
+
+        # @api private
+        def handlers
+          @handlers ||= HandlerList.new
+        end
+
+        # @api private
+        def before_initialize_hooks
+          @before_initialize_hooks ||= []
+        end
+
+        # @api private
+        def after_initialize_hooks
+          @after_initialize_hooks ||= []
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+require 'set'
+require 'thread'
+
+module Seahorse
+  module Client
+    class PluginList
+
+      include Enumerable
+
+      # @param [Array, Set] plugins
+      # @option options [Mutex] :mutex
+      def initialize(plugins = [], options = {})
+        @mutex = options[:mutex] || Mutex.new
+        @plugins = Set.new
+        if plugins.is_a?(PluginList)
+          plugins.send(:each_plugin) { |plugin| _add(plugin) }
+        else
+          plugins.each { |plugin| _add(plugin) }
+        end
+      end
+
+      # Adds and returns the `plugin`.
+      # @param [Plugin] plugin
+      # @return [void]
+      def add(plugin)
+        @mutex.synchronize do
+          _add(plugin)
+        end
+        nil
+      end
+
+      # Removes and returns the `plugin`.
+      # @param [Plugin] plugin
+      # @return [void]
+      def remove(plugin)
+        @mutex.synchronize do
+          @plugins.delete(PluginWrapper.new(plugin))
+        end
+        nil
+      end
+
+      # Replaces the existing list of plugins.
+      # @param [Array<Plugin>] plugins
+      # @return [void]
+      def set(plugins)
+        @mutex.synchronize do
+          @plugins.clear
+          plugins.each do |plugin|
+            _add(plugin)
+          end
+        end
+        nil
+      end
+
+      # Enumerates the plugins.
+      # @return [Enumerator]
+      def each(&block)
+        each_plugin do |plugin_wrapper|
+          yield(plugin_wrapper.plugin)
+        end
+      end
+
+      private
+
+      # Not safe to call outside the mutex.
+      def _add(plugin)
+        @plugins << PluginWrapper.new(plugin)
+      end
+
+      # Yield each PluginDetail behind the mutex
+      def each_plugin(&block)
+        @mutex.synchronize do
+          @plugins.each(&block)
+        end
+      end
+
+      # A utility class that computes the canonical name for a plugin
+      # and defers requiring the plugin until the plugin class is
+      # required.
+      # @api private
+      class PluginWrapper
+
+        # @param [String, Symbol, Module, Class] plugin
+        def initialize(plugin)
+          case plugin
+          when Module
+            @canonical_name = plugin.name || plugin.object_id
+            @plugin = plugin
+          when Symbol, String
+            @canonical_name, @gem_name = plugin.to_s.split('.').reverse
+            @plugin = nil
+          else
+            @canonical_name = plugin.object_id
+            @plugin = plugin
+          end
+        end
+
+        # @return [String]
+        attr_reader :canonical_name
+
+        # @return [Class<Plugin>]
+        def plugin
+          @plugin ||= require_plugin
+        end
+
+        # Returns the given plugin if it is already a PluginWrapper.
+        def self.new(plugin)
+          if plugin.is_a?(self)
+            plugin
+          else
+            super
+          end
+        end
+
+        # @return [Boolean]
+        # @api private
+        def eql? other
+          canonical_name == other.canonical_name
+        end
+
+        # @return [String]
+        # @api private
+        def hash
+          canonical_name.hash
+        end
+
+        private
+
+        # @return [Class<Plugin>]
+        def require_plugin
+          require(@gem_name) if @gem_name
+          plugin_class = Kernel
+          @canonical_name.split('::').each do |const_name|
+            plugin_class = plugin_class.const_get(const_name)
+          end
+          plugin_class
+        end
+
+      end
+    end
+  end
+end