moxml 0.5.12 → 0.5.13

data/lib/moxml/adapter/leptris/materialize.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Adapter
+    class Leptris
+      module Materialize
+        # Bulk materialization (issue #132): leptris_node_traverse
+        # walks the subtree with one FFI call; the only per-node cost
+        # is the C->Ruby callback and the property reads below. No
+        # Moxml::Node or Attribute wrapper is allocated.
+        def bulk_materialize?
+          true
+        end
+
+        def materialize_records(native, &block)
+          doc = native.is_a?(::Leptris::XML::Document) ? native : native.document
+          # Marker-bearing text needs the split pipeline (children-level
+          # ER expansion); the bulk path has no marker handling.
+          return nil if doc.nil? || attachments.get(doc, :entity_markers)
+
+          # On bindings whose traverse follows the document chain
+          # (leptris 1.9.28–1.9.31), element materialize falls back to
+          # the generic wrapper walk — only document materialization
+          # can filter safely there (issue #140).
+          root = if native.is_a?(::Leptris::XML::Document)
+                   doc.root
+                 else
+                   return nil unless TRAVERSE_SUBTREE_BOUNDED
+
+                   native
+                 end
+          return nil if root.nil?
+
+          depth_memo = {}.compare_by_identity
+          root.traverse do |node|
+            depth = material_depth_in_subtree(node, root, depth_memo)
+            next if depth.nil?
+
+            record = case node
+                     when ::Leptris::XML::Element
+                       element_material_record(node, depth)
+                     when ::Leptris::XML::CDATA
+                       # CDATA < Text in the binding: this arm must come
+                       # first or CDATA content reports as text.
+                       text_material_record(:cdata, node.content, depth)
+                     when ::Leptris::XML::Text
+                       text_material_record(:text, node.content, depth)
+                     when ::Leptris::XML::Comment
+                       text_material_record(:comment, node.content, depth)
+                     when ::Leptris::XML::ProcessingInstruction
+                       text_material_record(:processing_instruction, node.content, depth)
+                         .merge(qname: node.target)
+                     end
+            yield(record) if record
+          end
+          true
+        end
+
+        def element_material_record(node, depth)
+          attributes = node.each_attribute.map do |attr|
+            # Local name + separate prefix, matching the generic
+            # path's resolver semantics (moxml's canonical shape).
+            name = attr.name
+            prefix = attr.prefix
+            name = name.split(":", 2)[1] || name if prefix
+            [name, attr.value, attr.namespace_uri, prefix]
+          end
+          ns = node.namespace
+          # Own declarations only — same shape as the generic
+          # path's Element#declared_namespaces (issue #138).
+          decls = node.namespace_definitions.map { |d| [d.prefix, d.href] }
+          Materializer::Record.element(
+            qname: node.name,
+            prefix: node.prefix,
+            namespace_uri: ns&.href,
+            namespaces: decls.empty? ? Materializer::EMPTY_ATTRIBUTES : decls,
+            attributes: attributes,
+            depth: depth,
+          )
+        end
+
+        def text_material_record(kind, text, depth)
+          Materializer::Record.text(kind: kind, text: text, depth: depth)
+        end
+
+        # Depth relative to the subtree root, or nil when the node
+        # lies outside it (traverse follows the document chain since
+        # leptris 1.9.28, so epilog siblings can appear in the
+        # stream). Binding wrappers are address-stable and #parent is
+        # memoized, so each edge resolves once through the
+        # identity-keyed memo.
+        def material_depth_in_subtree(node, root, memo)
+          memo[node] ||= if node.equal?(root)
+                           0
+                         else
+                           parent = node.parent
+                           if parent.nil? || parent.is_a?(::Leptris::XML::Document)
+                             nil
+                           else
+
+                             parent_depth = material_depth_in_subtree(parent, root, memo)
+                             parent_depth.nil? ? nil : parent_depth + 1
+
+                           end
+                         end
+        end
+      end
+    end
+  end
+end

data/lib/moxml/adapter/leptris/sax_bridge.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Adapter
+    class Leptris
+      # Bridge between the leptris SAX callbacks and Moxml::SAX::Handler.
+      #
+      # @private
+      class LeptrisSAXBridge < ::Leptris::XML::SAX::Document
+        include Moxml::SAX::NamespaceSplitter
+
+        def initialize(handler)
+          @handler = handler
+          super()
+        end
+
+        def start_document
+          @handler.on_start_document
+        end
+
+        def end_document
+          @handler.on_end_document
+        end
+
+        def start_element(name, attrs = [])
+          attr_hash, ns_hash = split_attributes_and_namespaces(attrs)
+          @handler.on_start_element(name, attr_hash, ns_hash)
+        end
+
+        def end_element(name)
+          @handler.on_end_element(name)
+        end
+
+        def characters(string)
+          @handler.on_characters(string)
+        end
+
+        def comment(string)
+          @handler.on_comment(string)
+        end
+
+        def cdata_block(string)
+          @handler.on_cdata(string)
+        end
+
+        def processing_instruction(name, content)
+          @handler.on_processing_instruction(name, content || "")
+        end
+
+        def error(message, _line = 0, _column = 0)
+          @handler.on_error(Moxml::ParseError.new(message))
+        end
+      end
+    end
+  end
+end

data/lib/moxml/adapter/leptris/serialize.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Adapter
+    class Leptris
+      # Wire-format knowledge: the C serializer entry, the
+      # canonicalization pass (apostrophes stay literal, optional
+      # empty-element expansion), and the literal-region scanner that
+      # keeps both from touching CDATA/comment/PI content.
+      module Serialize
+        # moxml canonical serialization: apostrophes stay literal
+        # (only & < > " are escaped) and empty elements expand when the
+        # caller asked for it — matching the other adapters' contract.
+        # Runs segment-aware: CDATA content is literal and must not be
+        # touched.
+        # Regions whose content is literal and must never be rewritten.
+        # Scanned positionally (String#index), not with a regex: the
+        # scan is linear in the input length, so pathological document
+        # content cannot blow up the serializer.
+        LITERAL_REGIONS = {
+          "<!--" => "-->",
+          "<![CDATA[" => "]]>",
+          "<?" => "?>",
+        }.freeze
+
+        # All quantifiers are possessive and the bare-part class
+        # excludes "/" and ">": the possessive groups can never consume
+        # the closing delimiter, so no backtracking is possible and the
+        # match is linear even on malformed tags.
+        EMPTY_ELEMENT_RE = %r{<([A-Za-z_][\w.:-]*+)((?:"[^"]*+"|'[^']*+'|[^<>"'/]++)*+)/>}
+
+        def serialize(node, options = {})
+          # Entity restoration belongs to the wrapper layer
+          # (Node#to_xml runs adapter.restore_entities for every
+          # adapter); doing it here scanned the output a second time.
+          normalize_serialization(raw_serialize(node, options), options)
+        end
+
+        def raw_serialize(node, options)
+          # CDATA must precede Text in this chain: CDATA < Text in the
+          # binding, so a Text branch first would swallow CDATA nodes.
+          case node
+          when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
+               CustomizedLeptris::EntityReference, CustomizedLeptris::DocumentPI
+            return node.to_xml
+          when ::Leptris::XML::CDATA
+            return XmlEmitter.cdata(node.content)
+          when ::Leptris::XML::Comment
+            return "<!--#{node.content}-->"
+          when ::Leptris::XML::ProcessingInstruction
+            content = node.content.to_s
+            return content.empty? ? "<?#{node.target}?>" : "<?#{node.target} #{content}?>"
+          when ::Leptris::XML::Text, CustomizedLeptris::TextSegment
+            return XmlEmitter.escape_text(node.content.to_s)
+          when ::Leptris::XML::Document
+            return serialize_document(node, options)
+          end
+
+          include_decl = options.fetch(:declaration) do
+            options[:no_declaration] ? false : document_has_declaration?(node)
+          end
+          node.to_xml(
+            indent: options.fetch(:indent, 0),
+            no_decl: !include_decl,
+            encoding: options[:encoding],
+          )
+        end
+
+        def normalize_serialization(xml, options)
+          needs_apos = xml.include?("&apos;")
+          needs_expand = options[:expand_empty] && xml.include?("/>")
+          return xml unless needs_apos || needs_expand
+
+          out = +""
+          pos = 0
+          while pos < xml.length
+            opener_at, terminator = next_literal_region(xml, pos)
+            if opener_at.nil?
+              out << normalize_markup(xml[pos..], needs_apos, needs_expand)
+              break
+            end
+
+            out << normalize_markup(xml[pos...opener_at], needs_apos, needs_expand)
+            search_from = opener_at + opener_at_offset(terminator)
+            close = xml.index(terminator, search_from)
+            close_end = close.nil? ? xml.length : close + terminator.length
+            out << xml[opener_at...close_end]
+            pos = close_end
+          end
+          out
+        end
+
+        # Nearest literal region at/after from: [position, terminator].
+        def next_literal_region(xml, from)
+          best = nil
+          best_terminator = nil
+          LITERAL_REGIONS.each do |opener, terminator|
+            idx = xml.index(opener, from)
+            next if idx.nil?
+
+            if best.nil? || idx < best
+              best = idx
+              best_terminator = terminator
+            end
+          end
+          best.nil? ? nil : [best, best_terminator]
+        end
+
+        # Search for a terminator past its opener's overlap-safe offset
+        # ("-->" cannot start inside "<!--").
+        def opener_at_offset(terminator)
+          terminator == "-->" ? 4 : 0
+        end
+
+        def normalize_markup(markup, needs_apos, needs_expand)
+          markup = markup.gsub("&apos;", "'") if needs_apos
+          if needs_expand
+            markup = markup.gsub(EMPTY_ELEMENT_RE) do
+              "<#{Regexp.last_match(1)}#{Regexp.last_match(2)}></#{Regexp.last_match(1)}>"
+            end
+          end
+          markup
+        end
+      end
+    end
+  end
+end