allegro_api_client 0.0.1

data/gems/ruby/2.1.0/gems/multi_xml-0.5.5/lib/multi_xml/parsers/libxml2_parser.rb

@@ -0,0 +1,74 @@
+module MultiXml
+  module Parsers
+    module Libxml2Parser #:nodoc:
+      # Convert XML document to hash
+      #
+      # node::
+      #   The XML node object to convert to a hash.
+      #
+      # hash::
+      #   Hash to merge the converted element into.
+      def node_to_hash(node, hash={})
+        node_hash = {MultiXml::CONTENT_ROOT => ''}
+
+        name = node_name(node)
+
+        # Insert node hash into parent hash correctly.
+        case hash[name]
+          when Array then hash[name] << node_hash
+          when Hash  then hash[name] = [hash[name], node_hash]
+          when nil   then hash[name] = node_hash
+        end
+
+        # Handle child elements
+        each_child(node) do |c|
+          if c.element?
+            node_to_hash(c, node_hash)
+          elsif c.text? || c.cdata?
+            node_hash[MultiXml::CONTENT_ROOT] << c.content
+          end
+        end
+
+        # Remove content node if it is empty
+        if node_hash[MultiXml::CONTENT_ROOT].strip.empty?
+          node_hash.delete(MultiXml::CONTENT_ROOT)
+        end
+
+        # Handle attributes
+        each_attr(node) do |a|
+          key = node_name(a)
+
+          node_hash[key] = if v = node_hash[key]
+                             [a.value, v]
+                           else
+                             a.value
+                           end
+        end
+
+        hash
+      end
+
+      # Parse an XML Document IO into a simple hash.
+      # xml::
+      #   XML Document IO to parse
+      def parse(xml)
+        raise NotImplementedError, "inheritor should define #{__method__}"
+      end
+
+      # :stopdoc:
+      private
+
+      def each_child(*args)
+        raise NotImplementedError, "inheritor should define #{__method__}"
+      end
+
+      def each_attr(*args)
+        raise NotImplementedError, "inheritor should define #{__method__}"
+      end
+
+      def node_name(*args)
+        raise NotImplementedError, "inheritor should define #{__method__}"
+      end
+    end
+  end
+end

data/gems/ruby/2.1.0/gems/multi_xml-0.5.5/lib/multi_xml/parsers/nokogiri.rb

@@ -0,0 +1,32 @@
+require 'nokogiri' unless defined?(Nokogiri)
+require 'multi_xml/parsers/libxml2_parser'
+
+module MultiXml
+  module Parsers
+    module Nokogiri #:nodoc:
+      include Libxml2Parser
+
+      extend self
+
+      def parse_error() ::Nokogiri::XML::SyntaxError end
+
+      def parse(xml)
+        doc = ::Nokogiri::XML(xml)
+        raise doc.errors.first if doc.errors.length > 0
+        node_to_hash(doc.root)
+      end
+
+      def each_child(node, &block)
+        node.children.each(&block)
+      end
+
+      def each_attr(node, &block)
+        node.attribute_nodes.each(&block)
+      end
+
+      def node_name(node)
+        node.node_name
+      end
+    end
+  end
+end

data/gems/ruby/2.1.0/gems/multi_xml-0.5.5/lib/multi_xml/parsers/ox.rb

@@ -0,0 +1,97 @@
+require 'ox' unless defined?(Ox)
+
+# Each MultiXml parser is expected to parse an XML document into a Hash. The
+# conversion rules are:
+#
+# - Each document starts out as an empty Hash.
+#
+# - Reading an element created an entry in the parent Hash that has a key of
+#   the element name and a value of a Hash with attributes as key value
+#   pairs. Children are added as described by this rule.
+#
+# - Text and CDATE is stored in the parent element Hash with a key of
+#   MultiXml::CONTENT_ROOT and a value of the text itself.
+#
+# - If a key already exists in the Hash then the value associated with the key
+#   is converted to an Array with the old and new value in it.
+#
+# - Other elements such as the xml prolog, doctype, and comments are ignored.
+#
+
+module MultiXml
+  module Parsers
+    module Ox #:nodoc:
+
+      extend self
+
+      def parse_error
+        Exception
+      end
+
+      def parse(io)
+        handler = Handler.new
+        ::Ox.sax_parse(handler, io, :convert_special => true)
+        handler.doc
+      end
+
+      class Handler
+        attr_accessor :stack
+
+        def initialize()
+          @stack = []
+        end
+
+        def doc
+          @stack[0]
+        end
+
+        def attr(name, value)
+          unless @stack.empty?
+            append(name, value)
+          end
+        end
+
+        def text(value)
+          append(MultiXml::CONTENT_ROOT, value)
+        end
+
+        def cdata(value)
+          append(MultiXml::CONTENT_ROOT, value)
+        end
+
+        def start_element(name)
+          if @stack.empty?
+            @stack.push(Hash.new)
+          end
+          h = Hash.new
+          append(name, h)
+          @stack.push(h)
+        end
+
+        def end_element(name)
+          @stack.pop()
+        end
+
+        def error(message, line, column)
+          raise Exception.new("#{message} at #{line}:#{column}")
+        end
+
+        def append(key, value)
+          key = key.to_s
+          h = @stack.last
+          if h.has_key?(key)
+            v = h[key]
+            if v.is_a?(Array)
+              v << value
+            else
+              h[key] = [v, value]
+            end
+          else
+            h[key] = value
+          end
+        end
+
+      end # Handler
+    end # Ox
+  end # Parsers
+end # MultiXml

data/gems/ruby/2.1.0/gems/multi_xml-0.5.5/lib/multi_xml/parsers/rexml.rb

@@ -0,0 +1,113 @@
+require 'rexml/document' unless defined?(REXML::Document)
+
+module MultiXml
+  module Parsers
+    module Rexml #:nodoc:
+      extend self
+      def parse_error; ::REXML::ParseException; end
+
+      # Parse an XML Document IO into a simple hash using REXML
+      #
+      # xml::
+      #   XML Document IO to parse
+      def parse(xml)
+        doc = REXML::Document.new(xml)
+        if doc.root
+          merge_element!({}, doc.root)
+        else
+          raise REXML::ParseException, "The document #{doc.to_s.inspect} does not have a valid root"
+        end
+      end
+
+      private
+
+      # Convert an XML element and merge into the hash
+      #
+      # hash::
+      #   Hash to merge the converted element into.
+      # element::
+      #   XML element to merge into hash
+      def merge_element!(hash, element)
+        merge!(hash, element.name, collapse(element))
+      end
+
+      # Actually converts an XML document element into a data structure.
+      #
+      # element::
+      #   The document element to be collapsed.
+      def collapse(element)
+        hash = get_attributes(element)
+
+        if element.has_elements?
+          element.each_element {|child| merge_element!(hash, child) }
+          merge_texts!(hash, element) unless empty_content?(element)
+          hash
+        else
+          merge_texts!(hash, element)
+        end
+      end
+
+      # Merge all the texts of an element into the hash
+      #
+      # hash::
+      #   Hash to add the converted element to.
+      # element::
+      #   XML element whose texts are to me merged into the hash
+      def merge_texts!(hash, element)
+        unless element.has_text?
+          hash
+        else
+          # must use value to prevent double-escaping
+          texts = ''
+          element.texts.each { |t| texts << t.value }
+          merge!(hash, MultiXml::CONTENT_ROOT, texts)
+        end
+      end
+
+      # Adds a new key/value pair to an existing Hash. If the key to be added
+      # already exists and the existing value associated with key is not
+      # an Array, it will be wrapped in an Array. Then the new value is
+      # appended to that Array.
+      #
+      # hash::
+      #   Hash to add key/value pair to.
+      # key::
+      #   Key to be added.
+      # value::
+      #   Value to be associated with key.
+      def merge!(hash, key, value)
+        if hash.has_key?(key)
+          if hash[key].instance_of?(Array)
+            hash[key] << value
+          else
+            hash[key] = [hash[key], value]
+          end
+        elsif value.instance_of?(Array)
+          hash[key] = [value]
+        else
+          hash[key] = value
+        end
+        hash
+      end
+
+      # Converts the attributes array of an XML element into a hash.
+      # Returns an empty Hash if node has no attributes.
+      #
+      # element::
+      #   XML element to extract attributes from.
+      def get_attributes(element)
+        attributes = {}
+        element.attributes.each { |n,v| attributes[n] = v }
+        attributes
+      end
+
+      # Determines if a document element has text content
+      #
+      # element::
+      #   XML element to be checked.
+      def empty_content?(element)
+        element.texts.join.strip.empty?
+      end
+    end
+  end
+end

data/gems/ruby/2.1.0/gems/multi_xml-0.5.5/lib/multi_xml/version.rb

@@ -0,0 +1,3 @@
+module MultiXml
+  VERSION = "0.5.5" unless defined?(MultiXML::VERSION)
+end

data/gems/ruby/2.1.0/gems/multi_xml-0.5.5/multi_xml.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'multi_xml/version'
+
+Gem::Specification.new do |spec|
+  spec.add_development_dependency 'bundler', '~> 1.0'
+  spec.author = "Erik Michaels-Ober"
+  spec.cert_chain = ['certs/sferik.pem']
+  spec.description = %q{Provides swappable XML backends utilizing LibXML, Nokogiri, Ox, or REXML.}
+  spec.email = 'sferik@gmail.com'
+  spec.files = %w(.yardopts CHANGELOG.md CONTRIBUTING.md LICENSE.md README.md Rakefile multi_xml.gemspec)
+  spec.files += Dir.glob("lib/**/*.rb")
+  spec.files += Dir.glob("spec/**/*")
+  spec.homepage = 'https://github.com/sferik/multi_xml'
+  spec.licenses = ['MIT']
+  spec.name = 'multi_xml'
+  spec.require_paths = ['lib']
+  spec.required_rubygems_version = '>= 1.3.5'
+  spec.signing_key = File.expand_path("~/.gem/private_key.pem") if $0 =~ /gem\z/
+  spec.summary = %q{A generic swappable back-end for XML parsing}
+  spec.test_files = Dir.glob("spec/**/*")
+  spec.version = MultiXml::VERSION
+end

data/gems/ruby/2.1.0/gems/multi_xml-0.5.5/spec/helper.rb

@@ -0,0 +1,17 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start
+
+require 'multi_xml'
+require 'rspec'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/gems/ruby/2.1.0/gems/multi_xml-0.5.5/spec/multi_xml_spec.rb

@@ -0,0 +1,43 @@
+require 'helper'
+require 'parser_shared_example'
+
+class MockDecoder; end
+
+describe "MultiXml" do
+  context "Parsers" do
+    it "picks a default parser" do
+      expect(MultiXml.parser).to be_kind_of(Module)
+      expect(MultiXml.parser).to respond_to(:parse)
+    end
+
+    it "defaults to the best available gem" do
+      # Clear cache variable already set by previous tests
+      MultiXml.send(:remove_instance_variable, :@parser)
+      expect(MultiXml.parser.name).to eq('MultiXml::Parsers::Ox')
+    end
+
+    it "is settable via a symbol" do
+      MultiXml.parser = :rexml
+      expect(MultiXml.parser.name).to eq('MultiXml::Parsers::Rexml')
+    end
+
+    it "is settable via a class" do
+      MultiXml.parser = MockDecoder
+      expect(MultiXml.parser.name).to eq('MockDecoder')
+    end
+  end
+
+  [['LibXML', 'libxml'],
+   ['REXML', 'rexml/document'],
+   ['Nokogiri', 'nokogiri'],
+   ['Ox', 'ox']].each do |parser|
+    begin
+      require parser.last
+      context "#{parser.first} parser" do
+        it_behaves_like "a parser", parser.first
+      end
+    rescue LoadError => e
+      puts "Tests not run for #{parser.first} due to a LoadError"
+    end
+  end
+end

data/gems/ruby/2.1.0/gems/multi_xml-0.5.5/spec/parser_shared_example.rb

@@ -0,0 +1,694 @@
+shared_examples_for "a parser" do |parser|
+
+  before do
+    begin
+      MultiXml.parser = parser
+    rescue LoadError
+      pending "Parser #{parser} couldn't be loaded"
+    end
+  end
+
+  describe ".parse" do
+    context "a blank string" do
+      before do
+        @xml = ''
+      end
+
+      it "returns an empty Hash" do
+        expect(MultiXml.parse(@xml)).to eq({})
+      end
+    end
+
+    context "a whitespace string" do
+      before do
+        @xml = ' '
+      end
+
+      it "returns an empty Hash" do
+        expect(MultiXml.parse(@xml)).to eq({})
+      end
+    end
+
+    context "an invalid XML document" do
+      before do
+        @xml = '<open></close>'
+      end
+
+      it "raises MultiXml::ParseError" do
+        expect{MultiXml.parse(@xml)}.to raise_error(MultiXml::ParseError)
+      end
+    end
+
+    context "a valid XML document" do
+      before do
+        @xml = '<user/>'
+      end
+
+      it "parses correctly" do
+        expect(MultiXml.parse(@xml)).to eq({'user' => nil})
+      end
+
+      context "with CDATA" do
+        before do
+          @xml = '<user><![CDATA[Erik Michaels-Ober]]></user>'
+        end
+
+        it "returns the correct CDATA" do
+          expect(MultiXml.parse(@xml)['user']).to eq("Erik Michaels-Ober")
+        end
+      end
+
+      context "element with the same inner element and attribute name" do
+        before do
+          @xml = "<user name='John'><name>Smith</name></user>"
+        end
+
+        it "returns nams as Array" do
+          expect(MultiXml.parse(@xml)['user']['name']).to eq ['John', 'Smith']
+        end
+      end
+
+      context "with content" do
+        before do
+          @xml = '<user>Erik Michaels-Ober</user>'
+        end
+
+        it "returns the correct content" do
+          expect(MultiXml.parse(@xml)['user']).to eq("Erik Michaels-Ober")
+        end
+      end
+
+      context "with an attribute" do
+        before do
+          @xml = '<user name="Erik Michaels-Ober"/>'
+        end
+
+        it "returns the correct attribute" do
+          expect(MultiXml.parse(@xml)['user']['name']).to eq("Erik Michaels-Ober")
+        end
+      end
+
+      context "with multiple attributes" do
+        before do
+          @xml = '<user name="Erik Michaels-Ober" screen_name="sferik"/>'
+        end
+
+        it "returns the correct attributes" do
+          expect(MultiXml.parse(@xml)['user']['name']).to eq("Erik Michaels-Ober")
+          expect(MultiXml.parse(@xml)['user']['screen_name']).to eq("sferik")
+        end
+      end
+
+      context "typecast management" do
+        before do
+          @xml = %Q{
+            <global-settings>
+              <group>
+                <name>Settings</name>
+                <setting type="string">
+                  <description>Test</description>
+                </setting>
+              </group>
+            </global-settings>
+          }
+        end
+
+        context "with :typecast_xml_value => true" do
+          before do
+            @setting = MultiXml.parse(@xml)["global_settings"]["group"]["setting"]
+          end
+
+          it { expect(@setting).to eq "" }
+        end
+
+        context "with :typecast_xml_value => false" do
+          before do
+            @setting = MultiXml.parse(@xml, :typecast_xml_value => false)["global_settings"]["group"]["setting"]
+          end
+
+          it { expect(@setting).to eq({"type"=>"string", "description"=>{"__content__"=>"Test"}}) }
+        end
+      end
+
+      context "with :symbolize_keys => true" do
+        before do
+          @xml = '<users><user name="Erik Michaels-Ober"/><user><name>Wynn Netherland</name></user></users>'
+        end
+
+        it "symbolizes keys" do
+          expect(MultiXml.parse(@xml, :symbolize_keys => true)).to eq({:users => {:user => [{:name => "Erik Michaels-Ober"}, {:name => "Wynn Netherland"}]}})
+        end
+      end
+
+      context "with an attribute type=\"boolean\"" do
+        %w(true false).each do |boolean|
+          context "when #{boolean}" do
+            it "returns #{boolean}" do
+              xml = "<tag type=\"boolean\">#{boolean}</tag>"
+              expect(MultiXml.parse(xml)['tag']).to instance_eval("be_#{boolean}")
+            end
+          end
+        end
+
+        context "when 1" do
+          before do
+            @xml = '<tag type="boolean">1</tag>'
+          end
+
+          it "returns true" do
+            expect(MultiXml.parse(@xml)['tag']).to be_true
+          end
+        end
+
+        context "when 0" do
+          before do
+            @xml = '<tag type="boolean">0</tag>'
+          end
+
+          it "returns false" do
+            expect(MultiXml.parse(@xml)['tag']).to be_false
+          end
+        end
+      end
+
+      context "with an attribute type=\"integer\"" do
+        context "with a positive integer" do
+          before do
+            @xml = '<tag type="integer">1</tag>'
+          end
+
+          it "returns a Fixnum" do
+            expect(MultiXml.parse(@xml)['tag']).to be_a(Fixnum)
+          end
+
+          it "returns a positive number" do
+            expect(MultiXml.parse(@xml)['tag']).to be > 0
+          end
+
+          it "returns the correct number" do
+            expect(MultiXml.parse(@xml)['tag']).to eq(1)
+          end
+        end
+
+        context "with a negative integer" do
+          before do
+            @xml = '<tag type="integer">-1</tag>'
+          end
+
+          it "returns a Fixnum" do
+            expect(MultiXml.parse(@xml)['tag']).to be_a(Fixnum)
+          end
+
+          it "returns a negative number" do
+            expect(MultiXml.parse(@xml)['tag']).to be < 0
+          end
+
+          it "returns the correct number" do
+            expect(MultiXml.parse(@xml)['tag']).to eq(-1)
+          end
+        end
+      end
+
+      context "with an attribute type=\"string\"" do
+        before do
+          @xml = '<tag type="string"></tag>'
+        end
+
+        it "returns a String" do
+          expect(MultiXml.parse(@xml)['tag']).to be_a(String)
+        end
+
+        it "returns the correct string" do
+          expect(MultiXml.parse(@xml)['tag']).to eq("")
+        end
+      end
+
+      context "with an attribute type=\"date\"" do
+        before do
+          @xml = '<tag type="date">1970-01-01</tag>'
+        end
+
+        it "returns a Date" do
+          expect(MultiXml.parse(@xml)['tag']).to be_a(Date)
+        end
+
+        it "returns the correct date" do
+          expect(MultiXml.parse(@xml)['tag']).to eq(Date.parse('1970-01-01'))
+        end
+      end
+
+      context "with an attribute type=\"datetime\"" do
+        before do
+          @xml = '<tag type="datetime">1970-01-01 00:00</tag>'
+        end
+
+        it "returns a Time" do
+          expect(MultiXml.parse(@xml)['tag']).to be_a(Time)
+        end
+
+        it "returns the correct time" do
+          expect(MultiXml.parse(@xml)['tag']).to eq(Time.parse('1970-01-01 00:00'))
+        end
+      end
+
+      context "with an attribute type=\"dateTime\"" do
+        before do
+          @xml = '<tag type="datetime">1970-01-01 00:00</tag>'
+        end
+
+        it "returns a Time" do
+          expect(MultiXml.parse(@xml)['tag']).to be_a(Time)
+        end
+
+        it "returns the correct time" do
+          expect(MultiXml.parse(@xml)['tag']).to eq(Time.parse('1970-01-01 00:00'))
+        end
+      end
+
+      context "with an attribute type=\"double\"" do
+        before do
+          @xml = '<tag type="double">3.14159265358979</tag>'
+        end
+
+        it "returns a Float" do
+          expect(MultiXml.parse(@xml)['tag']).to be_a(Float)
+        end
+
+        it "returns the correct number" do
+          expect(MultiXml.parse(@xml)['tag']).to eq(3.14159265358979)
+        end
+      end
+
+      context "with an attribute type=\"decimal\"" do
+        before do
+          @xml = '<tag type="decimal">3.14159265358979</tag>'
+        end
+
+        it "returns a BigDecimal" do
+          expect(MultiXml.parse(@xml)['tag']).to be_a(BigDecimal)
+        end
+
+        it "returns the correct number" do
+          expect(MultiXml.parse(@xml)['tag']).to eq(3.14159265358979)
+        end
+      end
+
+      context "with an attribute type=\"base64Binary\"" do
+        before do
+          @xml = '<tag type="base64Binary">aW1hZ2UucG5n</tag>'
+        end
+
+        it "returns a String" do
+          expect(MultiXml.parse(@xml)['tag']).to be_a(String)
+        end
+
+        it "returns the correct string" do
+          expect(MultiXml.parse(@xml)['tag']).to eq("image.png")
+        end
+      end
+
+      context "with an attribute type=\"yaml\"" do
+        before do
+          @xml = "<tag type=\"yaml\">--- \n1: returns an integer\n:message: Have a nice day\narray: \n- has-dashes: true\n  has_underscores: true\n</tag>"
+        end
+
+        it "raises MultiXML::DisallowedTypeError by default" do
+          expect{ MultiXml.parse(@xml)['tag'] }.to raise_error(MultiXml::DisallowedTypeError)
+        end
+
+        it "returns the correctly parsed YAML when the type is allowed" do
+          expect(MultiXml.parse(@xml, :disallowed_types => [])['tag']).to eq({:message => "Have a nice day", 1 => "returns an integer", "array" => [{"has-dashes" => true, "has_underscores" => true}]})
+        end
+      end
+
+      context "with an attribute type=\"symbol\"" do
+        before do
+          @xml = "<tag type=\"symbol\">my_symbol</tag>"
+        end
+
+        it "raises MultiXML::DisallowedTypeError" do
+          expect{ MultiXml.parse(@xml)['tag'] }.to raise_error(MultiXml::DisallowedTypeError)
+        end
+
+        it "returns the correctly parsed Symbol when the type is allowed" do
+          expect(MultiXml.parse(@xml, :disallowed_types => [])['tag']).to eq(:my_symbol)
+        end
+      end
+
+      context "with an attribute type=\"file\"" do
+        before do
+          @xml = '<tag type="file" name="data.txt" content_type="text/plain">ZGF0YQ==</tag>'
+        end
+
+        it "returns a StringIO" do
+          expect(MultiXml.parse(@xml)['tag']).to be_a(StringIO)
+        end
+
+        it "is decoded correctly" do
+          expect(MultiXml.parse(@xml)['tag'].string).to eq('data')
+        end
+
+        it "has the correct file name" do
+          expect(MultiXml.parse(@xml)['tag'].original_filename).to eq('data.txt')
+        end
+
+        it "has the correct content type" do
+          expect(MultiXml.parse(@xml)['tag'].content_type).to eq('text/plain')
+        end
+
+        context "with missing name and content type" do
+          before do
+            @xml = '<tag type="file">ZGF0YQ==</tag>'
+          end
+
+          it "returns a StringIO" do
+            expect(MultiXml.parse(@xml)['tag']).to be_a(StringIO)
+          end
+
+          it "is decoded correctly" do
+            expect(MultiXml.parse(@xml)['tag'].string).to eq('data')
+          end
+
+          it "has the default file name" do
+            expect(MultiXml.parse(@xml)['tag'].original_filename).to eq('untitled')
+          end
+
+          it "has the default content type" do
+            expect(MultiXml.parse(@xml)['tag'].content_type).to eq('application/octet-stream')
+          end
+        end
+      end
+
+      context "with an attribute type=\"array\"" do
+        before do
+          @xml = '<users type="array"><user>Erik Michaels-Ober</user><user>Wynn Netherland</user></users>'
+        end
+
+        it "returns an Array" do
+          expect(MultiXml.parse(@xml)['users']).to be_a(Array)
+        end
+
+        it "returns the correct array" do
+          expect(MultiXml.parse(@xml)['users']).to eq(["Erik Michaels-Ober", "Wynn Netherland"])
+        end
+      end
+
+      context "with an attribute type=\"array\" in addition to other attributes" do
+        before do
+          @xml = '<users type="array" foo="bar"><user>Erik Michaels-Ober</user><user>Wynn Netherland</user></users>'
+        end
+
+        it "returns an Array" do
+          expect(MultiXml.parse(@xml)['users']).to be_a(Array)
+        end
+
+        it "returns the correct array" do
+          expect(MultiXml.parse(@xml)['users']).to eq(["Erik Michaels-Ober", "Wynn Netherland"])
+        end
+      end
+
+      context "with an attribute type=\"array\" containing only one item" do
+        before do
+          @xml = '<users type="array"><user>Erik Michaels-Ober</user></users>'
+        end
+
+        it "returns an Array" do
+          expect(MultiXml.parse(@xml)['users']).to be_a(Array)
+        end
+
+        it "returns the correct array" do
+          expect(MultiXml.parse(@xml)['users']).to eq(["Erik Michaels-Ober"])
+        end
+      end
+
+      %w(integer boolean date datetime file).each do |type|
+        context "with an empty attribute type=\"#{type}\"" do
+          before do
+            @xml = "<tag type=\"#{type}\"/>"
+          end
+
+          it "returns nil" do
+            expect(MultiXml.parse(@xml)['tag']).to be_nil
+          end
+        end
+      end
+
+      %w{yaml symbol}.each do |type|
+        context "with an empty attribute type=\"#{type}\"" do
+          before do
+            @xml = "<tag type=\"#{type}\"/>"
+          end
+
+          it "raises MultiXml::DisallowedTypeError by default" do
+            expect{ MultiXml.parse(@xml)['tag']}.to raise_error(MultiXml::DisallowedTypeError)
+          end
+
+          it "returns nil when the type is allowed" do
+            expect(MultiXml.parse(@xml, :disallowed_types => [])['tag']).to be_nil
+          end
+        end
+      end
+
+      context "with an empty attribute type=\"array\"" do
+        before do
+          @xml = '<tag type="array"/>'
+        end
+
+        it "returns an empty Array" do
+          expect(MultiXml.parse(@xml)['tag']).to eq([])
+        end
+
+        context "with whitespace" do
+          before do
+            @xml = '<tag type="array"> </tag>'
+          end
+
+          it "returns an empty Array" do
+            expect(MultiXml.parse(@xml)['tag']).to eq([])
+          end
+        end
+      end
+
+      context "with XML entities" do
+        before do
+          @xml_entities = {
+            "<" => "&lt;",
+            ">" => "&gt;",
+            '"' => "&quot;",
+            "'" => "&apos;",
+            "&" => "&amp;"
+          }
+        end
+
+        context "in content" do
+          it "returns unescaped XML entities" do
+            @xml_entities.each do |key, value|
+              xml = "<tag>#{value}</tag>"
+              expect(MultiXml.parse(xml)['tag']).to eq(key)
+            end
+          end
+        end
+
+        context "in attribute" do
+          it "returns unescaped XML entities" do
+            @xml_entities.each do |key, value|
+              xml = "<tag attribute=\"#{value}\"/>"
+              expect(MultiXml.parse(xml)['tag']['attribute']).to eq(key)
+            end
+          end
+        end
+      end
+
+
+      context "with dasherized tag" do
+        before do
+          @xml = '<tag-1/>'
+        end
+
+        it "returns undasherize tag" do
+          expect(MultiXml.parse(@xml).keys).to include('tag_1')
+        end
+      end
+
+      context "with dasherized attribute" do
+        before do
+          @xml = '<tag attribute-1="1"></tag>'
+        end
+
+        it "returns undasherize attribute" do
+          expect(MultiXml.parse(@xml)['tag'].keys).to include('attribute_1')
+        end
+      end
+
+      context "with children" do
+        context "with attributes" do
+          before do
+            @xml = '<users><user name="Erik Michaels-Ober"/></users>'
+          end
+
+          it "returns the correct attributes" do
+            expect(MultiXml.parse(@xml)['users']['user']['name']).to eq("Erik Michaels-Ober")
+          end
+        end
+
+        context "with text" do
+          before do
+            @xml = '<user><name>Erik Michaels-Ober</name></user>'
+          end
+
+          it "returns the correct text" do
+            expect(MultiXml.parse(@xml)['user']['name']).to eq("Erik Michaels-Ober")
+          end
+        end
+
+        context "with an unrecognized attribute type" do
+          before do
+            @xml = '<user type="admin"><name>Erik Michaels-Ober</name></user>'
+          end
+
+          it "passes through the type" do
+            expect(MultiXml.parse(@xml)['user']['type']).to eq('admin')
+          end
+        end
+
+        context "with attribute tags on content nodes" do
+          context "non 'type' attributes" do
+            before do
+              @xml = <<-XML
+                <options>
+                  <value currency='USD'>123</value>
+                  <value number='percent'>0.123</value>
+                </options>
+              XML
+              @parsed_xml = MultiXml.parse(@xml)
+            end
+
+            it "adds the attributes to the value hash" do
+              expect(@parsed_xml['options']['value'][0]['__content__']).to eq('123')
+              expect(@parsed_xml['options']['value'][0]['currency']).to eq('USD')
+              expect(@parsed_xml['options']['value'][1]['__content__']).to eq('0.123')
+              expect(@parsed_xml['options']['value'][1]['number']).to eq('percent')
+            end
+          end
+
+          context "unrecognized type attributes" do
+            before do
+              @xml = <<-XML
+                <options>
+                  <value type='USD'>123</value>
+                  <value type='percent'>0.123</value>
+                  <value currency='USD'>123</value>
+                </options>
+              XML
+              @parsed_xml = MultiXml.parse(@xml)
+            end
+
+            it "adds the attributes to the value hash passing through the type" do
+              expect(@parsed_xml['options']['value'][0]['__content__']).to eq('123')
+              expect(@parsed_xml['options']['value'][0]['type']).to eq('USD')
+              expect(@parsed_xml['options']['value'][1]['__content__']).to eq('0.123')
+              expect(@parsed_xml['options']['value'][1]['type']).to eq('percent')
+              expect(@parsed_xml['options']['value'][2]['__content__']).to eq('123')
+              expect(@parsed_xml['options']['value'][2]['currency']).to eq('USD')
+            end
+          end
+
+          context "mixing attributes and non-attributes content nodes type attributes" do
+            before do
+              @xml = <<-XML
+                <options>
+                  <value type='USD'>123</value>
+                  <value type='percent'>0.123</value>
+                  <value>123</value>
+                </options>
+              XML
+              @parsed_xml = MultiXml.parse(@xml)
+            end
+
+            it "adds the attributes to the value hash passing through the type" do
+              expect(@parsed_xml['options']['value'][0]['__content__']).to eq('123')
+              expect(@parsed_xml['options']['value'][0]['type']).to eq('USD')
+              expect(@parsed_xml['options']['value'][1]['__content__']).to eq('0.123')
+              expect(@parsed_xml['options']['value'][1]['type']).to eq('percent')
+              expect(@parsed_xml['options']['value'][2]).to eq('123')
+            end
+          end
+
+          context "mixing recognized type attribute and non-type attributes on content nodes" do
+            before do
+              @xml = <<-XML
+                <options>
+                  <value number='USD' type='integer'>123</value>
+                </options>
+              XML
+              @parsed_xml = MultiXml.parse(@xml)
+            end
+
+            it "adds the the non-type attribute and remove the recognized type attribute and do the typecast" do
+              expect(@parsed_xml['options']['value']['__content__']).to eq(123)
+              expect(@parsed_xml['options']['value']['number']).to eq('USD')
+            end
+          end
+
+          context "mixing unrecognized type attribute and non-type attributes on content nodes" do
+            before do
+              @xml = <<-XML
+                <options>
+                  <value number='USD' type='currency'>123</value>
+                </options>
+              XML
+              @parsed_xml = MultiXml.parse(@xml)
+            end
+
+            it "adds the the non-type attributes and type attribute to the value hash" do
+              expect(@parsed_xml['options']['value']['__content__']).to eq('123')
+              expect(@parsed_xml['options']['value']['number']).to eq('USD')
+              expect(@parsed_xml['options']['value']['type']).to eq('currency')
+            end
+          end
+        end
+
+        context "with newlines and whitespace" do
+          before do
+            @xml = <<-XML
+              <user>
+                <name>Erik Michaels-Ober</name>
+              </user>
+            XML
+          end
+
+          it "parses correctly" do
+            expect(MultiXml.parse(@xml)).to eq({"user" => {"name" => "Erik Michaels-Ober"}})
+          end
+        end
+
+        # Babies having babies
+        context "with children" do
+          before do
+            @xml = '<users><user name="Erik Michaels-Ober"><status text="Hello"/></user></users>'
+          end
+
+          it "parses correctly" do
+            expect(MultiXml.parse(@xml)).to eq({"users" => {"user" => {"name" => "Erik Michaels-Ober", "status" => {"text" => "Hello"}}}})
+          end
+        end
+      end
+
+      context "with sibling children" do
+        before do
+          @xml = '<users><user>Erik Michaels-Ober</user><user>Wynn Netherland</user></users>'
+        end
+
+        it "returns an Array" do
+          expect(MultiXml.parse(@xml)['users']['user']).to be_a(Array)
+        end
+
+        it "parses correctly" do
+          expect(MultiXml.parse(@xml)).to eq({"users" => {"user" => ["Erik Michaels-Ober", "Wynn Netherland"]}})
+        end
+      end
+
+    end
+  end
+
+end