aws-sdk-core 2.0.0 → 2.11.632

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

@@ -0,0 +1,6 @@
+Aws.add_service(:WorkDocs, {
+  api: "#{Aws::API_DIR}/workdocs/2016-05-01/api-2.json",
+  docs: "#{Aws::API_DIR}/workdocs/2016-05-01/docs-2.json",
+  examples: "#{Aws::API_DIR}/workdocs/2016-05-01/examples-1.json",
+  paginators: "#{Aws::API_DIR}/workdocs/2016-05-01/paginators-1.json",
+})

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

@@ -0,0 +1,6 @@
+Aws.add_service(:WorkLink, {
+  api: "#{Aws::API_DIR}/worklink/2018-09-25/api-2.json",
+  docs: "#{Aws::API_DIR}/worklink/2018-09-25/docs-2.json",
+  examples: "#{Aws::API_DIR}/worklink/2018-09-25/examples-1.json",
+  paginators: "#{Aws::API_DIR}/worklink/2018-09-25/paginators-1.json",
+})

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

@@ -0,0 +1,6 @@
+Aws.add_service(:WorkMail, {
+  api: "#{Aws::API_DIR}/workmail/2017-10-01/api-2.json",
+  docs: "#{Aws::API_DIR}/workmail/2017-10-01/docs-2.json",
+  examples: "#{Aws::API_DIR}/workmail/2017-10-01/examples-1.json",
+  paginators: "#{Aws::API_DIR}/workmail/2017-10-01/paginators-1.json",
+})

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

@@ -0,0 +1,6 @@
+Aws.add_service(:WorkMailMessageFlow, {
+  api: "#{Aws::API_DIR}/workmailmessageflow/2019-05-01/api-2.json",
+  docs: "#{Aws::API_DIR}/workmailmessageflow/2019-05-01/docs-2.json",
+  examples: "#{Aws::API_DIR}/workmailmessageflow/2019-05-01/examples-1.json",
+  paginators: "#{Aws::API_DIR}/workmailmessageflow/2019-05-01/paginators-1.json",
+})

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

@@ -0,0 +1,6 @@
+Aws.add_service(:WorkSpaces, {
+  api: "#{Aws::API_DIR}/workspaces/2015-04-08/api-2.json",
+  docs: "#{Aws::API_DIR}/workspaces/2015-04-08/docs-2.json",
+  examples: "#{Aws::API_DIR}/workspaces/2015-04-08/examples-1.json",
+  paginators: "#{Aws::API_DIR}/workspaces/2015-04-08/paginators-1.json",
+})

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

@@ -1,78 +1,108 @@
-require 'builder'
 require 'base64'
 
 module Aws
   module Xml
     class Builder
 
-      # @param [Seahorse::Model::Shapes::Structure] shape
-      def initialize(shape)
-        @shape = shape
-        @xml = []
-        @builder = ::Builder::XmlMarkup.new(target: @xml, indent: 2)
+      include Seahorse::Model::Shapes
+
+      def initialize(rules, options = {})
+        @rules = rules
+        @xml = options[:target] || []
+        indent = options[:indent] || '  '
+        pad = options[:pad] || ''
+        @builder = DocBuilder.new(target:@xml, indent:indent, pad:pad)
       end
 
-      # @param [Hash] params
-      # @return [String] Returns an XML doc string.
       def to_xml(params)
-        structure(@shape.location_name, @shape, params)
+        structure(@rules.location_name, @rules, params)
         @xml.join
       end
+      alias serialize to_xml
 
       private
 
-      def structure(name, shape, values)
+      def structure(name, ref, values)
         if values.empty?
-          node(name, shape)
+          node(name, ref)
         else
-          node(name, shape, structure_attrs(shape, values)) do
-            shape.members.each do |member_name, member_shape|
-              unless values[member_name].nil?
-                next if xml_attribute?(member_shape)
-                mname = member_shape.location_name || member_name.to_s
-                member(mname, member_shape, values[member_name])
-              end
+          node(name, ref, structure_attrs(ref, values)) do
+            ref.shape.members.each do |member_name, member_ref|
+              next if values[member_name].nil?
+              next if xml_attribute?(member_ref)
+              member(member_ref.location_name, member_ref, values[member_name])
             end
           end
         end
       end
 
-      def structure_attrs(shape, values)
-        shape.members.inject({}) do |attrs, (member_name, member_shape)|
-          if xml_attribute?(member_shape) && values.key?(member_name)
-            attrs[member_shape.location_name] = values[member_name]
+      def structure_attrs(ref, values)
+        ref.shape.members.inject({}) do |attrs, (member_name, member_ref)|
+          if xml_attribute?(member_ref) && values.key?(member_name)
+            attrs[member_ref.location_name] = values[member_name]
           end
           attrs
         end
       end
 
-      def list(name, shape, values)
-        if flat?(shape)
+      def list(name, ref, values)
+        if ref['flattened']
           values.each do |value|
-            member(name, shape.member, value)
+            member(ref.shape.member.location_name || name, ref.shape.member, value)
           end
         else
-          node(name, shape) do
+          node(name, ref) do
             values.each do |value|
-              mname = shape.member.location_name || 'member'
-              member(mname, shape.member, value)
+              mname = ref.shape.member.location_name || 'member'
+              member(mname, ref.shape.member, value)
             end
           end
         end
       end
 
-      def member(name, shape, value)
-        case shape.type
-        when 'structure' then structure(name, shape, value)
-        when 'list'      then list(name, shape, value)
-        when 'timestamp' then node(name, shape, shape.format_time(value, 'iso8601'))
-        when 'blob'      then node(name, shape, Base64.strict_encode64(value))
-        when 'map'       then raise NotImplementedError, 'not supported'
+      def map(name, ref, hash)
+        key_ref = ref.shape.key
+        value_ref = ref.shape.value
+        if ref['flattened']
+          hash.each do |key, value|
+            node(name, ref) do
+              member(key_ref.location_name || 'key', key_ref, key)
+              member(value_ref.location_name || 'value', value_ref, value)
+            end
+          end
         else
-          node(name, shape, value.to_s)
+          node(name, ref) do
+            hash.each do |key, value|
+              node('entry', ref)  do
+                member(key_ref.location_name || 'key', key_ref, key)
+                member(value_ref.location_name || 'value', value_ref, value)
+              end
+            end
+          end
         end
       end
 
+      def member(name, ref, value)
+        case ref.shape
+        when StructureShape then structure(name, ref, value)
+        when ListShape      then list(name, ref, value)
+        when MapShape       then map(name, ref, value)
+        when TimestampShape then node(name, ref, timestamp(value))
+        when BlobShape      then node(name, ref, blob(value))
+        else
+          node(name, ref, value.to_s)
+        end
+      end
+
+      def blob(value)
+        value = value.read unless String === value
+        Base64.strict_encode64(value)
+      end
+
+      def timestamp(value)
+        value.utc.iso8601
+      end
+
       # The `args` list may contain:
       #
       #   * [] - empty, no value or attributes
@@ -83,15 +113,15 @@ module Aws
       # Pass a block if you want to nest XML nodes inside.  When doing this,
       # you may *not* pass a value to the `args` list.
       #
-      def node(name, shape, *args, &block)
+      def node(name, ref, *args, &block)
         attrs = args.last.is_a?(Hash) ? args.pop : {}
-        attrs = shape_attrs(shape).merge(attrs)
+        attrs = shape_attrs(ref).merge(attrs)
         args << attrs
-        @builder.__send__(name, *args, &block)
+        @builder.node(name, *args, &block)
       end
 
-      def shape_attrs(shape)
-        if xmlns = shape.metadata('xmlNamespace')
+      def shape_attrs(ref)
+        if xmlns = ref['xmlNamespace']
           if prefix = xmlns['prefix']
             { 'xmlns:' + prefix => xmlns['uri'] }
           else
@@ -102,12 +132,8 @@ module Aws
         end
       end
 
-      def xml_attribute?(shape)
-        !!shape.metadata('xmlAttribute')
-      end
-
-      def flat?(shape)
-        shape.metadata('flattened')
+      def xml_attribute?(ref)
+        !!ref['xmlAttribute']
       end
 
     end

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

@@ -0,0 +1,10 @@
+module Aws
+  module Xml
+    # @api private
+    class DefaultMap < Hash
+
+      alias nil? empty?
+
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Aws
+  module Xml
+    class DocBuilder
+
+      # @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, :text)}#{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, text_or_attr)
+        string.to_s.encode(:xml => text_or_attr)
+      end
+
+      def attributes(attr)
+        if attr.empty?
+          ''
+        else
+          ' ' + attr.map do |key, value|
+            "#{key}=#{escape(value, :attr)}"
+          end.join(' ')
+        end
+      end
+
+      def increase_pad(&block)
+        pre_increase = @pad
+        @pad = @pad + @indent
+        yield
+        @pad = pre_increase
+      end
+
+    end
+  end
+end

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

@@ -1,4 +1,4 @@
-require 'multi_xml'
+require 'cgi'
 
 module Aws
   module Xml
@@ -14,22 +14,34 @@ module Aws
       private
 
       def error(context)
-        if empty_body?(context)
-          error_code = empty_body_error_code(context)
-          error_message = ''
+        body = context.http_response.body_contents
+        if body.empty?
+          code = http_status_error_code(context)
+          message = ''
         else
-          error_code, error_message = extract_error(context)
+          code, message = extract_error(body, context)
         end
         svc = context.client.class.name.split('::')[1]
         errors_module = Aws.const_get(svc).const_get(:Errors)
-        errors_module.error_class(error_code).new(context, error_message)
+        errors_module.error_class(code).new(context, message)
       end
 
-      def empty_body?(context)
-        context.http_response.body_contents.empty?
+      def extract_error(body, context)
+        [
+          error_code(body, context),
+          error_message(body),
+        ]
       end
 
-      def empty_body_error_code(context)
+      def error_code(body, context)
+        if matches = body.match(/<Code>(.+?)<\/Code>/)
+          remove_prefix(unescape(matches[1]), context)
+        else
+          http_status_error_code(context)
+        end
+      end
+
+      def http_status_error_code(context)
         status_code = context.http_response.status_code
         {
           302 => 'MovedTemporarily',
@@ -38,25 +50,30 @@ module Aws
           403 => 'Forbidden',
           404 => 'NotFound',
           412 => 'PreconditionFailed',
+          413 => 'RequestEntityTooLarge',
         }[status_code] || "Http#{status_code}Error"
       end
 
-      def extract_error(context)
-        error = MultiXml.parse(context.http_response.body_contents)
-        %w(Response ErrorResponse Errors Error).each do |wrapper|
-          error = error[wrapper] if error[wrapper]
+      def remove_prefix(error_code, context)
+        if prefix = context.config.api.metadata['errorPrefix']
+          error_code.sub(/^#{prefix}/, '')
+        else
+          error_code
         end
-        [remove_prefix(context, error['Code']), error['Message']]
       end
 
-      def remove_prefix(context, error_code)
-        if prefix = context.config.api.metadata('errorPrefix')
-          error_code.sub(/^#{prefix}/, '')
+      def error_message(body)
+        if matches = body.match(/<Message>(.+?)<\/Message>/m)
+          unescape(matches[1])
         else
-          error_code
+          ''
         end
       end
 
+      def unescape(str)
+        CGI.unescapeHTML(str)
+      end
+
     end
   end
 end

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

@@ -1,139 +1,103 @@
-require 'multi_xml'
-require 'time'
-require 'base64'
-
 module Aws
   module Xml
+
+    # A SAX-style XML parser that uses a shape context to handle types.
     class Parser
 
-      # @param [Seahorse::Model::Shapes::Structure] shape
-      def initialize(shape)
-        @shape = shape
-      end
+      autoload :Stack, 'aws-sdk-core/xml/parser/stack'
+      autoload :Frame, 'aws-sdk-core/xml/parser/frame'
+      autoload :ParsingError, 'aws-sdk-core/xml/parser/parsing_error'
 
-      # @param [String<xml>] xml
-      # @param [Hash, nil] target
-      # @return [Structure]
-      def parse(xml, target = nil, &block)
-        xml = MultiXml.parse(xml).values.first || {}
-        yield(xml) if block_given?
-        structure(@shape, xml, target)
-      end
+      autoload :LibxmlEngine, 'aws-sdk-core/xml/parser/engines/libxml'
+      autoload :NokogiriEngine, 'aws-sdk-core/xml/parser/engines/nokogiri'
+      autoload :OgaEngine, 'aws-sdk-core/xml/parser/engines/oga'
+      autoload :OxEngine, 'aws-sdk-core/xml/parser/engines/ox'
+      autoload :RexmlEngine, 'aws-sdk-core/xml/parser/engines/rexml'
 
-      private
+      # @param [Seahorse::Model::ShapeRef] rules
+      def initialize(rules, options = {})
+        @rules = rules
+        @engine = options[:engine] || self.class.engine
+      end
 
-      # @param [Seahorse::Model::Shapes::Structure] structure
-      # @param [Hash] values
-      # @param [Hash, nil] target
+      # Parses the XML document, returning a parsed structure.
+      #
+      # If you pass a block, this will yield for XML
+      # elements that are not modeled in the rules given
+      # to the constructor.
+      #
+      #   parser.parse(xml) do |path, value|
+      #     puts "uhandled: #{path.join('/')} - #{value}"
+      #   end
+      #
+      # The purpose of the unhandled callback block is to
+      # allow callers to access values such as the EC2
+      # request ID that are part of the XML body but not
+      # part of the operation result.
+      #
+      # @param [String] xml An XML document string to parse.
+      # @param [Structure] target (nil)
       # @return [Structure]
-      def structure(structure, values, target = nil)
-        target = Structure.new(structure.member_names) if target.nil?
-        structure.members.each do |member_name, member_shape|
-          value_key = member_key(member_shape) || member_name.to_s
-          if values.key?(value_key)
-            target[member_name] = parse_shape(member_shape, values[value_key])
-          elsif member_shape.is_a?(Seahorse::Model::Shapes::List)
-            target[member_name] = DefaultList.new
-          end
-        end
-        target
+      def parse(xml, target = nil, &unhandled_callback)
+        xml = '<xml/>' if xml.nil? or xml.empty?
+        stack = Stack.new(@rules, target, &unhandled_callback)
+        @engine.new(stack).parse(xml.to_s)
+        stack.result
       end
 
-      def member_key(shape)
-        if Seahorse::Model::Shapes::List === shape && flat?(shape)
-          shape.member.location_name || shape.location_name
-        else
-          shape.location_name
-        end
-      end
+      class << self
 
-      # @param [Seahorse::Model::Shapes::List] list
-      # @param [Array] values
-      # @return [Array]
-      def list(list, values)
-        unless flat?(list)
-          values = values[list.member.location_name || 'member']
+        # @param [Symbol,Class] engine
+        #   Must be one of the following values:
+        #
+        #   * :ox
+        #   * :oga
+        #   * :libxml
+        #   * :nokogiri
+        #   * :rexml
+        #
+        def engine= engine
+          @engine = Class === engine ? engine : load_engine(engine)
         end
-        values = [values] unless values.is_a?(Array)
-        values.collect { |value| parse_shape(list.member, value) }
-      end
 
-      # @param [Seahorse::Model::Shapes::Map] map
-      # @param [Hash] entries
-      # @return [Hash]
-      def map(map, entries)
-        data = {}
-        entries = entries['entry'] unless flat?(map)
-        entries = [entries] unless entries.is_a?(Array)
-        entries.each do |entry|
-          key = entry[map.key.location_name || 'key']
-          value = entry[map.value.location_name || 'value']
-          data[parse_shape(map.key, key)] = parse_shape(map.value, value)
+        # @return [Class] Returns the default parsing engine.
+        #   One of:
+        #
+        #   * {OxEngine}
+        #   * {OgaEngine}
+        #   * {LibxmlEngine}
+        #   * {NokogiriEngine}
+        #   * {RexmlEngine}
+        #
+        def engine
+          set_default_engine unless @engine
+          @engine
         end
-        data
-      end
 
-      # @param [Seahorse::Model::Shapes::Shape] shape
-      # @param [Object] value
-      # @return [Object]
-      def parse_shape(shape, value)
-        if value.nil?
-          case shape
-          when Seahorse::Model::Shapes::Structure then nil
-          when Seahorse::Model::Shapes::Map then {}
-          when Seahorse::Model::Shapes::List then []
-          when Seahorse::Model::Shapes::String then ''
-          else nil
-          end
-        else
-          case shape
-          when Seahorse::Model::Shapes::String then string(shape, value)
-          when Seahorse::Model::Shapes::Structure then structure(shape, value)
-          when Seahorse::Model::Shapes::List then list(shape, value)
-          when Seahorse::Model::Shapes::Map then map(shape, value)
-          when Seahorse::Model::Shapes::Boolean then value == 'true'
-          when Seahorse::Model::Shapes::Integer then value.to_i
-          when Seahorse::Model::Shapes::Float then value.to_f
-          when Seahorse::Model::Shapes::Timestamp then timestamp(value)
-          when Seahorse::Model::Shapes::Blob then Base64.decode64(value)
-          else
-            raise "unhandled shape type: `#{shape.type}'"
+        def set_default_engine
+          [:ox, :oga, :libxml, :nokogiri, :rexml].each do |name|
+            @engine ||= try_load_engine(name)
           end
         end
-      end
 
-      def string(shape, value)
-        if value.is_a?(Hash)
-          decode_string(value)
-        else
-          value
-        end
-      end
+        private
 
-      def decode_string(value)
-        case value['encoding']
-        when 'base64' then Base64.decode64(value['__content__'])
-        else value['__content__']
+        def load_engine(name)
+          require "aws-sdk-core/xml/parser/engines/#{name}"
+          const_name = name[0].upcase + name[1..-1] + 'Engine'
+          const_get(const_name)
         end
-      end
 
-      def timestamp(value)
-        case value
-        when nil then nil
-        when /^\d+$/ then Time.at(value.to_i)
-        else
-          begin
-            Time.parse(value)
-          rescue ArgumentError
-            raise "unhandled timestamp format `#{value}'"
-          end
+        def try_load_engine(name)
+          load_engine(name)
+        rescue LoadError
+          false
         end
-      end
 
-      def flat?(shape)
-        !!shape.metadata('flattened')
       end
 
+      set_default_engine
+
     end
   end
 end