moxml 0.1.12 → 0.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4157530fd51f50d52969541f0a41d18f3b70d2ccada5dea86ea38e3882511385
-  data.tar.gz: ea71910278f9883ac2580e3f20d9d6a5ea2d0981fbbd9d9c7fecbcf6b2694247
+  metadata.gz: c46c9d241e38351b1547ab8be8297ff2902886f022ccdfb3fc2f196d2594bf2b
+  data.tar.gz: b1d34fb4306d96d940afea932d5d9f6c6bcffc74c6715e00a6f622302be2f878
 SHA512:
-  metadata.gz: 47dd22ad3d886d60cd6f4c2717f0d39e78ebbcaa743cb14a072476753410c681fb19b0a6d3fd6019f7a70bb2a7902bbb3239d4255f5fe5041a4fd2dce5beec74
-  data.tar.gz: fa217b1a960165a88dc97bcf765147d836dbe77e90be528cdb045ed99c28f6181d59634e50a4059348b89f0a23c4661660e1fb10fe8a46e06e1a434f9e08f456
+  metadata.gz: 9178c13199c195aa0b3ed628d5837fa6c1fdaeaa3e3cc462a8520a89ad6bb98963ff0a9c2b668038ff27a0653e2aa2fba98ce1c8bc10eccc74abab0daa26e455
+  data.tar.gz: 5b1b06dea56ac0b28dd2b8ca072fa554039936c336e6b262430d40f45ab2972b1e6bf38f3c13cf192c9fc2a9cc9fe827abc99aa662d30ebdaae97d361d981475

data/lib/moxml/adapter/base.rb

@@ -61,23 +61,23 @@ module Moxml
           )
         end
 
-        def create_element(name)
+        def create_element(name, owner_doc: nil)
           validate_element_name(name)
-          create_native_element(name)
+          create_native_element(name, owner_doc)
         end
 
-        def create_text(content)
+        def create_text(content, owner_doc: nil)
           # Ox freezes the content, so we need to dup it
-          create_native_text(normalize_xml_value(content).dup)
+          create_native_text(normalize_xml_value(content).dup, owner_doc)
         end
 
-        def create_cdata(content)
-          create_native_cdata(normalize_xml_value(content))
+        def create_cdata(content, owner_doc: nil)
+          create_native_cdata(normalize_xml_value(content), owner_doc)
         end
 
-        def create_comment(content)
+        def create_comment(content, owner_doc: nil)
           validate_comment_content(content)
-          create_native_comment(normalize_xml_value(content))
+          create_native_comment(normalize_xml_value(content), owner_doc)
         end
 
         def create_doctype(name, external_id, system_id)
@@ -146,7 +146,7 @@ module Moxml
 
         protected
 
-        def create_native_element(_name)
+        def create_native_element(_name, _owner_doc = nil)
           raise Moxml::NotImplementedError.new(
             "create_native_element not implemented",
             feature: "create_native_element",
@@ -154,7 +154,7 @@ module Moxml
           )
         end
 
-        def create_native_text(_content)
+        def create_native_text(_content, _owner_doc = nil)
           raise Moxml::NotImplementedError.new(
             "create_native_text not implemented",
             feature: "create_native_text",
@@ -162,7 +162,7 @@ module Moxml
           )
         end
 
-        def create_native_cdata(_content)
+        def create_native_cdata(_content, _owner_doc = nil)
           raise Moxml::NotImplementedError.new(
             "create_native_cdata not implemented",
             feature: "create_native_cdata",
@@ -170,7 +170,7 @@ module Moxml
           )
         end
 
-        def create_native_comment(_content)
+        def create_native_comment(_content, _owner_doc = nil)
           raise Moxml::NotImplementedError.new(
             "create_native_comment not implemented",
             feature: "create_native_comment",
@@ -217,6 +217,14 @@ module Moxml
             adapter: name,
           )
         end
+
+        def in_scope_namespaces(_element)
+          raise Moxml::NotImplementedError.new(
+            "in_scope_namespaces not implemented",
+            feature: "in_scope_namespaces",
+            adapter: name,
+          )
+        end
       end
     end
   end

data/lib/moxml/adapter/customized_oga/xml_generator.rb

@@ -16,7 +16,7 @@ module Moxml
         def on_element(element, output)
           name = element.expanded_name
 
-          attrs = ""
+          attrs = []
           element.attributes.each do |attr|
             attrs << " "
             on_attribute(attr, attrs)
@@ -28,7 +28,7 @@ module Moxml
                           ">"
                         end
 
-          output << "<#{name}#{attrs}#{closing_tag}"
+          output << "<#{name}#{attrs.join}#{closing_tag}"
         end
 
         def on_namespace_definition(ns, output)

data/lib/moxml/adapter/libxml.rb

@@ -126,21 +126,21 @@ module Moxml
           ::LibXML::XML::Document.new
         end
 
-        def create_native_element(name)
+        def create_native_element(name, _owner_doc = nil)
           ::LibXML::XML::Node.new(name.to_s)
         end
 
-        def create_native_text(content)
+        def create_native_text(content, _owner_doc = nil)
           native = ::LibXML::XML::Node.new_text(content.to_s)
           CustomizedLibxml::Text.new(native)
         end
 
-        def create_native_cdata(content)
+        def create_native_cdata(content, _owner_doc = nil)
           native = ::LibXML::XML::Node.new_cdata(content.to_s)
           CustomizedLibxml::Cdata.new(native)
         end
 
-        def create_native_comment(content)
+        def create_native_comment(content, _owner_doc = nil)
           native = ::LibXML::XML::Node.new_comment(content.to_s)
           CustomizedLibxml::Comment.new(native)
         end

data/lib/moxml/adapter/nokogiri.rb

@@ -70,20 +70,20 @@ module Moxml
           )
         end
 
-        def create_native_element(name)
-          ::Nokogiri::XML::Element.new(name, create_document)
+        def create_native_element(name, owner_doc = nil)
+          ::Nokogiri::XML::Element.new(name, owner_doc || create_document)
         end
 
-        def create_native_text(content)
-          ::Nokogiri::XML::Text.new(content, create_document)
+        def create_native_text(content, owner_doc = nil)
+          ::Nokogiri::XML::Text.new(content, owner_doc || create_document)
         end
 
-        def create_native_cdata(content)
-          ::Nokogiri::XML::CDATA.new(create_document, content)
+        def create_native_cdata(content, owner_doc = nil)
+          ::Nokogiri::XML::CDATA.new(owner_doc || create_document, content)
         end
 
-        def create_native_comment(content)
-          ::Nokogiri::XML::Comment.new(create_document, content)
+        def create_native_comment(content, owner_doc = nil)
+          ::Nokogiri::XML::Comment.new(owner_doc || create_document, content)
         end
 
         def create_native_doctype(name, external_id, system_id)
@@ -334,6 +334,10 @@ module Moxml
           node.namespace_definitions
         end
 
+        def in_scope_namespaces(element)
+          element.namespace_scopes
+        end
+
         # Doctype accessor methods
         def doctype_name(native)
           native.name

data/lib/moxml/adapter/oga.rb

@@ -64,19 +64,19 @@ module Moxml
           ::Oga::XML::Document.new
         end
 
-        def create_native_element(name)
+        def create_native_element(name, _owner_doc = nil)
           ::Oga::XML::Element.new(name: name)
         end
 
-        def create_native_text(content)
+        def create_native_text(content, _owner_doc = nil)
           ::Oga::XML::Text.new(text: encode_entity_markers(content))
         end
 
-        def create_native_cdata(content)
+        def create_native_cdata(content, _owner_doc = nil)
           ::Oga::XML::Cdata.new(text: content)
         end
 
-        def create_native_comment(content)
+        def create_native_comment(content, _owner_doc = nil)
           ::Oga::XML::Comment.new(text: content)
         end
 
@@ -479,7 +479,7 @@ module Moxml
 
             if should_include_decl && !node.xml_declaration && !has_existing_declaration
               # Need to add declaration - create default one
-              output = +""
+              output = []
               output << '<?xml version="1.0" encoding="UTF-8"?>'
               output << "\n"
 
@@ -491,10 +491,10 @@ module Moxml
                 output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
               end
 
-              return output
+              return output.join
             elsif !should_include_decl
               # Skip xml_declaration
-              output = +""
+              output = []
 
               # Serialize doctype if present
               output << node.doctype.to_xml << "\n" if node.doctype
@@ -506,7 +506,7 @@ module Moxml
                 output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
               end
 
-              return output
+              return output.join
             end
           end
 
@@ -514,19 +514,20 @@ module Moxml
           # But first check if we need to handle declaration specially
           if node.is_a?(::Oga::XML::Document) && node.xml_declaration
             # Document has declaration - use custom handling to avoid duplicates
-            output = +""
+            output = []
+            xml_declaration_serialized = false
 
             # Serialize children, but skip XmlDeclaration if it would cause duplication
             node.children.each do |child|
-              # Check if this would cause duplication by seeing if we already have one in output
-              if child.is_a?(::Oga::XML::XmlDeclaration) && output.include?("<?xml")
-                next # Skip duplicate declaration
-              end
+              xml_declaration = child.is_a?(::Oga::XML::XmlDeclaration)
+              next if xml_declaration && xml_declaration_serialized
+
+              xml_declaration_serialized = true if xml_declaration
 
               output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
             end
 
-            output
+            output.join
           else
             # Normal case - use XmlGenerator directly
             ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(node).to_xml

data/lib/moxml/adapter/ox.rb

@@ -67,21 +67,21 @@ module Moxml
           ::Ox::Document.new(**attrs)
         end
 
-        def create_native_element(name)
+        def create_native_element(name, _owner_doc = nil)
           element = ::Ox::Element.new(name)
           element.instance_variable_set(:@attributes, {})
           element
         end
 
-        def create_native_text(content)
+        def create_native_text(content, _owner_doc = nil)
           content
         end
 
-        def create_native_cdata(content)
+        def create_native_cdata(content, _owner_doc = nil)
           ::Ox::CData.new(content)
         end
 
-        def create_native_comment(content)
+        def create_native_comment(content, _owner_doc = nil)
           ::Ox::Comment.new(content)
         end
 

data/lib/moxml/adapter/rexml.rb

@@ -69,19 +69,19 @@ module Moxml
           ::REXML::Document.new
         end
 
-        def create_native_element(name)
+        def create_native_element(name, _owner_doc = nil)
           ::REXML::Element.new(name.to_s)
         end
 
-        def create_native_text(content)
+        def create_native_text(content, _owner_doc = nil)
           ::REXML::Text.new(content.to_s, true, nil)
         end
 
-        def create_native_cdata(content)
+        def create_native_cdata(content, _owner_doc = nil)
           ::REXML::CData.new(content.to_s)
         end
 
-        def create_native_comment(content)
+        def create_native_comment(content, _owner_doc = nil)
           ::REXML::Comment.new(content.to_s)
         end
 

data/lib/moxml/document.rb

@@ -34,19 +34,19 @@ module Moxml
     end
 
     def create_element(name)
-      Element.new(adapter.create_element(name), context)
+      Element.new(adapter.create_element(name, owner_doc: @native), context)
     end
 
     def create_text(content)
-      Text.new(adapter.create_text(content), context)
+      Text.new(adapter.create_text(content, owner_doc: @native), context)
     end
 
     def create_cdata(content)
-      Cdata.new(adapter.create_cdata(content), context)
+      Cdata.new(adapter.create_cdata(content, owner_doc: @native), context)
     end
 
     def create_comment(content)
-      Comment.new(adapter.create_comment(content), context)
+      Comment.new(adapter.create_comment(content, owner_doc: @native), context)
     end
 
     def create_doctype(name, external_id, system_id)

data/lib/moxml/element.rb

@@ -117,6 +117,14 @@ module Moxml
     end
     alias namespace_definitions namespaces
 
+    # Returns all namespaces in scope for this element,
+    # including those inherited from ancestor elements.
+    def in_scope_namespaces
+      adapter.in_scope_namespaces(@native).map do |ns|
+        Namespace.new(ns, context)
+      end
+    end
+
     # Returns the namespace URI of this element (alias for namespace_uri)
     def namespace_name
       namespace_uri

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.1.12"
+  VERSION = "0.1.14"
 end

data/spec/moxml/adapter/oga_spec.rb

@@ -12,6 +12,22 @@ RSpec.describe Moxml::Adapter::Oga do
 
   it_behaves_like "xml adapter"
 
+  describe "serialization" do
+    it "does not duplicate XML declarations when declaration nodes repeat" do
+      context = Moxml::Context.new(:oga)
+      doc = context.create_document
+
+      doc.add_child(doc.create_declaration("1.0", "UTF-8"))
+      doc.add_child(doc.create_declaration("1.0", "UTF-8"))
+      doc.add_child(doc.create_element("root"))
+
+      serialized = doc.to_xml
+
+      expect(serialized.scan("<?xml").size).to eq(1)
+      expect(serialized).to include("<root></root>")
+    end
+  end
+
   describe "entity handling" do
     it "preserves non-breaking space through parse and serialize round-trip" do
       xml = "<root>Item&nbsp;One</root>"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.14
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-16 00:00:00.000000000 Z
+date: 2026-04-20 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API