moxml 0.5.12 → 0.5.14

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Adapter
+    class Leptris
+      module Markers
+        # Marker presence is a document-level fact: parse records it,
+        # the ER builder path flips it, and the split/restore scans
+        # consult it. Customized natives only exist as split products
+        # of marker-bearing text, so they always report true.
+        def entity_bearing?(native)
+          case native
+          when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
+             CustomizedLeptris::EntityReference, CustomizedLeptris::TextSegment,
+             CustomizedLeptris::DocumentPI
+            true
+          else
+            doc = native.document
+            doc.nil? || attachments.get(doc, :entity_markers) != false
+          end
+        end
+
+        # Expand marker-bearing text nodes into the child sequence the
+        # moxml contract exposes: text, EntityReference, text, ...
+        def split_entity_markers(natives, parent)
+          result = []
+          natives.each do |child|
+            # FFI Text#content returns a fresh unfrozen BINARY string:
+            # retag in place (dup would be a throwaway allocation), but
+            # before include? — BINARY.include? with the UTF-8 marker raises
+            if child.is_a?(::Leptris::XML::Text)
+              content = child.content
+              content.force_encoding("UTF-8")
+            end
+            if content&.include?(Entity::MARKER)
+              content.scan(/([^#{Entity::MARKER}]*)(?:#{Entity::MARKER}([\w.:-]+);)?/o) do
+                text_part = Regexp.last_match(1)
+                name = Regexp.last_match(2)
+                result << CustomizedLeptris::TextSegment.new(text_part, parent) unless text_part.empty?
+                result << CustomizedLeptris::EntityReference.new(name) if name
+              end
+            else
+              result << child
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Adapter
+    class Leptris
+      module Materialize
+        BINDING_FFI = ::Leptris::XML::FFI
+        private_constant :BINDING_FFI
+
+        EMPTY_FIELDS = Materializer::EMPTY_ATTRIBUTES
+
+        NODE_ELEMENT = ::Leptris::XML::FFI::NODE_ELEMENT
+        NODE_TEXT = ::Leptris::XML::FFI::NODE_TEXT
+        NODE_COMMENT = ::Leptris::XML::FFI::NODE_COMMENT
+        NODE_CDATA = ::Leptris::XML::FFI::NODE_CDATA
+        NODE_PI = ::Leptris::XML::FFI::NODE_PI
+        private_constant :NODE_ELEMENT, :NODE_TEXT, :NODE_COMMENT, :NODE_CDATA,
+                         :NODE_PI
+
+        # Reused child-pointer staging buffer capacity for the raw
+        # pointer walk. Elements with more children grow the buffer
+        # geometrically for the rest of the stream.
+        CHILDREN_CAPACITY = 64
+        private_constant :CHILDREN_CAPACITY
+
+        # Bulk materialization (issues #132/#143): a Ruby-side
+        # post-order recursion over RAW C pointers — no binding
+        # wrapper per node, no per-node FFI callback, no depth memo
+        # (depth is a recursion parameter), no record allocation.
+        # Child lists arrive through the batch leptris_node_children
+        # call; element fields are read straight off the C handles
+        # (the binding's own first/next attribute iteration face),
+        # skipping the per-attribute wrapper its public API
+        # allocates. The unprefixed-attribute namespace read is
+        # skipped because the answer is nil by definition
+        # (no-namespace attributes).
+        def bulk_materialize?
+          true
+        end
+
+        def materialize_fields(native, buffers, &block)
+          return nil unless Leptris::BULK_FIELD_READS
+
+          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)
+
+          root_ptr = if native.is_a?(::Leptris::XML::Document)
+                       doc.root&.c_ptr
+                     else
+                       native.c_ptr
+                     end
+          return nil unless root_ptr
+
+          walk_fields(root_ptr, 0, buffers,
+                      ::FFI::MemoryPointer.new(:pointer, CHILDREN_CAPACITY),
+                      &block)
+          true
+        end
+
+        def walk_fields(ptr, depth, buffers, child_buf, &block)
+          f = BINDING_FFI
+          capacity = CHILDREN_CAPACITY
+          count = f.leptris_node_children(ptr, child_buf, capacity)
+          while count == capacity
+            capacity *= 4
+            child_buf = ::FFI::MemoryPointer.new(:pointer, capacity)
+            count = f.leptris_node_children(ptr, child_buf, capacity)
+          end
+
+          # Snapshot before recursing — the recursion reuses this
+          # buffer for the next level's child list.
+          children = child_buf.read_array_of_pointer(count)
+
+          children.each do |child|
+            case f.leptris_node_get_type(child)
+            when NODE_ELEMENT
+              walk_fields(child, depth + 1, buffers, child_buf, &block)
+            when NODE_TEXT
+              yield(:text, nil, nil, nil, EMPTY_FIELDS, EMPTY_FIELDS, f.leptris_text_node_get_content(child), depth + 1)
+            when NODE_CDATA
+              yield(:cdata, nil, nil, nil, EMPTY_FIELDS, EMPTY_FIELDS, f.leptris_cdata_node_get_content(child), depth + 1)
+            when NODE_COMMENT
+              yield(:comment, nil, nil, nil, EMPTY_FIELDS, EMPTY_FIELDS, f.leptris_comment_node_get_content(child), depth + 1)
+            when NODE_PI
+              yield(:processing_instruction, f.leptris_pi_node_get_target(child), nil, nil, EMPTY_FIELDS, EMPTY_FIELDS, f.leptris_pi_node_get_data(child), depth + 1)
+            end
+          end
+
+          emit_element_fields(ptr, buffers, depth, &block)
+        end
+
+        def emit_element_fields(ptr, buffers, depth, &block)
+          f = BINDING_FFI
+          ns_buf = buffers.namespaces
+          attrs_buf = buffers.attributes
+
+          name = f.leptris_element_name(ptr)
+          prefix = f.leptris_element_prefix(ptr)
+          uri = f.leptris_element_namespace(ptr)
+          uri = nil if uri && uri.empty?
+
+          # Own declarations only — same shape as the generic path's
+          # Element#declared_namespaces (issue #138).
+          ns_buf.clear
+          i = 0
+          ns_count = f.leptris_element_namespace_count(ptr)
+          while i < ns_count
+            ns_buf << f.leptris_element_namespace_decl_prefix(ptr, i)
+            ns_buf << f.leptris_element_namespace_decl_uri(ptr, i)
+            i += 1
+          end
+
+          attrs_buf.clear
+          attr = f.leptris_element_first_attribute(ptr)
+          until attr.nil? || attr.null?
+            attr_name = f.leptris_attribute_get_name(attr)
+            attr_value = f.leptris_attribute_get_value(ptr, attr)
+            colon = attr_name.index(":")
+            if colon
+              attr_prefix = attr_name[0, colon]
+              # Local name + separate prefix, matching the generic
+              # path's resolver semantics (moxml's canonical shape).
+              attr_name = attr_name[(colon + 1)..]
+              attr_uri = f.leptris_attribute_namespace_uri(attr)
+            else
+              attr_prefix = nil
+              attr_uri = nil
+            end
+            attrs_buf << attr_name << attr_value << attr_uri << attr_prefix
+            attr = f.leptris_attribute_next(attr)
+          end
+
+          yield(:element, name, prefix, uri, ns_buf, attrs_buf, nil, depth)
+        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,135 @@
+# 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.
+          xml = normalize_serialization(raw_serialize(node, options), options)
+          # The binding's FFI strings come back binary-tagged; the
+          # engine encoded the bytes per this option, so tag them.
+          xml.force_encoding(options[:encoding]) if options[:encoding]
+          xml
+        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
+          xml = node.to_xml(
+            indent: options.fetch(:indent, 0),
+            no_decl: !include_decl,
+            encoding: options[:encoding],
+          )
+          # Element output always ends with the close tag — but the
+          # engine's serializer appends a stray trailing newline when
+          # the element's last text child is non-ASCII.
+          xml.sub(/\n+\z/, "")
+        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