moxml 0.5.148 → 0.5.150

data/lib/moxml/adapter/base.rb

@@ -178,6 +178,18 @@ module Moxml
           method(:sax_parse).owner != Moxml::Adapter::Base.singleton_class
         end
 
+        # Whether the SAX engine reports an event family as distinct
+        # events. Engines that cannot must raise the named error when
+        # the handler subscribes (model, SAX: the callback stream is
+        # authoritative; absence is loud, never a silent fold).
+        #
+        # @param family [Symbol] :cdata, :comment, or
+        #   :processing_instruction
+        # @return [Boolean]
+        def sax_event_family_supported?(_family)
+          true
+        end
+
         def create_document(_native_doc = nil)
           raise Moxml::NotImplementedError.new(
             "create_document not implemented",
@@ -312,6 +324,30 @@ module Moxml
         # validator raise; leptris gates on >= 1.9.321.0.
         XSD_SUPPORTED = false
 
+        # RELAX NG validation (moxml RelaxNG contract): the same
+        # loud-capability rule.
+        RELAXNG_SUPPORTED = false
+
+        def relaxng_compile(_schema_source)
+          raise Moxml::NotImplementedError,
+                "RELAX NG validation requires an adapter with an RNG engine"
+        end
+
+        def relaxng_compile_file(_path)
+          raise Moxml::NotImplementedError,
+                "RELAX NG validation requires an adapter with an RNG engine"
+        end
+
+        def relaxng_validate_errors(_handle, _native_document)
+          raise Moxml::NotImplementedError,
+                "RELAX NG validation requires an adapter with an RNG engine"
+        end
+
+        def relaxng_valid?(_handle, _native_document)
+          raise Moxml::NotImplementedError,
+                "RELAX NG validation requires an adapter with an RNG engine"
+        end
+
         # Issue #384: schema handles are adapter-native objects — a
         # handle compiled through one adapter must not dispatch
         # through another. Adapters with an XSD engine answer their
@@ -499,6 +535,43 @@ namespace_validation_mode: :strict)
           node
         end
 
+        # Whether add_next_sibling/add_previous_sibling answer the
+        # native actually installed (libxml imports cross-document
+        # fragments and answers the copy) — the facade then refreshes
+        # the caller's wrapper to it.
+        def add_sibling_returns_inserted?
+          false
+        end
+
+        # Whether element-level to_xml(indent:) is honored. The
+        # facade raises a named AdapterError on incapable engines
+        # instead of returning unindented output silently (D-09).
+        def element_indent_supported?
+          false
+        end
+
+        # Whether adapter.at_xpath is safe as the primary first-node
+        # lane. leptris: its at_xpath falls back to the model's Ruby
+        # engine when the native lane answers nothing (an engine index
+        # left stale by sibling insertion), so it reflects the live
+        # tree where the node-set lane does not.
+        def native_at_xpath?
+          false
+        end
+
+        # libxml2 (nokogiri and libxml-ruby alike) rejects an empty
+        # namespace URI in an XPath binding context, but the model's
+        # `xmlns:` idiom must be able to address the no-namespace
+        # default. Adapters route such expressions through the
+        # reference engine.
+        def empty_default_namespace_binding?(namespaces)
+          return false unless namespaces
+
+          namespaces.any? do |prefix, uri|
+            prefix.to_s == "xmlns" && uri.to_s.empty?
+          end
+        end
+
         # Whether children() results need per-child patch_node
         # rewriting. Adapters whose natives arrive pre-wrapped (all but
         # ox and libxml) answer false so the wrapper layer can skip

data/lib/moxml/adapter/leptris.rb

@@ -71,6 +71,13 @@ module Moxml
         defined?(::Leptris::XML::NativeNode) &&
         Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.162.6")
 
+      # leptris-ruby#460: set-text by document+address, kind-dispatched
+      # in C — no binding twin mint per write. Face-probed, not
+      # version-gated (the floor admits bindings without it).
+      NATIVE_SET_BINDING_TEXT =
+        defined?(::Leptris::XML::Native) &&
+        ::Leptris::XML::Native.respond_to?(:set_binding_text)
+
       # 1.9.163.2's native layer returns UTF-8, unfrozen strings
       # (1.9.162.x answered ASCII-8BIT — the reads retagged with a
       # dup+force_encoding per call).
@@ -234,6 +241,16 @@ module Moxml
 
       XSD_SUPPORTED = NATIVE_XSD
 
+      # RELAX NG (moxml RelaxNG contract): the binding ships the RNG
+      # facade over the engine's Jing-compatible validator.
+      RELAXNG_SUPPORTED = begin
+        require "leptris/xml/relaxng"
+        defined?(::Leptris::XML::RelaxNG) &&
+          ::Leptris::XML::RelaxNG.respond_to?(:parse_file)
+      rescue LoadError
+        false
+      end
+
       # Schema#release (moxml#362.3, binding 1.9.342+): the
       # deterministic drop face — disarms the AutoPointer's GC
       # finalizer and frees now. Face-probed with the version
@@ -319,6 +336,40 @@ module Moxml
           ::Leptris::XML::XSD.compile_file(path)
         end
 
+        def relaxng_compile(schema_source)
+          unless RELAXNG_SUPPORTED
+            raise Moxml::NotImplementedError,
+                  "RELAX NG validation requires a leptris binding with the RNG face"
+          end
+
+          ::Leptris::XML::RelaxNG.parse(schema_source)
+        rescue ::Leptris::XML::Error => e
+          raise Moxml::ValidationError.new(
+            "RELAX NG schema parse failed: #{e.message}",
+          )
+        end
+
+        def relaxng_compile_file(path)
+          unless RELAXNG_SUPPORTED
+            raise Moxml::NotImplementedError,
+                  "RELAX NG validation requires a leptris binding with the RNG face"
+          end
+
+          ::Leptris::XML::RelaxNG.parse_file(path)
+        rescue ::Leptris::XML::Error => e
+          raise Moxml::ValidationError.new(
+            "RELAX NG schema parse failed: #{e.message}",
+          )
+        end
+
+        def relaxng_validate_errors(handle, document)
+          handle.validate_errors(to_binding(document))
+        end
+
+        def relaxng_valid?(handle, document)
+          handle.valid?(to_binding(document))
+        end
+
         def xsd_builtin_valid?(builtin, lexical)
           unless XSD_SUPPORTED
             raise Moxml::NotImplementedError,
@@ -348,9 +399,13 @@ module Moxml
 
         def xsd_content_valid?(xsd_handle, element_name, children)
           # The binding reads each child's name + effective
-          # namespace through its own node API — pass the natives.
+          # namespace through its own node API (c_ptr) — bridge to
+          # the binding's nodes. 1.9.374+ mints registered klasses
+          # at create, so children arrive as Identity wrappers whose
+          # .native is self (no c_ptr); to_binding hands back the
+          # binding node whatever the wrapper flavor.
           xsd_handle.content_valid?(
-            element_name, children.map(&:native)
+            element_name, children.map { |c| to_binding(c.native) }
           )
         end
 
@@ -525,12 +580,18 @@ module Moxml
               include ::Moxml::Node
               include ::Moxml::ProcessingInstruction
 
-              # Same nil bridge as Comment (leptris-ruby#344).
+              # Same nil bridge as Comment (leptris-ruby#344); the
+              # separating whitespace after the target is not content
+              # (uniform PI semantics, TODO.sota/02).
               def content
                 content = native_content
-                return ::Moxml::Adapter::Leptris.to_binding(self).content if content.nil?
+                if content.nil?
+                  return ::Moxml::Adapter::Leptris.to_binding(self)
+                      .content.to_s
+                      .sub(/\A\s+/, "")
+                end
 
-                content
+                content.sub(/\A\s+/, "")
               end
             end
 
@@ -569,6 +630,21 @@ module Moxml
                 bearing
               end
 
+              # The resolved verdict plus its generation stamp; the
+              # prewrapped traversal hands it down the tree so a fresh
+              # child skips its own document climb.
+              def doc_entity_stamp
+                doc_entity_bearing?
+                @doc_entity_stamp
+              end
+
+              def inherit_document_state(parent)
+                # The parent's own children call resolved the
+                # document-level verdict for this generation, and
+                # parent and child share the document.
+                @doc_entity_stamp = parent.doc_entity_stamp
+              end
+
               def [](key)
                 if key.is_a?(String) && !key.include?(":")
                   value = attr_read(key)
@@ -640,12 +716,17 @@ module Moxml
             if NN.method_defined?(:children_read)
               module ChildReads
                 def children
-                  @children = nil if @children_gen != context.children_generation
-                  @children_gen = context.children_generation
+                  ctx = @context || context
+                  generation = ctx.children_generation
+                  if @children_gen != generation
+                    @children = nil
+                    @children_gen = generation
+                  end
                   @children ||= if doc_entity_bearing?
                                   super
                                 else
-                                  NodeSet.new(children_read, context, self)
+                                  NodeSet.new(children_read, ctx, self,
+                                              prewrapped: true)
                                 end
                 end
               end
@@ -1105,6 +1186,60 @@ module Moxml
           @attachments ||= Moxml::NativeAttachment.new
         end
 
+        # --- engine XPath index guard ---------------------------------
+        # Sibling insertions do not invalidate the engine's document
+        # index that the node-set XPath lane uses, so after one the
+        # lane answers stale results (the tree and the first-only
+        # entry are correct; upstream bug filed). Track the state per
+        # binding document and route XPath to the reference Ruby
+        # engine until a child insertion rebuilds the engine index.
+        XPATH_INDEX_STALE = :xpath_index_stale
+
+        def mark_xpath_index_stale(node)
+          doc = xpath_index_document(node)
+          attachments.set(doc, XPATH_INDEX_STALE, true) if doc
+        end
+
+        def clear_xpath_index_stale(node)
+          doc = xpath_index_document(node)
+          attachments.set(doc, XPATH_INDEX_STALE, false) if doc
+        end
+
+        def xpath_index_stale?(doc)
+          # leptris-ruby#519 is fixed upstream: on builds whose
+          # node-set index survives sibling insertion the stale mark
+          # is moot, and post-insert XPath stays on the native lane.
+          return false if native_xpath_index_fixed?
+
+          doc && attachments.get(doc, XPATH_INDEX_STALE)
+        end
+
+        # Runs the #519 repro once at the binding level: populate the
+        # node-set index, insert a sibling, and require the re-query
+        # to see the inserted element. True on fixed builds, so the
+        # guard auto-retires without a moxml release.
+        def native_xpath_index_fixed?
+          return @native_xpath_index_fixed unless @native_xpath_index_fixed.nil?
+
+          @native_xpath_index_fixed = begin
+            native_doc = ::Leptris::XML::Document.parse("<r><a/><b/></r>")
+            root = native_doc.root
+            root.xpath("child::*")
+            b = root.children.to_a[1]
+            b.add_previous_sibling(native_doc.create_element("c"))
+            names = root.xpath("child::*").to_a.map { |n| n.name.to_s }
+            names == %w[a c b]
+          rescue StandardError
+            false
+          end
+        end
+
+        def xpath_index_document(node)
+          return node if node.is_a?(::Leptris::XML::Document)
+
+          node.document
+        end
+
         def set_root(doc, element)
           to_binding(doc).root = to_binding(element)
         end
@@ -1125,13 +1260,23 @@ module Moxml
           true
         end
 
+        # Canonical XML excludes the initial whitespace of PI data;
+        # the C canonicalizer keeps the raw separator when the source
+        # used more than one whitespace character, so collapse it to
+        # the single canonical space (libxml2 oracle). In canonical
+        # output a literal "<?" can only start a PI: "<" is escaped in
+        # text and attribute values, and comments/DTD are not emitted
+        # on this lane.
+        NATIVE_C14N_PI_SEPARATOR = /<\?([^\s?]+)[ \t\r\n]+/
+
         def native_inclusive10(native)
           return nil unless native_c14n_byte_safe?
 
-          to_binding(native).canonicalize(
+          canonical = to_binding(native).canonicalize(
             ::Leptris::XML::FFI::C14N_1_0, nil,
             mode: ::Leptris::XML::FFI::C14N_MODE_CANONICAL
           )
+          canonical.gsub(NATIVE_C14N_PI_SEPARATOR, '<?\1 ')
         end
 
         def expanded_attr_value(element, uri, local)
@@ -1174,8 +1319,44 @@ module Moxml
           true
         end
 
+        # Our at_xpath falls back to the model's Ruby engine when the
+        # native lane answers nothing — the engine's node-set XPath
+        # index is stale after sibling insertion, so `at` must not be
+        # routed through the node-set lane.
+        def native_at_xpath?
+          true
+        end
+
+        # UTF-8 is the default effective encoding; a prolog declaring
+        # another encoding hands byte validity to that encoding's lane.
+        DECLARED_ENCODING_RE =
+          /<\?xml\s[^>]*?encoding\s*=\s*["']([^"']+)["']/i
+        private_constant :DECLARED_ENCODING_RE
+
+        def encoding_lane_owns_validity?(xml_string)
+          # Binary-tagged head: the prolog is ASCII, and matching
+          # never raises on binary-tagged bytes (invalid-UTF-8 input
+          # is exactly the case this check exists for).
+          declared = xml_string.b[0, 256].match(DECLARED_ENCODING_RE)
+          declared &&
+            !declared[1].match?(/\A(?:utf-?8|us-ascii|ascii)\z/i)
+        end
+
         def parse(xml, options = {}, _context = nil)
           xml_string = xml.is_a?(IO) || xml.is_a?(StringIO) ? xml.read : xml.to_s
+          # Strict parse raises on bytes invalid in the effective
+          # encoding (default UTF-8; declared non-UTF-8 encodings own
+          # their validity) — the validating engines do this at load
+          # (libxml2: "Invalid bytes in character encoding"), the
+          # leptris engine lane does not yet (leptris-ruby#514), so
+          # the facade names it (taxonomy differential, D-18).
+          if options[:strict] && !xml_string.valid_encoding? &&
+              !encoding_lane_owns_validity?(xml_string)
+            raise Moxml::ParseError.new(
+              "Invalid bytes in character encoding (#{xml_string.encoding})",
+              source: xml_string[0, 100],
+            )
+          end
           # The marker flag rides preprocess's own `&` scan — no
           # second full-buffer probe (issue #132 parse-side note).
           entity_mode_keep =
@@ -1213,7 +1394,11 @@ module Moxml
               options: parse_flags(options, recover: recover,
                                             context: _context),
             )
-          rescue ::Leptris::XML::ParseError => e
+          rescue ::Leptris::XML::Error => e
+            # Invalid encoding bytes surface as the base engine
+            # error class, not ParseError — parse failures are all
+            # named by the facade (taxonomy differential, malformed
+            # class).
             raise Moxml::ParseError.new(e.message) if options[:strict]
 
             # Engines below the 1.9.344 recover floor (or the
@@ -1383,7 +1568,11 @@ module Moxml
             else
               ::Leptris::XML.parse_html(html_string)
             end
-          rescue ::Leptris::XML::ParseError => e
+          rescue ::Leptris::XML::Error => e
+            # ParseError is the common class; other engine errors
+            # (invalid encoding bytes surface as the base class) are
+            # parse failures too — the facade names them all
+            # (taxonomy differential, malformed class).
             raise Moxml::ParseError.new(e.message)
           end
           attachments.set(native_doc, :entity_markers, false)
@@ -2265,9 +2454,19 @@ module Moxml
         def attribute_pairs(element)
           binding_element = to_binding(element)
           return super unless binding_element.respond_to?(:attribute_pairs)
-          return binding_element.attributes_snapshot.to_a if ELEMENT_ATTR_SNAPSHOT
 
-          binding_element.attribute_pairs
+          pairs = if ELEMENT_ATTR_SNAPSHOT
+                    binding_element.attributes_snapshot.to_a
+                  else
+                    binding_element.attribute_pairs
+                  end
+          # The engine exposes qualified names; the facade's listing
+          # face is bare (Attribute#name), uniform with every adapter.
+          pairs.map { |(name, value)| [local_name(name), value] }
+        end
+
+        def local_name(name)
+          name.include?(":") ? name.split(":", 2)[1] : name
         end
 
         def attribute_element(attr)
@@ -2544,6 +2743,15 @@ module Moxml
         end
 
         def add_child(parent, child)
+          result = add_child_impl(parent, child)
+          # A successful child insertion rebuilds the engine's
+          # document index; the upstream sibling-insert bug leaves it
+          # stale (see native_xpath), so a rebuild clears the guard.
+          clear_xpath_index_stale(parent) if result
+          result
+        end
+
+        def add_child_impl(parent, child)
           # Same-document Identity append — the builder hot path. One
           # document pair decides the verdict: the pin, the absorb
           # checks and the binding bridges only exist for
@@ -2656,6 +2864,12 @@ module Moxml
         end
 
         def add_previous_sibling(node, new_node)
+          result = add_previous_sibling_impl(node, new_node)
+          mark_xpath_index_stale(node)
+          result
+        end
+
+        def add_previous_sibling_impl(node, new_node)
           if NATIVE_READ_LAYER
             node = to_binding(node)
             new_node = to_binding(new_node)
@@ -2696,6 +2910,12 @@ module Moxml
         end
 
         def add_next_sibling(node, new_node)
+          result = add_next_sibling_impl(node, new_node)
+          mark_xpath_index_stale(node)
+          result
+        end
+
+        def add_next_sibling_impl(node, new_node)
           if NATIVE_READ_LAYER
             node = to_binding(node)
             new_node = to_binding(new_node)
@@ -2910,6 +3130,18 @@ module Moxml
         end
 
         def set_text_content(node, content)
+          # Native-layer fast path (leptris-ruby#460): the C setter
+          # takes document+address directly — no binding twin mint
+          # per write. The Identity wrapper's own content= would
+          # re-enter the facade, so call the module face.
+          if NATIVE_SET_BINDING_TEXT && node.is_a?(::Leptris::XML::NativeNode) &&
+              (doc = doc_for(node))
+            ::Leptris::XML::Native.set_binding_text(
+              doc, node.address, content.to_s
+            )
+            return
+          end
+
           node = to_binding(node) if NATIVE_READ_LAYER
           case node
           when ::Leptris::XML::Document
@@ -2959,16 +3191,20 @@ module Moxml
         end
 
         def processing_instruction_content(node)
+          # The model's PI content excludes the separating whitespace
+          # after the target (Nokogiri semantics; uniform across
+          # adapters — TODO.sota/02).
           if NATIVE_READ_LAYER && node.is_a?(NN)
             content = NN_CONTENT.bind_call(node)
             # NativeNode#content answers nil for PI-kind nodes too
             # (leptris-ruby#344 covers comments); bridge for the data.
-            return to_binding(node).content if content.nil?
+            return to_binding(node).content.to_s.sub(/\A\s+/, "") if
+              content.nil?
 
-            return content
+            return content.sub(/\A\s+/, "")
           end
 
-          node.content
+          node.content.to_s.sub(/\A\s+/, "")
         end
 
         def set_processing_instruction_content(node, content)
@@ -3104,6 +3340,12 @@ module Moxml
           # namespace-bound queries to the Ruby engine until the
           # engine grows correct prefix resolution.
           return nil if namespaces && !namespaces.empty?
+          # Reverse axes answer reverse-ordered from the native
+          # engine; route them to the Ruby engine (document order).
+          return nil if REVERSE_AXIS_CACHE.get_or_set(expression) do
+            expression_uses_reverse_axis?(expression)
+          end
+
           # The binding reports the root element parentless while moxml
           # roots it at the document, so parent-axis queries from the
           # root element keep the Ruby engine.
@@ -3119,6 +3361,9 @@ module Moxml
             ::Leptris::XML::XPath.compile(expression)
           end
           document = node.is_a?(::Leptris::XML::Document) ? node : node.document
+          # A sibling insertion left the engine index stale; the
+          # reference engine walks the live tree (see the guard above).
+          return nil if xpath_index_stale?(document)
 
           if namespaces && !namespaces.empty?
             # Namespace-bound evaluation has no raw-pointer entry —
@@ -3190,6 +3435,14 @@ module Moxml
             node.is_a?(::Leptris::XML::Element)
         end
 
+        # Reverse axes answer in reverse document order from the
+        # native engine; XPath path results are document-ordered (the
+        # model's order contract — TODO.sota/02, M3), so these
+        # expressions route to the Ruby engine, which orders them.
+        REVERSE_AXES = %w[ancestor ancestor-or-self preceding
+                          preceding-sibling parent].freeze
+        REVERSE_AXIS_CACHE = XPath::Cache.new(200)
+
         def expression_uses_parent_axis?(expression)
           ast = XPath::Parser.parse_with_cache(expression)
           contains_parent_axis?(ast)
@@ -3197,6 +3450,24 @@ module Moxml
           true
         end
 
+        def expression_uses_reverse_axis?(expression)
+          ast = XPath::Parser.parse_with_cache(expression)
+          contains_reverse_axis?(ast)
+        rescue XPath::SyntaxError
+          false
+        end
+
+        def contains_reverse_axis?(ast)
+          return true if ast.type == :parent
+          if ast.type == :axis && REVERSE_AXES.include?(ast.children.first)
+            return true
+          end
+
+          ast.children.any? do |child|
+            child.is_a?(XPath::AST::Node) && contains_reverse_axis?(child)
+          end
+        end
+
         def contains_parent_axis?(ast)
           return true if ast.type == :parent
           return true if ast.type == :axis && ast.children.first == "parent"
@@ -3366,13 +3637,12 @@ module Moxml
 
         def record_source_declaration(native_doc, xml_string)
           head = xml_string[0, 256]
-          had = if head.match?(SOURCE_DECLARATION_RE)
-                  true
-                elsif head.match?(/\A\s*\z/)
-                  xml_string.match?(SOURCE_DECLARATION_RE)
-                else
-                  false
-                end
+          # invalid bytes never reach regexes: named parse errors own
+          # malformed input (taxonomy differential, malformed class)
+          had = xml_string.valid_encoding? &&
+            (head.match?(SOURCE_DECLARATION_RE) ||
+             (head.match?(/\A\s*\z/) &&
+              xml_string.match?(SOURCE_DECLARATION_RE)))
           attachments.set(native_doc, :had_source_declaration, had)
         end
       end