moxml 0.1.22 → 0.1.24

data/lib/moxml/adapter/ox.rb

@@ -2,11 +2,8 @@
 
 return if RUBY_ENGINE == "opal"
 
-require_relative "base"
 require "ox"
 require "stringio"
-require_relative "customized_ox"
-require_relative "../sax/namespace_splitter"
 
 # insert :parent methods to all Ox classes inherit the Node class
 Ox::Node.attr_accessor :parent
@@ -19,7 +16,16 @@ module Moxml
         end
 
         def set_root(doc, element)
-          replace_children(doc, [element])
+          existing_root = root(doc)
+          element.parent = doc if element.is_a?(::Ox::Node)
+          if existing_root
+            # Replace the existing root element, preserving other children
+            idx = doc.nodes.index(existing_root)
+            doc.nodes[idx] = element
+          else
+            # No root yet, just append the element
+            doc << element
+          end
         end
 
         def parse(xml, options = {}, _context = nil)
@@ -101,9 +107,14 @@ module Moxml
         end
 
         def create_native_doctype(name, external_id, system_id)
-          ::Ox::DocType.new(
-            "#{name} PUBLIC \"#{external_id}\" \"#{system_id}\"",
-          )
+          value = if external_id
+                    "#{name} PUBLIC \"#{external_id}\" \"#{system_id}\""
+                  elsif system_id
+                    "#{name} SYSTEM \"#{system_id}\""
+                  else
+                    name.to_s
+                  end
+          ::Ox::DocType.new(value)
         end
 
         def create_native_processing_instruction(target, content)
@@ -257,7 +268,7 @@ module Moxml
           # Ox doesn't set parent references during parsing.
           # Set them here so parent/sibling navigation works.
           result.each do |child|
-            child.parent = node if child.respond_to?(:parent=)
+            child.parent = node if child.is_a?(::Ox::Element)
           end
           result
         end
@@ -368,27 +379,32 @@ module Moxml
         end
 
         def add_child(element, child)
-          # Special handling for declarations on Ox documents
           if element.is_a?(::Ox::Document) && child.is_a?(::Ox::Instruct) && child.target == "xml"
-            # Transfer declaration attributes to document
             element.attributes ||= {}
-            if child.attributes["version"]
-              element.attributes[:version] =
-                child.attributes["version"]
-            end
-            if child.attributes["encoding"]
-              element.attributes[:encoding] =
-                child.attributes["encoding"]
-            end
-            if child.attributes["standalone"]
-              element.attributes[:standalone] =
-                child.attributes["standalone"]
-            end
+            element.attributes[:version] = child.attributes["version"] if child.attributes["version"]
+            element.attributes[:encoding] = child.attributes["encoding"] if child.attributes["encoding"]
+            element.attributes[:standalone] = child.attributes["standalone"] if child.attributes["standalone"]
+            attachments.set(element, :decl_explicit, {
+                              encoding: child.attributes.key?("encoding") ? child.attributes["encoding"] : nil,
+                              standalone: child.attributes.key?("standalone") ? child.attributes["standalone"] : nil,
+                            })
+            return
           end
 
           child.parent = element if child.is_a?(::Ox::Node)
           element.nodes ||= []
-          element.nodes << child
+
+          # Insert doctype before root element in document
+          if element.is_a?(::Ox::Document) && child.is_a?(::Ox::DocType)
+            root_idx = element.nodes.index { |n| n.is_a?(::Ox::Element) }
+            if root_idx
+              element.nodes.insert(root_idx, child)
+            else
+              element.nodes << child
+            end
+          else
+            element.nodes << child
+          end
 
           # Mark document if EntityReference is added (avoids tree scan in serialize)
           if child.is_a?(::Moxml::Adapter::CustomizedOx::EntityReference)
@@ -464,8 +480,8 @@ module Moxml
         end
 
         def assign_parents(node, parent = nil)
-          node.parent = parent if node.respond_to?(:parent=) && parent
-          return unless node.respond_to?(:nodes)
+          node.parent = parent if node.is_a?(::Ox::Element) && parent
+          return unless node.is_a?(::Ox::Element) || node.is_a?(::Ox::Document)
 
           node.nodes&.each do |child|
             assign_parents(child, node)
@@ -671,12 +687,26 @@ module Moxml
         end
 
         def has_declaration?(native_doc, _wrapper)
-          # Ox stores declaration in document attributes
           native_doc[:version] || native_doc[:encoding] || native_doc[:standalone]
         end
 
+        def remove_declaration(native_doc)
+          native_doc.attributes&.delete(:version)
+          native_doc.attributes&.delete(:encoding)
+          native_doc.attributes&.delete(:standalone)
+          attachments.delete(native_doc, :decl_explicit)
+        end
+
         private
 
+        def resolve_decl_attr(node, attr, fallback)
+          if attachments.key?(node, :decl_explicit)
+            attachments.get(node, :decl_explicit)[attr]
+          else
+            node[attr] || fallback
+          end
+        end
+
         def serialize_standard(node, options = {})
           output = ""
           if node.is_a?(::Ox::Document)
@@ -688,8 +718,8 @@ module Moxml
 
             if should_include_decl
               version = node[:version] || "1.0"
-              encoding = options[:encoding] || node[:encoding]
-              standalone = node[:standalone]
+              encoding = resolve_decl_attr(node, :encoding, options[:encoding])
+              standalone = resolve_decl_attr(node, :standalone, nil)
 
               decl = create_native_declaration(version, encoding, standalone)
               output = ::Ox.dump(::Ox::Document.new << decl).strip
@@ -698,7 +728,7 @@ module Moxml
 
           ox_options = {
             indent: -1,
-            with_instructions: true,
+            with_instructions: false,
             encoding: options[:encoding],
             no_empty: options[:expand_empty],
           }
@@ -750,8 +780,8 @@ module Moxml
                                   end
             if should_include_decl
               version = node[:version] || "1.0"
-              encoding = options[:encoding] || node[:encoding]
-              standalone = node[:standalone]
+              encoding = resolve_decl_attr(node, :encoding, options[:encoding])
+              standalone = resolve_decl_attr(node, :standalone, nil)
               output << "<?xml version=\"#{version}\""
               output << " encoding=\"#{encoding}\"" if encoding
               output << " standalone=\"#{standalone}\"" if standalone

data/lib/moxml/adapter/rexml.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "base"
 require "rexml/document"
 require "rexml/xpath"
 require "set" unless RUBY_ENGINE == "opal"
 require "stringio" if RUBY_ENGINE == "opal"
-require_relative "customized_rexml"
-require_relative "../sax/namespace_splitter"
 
 module Moxml
   module Adapter
@@ -173,7 +170,7 @@ module Moxml
         end
 
         def duplicate_node(node)
-          if node.respond_to?(:deep_clone)
+          if node.is_a?(::REXML::Parent)
             node.deep_clone
           else
             Marshal.load(Marshal.dump(node))
@@ -620,9 +617,7 @@ module Moxml
         def has_declaration?(native_doc, wrapper)
           xml_decl = attachments.get(native_doc, :xml_declaration)
           if xml_decl.nil?
-            # Attachment key doesn't exist - check native doc or wrapper flag
             if attachments.key?(native_doc, :xml_declaration)
-              # Explicitly set to nil (was removed)
               false
             else
               wrapper.has_xml_declaration
@@ -632,6 +627,10 @@ module Moxml
           end
         end
 
+        def remove_declaration(native_doc)
+          attachments.set(native_doc, :xml_declaration, nil)
+        end
+
         private
 
         def write_with_formatter(node, output, indent = 2)

data/lib/moxml/adapter.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "adapter/base"
-
 module Moxml
   module Adapter
+    autoload :Base, "moxml/adapter/base"
+    autoload :CustomizedOga, "moxml/adapter/customized_oga"
+    autoload :CustomizedOx, "moxml/adapter/customized_ox"
+    autoload :CustomizedRexml, "moxml/adapter/customized_rexml"
+    autoload :CustomizedLibxml, "moxml/adapter/customized_libxml"
+
     AVAILABLE_ADAPTERS = %i[nokogiri oga rexml ox headed_ox libxml].freeze
 
     # Adapters that work under the Opal (JavaScript) runtime.
@@ -46,7 +50,7 @@ module Moxml
       def validate_platform!(name)
         return if platform_adapters.include?(name.to_sym)
 
-        available = platform_adapters.map(&:to_s).join(", ")
+        available = platform_adapters.join(", ")
         raise Moxml::AdapterError.new(
           "The '#{name}' adapter is not available on this platform. Available: #{available}",
           adapter: name,
@@ -59,11 +63,15 @@ module Moxml
       end
 
       def require_adapter(name)
-        require "#{__dir__}/adapter/#{name}"
+        # Opal pre-loads all dependencies via the Rakefile; skip runtime require.
+        return if RUBY_ENGINE == "opal"
+
+        require "moxml/adapter/base"
+        require "moxml/adapter/#{name}"
       rescue LoadError
         begin
           require name.to_s
-          require "#{__dir__}/adapter/#{name}"
+          require "moxml/adapter/#{name}"
         rescue LoadError => e
           raise Moxml::AdapterError.new(
             "Failed to load #{name} adapter",

data/lib/moxml/attribute.rb

@@ -21,6 +21,8 @@ module Moxml
       adapter.restore_entities(val)
     end
 
+    alias content value
+
     # Returns raw native value without entity marker restoration.
     def raw_value
       @native.value
@@ -46,11 +48,12 @@ module Moxml
     end
 
     def element
-      adapter.attribute_element(@native)
+      native_elem = adapter.attribute_element(@native)
+      native_elem && Moxml::Node.wrap(native_elem, context)
     end
 
     def remove
-      adapter.remove_attribute(element, name)
+      adapter.remove_attribute(adapter.attribute_element(@native), name)
       if @parent_node.is_a?(Moxml::Element)
         @parent_node.invalidate_attribute_cache!
       end

data/lib/moxml/config.rb

@@ -2,6 +2,9 @@
 
 module Moxml
   class Config
+    LINE_ENDING_LF = "\n"
+    LINE_ENDING_CRLF = "\r\n"
+    VALID_LINE_ENDINGS = [LINE_ENDING_LF, LINE_ENDING_CRLF].freeze
     VALID_ADAPTERS = %i[nokogiri oga rexml ox headed_ox libxml].freeze
     DEFAULT_ADAPTER = :nokogiri
     OPAL_DEFAULT_ADAPTER = :rexml
@@ -46,7 +49,7 @@ module Moxml
     # - :strict — only restore DTD-declared entities (falls back to lenient until DTD parsing is implemented)
     ENTITY_RESTORATION_MODES = %i[strict lenient].freeze
 
-    attr_reader :adapter_name
+    attr_reader :adapter_name, :default_line_ending
     attr_accessor :strict_parsing,
                   :default_encoding,
                   :entity_encoding,
@@ -58,13 +61,23 @@ module Moxml
                   :namespace_validation_mode,
                   :entity_restoration_mode
 
+    def default_line_ending=(value)
+      unless VALID_LINE_ENDINGS.include?(value)
+        raise ArgumentError,
+              "Invalid line_ending: #{value.inspect}. " \
+              "Must be Config::LINE_ENDING_LF or Config::LINE_ENDING_CRLF"
+      end
+
+      @default_line_ending = value
+    end
+
     def initialize(adapter_name = nil, strict_parsing = nil,
                    default_encoding = nil)
       self.adapter = adapter_name || Config.default.adapter_name
       @strict_parsing = strict_parsing || Config.default.strict_parsing
       @default_encoding = default_encoding || Config.default.default_encoding
-      # reserved for future use
       @default_indent = 2
+      @default_line_ending = LINE_ENDING_LF
       @entity_encoding = :basic
       @restore_entities = false
       @preload_entity_sets = []
@@ -100,6 +113,7 @@ module Moxml
     end
 
     def entity_load_mode=(mode)
+      mode = mode.to_sym
       unless ENTITY_LOAD_MODES.include?(mode)
         raise ArgumentError,
               "Invalid entity_load_mode: #{mode}. Must be one of: #{ENTITY_LOAD_MODES.join(', ')}"

data/lib/moxml/context.rb

@@ -17,13 +17,12 @@ module Moxml
     end
 
     def parse(xml, options = {})
-      # Detect if input has XML declaration
-      xml_string = if xml.respond_to?(:read)
+      xml_string = if xml.is_a?(String)
+                     xml
+                   else
                      xml.read.tap do
-                       xml.rewind if xml.respond_to?(:rewind)
+                       xml.rewind if xml.is_a?(IO) || xml.is_a?(StringIO)
                      end
-                   else
-                     xml.to_s
                    end
       has_declaration = xml_string.strip.start_with?("<?xml")
 
@@ -59,9 +58,6 @@ module Moxml
     #   end
     #
     def sax_parse(xml, handler = nil, &block)
-      # Load SAX module if not already loaded
-      require_relative "sax" unless defined?(Moxml::SAX)
-
       # Create block handler if block given
       handler ||= SAX::BlockHandler.new(&block) if block
 
@@ -75,6 +71,10 @@ module Moxml
       config.adapter.sax_parse(xml, handler)
     end
 
+    def build(&block)
+      Builder.new(self).build(&block)
+    end
+
     private
 
     def build_entity_registry

data/lib/moxml/declaration.rb

@@ -34,13 +34,8 @@ module Moxml
     end
 
     def remove
-      # Mark document as having no declaration when declaration is removed
-      # Store in adapter's attachment map so all wrappers see it
-      native_doc = adapter.document(@native)
-      if native_doc && adapter.respond_to?(:attachments)
-        adapter.attachments.set(native_doc, :has_declaration, false)
-      end
-
+      native_doc = @parent_node&.native
+      adapter.remove_declaration(native_doc) if native_doc
       super
     end
 

data/lib/moxml/document.rb

@@ -1,16 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "node"
-require_relative "element"
-require_relative "text"
-require_relative "cdata"
-require_relative "comment"
-require_relative "processing_instruction"
-require_relative "declaration"
-require_relative "namespace"
-require_relative "doctype"
-require_relative "entity_reference"
-
 module Moxml
   class Document < Node
     attr_accessor :has_xml_declaration
@@ -81,14 +70,8 @@ module Moxml
       if node.is_a?(Declaration)
         # Mark that document now has a declaration
         @has_xml_declaration = true
-
-        if children.empty?
-          adapter.add_child(@native, node.native)
-        else
-          adapter.add_previous_sibling(adapter.children(@native).first,
-                                       node.native)
-        end
-      elsif root && !node.is_a?(ProcessingInstruction) && !node.is_a?(Comment)
+        adapter.add_child(@native, node.native)
+      elsif root && !node.is_a?(ProcessingInstruction) && !node.is_a?(Comment) && !node.is_a?(Doctype)
         raise Error, "Document already has a root element"
       else
         adapter.add_child(@native, node.native)

data/lib/moxml/document_builder.rb

@@ -13,15 +13,13 @@ module Moxml
       @current_doc = context.create_document(native_doc)
 
       # Transfer has_declaration flag if present in attachments
-      if adapter.respond_to?(:attachments) &&
-          adapter.attachments.key?(native_doc, :has_declaration)
+      if adapter.attachments.key?(native_doc, :has_declaration)
         has_declaration = adapter.attachments.get(native_doc, :has_declaration)
         @current_doc.has_xml_declaration = has_declaration
       end
 
       # Transfer DOCTYPE from parsed document if it exists in attachments
-      if adapter.respond_to?(:attachments) &&
-          adapter.attachments.key?(native_doc, :doctype)
+      if adapter.attachments.key?(native_doc, :doctype)
         doctype = adapter.attachments.get(native_doc, :doctype)
         if doctype
           adapter.attachments.set(@current_doc.native, :doctype, doctype)
@@ -35,10 +33,16 @@ module Moxml
     private
 
     def visit_node(node)
-      method_name = "visit_#{node_type(node)}"
-      return unless respond_to?(method_name, true)
-
-      send(method_name, node)
+      case node_type(node)
+      when :document then visit_document(node)
+      when :element then visit_element(node)
+      when :text then visit_text(node)
+      when :cdata then visit_cdata(node)
+      when :comment then visit_comment(node)
+      when :processing_instruction then visit_processing_instruction(node)
+      when :doctype then visit_doctype(node)
+      when :entity_reference then visit_entity_reference(node)
+      end
     end
 
     def visit_document(doc)

data/lib/moxml/element.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "attribute"
-require_relative "namespace"
-
 module Moxml
   class Element < Node
     def name
@@ -137,6 +134,8 @@ module Moxml
       adapter.restore_entities(val)
     end
 
+    alias content text
+
     def text=(content)
       adapter.set_text_content(@native, normalize_xml_value(content))
       invalidate_children_cache!
@@ -158,7 +157,8 @@ module Moxml
     end
 
     def inner_xml=(xml)
-      doc = context.parse("<root>#{xml}</root>")
+      wrapper = "_moxml_inner_#{Process.pid}_#{object_id}"
+      doc = context.parse("<#{wrapper}>#{xml}</#{wrapper}>")
       adapter.replace_children(@native, doc.root.children.map(&:native))
       invalidate_children_cache!
     end

data/lib/moxml/entity_registry.rb

@@ -226,7 +226,8 @@ module Moxml
     # kept for backward compatibility.
     # @return [self]
     def load_html5
-      warn "EntityRegistry#load_html5 is a no-op (all entities load during initialize)", uplevel: 1
+      warn "EntityRegistry#load_html5 is a no-op (all entities load during initialize)",
+           uplevel: 1
       self
     end
 
@@ -235,7 +236,8 @@ module Moxml
     # kept for backward compatibility.
     # @return [self]
     def load_mathml
-      warn "EntityRegistry#load_mathml is a no-op (all entities load during initialize)", uplevel: 1
+      warn "EntityRegistry#load_mathml is a no-op (all entities load during initialize)",
+           uplevel: 1
       self
     end
 
@@ -245,7 +247,8 @@ module Moxml
     # @param _set_name [Symbol] (ignored, all loaded together)
     # @return [self]
     def load_iso(_set_name = :iso8879)
-      warn "EntityRegistry#load_iso is a no-op (all entities load during initialize)", uplevel: 1
+      warn "EntityRegistry#load_iso is a no-op (all entities load during initialize)",
+           uplevel: 1
       self
     end
 
@@ -254,7 +257,8 @@ module Moxml
     # kept for backward compatibility.
     # @return [self]
     def load_all
-      warn "EntityRegistry#load_all is a no-op (all entities load during initialize)", uplevel: 1
+      warn "EntityRegistry#load_all is a no-op (all entities load during initialize)",
+           uplevel: 1
       self
     end
 

data/lib/moxml/entity_registry_opal_data.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
+
 #
 # Auto-generated entity data for Opal runtime.
-# Generated from data/w3c_entities.json
-# Do not edit manually. Regenerate with: rake opal:generate_entity_data
+# Source: data/w3c_entities.json (2125 entities)
+# Regenerate with: rake opal:generate_entity_data
 
 module Moxml
   class EntityRegistry

data/lib/moxml/node.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "xml_utils"
-require_relative "node_set"
-
 module Moxml
   class Node
     include XmlUtils
+    include Enumerable
 
     TYPES = %i[
       element text cdata comment processing_instruction document
@@ -98,6 +96,7 @@ module Moxml
       serialize_options[:no_declaration] = !should_include_declaration?(options)
 
       result = adapter.serialize(@native, serialize_options)
+      result = apply_line_ending(result, serialize_options[:line_ending])
 
       # Restore entity markers to named entity references
       adapter.restore_entities(result)
@@ -142,13 +141,14 @@ module Moxml
       ""
     end
 
-    # Attribute accessor - only works on Element nodes
-    # Returns nil for non-element nodes
-    def [](name)
-      return nil unless respond_to?(:attribute)
-
-      attr = attribute(name)
-      attr&.value if attr.respond_to?(:value)
+    # Returns the content/value of this node as a string.
+    # Each subclass overrides this with type-specific semantics:
+    # - Text, Comment, Cdata: raw text content
+    # - ProcessingInstruction: instruction content
+    # - Attribute: attribute value
+    # - Element: delegates to text (descendant text concatenation)
+    def content
+      ""
     end
 
     # Returns the namespace of this node
@@ -175,15 +175,39 @@ module Moxml
     def each_node(&block)
       children.each do |child|
         yield child
-        child.each_node(&block) if child.respond_to?(:each_node)
+        child.each_node(&block)
       end
     end
 
-    # Clone node (deep copy)
-    def clone
+    # Yield direct children, enabling Enumerable on the node.
+    def each(&block)
+      return to_enum(:each) unless block
+
+      children.each(&block)
+    end
+
+    def outer_xml
+      to_xml
+    end
+
+    def before(node)
+      add_previous_sibling(node)
+    end
+
+    def after(node)
+      add_next_sibling(node)
+    end
+
+    def blank?
+      text.strip.empty?
+    end
+
+    # Deep copy of the node (both dup and clone create deep copies for XML nodes)
+    def dup
       Moxml::Node.wrap(adapter.dup(@native), context)
     end
-    alias dup clone
+
+    alias clone dup
 
     def ==(other)
       self.class == other.class && @native == other.native
@@ -279,6 +303,7 @@ module Moxml
       {
         encoding: context.config.default_encoding,
         indent: context.config.default_indent,
+        line_ending: context.config.default_line_ending,
         # The short format of empty tags in Oga and Nokogiri isn't configurable
         # Oga: <empty /> (with a space)
         # Nokogiri: <empty/> (without a space)
@@ -294,5 +319,11 @@ module Moxml
       # For Document nodes, delegate to adapter for native state check
       adapter.has_declaration?(@native, self)
     end
+
+    def apply_line_ending(xml, line_ending)
+      return xml if line_ending == Config::LINE_ENDING_LF || !xml.include?("\n")
+
+      xml.gsub(/\r?\n/, line_ending)
+    end
   end
 end

data/lib/moxml/node_set.rb

@@ -68,8 +68,7 @@ module Moxml
     end
 
     def <<(node)
-      # If it's a wrapped Moxml node, unwrap to native before storing
-      native_node = node.respond_to?(:native) ? node.native : node
+      native_node = node.is_a?(Node) ? node.native : node
       @nodes << native_node
       @wrapped << nil
       self
@@ -113,8 +112,7 @@ module Moxml
     # Delete a node from the set
     # Accepts both wrapped Moxml nodes and native nodes
     def delete(node)
-      # If it's a wrapped Moxml node, unwrap to native
-      native_node = node.respond_to?(:native) ? node.native : node
+      native_node = node.is_a?(Node) ? node.native : node
       idx = @nodes.index(native_node)
       if idx
         @nodes.delete_at(idx)

data/lib/moxml/sax/block_handler.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "handler"
-
 module Moxml
   module SAX
     # Block-based SAX handler with DSL