moxml 0.1.26 → 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/config.rb

@@ -5,8 +5,15 @@ module Moxml
     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
+    VALID_ADAPTERS = %i[nokogiri oga rexml ox headed_ox libxml leptris].freeze
+    # Preferred CRuby default (issue #96): fastest on every measured
+    # operation and the cleanest deployment story. Only takes effect
+    # when the installed leptris supports programmatic document
+    # construction (Leptris::XML::Document.create); otherwise moxml
+    # falls back to FALLBACK_ADAPTER so released-gem environments keep
+    # working. Oga remains the Opal default (pure Ruby).
+    PREFERRED_ADAPTER = :leptris
+    FALLBACK_ADAPTER = :nokogiri
     OPAL_DEFAULT_ADAPTER = :oga
 
     # Entity loading modes:
@@ -30,7 +37,26 @@ module Moxml
       def runtime_default_adapter
         return OPAL_DEFAULT_ADAPTER if RUBY_ENGINE == "opal"
 
-        detect_loaded_adapter || DEFAULT_ADAPTER
+        return PREFERRED_ADAPTER if leptris_preferred_available?
+
+        detect_loaded_adapter || FALLBACK_ADAPTER
+      end
+
+      # True when the leptris gem is installed AND new enough for the
+      # adapter (it needs programmatic document construction, which
+      # released 1.1.x lacks). Memoized: the require probe runs once.
+      def leptris_preferred_available?
+        return @leptris_preferred_available if defined?(@leptris_preferred_available)
+
+        @leptris_preferred_available = begin
+          require "leptris"
+          # leptris-ruby 1.9.0 regression (leptris-ruby#53): the XML
+          # autoload manifest is shadowed; load it explicitly.
+          require "leptris/xml"
+          ::Leptris::XML::Document.respond_to?(:create)
+        rescue LoadError, NameError
+          false
+        end
       end
 
       def detect_loaded_adapter

data/lib/moxml/context.rb

@@ -6,6 +6,18 @@ module Moxml
 
     def initialize(adapter = nil)
       @config = Config.new(adapter)
+      # Bumped on any namespace-scope mutation; Element scope caches
+      # compare against it so every wrapper sees changes without
+      # needing wrapper identity.
+      @namespace_scope_generation = 0
+    end
+
+    def namespace_scope_generation
+      @namespace_scope_generation
+    end
+
+    def bump_namespace_scope_generation
+      @namespace_scope_generation += 1
     end
 
     def entity_registry

data/lib/moxml/element.rb

@@ -37,19 +37,23 @@ module Moxml
       ns&.uri
     end
 
+    # Write path shares the resolver's expanded-name semantics (see
+    # AttributeResolver.assign): bare names target no-namespace
+    # attributes only; prefixed names replace by namespace URI and
+    # require a declared prefix. Cache coherence is the resolver's.
     def []=(name, value)
-      adapter.set_attribute(@native, name, normalize_xml_value(value))
-      @attributes = nil
+      Moxml::AttributeResolver.assign(self, name, normalize_xml_value(value))
     end
 
+    # Unified XML-correct name resolution (see AttributeResolver):
+    # bare names match only no-namespace attributes; prefixed names
+    # resolve through in-scope declarations to expanded names.
     def [](name)
-      val = adapter.get_attribute_value(@native, name)
-      val ? adapter.restore_entities(val) : val
+      Moxml::AttributeResolver.resolve(self, name)&.value
     end
 
     def attribute(name)
-      native_attr = adapter.get_attribute(@native, name)
-      native_attr && Attribute.new(native_attr, context)
+      Moxml::AttributeResolver.resolve(self, name)
     end
 
     # Returns attribute value by name (used by XPath engine)
@@ -66,15 +70,14 @@ module Moxml
     end
 
     def remove_attribute(name)
-      adapter.remove_attribute(@native, name)
-      @attributes = nil
+      Moxml::AttributeResolver.remove(self, name)
       self
     end
 
     def add_namespace(prefix, uri)
       adapter.create_namespace(@native, prefix, uri,
                                namespace_validation_mode: context.config.namespace_validation_mode)
-      @namespaces = nil
+      invalidate_namespace_cache!
       self
     rescue ValidationError => e
       # Re-raise as NamespaceError, provide attributes for error context
@@ -106,7 +109,7 @@ module Moxml
       else
         adapter.set_namespace(@native, ns_or_hash&.native)
       end
-      @namespaces = nil
+      invalidate_namespace_cache!
     end
 
     def namespaces
@@ -119,9 +122,14 @@ module Moxml
     # 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)
+      generation = context.namespace_scope_generation
+      if @in_scope_namespaces.nil? || @in_scope_generation != generation
+        @in_scope_namespaces = adapter.in_scope_namespaces(@native).map do |ns|
+          Namespace.new(ns, context)
+        end
+        @in_scope_generation = generation
       end
+      @in_scope_namespaces
     end
 
     # Returns the namespace URI of this element (alias for namespace_uri)
@@ -209,5 +217,14 @@ module Moxml
     def invalidate_attribute_cache!
       @attributes = nil
     end
+
+    # Clear the namespace caches and bump the context's scope
+    # generation so every wrapper — including ones not reachable from
+    # any children cache — recomputes on next read.
+    def invalidate_namespace_cache!
+      @namespaces = nil
+      @in_scope_namespaces = nil
+      context.bump_namespace_scope_generation
+    end
   end
 end

data/lib/moxml/entity/reference.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Entity
+    # A named entity reference (&name;) as a value object, for
+    # adapters whose native trees cannot represent entity references
+    # (ox stores them in the tree; rexml and leptris carry them
+    # alongside). Adapter-specific namespaces alias this class so
+    # node_type dispatch keeps working.
+    class Reference
+      attr_reader :name
+      attr_accessor :parent
+
+      def initialize(name)
+        @name = name
+        @parent = nil
+      end
+
+      def to_xml
+        "&#{name};"
+      end
+
+      def ==(other)
+        other.is_a?(Reference) && name == other.name
+      end
+    end
+  end
+end