xml-mapping_extensions 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 159f916e7e1a374d68857ce63626f37b763312e3
-  data.tar.gz: 50ffcf3d3606eec904e7ce9faaecccf90905ac39
+  metadata.gz: 26f76a9fe36b5554f940110297aefbf62e26cc99
+  data.tar.gz: 30c72c8dc6b1c9c8757c493c14919a65ff4df36f
 SHA512:
-  metadata.gz: fdd87b9bb6d862300aac1b9bf993b9023f2704c6f788347868eb9eb89cd2a5911f92c321c4bba1af4a8520d3957f80b05678d7e75302b2b9e756bf61600d355a
-  data.tar.gz: fbc3c1cc7ba3627c21c6fe6cf2711031620f4638554a1d53d97e46c43547cb86426be36ef46eb4fb7bfbc5f78a1a341937a6342867710cc0a35bd93ad74f58c3
+  metadata.gz: a5d5359795785430506b583c13ad3274ba6cf5b237cd5cdb90f201da76d959bc295faf408f5e885e3d9e69b79a5bc4ea64a951a3eeb1e12405f2b40a6e12ccef
+  data.tar.gz: e16fabb2475ce3b7c3e15b68e57fa8a9c6acf32f89834e370ab2e6176f2c427dec7bd04422218272ef093243039245fb2a031204ddea05e7bc257f229b965f9d

data/.ruby-version

@@ -1 +1 @@
-2.2.2
+2.2.3

data/CHANGES.md

@@ -1,3 +1,7 @@
+## 0.4.1 (18 May 2016)
+
+- Fixed various issues with nested namespaces
+
 ## 0.4.0 (16 May 2016)
 
 - Renamed `NamespacedElement` to `Namespaced` and made it an explicit include rather than auto-injected

data/README.md

@@ -183,19 +183,18 @@ Outputs:
 
 ## Namespaces
 
-The `Namespace` class encapsulates an XML namespace:
-
-```ruby
-namespace = Namespace.new(uri: 'http://example.org/px', schema_location: 'http://example.org/px.xsd')
-```
-
-The `Namespaced` module extends `XML::Mapping` to add a `namespace` attribute and write the namespace
-out when saving to XML.
+The `Namespace` class encapsulates an XML namespace. The `Namespaced` module extends `XML::Mapping` to
+add a `namespace` attribute and write the namespace out when saving to XML.
 
 ```ruby
 class MyElem
   include XML::MappingExtensions::Namespaced # instead of XML::Mapping
 
+  namespace Namespace.new(
+    prefix: 'px',
+    uri: 'http://example.org/px'
+  )
+
   root_element_name 'my_elem'
 
   date_node :plain_date, 'plain_date'
@@ -204,10 +203,12 @@ class MyElem
   uri_node :uri, 'uri'
   mime_type_node :mime_type, 'mime_type'
 end
+
+MyElem.namespace
+# => #<XML::MappingExtensions::Namespace:0x007fb1c6b73e80>
 ```
 
-Setting a namespace on a namespaced object will cause that namespace to be written out when the object is saved
-to XML:
+The namespace will then be written out when the object is saved to XML:
 
 ```ruby
 obj = MyElem.new(...)
@@ -215,11 +216,12 @@ obj.namespace = namespace
 
 puts obj.write_xml
 ```
-
-Outputs:
-
 ```xml
-<element xmlns='http://example.org/px/' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:schemaLocation='http://example.org/px.xsd' attribute='123'>
+<element
+    xmlns='http://example.org/px/'
+    xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
+    xsi:schemaLocation='http://example.org/px.xsd'
+    attribute='123'>
   element text
   <child>child 1</child>
   <child>child 2</child>
@@ -229,18 +231,26 @@ Outputs:
 Setting a `prefix` attribute on the namespace will set the prefix on each element in the output:
 
 ```ruby
-namespace = Namespace.new(prefix: 'px', uri: 'http://example.org/px', schema_location: 'http://example.org/px.xsd')
+
+class MyElem
+  namespace Namespace.new(
+    prefix: 'px',
+    uri: 'http://example.org/px',
+    schema_location: 'http://example.org/px.xsd'
+  )
+end
 
 obj = MyElem.new(...)
 obj.namespace = namespace
 
 puts obj.write_xml
 ```
-
-Outputs:
-
 ```xml
-<px:element xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:schemaLocation='http://example.org/px.xsd' xmlns:px='http://example.org/px/' attribute='123'>
+<px:element
+    xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
+    xsi:schemaLocation='http://example.org/px.xsd'
+    xmlns:px='http://example.org/px/'
+    attribute='123'>
   element text
   <px:child>child 1</px:child>
   <px:child>child 2</px:child>

data/lib/xml/mapping_extensions.rb

@@ -6,6 +6,30 @@ module XML
   # [XML::Mapping](http://multi-io.github.io/xml-mapping/)
   module MappingExtensions
     Dir.glob(File.expand_path('../mapping_extensions/*.rb', __FILE__), &method(:require))
+
+    # Ensures that the specified argument is a URI.
+    # @param url [String, URI] The argument. If the argument is already
+    #   a URI, it is returned unchanged; otherwise, the argument's string
+    #   form (as returned by +`to_s`+) is parsed as a URI.
+    # @return [nil, URI] +`nil`+ if +`url`+ is nil, otherwise the URI.
+    # @raise [URI::InvalidURIError] if `url` is a string that is not a valid URI
+    def self.to_uri(url)
+      return nil unless url
+      return url if url.is_a? URI
+      stripped = url.respond_to?(:strip) ? url.strip : url.to_s.strip
+      URI.parse(stripped)
+    end
+
+    # Ensures that the specified argument is a URI string.
+    # @param url [String, URI] The argument. If the argument is already
+    #   a URI, it is returned unchanged; otherwise, the argument's string
+    #   form (as returned by +`to_s`+) is parsed as a URI.
+    # @return [nil, String] +`nil`+ if +`url`+ is nil, otherwise the URI string.
+    # @raise [URI::InvalidURIError] if `url` is a string that is not a valid URI
+    def self.to_uri_str(url)
+      uri = to_uri(url)
+      uri && uri.to_s
+    end
   end
 
   module Mapping

data/lib/xml/mapping_extensions/namespace.rb

@@ -12,38 +12,20 @@ module XML
       # @return [String, nil] the namespace prefix
       attr_reader :prefix
 
-      # @return [String, nil] the schema location URI(s), as a space-separated string list
+      # @return [URI, String, nil] the schema location URI
       attr_reader :schema_location
 
       # Creates a new {Namespace}
       # @param uri [URI, String] the namespace URI
       # @param prefix [String, nil] the namespace prefix
-      # @param schema_location [String, nil] the schema location(s)
+      # @param schema_location [String, nil] the schema location
+      # @raise [URI::InvalidURIError] if `uri` is nil, or a string that is not a valid URI
+      # @raise [URI::InvalidURIError] if `schema_location` is a string that is not a valid URI
       def initialize(uri:, prefix: nil, schema_location: nil)
-        @uri             = uri.to_s
+        fail URI::InvalidURIError, 'uri cannot be nil' unless uri
+        @uri             = MappingExtensions.to_uri_str(uri)
         @prefix          = prefix
-        @schema_location = schema_location
-      end
-
-      # Sets `uri` as the default (no-prefix) namespace on `elem`, with
-      # `schema_location` as the schema location.
-      # @param elem [REXML::Element] The element to set the namespace on
-      def set_default_namespace(elem) # rubocop:disable Style/AccessorMethodName
-        elem.add_namespace(uri)
-        return unless schema_location
-        # TODO: Figure out xsi:noNamespaceSchemaLocation
-        elem.add_namespace('xsi', 'http://www.w3.org/2001/XMLSchema-instance')
-        elem.add_attribute('xsi:schemaLocation', schema_location)
-      end
-
-      # Sets `prefix` as the prefix for namespace `uri` on the specified document
-      # root element, and all its descendants that have that namespace.
-      # @param root [REXML::Element] The document root to set the namespace on
-      def set_prefix(root) # rubocop:disable Style/AccessorMethodName
-        return unless prefix
-        set_prefix_recursive(root)
-        root.add_namespace(nil) if root.attributes['xmlns'] == uri # clear the no-prefix namespace
-        root.add_namespace(prefix, uri)
+        @schema_location = MappingExtensions.to_uri_str(schema_location)
       end
 
       def to_s
@@ -60,20 +42,11 @@ module XML
         state.hash
       end
 
+      protected
+
       def state
         [uri, prefix, schema_location]
       end
-
-      protected :state
-
-      def set_prefix_recursive(elem) # rubocop:disable Style/AccessorMethodName
-        return unless elem.namespace == uri
-        # name= with a prefixed name sets namespace by side effect and is the only way to actually output the prefix
-        elem.name = "#{prefix}:#{elem.name}"
-        elem.each_element { |e| set_prefix_recursive(e) }
-      end
-
-      private :set_prefix_recursive
     end
   end
 end

data/lib/xml/mapping_extensions/namespaced.rb

@@ -26,21 +26,59 @@ module XML
       # Hack to make sure these don't get defined till after `XML::Mapping`'s include
       # hooks have a chance to define their super methods
       module InstanceMethods
-        # Overrides `XML::Mapping#pre_save` to set the XML namespace and schema location
-        # on the generated element.
-        def pre_save(options = {mapping: :_default})
-          xml = super(options)
-          namespace.set_default_namespace(xml) if namespace
-          xml
+
+        # Overrides `XML::Mapping#fill_into_xml` to set the XML namespace
+        def fill_into_xml(xml, options = { mapping: :_default })
+          add_namespace(xml)
+          super(xml, options)
+          return unless namespace
+          set_prefix_recursive(namespace.prefix, xml)
+        end
+
+        private
+
+        def set_prefix_recursive(prefix, elem)
+          return elem unless prefix
+          return elem unless elem.namespace == namespace.uri || elem.namespace.to_s.empty?
+
+          set_prefix(prefix, elem)
+          elem.each_element { |e| set_prefix_recursive(prefix, e) }
+          elem
+        end
+
+        def add_namespace(elem)
+          return unless namespace
+          prefix, uri, schema_location = namespace.prefix, namespace.uri, namespace.schema_location # rubocop:disable Style/ParallelAssignment
+          if prefix
+            set_prefix(prefix, elem)
+            add_schema_location(uri, schema_location, elem.root)
+            elem.root.add_namespace(prefix, uri)
+          else
+            add_schema_location(uri, schema_location, elem)
+            elem.add_namespace(uri)
+          end
         end
 
-        # Overrides `XML::Mapping#save_to_xml` to set the XML namespace prefix on
-        # the generated element, and all its descendants that have that namespace.
-        def save_to_xml(options = {mapping: :_default})
-          xml = super(options)
-          namespace.set_prefix(xml) if namespace
-          xml
+        def set_prefix(prefix, elem)
+          # name= with a prefixed name sets namespace by side effect and is the only way to actually output the prefix
+          elem.name = "#{prefix}:#{elem.name}" if elem.prefix.to_s.empty?
         end
+
+        def add_schema_location(uri, schema_location, elem)
+          return elem unless schema_location
+
+          schema_location_attr = elem.attribute('xsi:schemaLocation')
+          all_declarations     = schema_location_attr ? schema_location_attr.value : ''
+
+          declaration = "#{uri} #{schema_location}"
+          return elem if all_declarations.include?(declaration)
+
+          all_declarations << " #{declaration}"
+          elem.add_attribute('xsi:schemaLocation', all_declarations.strip)
+
+          elem.add_namespace('xsi', 'http://www.w3.org/2001/XMLSchema-instance') unless elem.root && elem.root.attribute('xmlns:xsi')
+        end
+
       end
     end
   end

data/lib/xml/mapping_extensions/version.rb

@@ -1,6 +1,6 @@
 module XML
   module MappingExtensions
     # The version of this gem
-    VERSION = '0.4.0'
+    VERSION = '0.4.1'
   end
 end

data/spec/unit/xml/mapping_extensions/mapping_extensions_spec.rb

@@ -40,42 +40,6 @@ module XML
       end
     end
 
-    describe ':namespace' do
-      it 'sets the namespace on save' do
-        uri = 'http://example.org/px/'
-        schema_location = 'http://example.org/px.xsd'
-        namespace = MappingExtensions::Namespace.new(uri: uri, prefix: 'px', schema_location: schema_location)
-
-        obj = MXSpecObject.new
-        obj.attribute = 123
-        obj.text = 'element text'
-        obj.children = ['child 1', 'child 2']
-        obj.namespace = namespace
-
-        namespace_attribs = "xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:schemaLocation='#{schema_location}' xmlns:px='#{uri}'"
-        expected = "<px:element #{namespace_attribs} attribute='123'>element text<px:child>child 1</px:child><px:child>child 2</px:child></px:element>"
-
-        expect(obj.save_to_xml).to be_xml(expected)
-      end
-
-      it 'works without prefixes' do
-        uri = 'http://example.org/px/'
-        schema_location = 'http://example.org/px.xsd'
-        namespace = MappingExtensions::Namespace.new(uri: uri, schema_location: schema_location)
-
-        obj = MXSpecObject.new
-        obj.attribute = 123
-        obj.text = 'element text'
-        obj.children = ['child 1', 'child 2']
-        obj.namespace = namespace
-
-        namespace_attribs = "xmlns='#{uri}' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:schemaLocation='#{schema_location}'"
-        expected = "<element #{namespace_attribs} attribute='123'>element text<child>child 1</child><child>child 2</child></element>"
-
-        expect(obj.save_to_xml).to be_xml(expected)
-      end
-    end
-
     module ClassMethods
       describe '#parse_xml' do
 

data/spec/unit/xml/mapping_extensions/namespace_spec.rb

@@ -3,20 +3,6 @@ require 'spec_helper'
 module XML
   module MappingExtensions
     describe Namespace do
-      describe '#set_default_namespace' do
-        it 'sets the default namespace'
-        it 'sets the schema location'
-        it 'allows a nil schema location'
-        it 'sets the no-namespace schema location'
-        it 'allows a nil no-namespace schema location'
-      end
-
-      describe '#set_prefix' do
-        it 'sets the prefix'
-        it 'clears the no-prefix namespace, if previously present'
-        it 'leaves an unrelated no-prefix namespace intact'
-      end
-
       describe '#to_s' do
         it 'includes the prefix, namespace, and schema location' do
           uri             = 'http://example.org/px/'
@@ -39,6 +25,16 @@ module XML
           namespace = Namespace.new(uri: uri, prefix: prefix)
           expect(namespace.to_s).to match(/Namespace.*#{uri}.*#{prefix}.*nil/)
         end
+
+        it 'rejects a nil uri' do
+          expect { Namespace.new(uri: nil) }.to raise_error(URI::InvalidURIError)
+        end
+        it 'rejects an invalid uri' do
+          expect { Namespace.new(uri: 'I am not a URI') }.to raise_error(URI::InvalidURIError)
+        end
+        it 'rejects an invalid schema_location' do
+          expect { Namespace.new(uri: 'http://example.org/px/', schema_location: 'I am not a URI') }.to raise_error(URI::InvalidURIError)
+        end
       end
 
       describe 'equality' do

data/spec/unit/xml/mapping_extensions/namespaced_spec.rb

@@ -5,8 +5,13 @@ require 'xml/mapping_extensions/namespace'
 module XML
   module MappingExtensions
 
-    UNPREFIXED = Namespace.new(uri: 'http://example.org/nse')
-    PREFIXED   = Namespace.new(uri: 'http://example.org/nse', prefix: 'px')
+    UNPREFIXED    = Namespace.new(uri: 'http://example.org/nse')
+    PREFIXED      = Namespace.new(uri: 'http://example.org/nse', prefix: 'px')
+    UNPREFIXED_SL = Namespace.new(uri: 'http://example.org/nse', schema_location: 'http://example.org/nse.xsd')
+    PREFIXED_SL   = Namespace.new(uri: 'http://example.org/nse', schema_location: 'http://example.org/nse.xsd', prefix: 'px')
+    PREFIXED_SL1  = Namespace.new(uri: 'http://example.org/nse1', schema_location: 'http://example.org/nse1.xsd', prefix: 'px1')
+    PREFIXED_SL2  = Namespace.new(uri: 'http://example.org/nse2', schema_location: 'http://example.org/nse2.xsd', prefix: 'px2')
+    PREFIXED_SL3  = Namespace.new(uri: 'http://example.org/nse3', schema_location: 'http://example.org/nse3.xsd', prefix: 'px3')
 
     # TODO: both versions with schema location
 
@@ -26,28 +31,218 @@ module XML
       text_node :text, 'text()'
     end
 
+    class UnprefixedSL
+      include Namespaced
+      namespace UNPREFIXED_SL
+      root_element_name 'unprefixed'
+      text_node :attr, '@attr'
+      text_node :text, 'text()'
+
+      def initialize(attr = nil, text = nil)
+        self.attr = attr
+        self.text = text
+      end
+    end
+
+    class PrefixedSL
+      include Namespaced
+      namespace PREFIXED_SL
+      root_element_name 'prefixed'
+      text_node :attr, '@attr'
+      text_node :text, 'text()'
+    end
+
+    class Innermost
+      include Namespaced
+      namespace PREFIXED_SL3
+      object_node :unprefixed, 'unprefixed', class: UnprefixedSL, default_value: nil
+      text_node :text, 'text()'
+
+      def initialize(text_val, unprefixed = nil)
+        self.text       = text_val
+        self.unprefixed = unprefixed
+      end
+    end
+
+    class Inner
+      include Namespaced
+      namespace PREFIXED_SL2
+      text_node :attr, '@attr'
+      text_node :subnested, 'subnested'
+      object_node :innermost, 'innermost', class: Innermost
+
+      def initialize(attr_val, subnested_val, innermost)
+        self.attr      = attr_val
+        self.subnested = subnested_val
+        self.innermost = innermost
+      end
+    end
+
+    class Outer
+      include Namespaced
+      namespace PREFIXED_SL1
+      root_element_name 'outer'
+      text_node :nested, 'nested'
+      array_node :inners, 'inner', class: Inner, default_value: []
+
+      def initialize(nested, inners)
+        self.nested = nested
+        self.inners = inners
+      end
+    end
+
     describe Namespaced do
-      describe '#save_to_xml' do
-        it 'writes XML with a default namespace' do
-          obj = Unprefixed.new
-          obj.attr = 'attr value'
-          obj.text = 'text value'
-          expected = '<unprefixed xmlns="http://example.org/nse" attr="attr value">text value</unprefixed>'
+
+      describe 'nested' do
+        it 'writes XML' do
+          obj      = Outer.new('nested',
+                               [Inner.new('1', 'a', Innermost.new('1')),
+                                Inner.new('2', 'b', Innermost.new('2', UnprefixedSL.new('attr', 'text')))])
+          expected = '
+            <px1:outer
+                xmlns:px1="http://example.org/nse1"
+                xmlns:px2="http://example.org/nse2"
+                xmlns:px3="http://example.org/nse3"
+                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                xsi:schemaLocation="http://example.org/nse1 http://example.org/nse1.xsd http://example.org/nse2 http://example.org/nse2.xsd http://example.org/nse3 http://example.org/nse3.xsd">
+              <px1:nested>nested</px1:nested>
+              <px2:inner attr="1">
+                <px2:subnested>a</px2:subnested>
+                <px3:innermost>1</px3:innermost>
+              </px2:inner>
+              <px2:inner attr="2">
+                <px2:subnested>b</px2:subnested>
+                <px3:innermost>
+                  <unprefixed xmlns="http://example.org/nse" xsi:schemaLocation="http://example.org/nse http://example.org/nse.xsd" attr="attr">text</unprefixed>
+                  2
+                </px3:innermost>
+              </px2:inner>
+            </px1:outer>'
           expect(obj.write_xml).to be_xml(expected)
         end
-        it 'writes XML with a prefixed namespace' do
-          obj = Prefixed.new
-          obj.attr = 'attr value'
-          obj.text = 'text value'
-          expected = '<px:prefixed xmlns:px="http://example.org/nse" attr="attr value">text value</unprefixed>'
-          expect(obj.write_xml).to be_xml(expected)
+
+        it 'parses XML' do
+          xml    = '<px1:outer
+                    xmlns:px1="http://example.org/nse1"
+                    xmlns:px2="http://example.org/nse2"
+                    xmlns:px3="http://example.org/nse3"
+                    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                    xsi:schemaLocation="http://example.org/nse1 http://example.org/nse1.xsd http://example.org/nse2 http://example.org/nse2.xsd http://example.org/nse3 http://example.org/nse3.xsd">
+                  <px1:nested>nested</px1:nested>
+                  <px2:inner attr="1">
+                    <px2:subnested>a</px2:subnested>
+                    <px3:innermost>1</px3:innermost>
+                  </px2:inner>
+                  <px2:inner attr="2">
+                    <px2:subnested>b</px2:subnested>
+                    <px3:innermost>2</px3:innermost>
+                  </px2:inner>
+                </px1:outer>'
+          result = Outer.parse_xml(xml)
+          expect(result).to be_an(Outer)
+          expect(result.nested).to eq('nested')
+          inners = result.inners
+          expect(inners).to be_an(Array)
+          expect(inners.size).to eq(2)
+          expect(inners[0].attr).to eq('1')
+          expect(inners[1].attr).to eq('2')
+          expect(inners[0].subnested).to eq('a')
+          expect(inners[1].subnested).to eq('b')
+          innermost1 = inners[0].innermost
+          expect(innermost1).to be_an(Innermost)
+          expect(innermost1.text).to eq('1')
+          innermost2 = inners[1].innermost
+          expect(innermost2).to be_an(Innermost)
+          expect(innermost2.text).to eq('2')
+        end
+      end
+
+      describe 'without schema location' do
+        describe '#save_to_xml' do
+          it 'writes XML with a default namespace' do
+            obj      = Unprefixed.new
+            obj.attr = 'attr value'
+            obj.text = 'text value'
+            expected = '<unprefixed xmlns="http://example.org/nse" attr="attr value">text value</unprefixed>'
+            expect(obj.write_xml).to be_xml(expected)
+          end
+          it 'writes XML with a prefixed namespace' do
+            obj      = Prefixed.new
+            obj.attr = 'attr value'
+            obj.text = 'text value'
+            expected = '<px:prefixed xmlns:px="http://example.org/nse" attr="attr value">text value</px:prefixed>'
+            expect(obj.write_xml).to be_xml(expected)
+          end
+        end
+        describe '#parse_xml' do
+          it 'parses XML with a default namespace' do
+            parsed = Unprefixed.parse_xml('<unprefixed xmlns="http://example.org/nse" attr="attr value">text value</unprefixed>')
+            expect(parsed).to be_an(Unprefixed)
+            expect(parsed.attr).to eq('attr value')
+            expect(parsed.text).to eq('text value')
+          end
+          it 'parses XML with a prefixed namespace' do
+            parsed = Prefixed.parse_xml('<px:prefixed xmlns:px="http://example.org/nse" attr="attr value">text value</px:prefixed>')
+            expect(parsed).to be_an(Prefixed)
+            expect(parsed.attr).to eq('attr value')
+            expect(parsed.text).to eq('text value')
+          end
         end
       end
 
-      describe '#parse_xml' do
-        it 'parses XML with a default namespace'
-        it 'parses XML with a prefixed namespace'
+      describe 'with schema location' do
+        describe '#save_to_xml' do
+          it 'writes XML with a default namespace' do
+            obj      = UnprefixedSL.new
+            obj.attr = 'attr value'
+            obj.text = 'text value'
+            expected = '<unprefixed
+                          xmlns="http://example.org/nse"
+                          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                          xsi:schemaLocation="http://example.org/nse http://example.org/nse.xsd"
+                          attr="attr value"
+                        >text value</unprefixed>'
+            expect(obj.write_xml).to be_xml(expected)
+          end
+          it 'writes XML with a prefixed namespace' do
+            obj      = PrefixedSL.new
+            obj.attr = 'attr value'
+            obj.text = 'text value'
+            expected = '<px:prefixed
+                          xmlns:px="http://example.org/nse"
+                          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                          xsi:schemaLocation="http://example.org/nse http://example.org/nse.xsd"
+                          attr="attr value"
+                        >text value</px:prefixed>'
+            expect(obj.write_xml).to be_xml(expected)
+          end
+        end
+        describe '#parse_xml' do
+          it 'parses XML with a default namespace' do
+            parsed = UnprefixedSL.parse_xml('<unprefixed
+                          xmlns="http://example.org/nse"
+                          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                          xsi:schemaLocation="http://example.org/nse http://example.org/nse.xsd"
+                          attr="attr value"
+                        >text value</unprefixed>')
+            expect(parsed).to be_an(UnprefixedSL)
+            expect(parsed.attr).to eq('attr value')
+            expect(parsed.text).to eq('text value')
+          end
+          it 'parses XML with a prefixed namespace' do
+            parsed = PrefixedSL.parse_xml('<px:prefixed
+                          xmlns:px="http://example.org/nse"
+                          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                          xsi:schemaLocation="http://example.org/nse http://example.org/nse.xsd"
+                          attr="attr value"
+                        >text value</px:prefixed>')
+            expect(parsed).to be_an(PrefixedSL)
+            expect(parsed.attr).to eq('attr value')
+            expect(parsed.text).to eq('text value')
+          end
+        end
       end
     end
   end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xml-mapping_extensions
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - David Moles
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-16 00:00:00.000000000 Z
+date: 2016-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mime-types
@@ -231,7 +231,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Some extensions for for XML::Mapping