aws-sdk-core 2.0.33 → 2.0.34

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

@@ -0,0 +1,20 @@
+require 'ox'
+require 'stringio'
+
+module Aws
+  module Xml
+    class Parser
+      class OxEngine
+
+        def initialize(stack)
+          @stack = stack
+        end
+
+        def parse(xml)
+          Ox.sax_parse(@stack, StringIO.new(xml))
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'rexml/document'
+require 'rexml/streamlistener'
+
+module Aws
+  module Xml
+    class Parser
+      class RexmlEngine
+
+        include REXML::StreamListener
+
+        def initialize(stack)
+          @stack = stack
+          @depth = 0
+        end
+
+        def parse(xml)
+          begin
+            source = REXML::Source.new(xml)
+            REXML::Parsers::StreamParser.new(source, self).parse
+          rescue REXML::ParseException => error
+            @stack.error(error.message)
+          end
+        end
+
+        def tag_start(name, attrs)
+          @depth += 1
+          @stack.start_element(name)
+          attrs.each do |attr|
+            @stack.attr(*attr)
+          end
+        end
+
+        def text(value)
+          @stack.text(value) if @depth > 0
+        end
+
+        def tag_end(name)
+          @stack.end_element
+          @depth -= 1
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,284 @@
+require 'base64'
+require 'time'
+
+module Aws
+  module Xml
+    class Parser
+      class Frame
+
+        def initialize(parent, shape, result = nil)
+          @parent = parent
+          @shape = shape
+          @result = result
+        end
+
+        attr_reader :parent
+
+        attr_reader :shape
+
+        attr_reader :result
+
+        def set_text(value); end
+
+        def child_frame(xml_name)
+          NullFrame.new(self)
+        end
+
+        def consume_child_frame(child); end
+
+        private
+
+        class << self
+
+          def new(parent, shape, result = nil)
+            if self == Frame
+              frame = frame_class(shape).allocate
+              frame.send(:initialize, parent, shape, result)
+              frame
+            else
+              super
+            end
+          end
+
+          private
+
+          def frame_class(shape)
+            @classes ||= {
+              'blob' => BlobFrame,
+              'boolean' => BooleanFrame,
+              'byte' => BlobFrame,
+              'character' => StringFrame,
+              'double' => FloatFrame,
+              'float' => FloatFrame,
+              'integer' => IntegerFrame,
+              'list' => ListFrame,
+              'list:flat' => FlatListFrame,
+              'long' => IntegerFrame,
+              'map' => MapFrame,
+              'map:flat' => MapEntryFrame,
+              'string' => StringFrame,
+              'structure' => StructureFrame,
+              'timestamp' => TimestampFrame,
+            }
+            if shape
+              type = shape.type
+              type += ':flat' if shape.definition['flattened']
+              @classes[type]
+            else
+              NullFrame
+            end
+          end
+
+        end
+      end
+
+      class StructureFrame < Frame
+
+        def initialize(parent, shape, result = nil)
+          super
+          @result ||= Structure.new(shape.member_names)
+          @members = {}
+          shape.members.each do |member_name, member_shape|
+            apply_default_value(member_name, member_shape)
+            @members[xml_name(member_shape)] = {
+              name: member_name,
+              shape: member_shape,
+            }
+          end
+        end
+
+        def child_frame(xml_name)
+          if @member = @members[xml_name]
+            Frame.new(self, @member[:shape])
+          else
+            NullFrame.new(self)
+          end
+        end
+
+        def consume_child_frame(child)
+          case child
+          when MapEntryFrame
+            @result[@member[:name]][child.key.result] = child.value.result
+          when FlatListFrame
+            @result[@member[:name]] << child.result
+          when NullFrame
+          else
+            @result[@member[:name]] = child.result
+          end
+        end
+
+        private
+
+        def apply_default_value(name, shape)
+          case shape
+          when Seahorse::Model::Shapes::List then @result[name] = DefaultList.new
+          when Seahorse::Model::Shapes::Map then @result[name] = {}
+          end
+        end
+
+        def xml_name(member_shape)
+          if member_shape.type == 'list' && member_shape.definition['flattened']
+            member_shape.member.location_name || member_shape.location_name
+          else
+            member_shape.location_name
+          end
+        end
+
+      end
+
+      class ListFrame < Frame
+
+        def initialize(*args)
+          super
+          @result = []
+          @member_xml_name = @shape.member.location_name || 'member'
+        end
+
+        def child_frame(xml_name)
+          if xml_name == @member_xml_name
+            Frame.new(self, @shape.member)
+          else
+            raise NotImplementedError
+          end
+        end
+
+        def consume_child_frame(child)
+          @result << child.result unless NullFrame === child
+        end
+
+      end
+
+      class FlatListFrame < Frame
+
+        def initialize(*args)
+          super
+          @member = Frame.new(self, @shape.member)
+        end
+
+        def result
+          @member.result
+        end
+
+        def set_text(value)
+          @member.set_text(value)
+        end
+
+        def child_frame(xml_name)
+          @member.child_frame(xml_name)
+        end
+
+        def consume_child_frame(child)
+          @result = @member.result
+        end
+
+      end
+
+      class MapFrame < Frame
+
+        def initialize(*args)
+          super
+          @result = {}
+        end
+
+        def child_frame(xml_name)
+          if xml_name == 'entry'
+            MapEntryFrame.new(self, @shape)
+          else
+            raise NotImplementedError
+          end
+        end
+
+        def consume_child_frame(child)
+          @result[child.key.result] = child.value.result
+        end
+
+      end
+
+      class MapEntryFrame < Frame
+
+        def initialize(*args)
+          super
+          @key_name = @shape.key.location_name || 'key'
+          @key = Frame.new(self, @shape.key)
+          @value_name = @shape.value.location_name || 'value'
+          @value = Frame.new(self, @shape.value)
+        end
+
+        # @return [StringFrame]
+        attr_reader :key
+
+        # @return [Frame]
+        attr_reader :value
+
+        def child_frame(xml_name)
+          if @key_name == xml_name
+            @key
+          elsif @value_name == xml_name
+            @value
+          else
+            NullFrame.new(self)
+          end
+        end
+
+      end
+
+      class NullFrame < Frame
+        def self.new(parent)
+          super(parent, nil)
+        end
+      end
+
+      class BlobFrame < Frame
+        def set_text(value)
+          @result = Base64.decode64(value)
+        end
+      end
+
+      class BooleanFrame < Frame
+        def set_text(value)
+          @result = (value == 'true')
+        end
+      end
+
+      class FloatFrame < Frame
+        def set_text(value)
+          @result = value.to_f
+        end
+      end
+
+      class IntegerFrame < Frame
+        def set_text(value)
+          @result = value.to_i
+        end
+      end
+
+      class StringFrame < Frame
+        def initialize(*args)
+          super
+          @result = ''
+        end
+        def set_text(value)
+          @result = value
+        end
+      end
+
+      class TimestampFrame < Frame
+        def set_text(value)
+          @result = parse(value)
+        end
+        def parse(value)
+          case value
+          when nil then nil
+          when /^\d+$/ then Time.at(value.to_i)
+          else
+            begin
+              Time.parse(value).utc
+            rescue ArgumentError
+              raise "unhandled timestamp format `#{value}'"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Aws
+  module Xml
+    class Parser
+      class ParsingError < RuntimeError
+
+        def initialize(msg, line, column)
+          super(msg)
+        end
+
+        # @return [Integer,nil]
+        attr_reader :line
+
+        # @return [Integer,nil]
+        attr_reader :column
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Aws
+  module Xml
+    class Parser
+      class Stack
+
+        def initialize(shape, result = nil)
+          @shape = shape
+          @frame = self
+          @result = result
+        end
+
+        attr_reader :frame
+
+        attr_reader :result
+
+        def start_element(name)
+          @frame = @frame.child_frame(name.to_s)
+        end
+
+        def attr(name, value)
+          if name.to_s == 'encoding' && value.to_s == 'base64'
+            @frame = BlobFrame.new(@frame.parent, @frame.shape)
+          else
+            start_element(name)
+            text(value)
+            end_element(name)
+          end
+        end
+
+        def text(value)
+          @frame.set_text(value)
+        end
+
+        def end_element(*args)
+          @frame.parent.consume_child_frame(@frame)
+          if @frame.parent.is_a?(FlatListFrame)
+            @frame = @frame.parent
+            @frame.parent.consume_child_frame(@frame)
+          end
+          @frame = @frame.parent
+        end
+
+        def error(msg, line = nil, column = nil)
+          raise ParsingError.new(msg, line, column)
+        end
+
+        def child_frame(name)
+          Frame.new(self, @shape, @result)
+        end
+
+        def consume_child_frame(frame)
+          @result = frame.result
+        end
+
+      end
+    end
+  end
+end

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

@@ -58,7 +58,7 @@ module Seahorse
               name, shape = input.member_by_location_name(placeholder)
               param = context.params[name]
               if greedy
-                param.split('/').map{ |value| escape(value) }.join('/')
+                param = param.gsub(/[^\/]+/) { |v| escape(v) }
               else
                 escape(param)
               end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-sdk-core
 version: !ruby/object:Gem::Version
-  version: 2.0.33
+  version: 2.0.34
 platform: ruby
 authors:
 - Amazon Web Services
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-26 00:00:00.000000000 Z
+date: 2015-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -24,20 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: multi_xml
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: builder
   requirement: !ruby/object:Gem::Requirement
@@ -315,6 +301,13 @@ files:
 - lib/aws-sdk-core/xml/default_list.rb
 - lib/aws-sdk-core/xml/error_handler.rb
 - lib/aws-sdk-core/xml/parser.rb
+- lib/aws-sdk-core/xml/parser/engines/libxml.rb
+- lib/aws-sdk-core/xml/parser/engines/nokogiri.rb
+- lib/aws-sdk-core/xml/parser/engines/ox.rb
+- lib/aws-sdk-core/xml/parser/engines/rexml.rb
+- lib/aws-sdk-core/xml/parser/frame.rb
+- lib/aws-sdk-core/xml/parser/parsing_error.rb
+- lib/aws-sdk-core/xml/parser/stack.rb
 - lib/aws-sdk-core/xml/rest_handler.rb
 - lib/seahorse.rb
 - lib/seahorse/client/base.rb