moxml 0.5.114 → 0.5.115

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6cc0d0436680fb9c46169bc93e45197b20b71bf6970d737750e63fb110a5e75e
-  data.tar.gz: 8f71ca799b845b4fb28a977f6515ac1b702b6557259667c5b034f5b612ef6b67
+  metadata.gz: 3269b76bcc581101e3b7f6219c58fc5010752ab1af4f4bb35b8e505989f08e04
+  data.tar.gz: 1c255835027897f446de2bb88b175a5b71432636b2a7ab3810480323865a4dac
 SHA512:
-  metadata.gz: 1edf604a33151f0079608d52231a1486a252cda307f49fd958e05f41e3229394a952245159939c2f4dac67ecba9f612ef6c4718d7f450c3260e1f78fc4d83135
-  data.tar.gz: 92aeae211e0b8abae0ce569c9dbd650f3b2b8426e975a42e3341317ebeb6c09928adbb0265b2ea7cdb726ca40d9ac376be1e537200d2166255fc30f365afd7ed
+  metadata.gz: 12d97fd4ae488aee81c5e04e5b55be1336bea7bad60f14fc2481ee9fdd80689edac7dfc3113a6dc65be605a555d388d10e89566a206993c84438d0fcbd9e8d41
+  data.tar.gz: 1bf50772dde870a02dd80c1d4d686d2d47149b1d4b9210113bed8e2732dec6c48291105ee26969c92c1d46d6f7086931516c0f6110ce868d662cb2bfa1ea2871

data/lib/moxml/adapter/base.rb

@@ -13,6 +13,18 @@ module Moxml
       class << self
         include XmlUtils
 
+        # Binding-level markup-accumulating builder face
+        # (leptris 1.9.313, #374 lever 2): nil = the adapter has no
+        # face and the Builder takes the per-node tree path.
+        def builder_face(_native_document)
+          nil
+        end
+
+        # A built subtree carried entity references as marker text —
+        # arm the document's marker restoration (the entity
+        # preservation contract).
+        def mark_entity_markers(_native_document); end
+
         def preprocess_entities(xml)
           Entity.preprocess_entities(xml)
         end

data/lib/moxml/adapter/leptris.rb

@@ -161,6 +161,16 @@ module Moxml
         ::Leptris::XML::Document.method_defined?(:absorb) &&
         Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.311.3")
 
+      # Markup-accumulating builder face (leptris-ruby#374 lever 2,
+      # binding 1.9.313): the DSL accumulates markup in a plain
+      # String and ONE native crossing (parse + attach) flushes the
+      # whole subtree. See Adapter::Base#builder_face.
+      NATIVE_BUILDER =
+        defined?(::Leptris::XML::Builder) &&
+        defined?(::Leptris::XML::Document) &&
+        ::Leptris::XML::Document.method_defined?(:build) &&
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.313.0")
+
       # XSLT 1.0/2.0/3.0 through the engine's compiled-stylesheet
       # faces (Moxml::XSLT contract). Top-level parameters are not
       # threaded through the faces yet (leptris-ruby#360) — non-empty
@@ -208,6 +218,27 @@ module Moxml
         # (and on installs without the native layer — the constant
         # check short-circuits), a Node.wrap over the shared C
         # pointer for NativeNodes.
+        def builder_face(native_document)
+          return nil unless NATIVE_BUILDER && NATIVE_READ_LAYER
+
+          doc = if native_document.is_a?(NN)
+                  to_binding(native_document)
+                else
+                  native_document
+                end
+          ::Leptris::XML::Builder.new(doc)
+        end
+
+        def mark_entity_markers(native_document)
+          doc = if native_document.is_a?(NN)
+                  to_binding(native_document)
+                else
+                  native_document
+                end
+          attachments.set(doc, :entity_markers, true)
+          bump_serialize_generation
+        end
+
         def to_binding(node)
           return node unless NATIVE_READ_LAYER &&
             node.is_a?(::Leptris::XML::NativeNode)

data/lib/moxml/builder.rb

@@ -11,14 +11,40 @@ module Moxml
       @context = context
       @current = @document = context.create_document
       @namespaces = {}
+      # Markup-accumulating face (leptris 1.9.313, #374 lever 2):
+      # leaf DSL ops write markup into one String and a single
+      # native crossing flushes the whole subtree at build end.
+      # Tree-only ops (declaration/doctype/PI/entity/namespace)
+      # flush first and run on the document; the face retires after
+      # its first flush.
+      @face = context.config.adapter.builder_face(@document.native)
+      @face_stack = []
+      @face_counts = Hash.new(0)
+      @face_deferred = []
+      @face_entity_markers = false
     end
 
     def build(&block)
       instance_eval(&block)
+      flush_face
       @document
     end
 
+    # Element ops inside a face-accumulated subtree cannot touch the
+    # tree yet (nothing exists until the flush): PIs ride the raw
+    # hatch in exact position; namespace/entity/declaration/doctype
+    # defer to the flush and re-target their element by position (an
+    # element's namespace set is unordered, so deferral is exact;
+    # deferred children land at their element's end).
+    def face_defer(operation, args)
+      @face_deferred << [operation, args, @face_stack.dup]
+    end
+
     def declaration(version: "1.0", encoding: "UTF-8", standalone: nil)
+      args = [version, encoding, standalone]
+      return face_defer(:declaration, args) if @face && @face_stack.any?
+
+      flush_face
       @current.add_child(
         @document.create_declaration(version, encoding, standalone),
       )
@@ -41,34 +67,65 @@ module Moxml
     end
 
     def text(content)
+      return face_content { @face.text(content) } if @face
+
       @current.add_child(@document.create_text(content))
     end
 
     def cdata(content)
+      return face_content { @face.cdata(content) } if @face
+
       @current.add_child(@document.create_cdata(content))
     end
 
     def comment(content)
+      return face_content { @face.comment(content) } if @face
+
       @current.add_child(@document.create_comment(content))
     end
 
     def entity_reference(name)
+      # In-position through the marker face: the reference lands as
+      # marker text exactly where the DSL puts it, and the flush
+      # arms the document's entity-marker restoration.
+      if @face && @face_stack.any?
+        @face.raw("#{Entity::MARKER}#{name};")
+        @face_entity_markers = true
+        return
+      end
+
+      flush_face
       @current.add_child(@document.create_entity_reference(name))
     end
 
     def processing_instruction(target, content)
+      if @face
+        if @face_stack.empty?
+          flush_face
+        else
+          @face.raw("<?#{target} #{content}?>")
+          return
+        end
+      end
       @current.add_child(
         @document.create_processing_instruction(target, content),
       )
     end
 
     def namespace(prefix, uri)
+      return face_defer(:namespace, [prefix, uri]) if @face && @face_stack.any?
+
+      flush_face
       @current.add_namespace(prefix, uri)
       @namespaces[prefix] = uri
     end
 
     # Convenience method for DOCTYPE
     def doctype(name, external_id = nil, system_id = nil)
+      args = [name, external_id, system_id]
+      return face_defer(:doctype, args) if @face && @face_stack.any?
+
+      flush_face
       @current.add_child(
         @document.create_doctype(name, external_id, system_id),
       )
@@ -109,13 +166,139 @@ module Moxml
       true
     end
 
+    FACE_NAME = /\A[a-zA-Z_][\w.-]*\z/
+    FACE_ESCAPE = { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;",
+                    '"' => "&quot;" }.freeze
+    FACE_ESCAPE_RE = /[&<>"]/
+
     private
 
+    # One face.element per DSL element — the face opens/closes the
+    # markup around the block itself, so nesting is free. Prefixed
+    # names (p:tag) fall outside the face's name shape and ride the
+    # raw hatch with manual escaping. Returns no wrapper: nothing
+    # exists until the flush.
+    def face_element(tag_name, attrs, text_content, block, eval_block)
+      unless FACE_NAME.match?(tag_name)
+        return face_raw_element(tag_name, attrs, text_content, block,
+                                eval_block)
+      end
+
+      face_attrs = {}
+      attrs.each do |key, value|
+        k = key.to_s
+        if k == "xmlns" || k.start_with?("xmlns:")
+          face_attrs[k] = value.to_s
+          @namespaces[k.delete_prefix("xmlns:")] = value.to_s
+        else
+          face_attrs[k] = value
+        end
+      end
+      ordinal = @face_counts[@face_stack.length]
+      @face_counts[@face_stack.length] = ordinal + 1
+      @face_stack << ordinal
+      begin
+        @face.element(tag_name, face_attrs) do
+          @face.text(text_content) if text_content
+          run_builder_block(block, eval_block) if block
+        end
+      ensure
+        @face_stack.pop
+        @face_counts.delete(@face_stack.length + 1)
+      end
+    end
+
+    def face_raw_element(tag_name, attrs, text_content, block, eval_block)
+      open = "<#{tag_name}"
+      attrs.each do |key, value|
+        k = key.to_s
+        if k == "xmlns" || k.start_with?("xmlns:")
+          @namespaces[k.delete_prefix("xmlns:")] = value.to_s
+        end
+        open << " " << k << '="' << face_escape(value) << '"'
+      end
+      ordinal = @face_counts[@face_stack.length]
+      @face_counts[@face_stack.length] = ordinal + 1
+      @face_stack << ordinal
+      begin
+        if block || text_content
+          @face.raw("#{open}>")
+          @face.text(text_content) if text_content
+          run_builder_block(block, eval_block) if block
+          @face.raw("</#{tag_name}>")
+        else
+          @face.raw("#{open}/>")
+        end
+      ensure
+        @face_stack.pop
+        @face_counts.delete(@face_stack.length + 1)
+      end
+    end
+
+    # Content at document level has no root to attach to and the
+    # Document face flush demands exactly one root — retire the face
+    # and take the tree path (legacy semantics: doc-level text is a
+    # document child). Inside a subtree the text accumulates in
+    # position; @current never leaves the document in face mode, so
+    # the face stack is the nesting test.
+    def face_content
+      return yield if @face && @face_stack.any?
+
+      flush_face if @face
+    end
+
+    def run_builder_block(block, eval_block)
+      eval_block ? instance_eval(&block) : block.call
+    end
+
+    def face_escape(value)
+      value.to_s.gsub(FACE_ESCAPE_RE, FACE_ESCAPE)
+    end
+
+    def flush_face
+      return unless @face
+
+      face = @face
+      @face = nil
+      face.flush
+      if @face_entity_markers
+        @context.config.adapter.mark_entity_markers(@document.native)
+      end
+      apply_face_deferred
+    end
+
+    # Deferred tree-ops re-target their element by position: the
+    # stack records each element's ordinal among its parent's
+    # elements, and the flushed tree preserves markup order.
+    def apply_face_deferred
+      @face_deferred.each do |op, args, stack|
+        target = @document.root
+        stack[1..].each do |ordinal|
+          target = target.elements.to_a[ordinal]
+        end
+        case op
+        when :namespace
+          target.add_namespace(*args)
+          @namespaces[args[0]] = args[1]
+        when :declaration
+          target.add_child(@document.create_declaration(*args))
+        when :doctype
+          target.add_child(@document.create_doctype(*args))
+        end
+      end
+      @face_deferred = []
+    end
+
     # Single method for all element creation.
     # eval_block: true  → instance_eval (build DSL context)
     # eval_block: false → yield (preserves caller's self)
     def create_element_node(tag_name, attrs = {}, text_content: nil,
 block: nil, eval_block: true)
+      if @face
+        face_element(tag_name, attrs, text_content, block, eval_block)
+        return nil
+      end
+
       el = @document.create_element(tag_name)
 
       attrs.each do |key, value|

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.5.114"
+  VERSION = "0.5.115"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.114
+  version: 0.5.115
 platform: ruby
 authors:
 - Ribose Inc.