aws-sdk-core 2.0.48 → 2.1.0

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

@@ -3,11 +3,14 @@ require 'cgi'
 module Seahorse
   module Client
     module Plugins
+      # @api private
       class RestfulBindings < Plugin
 
         # @api private
         class Handler < Client::Handler
 
+          include Seahorse::Model::Shapes
+
           def call(context)
             build_request(context)
             @handler.call(context).on(200..299) do |response|
@@ -30,31 +33,31 @@ module Seahorse
           def populate_http_headers(context)
             params = context.params
             headers = context.http_request.headers
-            each_member(context.operation.input) do |member_name, member|
+            each_member(context.operation.input) do |member_name, member_ref|
               value = params[member_name]
               next if value.nil?
-              case member.location
-              when 'header'  then serialize_header(headers, member, value)
-              when 'headers' then serialize_header_map(headers, member, value)
+              case member_ref.location
+              when 'header'  then serialize_header(headers, member_ref, value)
+              when 'headers' then serialize_header_map(headers, member_ref, value)
               end
             end
           end
 
-          def serialize_header(headers, shape, value)
-            headers[shape.location_name] = serialize_header_value(shape, value)
+          def serialize_header(headers, ref, value)
+            headers[ref.location_name] = serialize_header_value(ref, value)
           end
 
-          def serialize_header_map(headers, shape, values)
-            prefix = shape.location_name || ''
+          def serialize_header_map(headers, ref, values)
+            prefix = ref.location_name || ''
             values.each_pair do |name, value|
-              value = serialize_header_value(shape.value, value)
+              value = serialize_header_value(ref.shape.value, value)
               headers["#{prefix}#{name}"] = value
             end
           end
 
-          def serialize_header_value(shape, value)
-            if shape.is_a?(Model::Shapes::Timestamp)
-              shape.format_time(value, 'httpdate')
+          def serialize_header_value(ref, value)
+            if TimestampShape === ref.shape
+              value.utc.httpdate
             else
               value.to_s
             end
@@ -63,51 +66,55 @@ module Seahorse
           # Extracts HTTP response headers and status code.
           def parse_response(response)
             headers = response.context.http_response.headers
-            each_member(response.context.operation.output) do |key, shape|
-              case shape.location
+            each_member(response.context.operation.output) do |key, ref|
+              case ref.location
               when 'statusCode'
                 status_code = response.context.http_response.status_code
                 response.data[key] = status_code
               when 'header'
-                if headers.key?(shape.location_name)
-                  response.data[key] = extract_header(headers, shape)
+                if headers.key?(ref.location_name)
+                  response.data[key] = extract_header(headers, ref)
                 end
               when 'headers'
-                response.data[key] = extract_header_map(headers, shape)
+                response.data[key] = extract_header_map(headers, ref)
               end
             end
           end
 
-          def extract_header(headers, shape)
-            parse_header_value(shape, headers[shape.location_name])
+          def extract_header(headers, ref)
+            parse_header_value(ref, headers[ref.location_name])
           end
 
-          def extract_header_map(headers, shape)
-            prefix = shape.location_name || ''
+          def extract_header_map(headers, ref)
+            prefix = ref.location_name || ''
             hash = {}
             headers.each do |header, value|
               if match = header.match(/^#{prefix}(.+)/i)
-                hash[match[1]] = parse_header_value(shape.value, value)
+                hash[match[1]] = parse_header_value(ref.shape.value, value)
               end
             end
             hash
           end
 
-          def parse_header_value(shape, value)
+          def parse_header_value(ref, value)
             if value
-              case shape
-              when Model::Shapes::Integer then value.to_i
-              when Model::Shapes::Float then value.to_f
-              when Model::Shapes::Boolean then value == 'true'
-              when Model::Shapes::Timestamp
-                shape.format == 'unix_timestamp' ? value.to_i : Time.parse(value)
+              case ref.shape
+              when IntegerShape then value.to_i
+              when FloatShape then value.to_f
+              when BooleanShape then value == 'true'
+              when TimestampShape
+                if value =~ /\d+(\.\d*)/
+                  Time.at(value.to_f)
+                else
+                  Time.parse(value)
+                end
               else value
               end
             end
           end
 
-          def each_member(shape, &block)
-            shape.members.each(&block) if shape
+          def each_member(ref, &block)
+            ref.shape.members.each(&block) if ref
           end
 
         end

data/lib/seahorse/client/request_context.rb

@@ -4,7 +4,7 @@ module Seahorse
   module Client
     class RequestContext
 
-      # @option options [required,String] :operation_name (nil)
+      # @option options [required,Symbol] :operation_name (nil)
       # @option options [required,Model::Operation] :operation (nil)
       # @option options [Hash] :params ({})
       # @option options [Configuration] :config (nil)
@@ -23,7 +23,7 @@ module Seahorse
         @metadata = {}
       end
 
-      # @return [String] Name of the API operation called.
+      # @return [Symbol] Name of the API operation called.
       attr_accessor :operation_name
 
       # @return [Model::Operation]

data/lib/seahorse/client/response.rb

@@ -59,11 +59,12 @@ module Seahorse
 
       # @api private
       def inspect
-        if @data
-          @data.respond_to?(:pretty_inspect) ? @data.pretty_inspect : super
-        else
-          super
-        end
+        @data.inspect
+      end
+
+      # @api private
+      def pretty_print(q)
+        @data.pretty_print(q)
       end
 
       # @api private

data/lib/seahorse/model/api.rb

@@ -2,82 +2,39 @@ module Seahorse
   module Model
     class Api
 
-      # @param [Hash] definition
-      def initialize(definition = {})
-        @metadata = definition['metadata'] || {}
-        @version = metadata('apiVersion')
-        @documentation = definition['documentation']
-        @definition = definition
-        @shape_map = ShapeMap.new(definition['shapes'] || {})
-        compute_operations
+      def initialize
+        @metadata = {}
+        @operations = {}
       end
 
       # @return [String, nil]
-      attr_reader :version
-
-      # @return [Array<Symbol>]
-      attr_reader :operation_names
-
-      # @return [String, nil]
-      attr_reader :documentation
-
-      # @return [ShapeMap]
-      attr_reader :shape_map
+      attr_accessor :version
 
       # @return [Hash]
-      attr_reader :definition
+      attr_accessor :metadata
 
-      # @param [Symbol] name
-      # @return [Boolean] Returns `true` if this API provides an operation
-      #   with the given name.
-      def operation?(name)
-        @operation_defs.key?(name.to_sym)
+      def operations(&block)
+        if block_given?
+          @operations.each(&block)
+        else
+          @operations.enum_for(:each)
+        end
       end
 
-      # @param [Symbol] name
-      # @return [Operation]
       def operation(name)
-        name = name.to_sym
-        if definition = @operation_defs[name]
-          @operations[name] ||= Operation.new(definition, shape_map: @shape_map)
+        if @operations.key?(name.to_sym)
+          @operations[name.to_sym]
         else
-          raise ArgumentError, "unknown operation :#{name}"
+          raise ArgumentError, "unknown operation #{name.inspect}"
         end
       end
 
-      # @return [Enumerable]
-      def operations
-        enum_for(:each_operation) { |*args| operation_names.size }
-      end
-
-      # @param [String] key
-      # @return [Object, nil]
-      def metadata(key)
-        @metadata[key]
+      def operation_names
+        @operations.keys
       end
 
-      # @api private
-      # @return [String]
-      def inspect
-        "#<#{self.class.name} version=#{version.inspect}>"
-      end
-
-      private
-
-      def each_operation(&block)
-        operation_names.each do |name|
-          yield(name, operation(name))
-        end
-      end
-
-      def compute_operations
-        @operations = {}
-        @operation_defs = {}
-        (definition['operations'] || {}).each do |name,definition|
-          name = Util.underscore(name).to_sym
-          @operation_defs[name] = definition
-        end
-        @operation_names = @operation_defs.keys
+      def add_operation(name, operation)
+        @operations[name.to_sym] = operation
       end
 
     end

data/lib/seahorse/model/operation.rb

@@ -2,74 +2,44 @@ module Seahorse
   module Model
     class Operation
 
-      # @param [Hash] definition
-      # @option options [ShapeMap] :shape_map
-      def initialize(definition = {}, options = {})
-        @definition = definition
-        @shape_map = options[:shape_map] || ShapeMap.new
-        @name = definition['name']
-        @input = shape_for(definition['input']) if definition['input']
-        @output = shape_for(definition['output']) if definition['output']
-        @deprecated = !!definition['deprecated']
-        @documentation = definition['documentation']
-        @paging = definition['paging'] || {}
+      def initialize
+        @http_method = 'POST'
+        @http_request_uri = '/'
+        @deprecated = false
+        @errors = []
+        @metadata = {}
       end
 
-      # @return [String]
-      attr_reader :name
+      # @return [String, nil]
+      attr_accessor :name
 
       # @return [String]
-      attr_reader :http_method
+      attr_accessor :http_method
 
       # @return [String]
-      attr_reader :http_request_uri
-
-      # @return [String<HTML>, nil]
-      attr_reader :documentation
-
-      # @return [Shape, nil]
-      attr_reader :input
+      attr_accessor :http_request_uri
 
-      # @return [Shape, nil]
-      attr_reader :output
+      # @return [Boolean]
+      attr_accessor :deprecated
 
-      # @return [Hash]
-      attr_reader :paging
+      # @return [String, nil]
+      attr_accessor :documentation
 
-      # @return [Hash]
-      attr_reader :definition
-
-      # @return [String]
-      def http_method
-        (@definition['http'] || {})['method'] || 'POST'
-      end
+      # @return [ShapeRef, nil]
+      attr_accessor :input
 
-      # @return [String]
-      def http_request_uri
-        (@definition['http'] || {})['requestUri'] || '/'
-      end
+      # @return [ShapeRef, nil]
+      attr_accessor :output
 
-      # @return [Boolean] Returns `true` if this API operation is deprecated.
-      def deprecated?
-        !!@definition['deprecated']
-      end
+      # @return [Array<ShapeRef>]
+      attr_accessor :errors
 
-      # @return [Enumerator] Returns an enumerator that yields error
-      #   shapes.
-      def errors
-        errors = (definition['errors'] || [])
-        errors = errors.map { |error| shape_for(error) }
-        errors.enum_for(:each)
+      def [](key)
+        @metadata[key.to_s]
       end
 
-      private
-
-      def shape_for(definition)
-        if definition.key?('shape')
-          @shape_map.shape(definition)
-        else
-          Shapes::Shape.new(definition, shape_map: @shape_map)
-        end
+      def []=(key, value)
+        @metadata[key.to_s] = value
       end
 
     end

data/lib/seahorse/model/shapes.rb

@@ -4,447 +4,203 @@ module Seahorse
   module Model
     module Shapes
 
-      @types = {}
-
-      class << self
-
-        # Registers a shape by type.
-        #
-        #     Shapes.register('structure', Shapes::StructureShape)
-        #
-        #     Shapes.type('structure')
-        #     #=> #<Shapes::StructureShape>
-        #
-        # @param [String] type
-        # @param [Class<Shape>] shape_class
-        # @return [void]
-        # @raise [ArgumentError] Raises an error if the given type or
-        #   shape class have already been registered.
-        def register(type, shape_class)
-          shape_class.type = type
-          @types[type] = shape_class
-        end
-
-        # Given a type, this method returned the registered shape class.
-        # @param [String] type
-        # @return [Class<Shape>]
-        # @raise [ArgumentError] Raises an ArgumentError if there is no
-        #   shape class registered with the given `type`.
-        def shape_class(type)
-          if @types.key?(type)
-            @types[type]
-          else
-            raise ArgumentError, "unregistered type `#{type}'"
-          end
-        end
-
-        # Returns an enumerator that yields registered type names and shape
-        # classes.
-        #
-        #    Seahorse::Model::Shapes.types.each do |type, shape_class|
-        #      puts "%s => %s" % [type, shape_class.name]
-        #    end
-        #
-        # @return [Enumerator] Returns an enumerable object that yields
-        #   registered type names and shape classes.
-        def types
-          Enumerator.new do |y|
-            @types.each do |name, shape_class|
-              y.yield(name, shape_class)
+      class ShapeRef
+
+        def initialize(options = {})
+          @metadata = {}
+          @required = false
+          @deprecated = false
+          options.each do |key, value|
+            if key == :metadata
+              value.each do |k,v|
+                self[k] = v
+              end
+            else
+              send("#{key}=", value)
             end
           end
         end
 
-      end
-
-      class Shape
-
-        # @param [Hash] definition
-        # @option options [ShapeMap] :shape_map (nil)
-        def initialize(definition, options = {})
-          definition['type'] ||= self.class.type
-          @name = definition['shape']
-          @definition = definition
-          @type = definition['type']
-          @location = definition['location'] || 'body'
-          @location_name = definition['locationName']
-          @shape_map = options[:shape_map] || ShapeMap.new
-        end
-
-        # @return [String]
-        attr_reader :name
-
-        # @return [Hash]
-        attr_reader :definition
-
-        # @return [String] The type name for this shape.
-        attr_reader :type
-
-        # @return [String] Returns one of 'body', 'uri', 'headers', 'status_code'
-        attr_reader :location
-
-        # @return [String, nil] Typically only set for shapes that are
-        #   structure members.  Serialized names are typically set on the
-        #   shape references, not on the shape definition.
-        attr_reader :location_name
-
-        attr_reader :documentation
-
-        # @return [ShapeMap]
-        attr_reader :shape_map
+        # @return [Shape]
+        attr_accessor :shape
 
         # @return [String, nil]
-        def documentation
-          @definition['documentation']
-        end
-
-        # @param [String] key
-        # @return [Object, nil]
-        def metadata(key)
-          @definition[key.to_s]
-        end
+        attr_accessor :location
 
-        # @api private
-        # @return [String]
-        def inspect
-          "#<#{self.class.name}>"
-        end
-
-        # @api private
-        def with(options)
-          self.class.new(@definition.merge(options), shape_map: shape_map)
-        end
+        # @return [String, nil]
+        attr_accessor :location_name
 
-        private
+        # @return [Boolean]
+        attr_accessor :required
 
-        def underscore(string)
-          Util.underscore(string)
-        end
+        # @return [String, nil]
+        attr_accessor :documentation
 
-        def shape_at(key)
-          if @definition[key]
-            shape_for(@definition[key])
-          else
-            raise ArgumentError, "expected shape definition at #{key.inspect}"
-          end
-        end
+        # @return [Boolean]
+        attr_accessor :deprecated
 
-        def shape_for(reference)
-          if reference.key?('shape')
-            # shape ref given, e.g. { "shape" => "ShapeName" },
-            # use the shape map to resolve this reference
-            @shape_map.shape(reference)
+        # Gets metadata for the given `key`.
+        def [](key)
+          if @metadata.key?(key.to_s)
+            @metadata[key.to_s]
           else
-            Shape.new(reference, shape_map: @shape_map)
+            @shape[key.to_s]
           end
         end
 
-        class << self
-
-          # @return [String]
-          attr_accessor :type
-
-          # Constructs and returns a new shape object.  You must specify
-          # the shape type using the "type" option or you must construct
-          # the shape using the appropriate subclass of `Shape`.
-          #
-          # @example Constructing a new shape
-          #
-          #   shape = Seahorse::Model::Shapes::Shape.new("type" => "structure")
-          #
-          #   shape.class
-          #   #=> Seahorse::Model::Shapes::Structure
-          #
-          #   shape.definition
-          #   #=> { "type" => "structure" }
-          #
-          # @example Constructing a new shape using the shape class
-          #
-          #   shape = Seahorse::Model::Shapes::String.new
-          #   shape.definition
-          #   #=> { "type" => "string" }
-          #
-          # @param [Hash] definition
-          # @option options [ShapeMap] :shape_map
-          # @return [Shape]
-          def new(definition = {}, options = {})
-            if self == Shape
-              from_type(definition, options)
-            else
-              super(apply_type(definition), options)
-            end
-          end
-
-          private
-
-          def apply_type(definition)
-            case definition['type']
-            when type then definition
-            when nil then { 'type' => type }.merge(definition)
-            else raise ArgumentError, "expected 'type' to be `#{type}'"
-            end
-          end
-
-          def from_type(definition, options)
-            if type = definition['type']
-              Shapes.shape_class(type).new(definition, options)
-            else
-              raise ArgumentError, 'must specify "type" in the definition'
-            end
-          end
-
+        # Sets metadata for the given `key`.
+        def []=(key, value)
+          @metadata[key.to_s] = value
         end
 
       end
 
-      class Structure < Shape
+      class Shape
 
-        def initialize(definition, options = {})
-          super
-          @members = {}
-          @member_refs = {}
-          @member_names = {}
-          compute_member_names
-          compute_required_member_names
-          @member_names = @member_names.values
+        def initialize
+          @metadata = {}
         end
 
-        # @return [Array<Symbol>] Returns a list of members names.
-        attr_reader :member_names
-
-        # @return [Array<Symbol>] Returns a list of required members names.
-        attr_reader :required
-
-        # @return [String, nil] Returns the name of the payload member if set.
-        attr_reader :payload
-
-        # @return [Shape, nil]
-        def payload_member
-          if payload
-            @payload_member ||= member(payload)
-          else
-            nil
-          end
-        end
-
-        # @param [Symbol] name
-        # @return [Shape]
-        def member(name)
-          if ref = @member_refs[name.to_sym]
-            @members[name] ||= shape_for(ref)
-          else
-            raise ArgumentError, "no such member :#{name}"
-          end
-        end
+        # @return [String]
+        attr_accessor :name
 
-        # @param [Symbol] name
-        # @return [Boolean] Returns `true` if this structure has a member with
-        #   the given name.
-        def member?(name)
-          @member_refs.key?(name.to_sym)
-        end
+        # @return [String, nil]
+        attr_accessor :documentation
 
-        # @return [Enumerable<Symbol,Shape>] Returns an enumerator that yields
-        #   member names and shapes.
-        def members
-          Enumerator.new do |y|
-            member_names.map do |member_name|
-              y.yield(member_name, member(member_name))
-            end
-          end
+        # Gets metadata for the given `key`.
+        def [](key)
+          @metadata[key.to_s]
         end
 
-        # Searches the structure members for a shape with the given
-        # serialized name.
-        #
-        # If found, the shape will be returned with its symbolized member
-        # name.
-        #
-        # If no shape is found with the given serialized name, then
-        # nil is returned.
-        #
-        # @example
-        #
-        #   name, shape = structure.member_by_location_name('SerializedName')
-        #   name #=> :member_name
-        #   shape #=> instance of Seahorse::Model::Shapes::Shape
-        #
-        # @param [String] location_name
-        # @return [Array<Symbol,Shape>, nil]
-        def member_by_location_name(location_name)
-          @by_location_name ||= index_members_by_location_name
-          @by_location_name[location_name]
+        # Sets metadata for the given `key`.
+        def []=(key, value)
+          @metadata[key.to_s] = value
         end
 
-        private
+      end
 
-        def index_members_by_location_name
-          members.each.with_object({}) do |(name, shape), hash|
-            hash[shape.location_name] = [name, shape]
-          end
-        end
+      class BlobShape < Shape
 
-        def compute_member_names
-          (definition['members'] || {}).each do |orig_name,ref|
-            name = underscore(orig_name).to_sym
-            if ref['location'] == 'headers'
-              @member_refs[name] = ref
-            else
-              @member_refs[name] = { 'locationName' => orig_name }.merge(ref)
-            end
-            @member_names[orig_name] = name
-          end
-          @payload = @member_names[definition['payload']] if definition['payload']
-        end
+        # @return [Integer, nil]
+        attr_accessor :min
 
-        def compute_required_member_names
-          @required = (definition['required'] || []).map do |orig_name|
-            @member_names[orig_name]
-          end
-        end
+        # @return [Integer, nil]
+        attr_accessor :max
 
       end
 
-      class List < Shape
+      class BooleanShape < Shape; end
 
-        def initialize(definition, options = {})
-          super
-          @min = definition['min']
-          @max = definition['max']
-          @member = shape_at('member')
-        end
+      class FloatShape < Shape; end
 
-        # @return [Shape]
-        attr_reader :member
+      class IntegerShape < Shape
 
         # @return [Integer, nil]
-        attr_reader :min
+        attr_accessor :min
 
         # @return [Integer, nil]
-        attr_reader :max
+        attr_accessor :max
 
       end
 
-      class Map < Shape
+      class ListShape < Shape
 
-        def initialize(definition, options = {})
-          super
-          @min = definition['min']
-          @max = definition['max']
-          @key = shape_at('key')
-          @value = shape_at('value')
-        end
-
-        # @return [Shape]
-        attr_reader :key
-
-        # @return [Shape]
-        attr_reader :value
+        # @return [ShapeRef]
+        attr_accessor :member
 
         # @return [Integer, nil]
-        attr_reader :min
+        attr_accessor :min
 
         # @return [Integer, nil]
-        attr_reader :max
+        attr_accessor :max
 
       end
 
-      class String < Shape
+      class MapShape < Shape
 
-        def initialize(definition, options = {})
-          super
-          @enum = Set.new(definition['enum']) if definition['enum']
-          @pattern = definition['pattern']
-          @min = definition['min']
-          @max = definition['max']
-        end
-
-        # @return [Set, nil]
-        attr_reader :enum
+        # @return [ShapeRef]
+        attr_accessor :key
 
-        # @return [String, nil]
-        attr_reader :pattern
+        # @return [ShapeRef]
+        attr_accessor :value
 
         # @return [Integer, nil]
-        attr_reader :min
+        attr_accessor :min
 
         # @return [Integer, nil]
-        attr_reader :max
+        attr_accessor :max
 
       end
 
-      class Character < String; end
+      class StringShape < Shape
 
-      class Byte < String; end
+        # @return [Set<String>, nil]
+        attr_accessor :enum
 
-      class Timestamp < Shape
-
-        def initialize(definition, options = {})
-          @format = definition['timestampFormat']
-          super
-        end
-
-        # @return [String]
-        attr_reader :format
+        # @return [Integer, nil]
+        attr_accessor :min
 
-        # @param [Time] time
-        # @param [String] default_format The format to default to
-        #   when {#format} is not set on this timestamp shape.
-        # @return [String]
-        def format_time(time, default_format)
-          format = @format || default_format
-          case format
-          when 'iso8601'       then time.utc.iso8601
-          when 'rfc822'        then time.utc.rfc822
-          when 'httpdate'      then time.httpdate
-          when 'unixTimestamp' then time.utc.to_i
-          else
-            msg = "invalid timestamp format #{format.inspect}"
-            raise ArgumentError, msg
-          end
-        end
+        # @return [Integer, nil]
+        attr_accessor :max
 
       end
 
-      class Integer < Shape
+      class StructureShape < Shape
 
-        def initialize(definition, options = {})
-          @min = definition['min']
-          @max = definition['max']
-          super
+        def initialize(options = {})
+          @members = {}
+          @members_by_location_name = {}
+          @required = Set.new
+          super()
         end
 
-        # @return [Integer, nil]
-        attr_reader :min
+        # @return [Set<Symbol>]
+        attr_accessor :required
 
-        # @return [Integer, nil]
-        attr_reader :max
+        # @param [Symbol] name
+        # @param [ShapeRef] shape_ref
+        def add_member(name, shape_ref)
+          name = name.to_sym
+          @required << name if shape_ref.required
+          @members_by_location_name[shape_ref.location_name] = [name, shape_ref]
+          @members[name] = shape_ref
+        end
 
-      end
+        # @return [Array<Symbol>]
+        def member_names
+          @members.keys
+        end
 
-      class Long < Integer; end
+        # @param [Symbol] member_name
+        # @return [Boolean] Returns `true` if there exists a member with
+        #   the given name.
+        def member?(member_name)
+          @members.key?(member_name.to_sym)
+        end
 
-      class Float < Shape; end
+        # @return [Enumerator<[Symbol,ShapeRef]>]
+        def members
+          @members.to_enum
+        end
 
-      class Double < Float; end
+        # @param [Symbol] name
+        # @return [ShapeRef]
+        def member(name)
+          if member?(name)
+            @members[name.to_sym]
+          else
+            raise ArgumentError, "no such member #{name.inspect}"
+          end
+        end
 
-      class Boolean < Shape; end
+        # @api private
+        def member_by_location_name(location_name)
+          @members_by_location_name[location_name]
+        end
 
-      class Blob < Shape; end
+      end
 
-      register('blob', Shapes::Blob)
-      register('byte', Shapes::Byte)
-      register('boolean', Shapes::Boolean)
-      register('character', Shapes::Character)
-      register('double', Shapes::Double)
-      register('float', Shapes::Float)
-      register('integer', Shapes::Integer)
-      register('list', Shapes::List)
-      register('long', Shapes::Long)
-      register('map', Shapes::Map)
-      register('string', Shapes::String)
-      register('structure', Shapes::Structure)
-      register('timestamp', Shapes::Timestamp)
+      class TimestampShape < Shape; end
 
     end
   end