moxml 0.1.25 → 0.2.0

data/lib/moxml/adapter/rexml.rb

@@ -2,6 +2,7 @@
 
 require "rexml/document"
 require "rexml/xpath"
+require "rexml/streamlistener"
 require "set" unless RUBY_ENGINE == "opal"
 require "stringio" if RUBY_ENGINE == "opal"
 
@@ -60,18 +61,21 @@ module Moxml
         # @param handler [Moxml::SAX::Handler] Moxml SAX handler
         # @return [void]
         def sax_parse(xml, handler)
-          require "rexml/parsers/sax2parser"
+          require "rexml/parsers/streamparser"
           require "rexml/source"
-          require "stringio"
 
-          bridge = REXMLSAX2Bridge.new(handler)
+          bridge = REXMLStreamBridge.new(handler)
 
           xml_string = xml.is_a?(IO) || xml.is_a?(StringIO) ? xml.read : xml.to_s
-          source = ::REXML::IOSource.new(StringIO.new(xml_string))
 
-          parser = ::REXML::Parsers::SAX2Parser.new(source)
-          parser.listen(bridge)
-          parser.parse
+          # StreamParser (rather than SAX2Parser) is used because
+          # SAX2Parser normalizes plain "&#NN;" and "&#NN;" attribute
+          # literals to the same raw string, making spec-correct decoding
+          # impossible after the fact. StreamParser delivers values in
+          # the same decoded form as REXML's DOM.
+          handler.on_start_document
+          ::REXML::Parsers::StreamParser.new(xml_string, bridge).parse
+          handler.on_end_document
         rescue ::REXML::ParseException => e
           error = Moxml::ParseError.new(e.message, line: e.line)
           handler.on_error(error)
@@ -117,15 +121,12 @@ module Moxml
         def create_native_doctype(name, external_id, system_id)
           return nil unless name
 
-          parts = [name]
-          if external_id
-            parts.push("PUBLIC", %("#{external_id}"))
-            parts << %("#{system_id}") if system_id
-          elsif system_id
-            parts.push("SYSTEM", %("#{system_id}"))
-          end
-
-          ::REXML::DocType.new(parts.join(" "))
+          external = if external_id
+                       system_id ? %(PUBLIC "#{external_id}" "#{system_id}") : %(PUBLIC "#{external_id}")
+                     elsif system_id
+                       %(SYSTEM "#{system_id}")
+                     end
+          external ? ::REXML::DocType.new(name.to_s, external) : ::REXML::DocType.new(name.to_s)
         end
 
         def set_root(doc, element)
@@ -250,9 +251,17 @@ module Moxml
         def attributes(element)
           return [] unless element.is_a?(::REXML::Element)
 
-          # Only return non-namespace attributes
-          element.attributes.values
-            .reject { |attr| attr.prefix.to_s.start_with?("xmlns") }
+          # Each real Attribute node, not Attributes#values: when two
+          # attributes share a local name across namespaces, REXML's
+          # values leaks its internal prefix-grouping Hash alongside
+          # the Attribute objects (issue #95).
+          result = []
+          element.attributes.each_attribute do |attr|
+            next if attr.prefix.to_s.start_with?("xmlns")
+
+            result << attr
+          end
+          result
         end
 
         def attribute_element(attribute)
@@ -271,10 +280,17 @@ module Moxml
           element = attribute.element
           element.attributes.delete(old_name)
           element.attributes << attribute
+          attribute
         end
 
         def set_attribute_value(attribute, value)
           attribute.normalized = value
+          attribute
+        end
+
+        def remove_attribute_native(attribute)
+          attribute.element.attributes.delete(attribute.expanded_name)
+          attribute
         end
 
         def get_attribute(element, name)
@@ -468,9 +484,11 @@ module Moxml
             element.add_namespace(prefix,
                                   ns.value)
           end
+          # Renames the node in place (works for elements and
+          # attributes alike); the caller keeps tracking the same
+          # native.
           element.name = "#{prefix}:#{element.name}"
-          owner = element.is_a?(::REXML::Attribute) ? element.element : element
-          ::REXML::Attribute.new(prefix, ns.value, owner)
+          element
         end
 
         def namespace_prefix(node)
@@ -518,11 +536,17 @@ module Moxml
         end
 
         def doctype_external_id(native)
-          native.public
+          # Constructed doctypes keep the identifier as a raw
+          # external_id string; parsed ones populate public directly
+          native.public ||
+            native.external_id&.match(/PUBLIC\s+"([^"]*)"/)&.[](1)
         end
 
         def doctype_system_id(native)
-          native.system
+          return native.system if native.system
+
+          quoted = native.external_id&.scan(/"([^"]*)"/)
+          quoted&.last&.first
         end
 
         # not used at the moment
@@ -642,29 +666,33 @@ module Moxml
       end
     end
 
-    # Bridge between REXML SAX2 and Moxml SAX
+    # Bridge between REXML StreamParser and Moxml SAX
     #
-    # Translates REXML::SAX2Parser events to Moxml::SAX::Handler events
+    # StreamParser (rather than SAX2Parser) is used because SAX2Parser
+    # normalizes plain "&#NN;" and "&amp;#NN;" attribute literals to
+    # the same raw string, which makes spec-correct decoding impossible
+    # after the fact. StreamParser delivers attribute values in the
+    # same decoded form as REXML's DOM.
     #
     # @private
-    class REXMLSAX2Bridge
+    class REXMLStreamBridge
+      include ::REXML::StreamListener
       include Moxml::SAX::NamespaceSplitter
 
       def initialize(handler)
         @handler = handler
       end
 
-      # REXML splits element name into uri/localname/qname
-      def start_element(_uri, _localname, qname, attributes)
+      def tag_start(name, attributes)
         attr_hash, ns_hash = split_attributes_and_namespaces(attributes)
-        @handler.on_start_element(qname, attr_hash, ns_hash)
+        @handler.on_start_element(name, attr_hash, ns_hash)
       end
 
-      def end_element(_uri, _localname, qname)
-        @handler.on_end_element(qname)
+      def tag_end(name)
+        @handler.on_end_element(name)
       end
 
-      def characters(text)
+      def text(text)
         @handler.on_characters(text)
       end
 
@@ -676,26 +704,9 @@ module Moxml
         @handler.on_comment(text)
       end
 
-      def processing_instruction(target, data)
+      def instruction(target, data)
         @handler.on_processing_instruction(target, data || "")
       end
-
-      def start_document
-        @handler.on_start_document
-      end
-
-      def end_document
-        @handler.on_end_document
-      end
-
-      # REXML calls these but we don't need to handle them
-      def xmldecl(version, encoding, standalone)
-        # XML declaration - we don't need to do anything
-      end
-
-      def progress(position)
-        # Progress callback - we don't need to do anything
-      end
     end
   end
 end

data/lib/moxml/adapter.rb

@@ -7,8 +7,9 @@ module Moxml
     autoload :CustomizedOx, "moxml/adapter/customized_ox"
     autoload :CustomizedRexml, "moxml/adapter/customized_rexml"
     autoload :CustomizedLibxml, "moxml/adapter/customized_libxml"
+    autoload :CustomizedLeptris, "moxml/adapter/customized_leptris"
 
-    AVAILABLE_ADAPTERS = %i[nokogiri oga rexml ox headed_ox libxml].freeze
+    AVAILABLE_ADAPTERS = %i[nokogiri oga rexml ox headed_ox libxml leptris].freeze
 
     # Adapters that work under the Opal (JavaScript) runtime.
     # Oga is pure Ruby and designed with Opal compatibility in mind — it is the

data/lib/moxml/attribute.rb

@@ -3,11 +3,14 @@
 module Moxml
   class Attribute < Node
     def name
-      @native.name
+      adapter.attribute_name(@native)
     end
 
     def name=(new_name)
-      adapter.set_attribute_name(@native, new_name)
+      # Mutation return contract (Adapter::Base): returns the native
+      # to keep tracking — same object for in-place adapters, fresh
+      # object for value-object adapters (leptris).
+      @native = adapter.set_attribute_name(@native, new_name)
     end
 
     # Returns the primary identifier for this attribute (its name)
@@ -44,7 +47,8 @@ module Moxml
     end
 
     def namespace=(ns)
-      adapter.set_namespace(@native, ns&.native)
+      # See name= for the mutation return contract.
+      @native = adapter.set_namespace(@native, ns&.native)
     end
 
     def element
@@ -53,7 +57,7 @@ module Moxml
     end
 
     def remove
-      adapter.remove_attribute(adapter.attribute_element(@native), name)
+      adapter.remove_attribute_native(@native)
       if @parent_node.is_a?(Moxml::Element)
         @parent_node.invalidate_attribute_cache!
       end

data/lib/moxml/attribute_resolver.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Moxml
+  # Canonical, adapter-independent attribute-name resolution.
+  #
+  # XML Namespaces 1.0 semantics, implemented once on the Moxml object
+  # model (the unified interface); adapters provide raw access only:
+  #
+  # - An attribute's expanded name is (namespace URI or none) + local
+  #   name. Unprefixed attributes are never in a namespace — the
+  #   default namespace declaration does not apply to attributes
+  #   (Namespaces 1.0 §5.2).
+  # - "prefix:local" resolves the prefix against the element's
+  #   in-scope declarations and matches by expanded name: an attribute
+  #   written as q:type matches a lookup as p:type whenever both
+  #   prefixes are bound to the same URI.
+  # - "xml" is prebound to the XML namespace URI; it never needs a
+  #   declaration (Namespaces 1.0 §4).
+  # - "xmlns"/"xmlns:*" are declarations, not attributes: never match.
+  # - An undeclared prefix names nothing: nil. No silent prefix-string
+  #   or bare-name fallback.
+  #
+  # When several attributes match (only possible in namespace-ill-formed
+  # documents), the first in document order wins, matching every
+  # adapter's attributes() ordering contract.
+  module AttributeResolver
+    XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace"
+
+    module_function
+
+    # @return [Moxml::Attribute, nil] the matching attribute wrapper
+    def resolve(element, name)
+      name = name.to_s
+      if name.include?(":")
+        prefix, local = name.split(":", 2)
+        return nil if prefix == "xmlns"
+
+        uri = prefix_uri(element, prefix)
+        return nil if uri.nil?
+
+        element.attributes.find do |attr|
+          local_name(attr.name) == local && attribute_uri(element, attr) == uri
+        end
+      else
+        element.attributes.find do |attr|
+          local_name(attr.name) == name && attribute_uri(element, attr).nil?
+        end
+      end
+    end
+
+    # URI a prefix is bound to for lookups on this element, or nil when
+    # the prefix is undeclared.
+    def prefix_uri(element, prefix)
+      return XML_NAMESPACE_URI if prefix == "xml"
+
+      element.in_scope_namespaces
+        .find { |candidate| candidate.prefix == prefix }&.uri
+    end
+
+    # Assign a value to the attribute named by XML-correct resolution,
+    # mirroring #resolve:
+    #
+    # - "xmlns"/"xmlns:*" are namespace declarations, not attributes:
+    #   delegated verbatim to the adapter (declaration creation is
+    #   adapter territory).
+    # - A bare name replaces the no-namespace attribute only — a
+    #   namespaced attribute sharing the local name is left alone.
+    # - A prefixed name replaces by expanded name: assigning p:x
+    #   overwrites an attribute spelled q:x when both prefixes are
+    #   bound to the same URI.
+    #
+    # When nothing matches, the attribute is created with the given
+    # spelling. A prefix not yet in scope is stored raw — builders
+    # legitimately write detached children before attaching them under
+    # the declaring ancestor, and reads resolve by expanded name once
+    # the prefix is in scope (matching nokogiri/libxml creation
+    # behavior; namespace validity is a property of the serialized
+    # document).
+    #
+    # @return [String] the assigned value
+    def assign(element, name, value)
+      name = name.to_s
+      adapter = element.context.config.adapter
+      if name == "xmlns" || name.start_with?("xmlns:")
+        adapter.set_attribute(element.native, name, value)
+        element.invalidate_attribute_cache!
+        return value
+      end
+
+      existing = resolve(element, name)
+      if existing
+        existing.value = value
+        return value
+      end
+
+      adapter.set_attribute(element.native, name, value)
+      element.invalidate_attribute_cache!
+      value
+    end
+
+    # Remove the attribute named by XML-correct resolution (see
+    # #assign for the name semantics).
+    #
+    # @return [Moxml::Attribute, nil] the removed attribute
+    def remove(element, name)
+      name = name.to_s
+      adapter = element.context.config.adapter
+      if name == "xmlns" || name.start_with?("xmlns:")
+        adapter.remove_attribute(element.native, name)
+        element.invalidate_attribute_cache!
+        return nil
+      end
+
+      attr = resolve(element, name)
+      return nil unless attr
+
+      adapter.remove_attribute_native(attr.native)
+      element.invalidate_attribute_cache!
+      attr
+    end
+
+    # XPath 1.0 attribute node test, sharing the resolver's
+    # expanded-name semantics:
+    #
+    # @param prefix [String, Symbol, nil]
+    #   - String: match by namespace URI resolved against the
+    #     element's in-scope declarations; the prefix spelling is
+    #     irrelevant (q:x matches a p:x test when URIs agree)
+    #   - :any: any namespace, including none (*:local)
+    #   - nil: bare name — no-namespace attributes only (Namespaces
+    #     1.0 §5.2)
+    # @param local [String, nil] local name, or nil for any (p:*)
+    # @return [Boolean]
+    def attribute_test?(element, attr, prefix, local)
+      return false if local && local_name(attr.name) != local
+
+      case prefix
+      when :any then true
+      when nil then attribute_uri(element, attr).nil?
+      else
+        uri = prefix_uri(element, prefix)
+        !uri.nil? && uri == attribute_uri(element, attr)
+      end
+    end
+
+    # Attribute node test with a URI resolved at XPath compile time
+    # (the static context's prefix mapping wins over the document's
+    # own declarations). See #attribute_test? for local semantics.
+    #
+    # @return [Boolean]
+    def attribute_test_uri?(element, attr, uri, local)
+      return false if local && local_name(attr.name) != local
+
+      attribute_uri(element, attr) == uri
+    end
+
+    # Local part of a wrapper attribute name. Local names cannot
+    # contain ':' in namespace-well-formed documents; splitting is for
+    # adapters whose natives carry the qualified name (leptris).
+    def local_name(name)
+      name.include?(":") ? name.split(":", 2)[1] : name
+    end
+
+    # URI of an attribute's namespace, nil for the no-namespace case.
+    #
+    # Uses the attribute's own namespace when the native binding
+    # exposes one with a URI (nokogiri/oga/libxml, and rexml/ox for
+    # declared prefixes). Otherwise reconstructs it from the attribute
+    # prefix via the element's in-scope declarations — covering
+    # adapters that report a prefix without resolving it (rexml/ox for
+    # the prebound xml prefix) and adapters that expose neither
+    # namespace nor separate prefix (leptris qualified names).
+    def attribute_uri(element, attr)
+      ns = attr.namespace
+      return ns.uri unless ns.nil? || ns.uri.to_s.empty?
+
+      prefix = ns&.prefix || prefix_part(attr.name)
+      return nil if prefix.nil? || prefix.empty?
+      return XML_NAMESPACE_URI if prefix == "xml"
+
+      element.in_scope_namespaces
+        .find { |candidate| candidate.prefix == prefix }&.uri
+    end
+
+    def prefix_part(name)
+      name.include?(":") ? name.split(":", 2)[0] : nil
+    end
+  end
+end

data/lib/moxml/c14n/attribute_handler.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    # Attribute axis handler for inclusive C14N.
+    # Implements W3C C14N 1.0 §2.4 / 1.1 §2.4 attribute rendering,
+    # including resolution of simple inheritable attributes (xml:lang,
+    # xml:space) for document subsets.
+    class AttributeHandler
+      attr_reader :encoder
+
+      def initialize(encoder)
+        @encoder = encoder
+      end
+
+      def process_attributes(element, output, omitted_ancestors = [])
+        return unless element.in_node_set?
+
+        attributes = collect_attributes(element, omitted_ancestors)
+        attributes.each do |attr|
+          output << " "
+          output << attr.qname
+          output << '="'
+          output << encoder.encode_attribute(attr.value)
+          output << '"'
+        end
+      end
+
+      private
+
+      def collect_attributes(element, omitted_ancestors)
+        attributes = element.sorted_attribute_nodes.select(&:in_node_set?)
+
+        return attributes if omitted_ancestors.empty?
+
+        inherited = collect_inherited_attributes(element, omitted_ancestors)
+        merge_attributes(attributes, inherited)
+      end
+
+      # Walk omitted ancestors to collect simple inheritable attributes
+      # not already declared on the element. Per C14N 1.1 §2.4, these
+      # are inherited from the nearest ancestor in which they are declared.
+      def collect_inherited_attributes(element, omitted_ancestors)
+        inherited = []
+        seen = Set.new
+
+        element.attribute_nodes.each do |attr|
+          seen.add(attr.name) if attr.simple_inheritable?
+        end
+
+        omitted_ancestors.reverse_each do |ancestor|
+          ancestor.attribute_nodes.each do |attr|
+            next unless attr.simple_inheritable?
+            next if seen.include?(attr.name)
+
+            inherited << attr
+            seen.add(attr.name)
+          end
+        end
+
+        inherited
+      end
+
+      def merge_attributes(element_attrs, inherited_attrs)
+        (element_attrs + inherited_attrs).sort_by do |attr|
+          [attr.namespace_uri.to_s, attr.local_name]
+        end
+      end
+    end
+  end
+end

data/lib/moxml/c14n/character_encoder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    # Character encoder for C14N output. Handles the entity escaping
+    # mandated by W3C C14N 1.0 §2.4 / 1.1 §2.4 for text and attribute values.
+    class CharacterEncoder
+      TEXT_ESCAPES = {
+        "&" => "&",
+        "<" => "&lt;",
+        ">" => "&gt;",
+        "\r" => "&#xD;",
+      }.freeze
+      ATTRIBUTE_ESCAPES = TEXT_ESCAPES.merge(
+        '"' => "&quot;",
+        "\t" => "&#x9;",
+        "\n" => "&#xA;",
+      ).freeze
+
+      def encode_text(text)
+        text.to_s.gsub(/[&<>\r]/, TEXT_ESCAPES)
+      end
+
+      def encode_attribute(value)
+        value.to_s.gsub(/[&<"\t\n\r]/, ATTRIBUTE_ESCAPES)
+      end
+    end
+  end
+end

data/lib/moxml/c14n/data_model.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    # Builds a C14N data model from a Moxml::Node tree (or XML string).
+    #
+    # The data model exists because canonicalization needs:
+    #   - sorted namespace and attribute axes (spec §2.3, §2.4)
+    #   - in_node_set flags for subset canonicalization (spec §3)
+    #   - xml:* inheritable attribute resolution
+    #
+    # Ported from canon (lutaml/canon) — adapted to build directly from
+    # Moxml::Node rather than via a separate Nokogiri pass. Matches
+    # canon's document-level node iteration (PIs and comments outside
+    # the document root element).
+    class DataModel
+      def self.from_xml(xml_string)
+        from_node(::Moxml.parse(xml_string))
+      end
+
+      def self.from_node(moxml_node)
+        return build_from_document(moxml_node) if moxml_node.is_a?(::Moxml::Document)
+
+        root = Nodes::RootNode.new
+        root.add_child(build_node(moxml_node))
+        root
+      end
+
+      # Build from a Moxml::Document. Matches canon's Nokogiri path:
+      # the root element is added first, then all other document-level
+      # children (PIs, comments) in document order.
+      def self.build_from_document(document)
+        root = Nodes::RootNode.new
+
+        if document.root
+          root.add_child(build_element_node(document.root))
+          # Iterate ALL document children — not just the root element.
+          # This captures PIs and comments that appear outside the
+          # document element, which are part of the canonical form.
+          document.children.each do |child|
+            next if child.equal?(document.root)
+            next if child.is_a?(::Moxml::Element)
+
+            built = build_node(child)
+            root.add_child(built) if built
+          end
+        end
+
+        root
+      end
+
+      def self.build_node(moxml_node)
+        case moxml_node
+        when ::Moxml::Element then build_element_node(moxml_node)
+        when ::Moxml::Text then build_text_node(moxml_node)
+        when ::Moxml::Comment then build_comment_node(moxml_node)
+        when ::Moxml::ProcessingInstruction then build_pi_node(moxml_node)
+        end
+      end
+
+      def self.build_element_node(moxml_element)
+        ns = moxml_element.namespace
+        element = Nodes::ElementNode.new(
+          name: moxml_element.name,
+          namespace_uri: ns&.uri,
+          prefix: ns&.prefix,
+        )
+
+        build_namespace_nodes(moxml_element, element)
+        build_attribute_nodes(moxml_element, element)
+
+        moxml_element.children.each do |child|
+          built = build_node(child)
+          element.add_child(built) if built
+        end
+
+        element
+      end
+
+      def self.build_namespace_nodes(moxml_element, element)
+        moxml_element.in_scope_namespaces.each do |ns|
+          element.add_namespace(
+            Nodes::NamespaceNode.new(prefix: ns.prefix || "", uri: ns.uri),
+          )
+        end
+
+        return if element.namespace_nodes.any? { |n| n.prefix == "xml" }
+
+        element.add_namespace(
+          Nodes::NamespaceNode.new(prefix: "xml", uri: XML_URI),
+        )
+      end
+
+      def self.build_attribute_nodes(moxml_element, element)
+        moxml_element.attributes.each do |attr|
+          ns = attr.namespace
+          element.add_attribute(
+            Nodes::AttributeNode.new(
+              name: attr.name,
+              value: attr.value,
+              namespace_uri: ns&.uri,
+              prefix: ns&.prefix,
+            ),
+          )
+        end
+      end
+
+      def self.build_text_node(moxml_text)
+        Nodes::TextNode.new(value: moxml_text.content)
+      end
+
+      def self.build_comment_node(moxml_comment)
+        Nodes::CommentNode.new(value: moxml_comment.content)
+      end
+
+      def self.build_pi_node(moxml_pi)
+        Nodes::ProcessingInstructionNode.new(
+          target: moxml_pi.target || moxml_pi.name,
+          data: moxml_pi.content || "",
+        )
+      end
+
+      def self.mark_all(node, value)
+        node.in_node_set = value
+        node.children.each { |child| mark_all(child, value) }
+      end
+
+      def self.mark_subset(root_node, matched)
+        matched.each { |node| mark_node_and_descendants(node) }
+        root_node.in_node_set = true
+      end
+
+      def self.mark_node_and_descendants(node)
+        node.in_node_set = true
+        node.children.each { |child| mark_node_and_descendants(child) }
+      end
+
+      private_class_method :build_from_document, :build_node,
+                           :build_element_node, :build_namespace_nodes,
+                           :build_attribute_nodes, :build_text_node,
+                           :build_comment_node, :build_pi_node,
+                           :mark_node_and_descendants
+    end
+  end
+end