aws-sdk-v1 1.52.0

data/lib/aws/core/xml/frame_stack.rb

@@ -0,0 +1,85 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Core
+    module XML
+
+      # @api private
+      module FrameStack
+
+        # @param [Hash] rules A hash of parser rules.  These
+        #   rules are typically generated by an {XML::Grammar}.
+        def initialize rules
+          @frame = RootFrame.new(rules)
+        end
+
+        def sax_parse xml
+          raise NotImplementedError
+        end
+        protected :sax_parse
+
+        # Parses the xml string and returns a hash with the resutls.
+        # @param [String] xml
+        # @return [Hash]
+        def parse xml
+          sax_parse(xml)
+          @frame.value
+        end
+
+        # Increase the frame stack level by one.
+        # @param [String] element_name The name of the xml opening tag.
+        # @param [Hash] attributes A hash of xml element attributes.
+        # @return [nil]
+        def start_element element_name, attributes = {}
+          @frame = @frame.build_child_frame(element_name)
+          self.attributes(attributes)
+          nil
+        end
+
+        # Increase the frame stack level by one by treating
+        # xml element attributes as nested elements.
+        # @param [Hash] attributes A hash of attributes names to values.
+        # @return [nil]
+        def attributes attributes
+          attributes.each_pair do |attr_name, attr_value|
+            attr_frame = @frame.build_child_frame(attr_name)
+            attr_frame.add_text(attr_value)
+            @frame.consume_child_frame(attr_frame)
+          end
+          nil
+        end
+
+        # Pops the top frame off the stack.  When closing frames
+        # their final value is computed.
+        # @overload end_element
+        # @return [nil]
+        def end_element *ignored
+          parent = @frame.parent_frame
+          child = @frame
+          parent.consume_child_frame(child)
+          @frame = @frame.parent_frame
+          nil
+        end
+
+        # Adds text to the current frame.  Frames that only contain
+        # text and no child elements are leaf nodes and have
+        # raw string values.
+        def set_text text
+          @frame.add_text(text) if @frame
+        end
+
+      end
+    end
+  end
+end

data/lib/aws/core/xml/grammar.rb

@@ -0,0 +1,307 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Core
+    module XML
+
+      # A class that simplifies building XML {Parser} rules.  This is also
+      # a compatability layer between the old and new formats of the api
+      # config.
+      class Grammar
+
+        def initialize rules = {}, options = {}
+          @rules = rules
+          @context = @rules
+          @element_name = 'xml'
+          @inflect_rename = options.key?(:inflect_rename) ?
+            options[:inflect_rename] : true
+        end
+
+        # Parses the XML with the rules provided by the current grammar.
+        # This method is meant to provide backwards compatability with
+        # the old XmlGrammar class that handled rules and parsing.
+        # @param [String] xml
+        # @return [Data] Returns a hash-like parsed response.
+        def parse xml
+          Data.new(Parser.parse(xml, rules))
+        end
+
+        # @return [Hash] Returns a hash of rules defined by this grammar.
+        attr_reader :rules
+
+        # Returns a new grammar (leaving the current one un-modified) with
+        # the given customizations applied.  Customizations can be given in
+        # a hash-form or in a block form.
+        #
+        # @example Block-form customizations
+        #
+        #   grammar.customize do
+        #     element "EnumElement" do
+        #       symbol_value
+        #       list
+        #     end
+        #   end
+        #
+        # @example Hash-form customizations
+        #
+        #   grammar.customize "EnumElement" => [:symbol_value, :list]
+        #
+        # @return [Grammar] Returns a grammar with the given customizations
+        #   applied.
+        #
+        def customize customizations = nil, &block
+          opts = { :inflect_rename => @inflect_rename }
+          self.class.customize(customizations, @rules, opts, &block)
+        end
+
+        # Applies customizations to the current grammar, not returning
+        # a new grammar.
+        def customize! customizations = nil, &block
+          apply_customizations(customizations) if customizations
+          instance_eval(&block) if block_given?
+          self
+        end
+
+        def self.customize customizations = nil, rules = {}, opts = {}, &block
+          grammar = self.new(deep_copy(rules), opts)
+          grammar.send(:apply_customizations, customizations) if customizations
+          grammar.instance_eval(&block) if block_given?
+          grammar
+        end
+
+        def self.parse xml
+          self.new.parse(xml)
+        end
+
+        protected
+
+        # Performs a deep copy of the rules hash so that it can be
+        # customized without chaning the parent grammar.
+        def self.deep_copy rules
+          rules.inject({}) do |copy,(key,value)|
+            copy[key] = value.is_a?(Hash) ? deep_copy(value) : value
+            copy
+          end
+        end
+
+        def apply_customizations customizations
+          customizations.each do |item|
+            (type, identifier, args) = parse_customization_item(item)
+            case type
+            when :method
+              validate_config_method(identifier)
+              validate_args(identifier, args)
+              send(identifier, *args)
+            when :element
+              element(identifier) do
+                apply_customizations(args)
+              end
+            end
+          end
+        end
+
+        def parse_customization_item item
+          case item
+          when Symbol
+            [:method, item, []]
+          when Hash
+            (method, arg) = item.to_a.first
+            if method.kind_of?(Symbol)
+              [:method, method, [arg].flatten]
+            else
+              [:element, method, arg]
+            end
+          end
+        end
+
+        def validate_config_method(method)
+          allow_methods = %w(
+            rename attribute_name boolean integer long float list force string
+            ignore collect_values symbol_value timestamp map_entry map blob
+            enum position
+          )
+          unless allow_methods.include?(method.to_s)
+            raise "#{method} cannot be used in configuration"
+          end
+        end
+
+        def validate_args(identifier, args)
+          arity = method(identifier).arity
+          if args.length > 0
+            raise "#{identifier} does not accept an argument" if
+              arity == 0
+          else
+            raise "#{identifier} requires an argument" unless
+              arity == 0 || arity == -1
+          end
+        end
+
+        def inflect value
+          Inflection.ruby_name(value.to_s).to_sym
+        end
+
+        # customization methods
+
+        def element element_name, &block
+
+          parent_context = @context
+          parent_element_name = @element_name
+
+          @context = context_for_child(element_name)
+
+          @element_name = element_name
+
+          begin
+            if block_given?
+              block.arity == 1 ? yield(parent_element_name) : yield
+            end
+          ensure
+            @context = parent_context
+            @element_name = parent_element_name
+          end
+
+        end
+
+        def ignore
+          @context[:ignore] = true
+        end
+
+        def rename new_name
+          if @inflect_rename
+            @context[:rename] = inflect(new_name)
+          else
+            @context[:rename] = new_name
+          end
+        end
+
+        def force
+          @context[:force] = true
+        end
+
+        def collect_values
+          @context[:list] = true
+        end
+
+        def index index_name, options = {}
+          @context[:index] = options.merge(:name => index_name)
+        end
+
+        def default_value name, value
+          @context[:defaults] ||= {}
+          @context[:defaults][name] = value
+        end
+
+        def list child_element_name = nil, &block
+          if child_element_name
+            ignore
+            element(child_element_name) do |parent_element_name|
+              rename(parent_element_name)
+              collect_values
+              yield if block_given?
+            end
+          else
+            collect_values
+          end
+        end
+
+        def map_entry key_element_name, value_element_name
+          @context[:map] = [key_element_name, value_element_name]
+        end
+
+        def map map_element_name, key_element_name, value_element_name
+          ignore
+          element(map_element_name) do |parent_element_name|
+            rename(parent_element_name)
+            map_entry(key_element_name, value_element_name)
+          end
+        end
+
+        def wrapper method_name, options = {}, &block
+          options[:for].each do |child|
+            context_for_child(child)[:wrap] = method_name
+          end
+        end
+
+        def construct_value &block
+          raise 'remove the need for this'
+        end
+
+        def boolean_value
+          @context[:type] = :boolean
+        end
+        alias_method :boolean, :boolean_value
+
+        def blob_value
+          @context[:type] = :blob
+        end
+        alias_method :blob, :blob_value
+
+        def datetime_value
+          @context[:type] = :datetime
+        end
+        alias_method :datetime, :datetime_value
+
+        def time_value
+          @context[:type] = :time
+        end
+        alias_method :timestamp, :time_value
+        alias_method :time, :time_value
+
+        def string_value
+          @context[:type] = :string
+        end
+        alias_method :string, :string_value
+
+        def integer_value
+          @context[:type] = :integer
+        end
+        alias_method :integer, :integer_value
+        alias_method :long, :integer_value
+
+        def float_value
+          @context[:type] = :float
+        end
+        alias_method :float, :float_value
+
+        def symbol_value
+          @context[:type] = :symbol
+        end
+        alias_method :symbol, :symbol_value
+
+        def eql? other
+          other.is_a?(Grammar) and self.rules == other.rules
+        end
+        alias_method :==, :eql?
+        public :==
+
+        def enum *args; end
+        def position *args; end
+        def http_trait *args; end
+        alias_method :http_header, :http_trait
+        alias_method :http_uri_label, :http_trait
+        alias_method :http_payload, :http_trait
+        alias_method :http_status, :http_trait
+
+
+        protected
+        def context_for_child child_element_name
+          @context[:children] ||= {}
+          @context[:children][child_element_name] ||= {}
+          @context[:children][child_element_name]
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Core
+    module XML
+      class Parser
+
+        # @param [Hash] rules A has of xml parsing rules.  Generally
+        #   rules will come from an xml grammar.
+        def initialize rules = {}
+          @rules = rules
+        end
+
+        # @return [Hash] Returns the rules for this xml parser that define
+        #   how it should transform the XMl into Ruby.
+        attr_reader :rules
+
+        # @param [String] xml An XML document string to parse.
+        # @return [Hash] Returns a hash of parsed xml data.
+        def parse xml
+          xml = '<xml/>' if xml.nil? or xml.empty?
+          sax_handler.parse(xml)
+        end
+
+        # @return [Hash] Returns a hash of mostly empty placeholder data.
+        def simulate
+          XML::Stub.simulate(rules)
+        end
+
+        # @param [String] xml An XML document string to parse.
+        # @param [Hash] rules A has of xml parsing rules.  Generally
+        #   rules will come from an xml grammar.
+        # @return [Hash] Returns a hash of parsed xml data.
+        def self.parse xml, rules = {}
+          self.new(rules).parse(xml)
+        end
+
+        protected
+
+        # There are three handlers, nokogiri is the fastest, followed
+        # by libxml-ruby.  Lastly (by a long shot) is REXML.  REXML
+        # is the only library that does not  rely on a native
+        # extension.
+        #
+        # Currently you can not choose your xml sax handler, and the only
+        # we express a gem dependency on is nokogiri.
+        #
+        def sax_handler
+          begin
+            SaxHandlers::Nokogiri.new(rules)
+          rescue NameError, LoadError
+            SaxHandlers::REXML.new(rules)
+          end
+        end
+
+      end
+    end
+  end
+end