aws-sdk-core 2.0.0.rc1

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

@@ -0,0 +1,32 @@
+
+module Seahorse
+  module Model
+    class Operation < Node
+
+      def initialize(*)
+        super
+        self.metadata = {}
+        self.input = InputShape.new
+        self.output = OutputShape.new
+      end
+
+      property :name, String
+      property :http_method, String
+      property :http_path, String
+      property :metadata, Hash
+      property :documentation, String
+      property :input, InputShape
+      property :output, OutputShape
+      property :errors, [Shape]
+
+      def to_hash
+        hash = super
+        hash.delete('metadata') if hash['metadata'].empty?
+        hash.delete('input') if hash['input']['members'].empty?
+        hash.delete('output') if hash['output']['members'].empty?
+        hash
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+
+module Seahorse
+  module Model
+    class OperationInput < Node
+      property :params, Symbol => Shape, always_serialize: true
+      property :raw_payload, Boolean
+
+      def initialize(*)
+        super
+        @param_map = nil
+      end
+
+      def header_params; params_for('header') end
+      def body_params; params_for('body') end
+      def uri_params; params_for('uri') end
+
+      def params_for(location)
+        build_params[location]
+      end
+
+      private
+
+      def build_params
+        @param_map ||= params.inject({}) do |hsh, (member_name, shape)|
+          (hsh[shape.location] ||= {})[member_name] = shape; hsh
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'thread'
+
+module Seahorse
+  module Model
+    class Operations
+      def initialize(raw_data = {})
+        @raw = raw_data.dup
+        @loaded = {}
+        @mutex = Mutex.new
+      end
+
+      def [](name)
+        name = name.to_s
+        @mutex.synchronize do
+          if @raw.key?(name)
+            @loaded[name] = Operation.from_hash(@raw.delete(name))
+          else
+            @loaded[name]
+          end
+        end
+      end
+
+      def []=(name, value)
+        name = name.to_s
+        @mutex.synchronize do
+          @raw.delete(name)
+          @loaded[name] = value
+        end
+      end
+
+      def load!
+        @raw.keys.each { |key| self[key] }
+      end
+
+      def keys
+        @mutex.synchronize do
+          (@loaded.keys + @raw.keys).sort
+        end
+      end
+
+      def values
+        self.load!
+        @loaded.values
+      end
+
+      def each(&block)
+        self.load!
+        @loaded.each(&block)
+      end
+
+      def to_h
+        self.load!
+        @loaded.dup
+      end
+      alias to_hash to_h
+
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+
+module Seahorse
+  module Model
+    class PropertyError < RuntimeError
+      attr_reader :key, :hash
+
+      def initialize(key, hash)
+        @key = key.to_s
+        @hash = hash
+        super("No such key #{key} in #{hash}")
+      end
+    end
+
+    class Property
+      include Model::Types
+
+      attr_accessor :name
+      attr_accessor :serialized_class
+      attr_accessor :always_serialize
+      attr_reader :serialized_location
+      attr_writer :serialized_name
+
+      def serialized_location=(value)
+        @serialized_location = value ? value.to_sym : nil
+      end
+
+      def serialized_name
+        (@serialized_name || name).to_sym
+      end
+
+      def initialize(name, type, options = {})
+        self.name = name.to_sym
+        self.serialized_class = type
+        self.serialized_location = options[:in]
+        self.serialized_name = options[:name]
+        self.always_serialize = options[:always_serialize]
+      end
+
+      def load_from(hash)
+        orig_hash = hash
+
+        if serialized_location
+          hash = hash[serialized_location.to_s]
+          raise PropertyError.new(serialized_location, orig_hash) unless hash
+        end
+
+        if !hash.has_key?(serialized_name.to_s)
+          raise PropertyError.new(serialized_name, hash)
+        end
+
+        value = hash[serialized_name.to_s]
+        deserialize(value, serialized_class)
+      end
+
+      def write_to(hash, value)
+        orig_hash = hash
+
+        if serialized_location
+          hash[serialized_location.to_s] ||= {}
+          hash = hash[serialized_location.to_s]
+        end
+
+        value = serialize(value, serialized_class)
+        if value != nil || always_serialize
+          hash[serialized_name.to_s] = value
+        end
+
+        orig_hash
+      end
+
+      private
+
+      def serialize(value, klass)
+        return if value.nil?
+
+        if klass == Operations
+          hsh = {}
+          value.each do |k, v|
+            hsh[key_case(k.to_s)] = serialize(v, Operation)
+          end
+          hsh
+        elsif value.is_a?(Hash) && klass.is_a?(Hash)
+          hsh = {}
+          value.each do |k, v|
+            keyclass = klass.keys.first
+            valclass = klass.values.first
+            hsh[serialize(k, keyclass).to_s] = serialize(v, valclass)
+          end
+          hsh
+        elsif klass.is_a?(Array)
+          value.map {|v| serialize(v, klass.first) }
+        elsif klass == Boolean
+          !!value
+        elsif value.respond_to?(:to_hash)
+          value ? value.to_hash : nil
+        elsif value.is_a?(Symbol)
+          value.to_s
+        else
+          value
+        end
+      end
+
+      def deserialize(value, klass)
+        if klass == Symbol
+          value ? value.to_sym : nil
+        elsif klass == Operations
+          hash = value.inject({}) do |hsh, (k, v)|
+            hsh[key_case(k)] = v; hsh
+          end
+          Operations.new(hash)
+        elsif klass.is_a?(Hash)
+          hsh = {}
+          value.each do |key, item|
+            key = deserialize(key, klass.keys.first)
+            item = deserialize(item, klass.values.first)
+            hsh[key] = item
+          end
+          hsh
+        elsif klass.is_a?(Array)
+          value.map {|v| deserialize(v, klass.first) }
+        elsif klass.respond_to?(:from_hash)
+          klass.from_hash(value)
+        elsif klass == Boolean
+          value || false
+        elsif klass
+          value
+        else
+          nil
+        end
+      end
+
+      def key_case(name)
+        name = name.to_s
+        name = name.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        name = name.gsub(/([a-z\d])([A-Z])/,'\1_\2')
+        name = name.tr("-", "_")
+        name.downcase
+      end
+    end
+  end
+end

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

@@ -0,0 +1,229 @@
+
+module Seahorse
+  module Model
+    module Shapes
+      class Shape < Node
+        class << self
+          def register_type(hash)
+            hash.each do |type, klass|
+              klass.type = type
+            end
+            types.update(hash)
+          end
+
+          def types; @@types ||= {} end
+
+          attr_accessor :type
+
+          def from_hash_class(hash)
+            return self if hash.nil?
+            raise "Shape #{hash} has undefined type" if hash["type"].nil?
+            if type = types[hash["type"].to_sym]
+              type
+            else
+              raise "Unregistered shape type #{hash["type"]}"
+            end
+          end
+        end
+
+        def initialize(*)
+          super
+          self.metadata = {}
+          self.type = self.class.type
+        end
+
+        attr_accessor :member_name
+
+        property :type, Symbol
+        property :required, Boolean
+        property :default, Object
+        property :documentation, String
+        property :location, String
+        property :serialized_name, String
+        property :metadata, Hash
+
+        alias required? required
+
+        def serialized_name
+          name = @serialized_name || @member_name.to_s
+          name == '' ? nil : name
+        end
+
+        def location
+          @location || 'body'
+        end
+
+        def to_hash
+          hash = super
+          hash.delete('serialized_name') if @serialized_name.nil?
+          hash.delete('metadata') if hash['metadata'].empty?
+          hash.delete('location') if @location.nil?
+          hash
+        end
+
+      end
+
+      class ScalarShape < Shape; end
+      class IntegerShape < ScalarShape; end
+      class FloatShape < ScalarShape; end
+      class BooleanShape < ScalarShape; end
+      class BlobShape < ScalarShape; end
+
+      class StringShape < ScalarShape
+        property :enum, [String]
+      end
+
+      class TimestampShape < ScalarShape; end
+      class Iso8601TimestampShape < TimestampShape; end
+      class Rfc822TimestampShape < TimestampShape; end
+      class UnixTimestampShape < TimestampShape; end
+
+      class ListShape < Shape
+        property :members, Shape
+
+        def initialize(*)
+          super
+          self.members = nil
+        end
+      end
+
+      class MapShape < Shape
+        property :keys, Shape
+        property :members, Shape
+
+        def initialize(*)
+          super
+          self.keys = nil
+          self.members = nil
+        end
+      end
+
+      class MemberHash < Hash
+        def []=(member_name, member)
+          member.member_name = member_name.to_sym
+          super(member.member_name, member)
+        end
+
+        def self.from_hash(hash)
+          hash.inject(new) {|hsh, (k, v)| hsh[k] = Shape.from_hash(v); hsh }
+        end
+
+        def to_hash
+          inject({}) {|hsh, (k, v)| hsh[k.to_s] = v.to_hash; hsh }
+        end
+      end
+
+      class StructureShape < Shape
+        property :members, MemberHash
+
+        def initialize(*)
+          super
+          self.members = MemberHash.new
+        end
+
+        def empty?
+          @members.empty?
+        end
+
+        def members= hash
+          @members = MemberHash.new
+          hash.each do |k, v|
+            @members[k] = v
+          end
+        end
+
+        # @return [Hash<String,Shape>] Returns a hash of members indexed
+        #  by their serialized names.  This is useful for parsing.
+        def serialized_members
+          @serialized_members ||= compute_serialized_members
+        end
+
+        private
+
+        def compute_serialized_members
+          members.inject({}) do |hash, (member_name, member)|
+            hash[member.serialized_name || member.member_name.to_s] = member
+            hash
+          end
+        end
+      end
+
+      class InputShape < StructureShape
+
+        property :payload, Symbol
+
+        # @return [Hash<Symbol, Shape>] Returns a hash of member shapes
+        #   that should be serialized into the request headers.
+        def header_members
+          member_map['header']
+        end
+
+        # @return [Hash<Symbol, Shape>] Returns a hash of member shapes
+        #   that should be serialized into the request uri path.
+        def uri_members
+          member_map['uri']
+        end
+
+        # @return [Hash<Symbol, Shape>] Returns a hash of member shapes
+        #   that should be serialized into the request body.
+        def body_members
+          member_map['body']
+        end
+
+        # @return [StructureShape] Returns a structure with each of the
+        #   members that represent the request body.
+        def payload_member
+          @payload_member ||= begin
+            if payload
+              members[payload]
+            else
+              shape = Seahorse::Model::Shapes::StructureShape.new
+              shape.members = body_members
+              shape.serialized_name = serialized_name
+              shape.metadata = metadata
+              shape
+            end
+          end
+        end
+
+        # @return [Boolean] Returns `true` if the request input body
+        #   should be sent as blob/raw data (e.g. from a file).
+        def raw_payload?
+          payload_member.is_a?(BlobShape)
+        end
+
+        private
+
+        def member_map
+          @member_map ||= begin
+            { 'header' => {}, 'uri' => {}, 'body' => {} }.tap do |map|
+              members.each do |member_name, member|
+                map[member.location][member_name] = member
+              end
+            end
+          end
+        end
+
+      end
+
+      class OutputShape < InputShape; end
+
+      class Shape < Node
+        register_type input: InputShape
+        register_type output: OutputShape
+        register_type structure: StructureShape
+        register_type list: ListShape
+        register_type map: MapShape
+        register_type string: StringShape
+        register_type integer: IntegerShape
+        register_type timestamp: TimestampShape
+        register_type iso8601_timestamp: Iso8601TimestampShape
+        register_type rfc822_timestamp: Rfc822TimestampShape
+        register_type unix_timestamp: UnixTimestampShape
+        register_type boolean: BooleanShape
+        register_type blob: BlobShape
+        register_type float: FloatShape
+      end
+    end
+  end
+end