moxml 0.5.130 → 0.5.132

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2f099a606cb34b83d050cd7127593bc1403b3c2ae0d75f1d2d5afaad0107177
-  data.tar.gz: 1d1d777052f784a68363fc7efee322aeb53cfea53781927df1c0e424a165327e
+  metadata.gz: 6e9c4fec61c2e21eec26368889b888c8cdf1b3c553161bafc0334861cef93529
+  data.tar.gz: 0d32dcd44ab21957f09078af75e147005d1da6a67a72a17626d488757c6a305c
 SHA512:
-  metadata.gz: 28d300923fb7a5225aae5241ccbf3af90269ce73258ce1351260fb437df8a70f390a889fcccc98556202fcbcda15a0dbc2b1a9a8ab753e54f81d79a4132ab431
-  data.tar.gz: f8085292e7b0bad93fc80075f1b1e6422021afb972dd11fd9088798b254cff3268068a7ae8786a29511440e7b716c6f48550671bebd772e34c6b509c96357f84
+  metadata.gz: 1d8da6f131247d4a9b61bc119e85ec19096bdc8769e35ec545f35da657d23556fb22b9d7b8e00c68684aa875a46134fb3d8845526d123f7d4379ef174ff70a8e
+  data.tar.gz: a8d0a826db5dd0de0febc05189048a86f7c23a2f8cb028395d6add3500f331b18d104498a1880c7e28e8786b81aab8beb2b9af8ae9e101b1c13755a3fdbe03ac

data/Gemfile

@@ -9,7 +9,7 @@ gemspec
 gem "benchmark"
 gem "benchmark-ips"
 gem "get_process_mem"
-gem "leptris", "~> 1.9.343"
+gem "leptris", "~> 1.9.345"
 gem "libxml-ruby", ">= 5.0"
 gem "nokogiri", "~> 1.18"
 gem "openssl", "~> 3.0"

data/lib/moxml/adapter/leptris.rb

@@ -182,6 +182,18 @@ module Moxml
         defined?(::Leptris::HTML) &&
         ::Leptris::HTML.respond_to?(:parse_fragment)
 
+      # The engine's recovery mode (moxml#369, engine leptris#1660
+      # via binding 1.9.344.0): non-strict parses pass recover:
+      # true and keep the best-effort tree (libxml2
+      # XML_PARSE_RECOVER semantics — mismatched closers close
+      # intermediates, unclosed elements close at EOF) instead of
+      # the rescue-to-empty fallback. The kwarg probe pairs the
+      # floor (a binding without the kwarg cannot arm).
+      RECOVER_MODE =
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.344.0") &&
+        ::Leptris::XML::ParseOptions.instance_method(:initialize)
+          .parameters.any? { |_, key| key == :recover }
+
       # 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
@@ -1031,23 +1043,45 @@ module Moxml
           # multi-pass consumers (comparison, diff, signature).
           # dtdattr: true opts into DTD ATTLIST default materialization
           # (off by default since libleptris 1.9.8, matching libxml2).
+          # #369: non-strict parses RECOVER on engines that carry
+          # the mode (1.9.344+) — the best-effort tree survives
+          # recoverable structural errors (libxml2
+          # XML_PARSE_RECOVER semantics). Strict callers never
+          # recover: malformed input raises. Direct adapter calls
+          # are caller-owned-options by contract (Context applies
+          # config.strict_parsing; bypassing it means the caller
+          # chose the mode).
+          recover = !options[:strict] && RECOVER_MODE
           native_doc = begin
             ::Leptris::XML::Document.parse(
               processed,
               readonly: options[:readonly] == true,
-              options: parse_flags(options, context: _context),
+              options: parse_flags(options, recover: recover,
+                                            context: _context),
             )
           rescue ::Leptris::XML::ParseError => e
-            # libleptris has no recovery mode that survives unclosed
-            # tags; non-strict callers get an empty document, matching
-            # the Libxml adapter's non-strict behavior. The fatal
-            # error rides the document as parse diagnostics (issue
-            # #147) — otherwise nothing says why it came back empty.
             raise Moxml::ParseError.new(e.message) if options[:strict]
 
+            # Engines below the 1.9.344 recover floor (or the
+            # residual unrecoverable edges, e.g. trailing content
+            # after the root close) have no best-effort tree: the
+            # empty-document fallback stands, with the fatal error
+            # as parse diagnostics (issue #147) — otherwise nothing
+            # says why it came back empty.
             recover_errors = [e.message]
             create_document
           end
+          if recover && native_doc.root.nil? && !recover_errors
+            # The recover path answers a rootless document for
+            # input with nothing to recover into (whitespace-only,
+            # declaration-only) — libxml2's recover behaves the
+            # same. Surface WHY on parse_errors so consumers report
+            # it instead of silently holding an empty tree.
+            recover_errors =
+              ["leptris parse recovered no document root " \
+               "(empty or whitespace-only input)"]
+          end
+
           register_mint_klasses!(native_doc)
           ctx = _context || Context.new(:leptris)
           doc = Wrappers::Document.new(native_doc, ctx)
@@ -1191,7 +1225,7 @@ module Moxml
           ::Leptris::XML::ParseOptions.const_defined?(:SKIP_DUP_DETECTION) &&
           ::Leptris::XML::ParseOptions.const_defined?(:SKIP_SOURCE_POSITIONS)
 
-        def parse_flags(options, context: nil)
+        def parse_flags(options, recover: false, context: nil)
           flags = 0
           flags |= ::Leptris::XML::ParseOptions::DTDATTR if options[:dtdattr] == true
           flags |= ::Leptris::XML::ParseOptions::KEEP_ENTITY_REFS if NATIVE_ENTITY_REFS &&
@@ -1203,6 +1237,13 @@ module Moxml
             flags |= po::SKIP_DUP_DETECTION if options[:skip_dup_detection] == true
             flags |= po::SKIP_SOURCE_POSITIONS if options[:skip_source_positions] == true
           end
+          if recover
+            # #369: flags and the recover kwarg ride the same
+            # options struct (leptris-ruby's constructor composes
+            # both).
+            return ::Leptris::XML::ParseOptions.new(flags, recover: true)
+          end
+
           flags.zero? ? nil : ::Leptris::XML::ParseOptions.new(flags)
         end
 

data/lib/moxml/builder.rb

@@ -7,7 +7,7 @@ module Moxml
     attr_reader :document
     alias_method :doc, :document
 
-    def initialize(context)
+    def initialize(context, strict: nil)
       @context = context
       @current = @document = context.create_document
       @namespaces = {}
@@ -22,6 +22,22 @@ module Moxml
       @face_counts = Hash.new(0)
       @face_deferred = []
       @face_entity_markers = false
+      # #371: strict mode — unknown methods raise instead of
+      # silently becoming empty elements. Per-build override
+      # (Context#build(strict:)), else the context's
+      # config.builder_strict.
+      @strict = strict.nil? ? context.config.builder_strict : strict
+    end
+
+    def strict?
+      @strict == true
+    end
+
+    # The tag-creation face NamespacedTags calls — the private
+    # create_element_node stays private.
+    def create_tag(tag_name, attrs = {}, text_content: nil, block: nil)
+      create_element_node(tag_name, attrs, text_content: text_content,
+                                           block: block, eval_block: false)
     end
 
     def build(&block)
@@ -30,6 +46,61 @@ module Moxml
       @document
     end
 
+    # Namespace-scoped tag syntax (#371, Nokogiri's xml["p"].tag
+    # parity): xml["w"].p creates <w:p>. The proxy creates through
+    # the same face as plain method_missing — caller-context
+    # blocks, text/attributes arguments, trailing-underscore
+    # escape — and honors the strict mode.
+    def [](namespace_prefix)
+      raise ArgumentError, "namespace prefix required" if namespace_prefix.nil? || namespace_prefix.to_s.empty?
+
+      NamespacedTags.new(self, namespace_prefix.to_s)
+    end
+
+    # Tag proxy bound to one namespace prefix. method_missing maps
+    # tag names to prefixed element creation; explicit Builder
+    # methods (text, element, ...) stay reachable by holding the
+    # builder — the proxy is tags-only by design.
+    class NamespacedTags
+      def initialize(builder, prefix)
+        @builder = builder
+        @prefix = prefix
+      end
+
+      def [](nested_prefix)
+        NamespacedTags.new(@builder, "#{@prefix}:#{nested_prefix}")
+      end
+
+      def method_missing(method_name, *args, &block)
+        # Trailing-underscore escape, same as plain Builder tags
+        # (type_ → type under the prefix).
+        tag = "#{@prefix}:#{method_name.to_s.chomp('_')}"
+        if @builder.strict?
+          raise NoMethodError,
+                "builder strict mode: unknown tag #{tag.inspect} " \
+                "would have silently created an empty element (#371)"
+        end
+
+        text_content = args.first.is_a?(String) ? args.shift : nil
+        attrs = args.first.is_a?(Hash) ? args.shift : {}
+        unless args.empty?
+          raise ArgumentError,
+                "unexpected arguments for #{tag}: #{args.inspect}"
+        end
+        if text_content && block
+          raise ArgumentError,
+                "#{tag}: cannot combine text content with a block"
+        end
+
+        @builder.create_tag(tag, attrs,
+                            text_content: text_content, block: block)
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        true
+      end
+    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
@@ -139,6 +210,13 @@ module Moxml
     def method_missing(method_name, *args, &block)
       return super if RESERVED_METHOD_PATTERN.match?(method_name.to_s)
 
+      if @strict
+        raise NoMethodError,
+              "builder strict mode: unknown method #{method_name.inspect} " \
+              "would have silently created an empty <#{method_name}> element " \
+              "(#371); call a Builder method or use the explicit element face"
+      end
+
       text_content = args.first.is_a?(String) ? args.shift : nil
       attrs = args.first.is_a?(Hash) ? args.shift : {}
 

data/lib/moxml/config.rb

@@ -114,6 +114,7 @@ module Moxml
 
     attr_reader :adapter_name, :default_line_ending
     attr_accessor :strict_parsing,
+                  :builder_strict,
                   :default_encoding,
                   :default_indent,
                   :restore_entities,
@@ -173,6 +174,11 @@ module Moxml
       @entity_provider = nil
       @namespace_validation_mode = :strict
       @entity_restoration_mode = :lenient
+      # #371: Builder method_missing creates elements for unknown
+      # methods (the DSL contract). builder_strict flips that to
+      # raising NoMethodError — external helper calls stop
+      # silently becoming empty elements.
+      @builder_strict = false
       @entity_mode = :expand
     end
 

data/lib/moxml/context.rb

@@ -275,8 +275,11 @@ module Moxml
       config.adapter.sax_parse(xml, handler)
     end
 
-    def build(&block)
-      Builder.new(self).build(&block)
+    # strict: (issue #371) flips unknown method_missing calls to
+    # NoMethodError instead of silently creating empty elements —
+    # nil defers to config.builder_strict.
+    def build(strict: nil, &block)
+      Builder.new(self, strict: strict).build(&block)
     end
 
     # Frozen serialization defaults, memoized per context — Node#to_xml

data/lib/moxml/version.rb

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

data/spec/moxml/adapter/leptris_spec.rb

@@ -595,11 +595,24 @@ RSpec.describe Moxml::Adapter::Leptris do
   describe "recover-path parse diagnostics" do
     let(:ctx) { Moxml.new(:leptris) }
 
-    it "records the fatal error on non-strict parses" do
-      doc = ctx.parse("<root><unclosed>", strict: false)
-      expect(doc.root).to be_nil
-      expect(doc.parse_errors).not_to be_empty
-      expect(doc.parse_errors).to all(be_a(String))
+    it "records the fatal error on non-strict parses below the recover floor" do
+      unless Moxml::Adapter::Leptris::RECOVER_MODE
+        doc = ctx.parse("<root><unclosed>", strict: false)
+        expect(doc.root).to be_nil
+        expect(doc.parse_errors).not_to be_empty
+        expect(doc.parse_errors).to all(be_a(String))
+      end
+    end
+
+    it "recovers an unclosed root at the floor (#369)" do
+      if Moxml::Adapter::Leptris::RECOVER_MODE
+        doc = ctx.parse("<root><unclosed>", strict: false)
+        expect(doc.root).not_to be_nil
+        # recovery diagnostics ride parse_errors once leptris-ruby
+        # #1200's DOM face lands; today the recovered tree is the
+        # contract.
+        expect(doc.parse_errors).to eq([])
+      end
     end
 
     it "answers [] on clean parses" do

data/spec/moxml/builder_namespaces_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# #371: Builder sharp edges — the namespace-scoped tag proxy
+# (Nokogiri's xml["p"].tag parity) and the strict mode where
+# unknown methods raise instead of silently becoming empty
+# elements.
+RSpec.describe "Builder namespaces + strict mode (#371)" do
+  describe "Builder#[] namespace-scoped tags" do
+    it "creates prefixed elements with text and attributes" do
+      doc = Moxml.new.build do
+        element("root") do
+          self["w"].p("text", "a" => 1)
+        end
+      end
+      expect(doc.root.children.first.name).to eq("w:p")
+      expect(doc.to_xml).to include(%(<w:p a="1">text</w:p>))
+    end
+
+    it "nests blocks in the caller context" do
+      doc = Moxml.new.build do
+        element("root") do
+          self["w"].sub { self["w"].deep("x") }
+        end
+      end
+      sub = doc.root.children.first
+      expect(sub.name).to eq("w:sub")
+      expect(sub.children.first.name).to eq("w:deep")
+      expect(sub.children.first.text).to eq("x")
+    end
+
+    it "strips the trailing-underscore escape under the prefix" do
+      doc = Moxml.new.build do
+        element("root") { self["epub"].type_ }
+      end
+      expect(doc.to_xml).to include("<epub:type>")
+    end
+
+    it "composes prefixes through nested []" do
+      doc = Moxml.new.build do
+        element("root") { self["w"]["ext"].node }
+      end
+      expect(doc.to_xml).to include("<w:ext:node>")
+    end
+
+    it "rejects a missing prefix" do
+      expect { Moxml.new.build { self[nil] } }
+        .to raise_error(ArgumentError, /prefix/)
+    end
+  end
+
+  describe "strict mode" do
+    it "raises NoMethodError for unknown methods (the silent-corruption fix)" do
+      expect do
+        Moxml.new.build(strict: true) do
+          element("root") { build_chart_type_unused }
+        end
+      end.to raise_error(NoMethodError, /build_chart_type_unused/)
+    end
+
+    it "raises for unknown namespaced tags too" do
+      expect do
+        Moxml.new.build(strict: true) do
+          element("root") { self["w"].chart_helper }
+        end
+      end.to raise_error(NoMethodError, /w:chart_helper/)
+    end
+
+    it "still builds known tags under strict" do
+      doc = Moxml.new.build(strict: true) do
+        element("root") { text "ok" }
+      end
+      expect(doc.to_xml).to include("<root>ok</root>")
+    end
+
+    it "defaults off and honors config.builder_strict" do
+      expect(Moxml.new.config.builder_strict).to be(false)
+      ctx = Moxml.new
+      ctx.config.builder_strict = true
+      expect do
+        ctx.build { element("root") { helperish } }
+      end.to raise_error(NoMethodError)
+    end
+
+    it "a per-build false overrides a strict config" do
+      ctx = Moxml.new
+      ctx.config.builder_strict = true
+      doc = ctx.build(strict: false) do
+        element("root") { helperish }
+      end
+      expect(doc.to_xml).to include("<helperish>")
+    end
+  end
+end

data/spec/moxml/recover_mode_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# #369: non-strict parses RECOVER on engines carrying the mode
+# (leptris 1.9.344+, leptris#1660) — the best-effort tree survives
+# recoverable structural errors (libxml2 XML_PARSE_RECOVER
+# semantics) instead of the rescue-to-empty fallback. Strict
+# callers never recover: malformed input raises.
+RSpec.describe "recover mode (#369)" do
+  let(:ctx) { Moxml.new(:leptris) }
+
+  describe "engines with the recover mode" do
+    before do
+      unless Moxml::Adapter::Leptris::RECOVER_MODE
+        skip "binding #{Leptris::VERSION} predates the recover mode"
+      end
+    end
+
+    it "recovers a mismatched closer into a tree" do
+      doc = ctx.parse("<root><a>x</b></root>", strict: false)
+      expect(doc.root).not_to be_nil
+      expect(doc.to_xml).to include("<a>x</a>")
+    end
+
+    it "closes unclosed elements at EOF" do
+      doc = ctx.parse("<root><a>x</root>", strict: false)
+      expect(doc.root).not_to be_nil
+      expect(doc.to_xml).to include("<a>x</a>")
+    end
+
+    it "keeps strict parsing raising" do
+      expect { ctx.parse("<root><a>x</b></root>", strict: true) }
+        .to raise_error(Moxml::ParseError)
+    end
+
+    it "raises by default (Context strict_parsing defaults true)" do
+      expect { ctx.parse("<root><a>x</b></root>") }
+        .to raise_error(Moxml::ParseError)
+    end
+
+    it "the recovered tree carries no parse errors (diagnostics ride #1200)" do
+      doc = ctx.parse("<root><a>x</b></root>", strict: false)
+      expect(doc.parse_errors).to eq([])
+    end
+  end
+
+  describe "engines below the recover floor" do
+    before do
+      if Moxml::Adapter::Leptris::RECOVER_MODE
+        skip "binding #{Leptris::VERSION} carries the recover mode"
+      end
+    end
+
+    it "keeps the empty-document fallback with diagnostics" do
+      doc = ctx.parse("<root><a>x</b></root>", strict: false)
+      expect(doc.root).to be_nil
+      expect(doc.parse_errors).not_to be_empty
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.130
+  version: 0.5.132
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-12 00:00:00.000000000 Z
+date: 2026-10-13 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -473,6 +473,7 @@ files:
 - spec/moxml/at_search_spec.rb
 - spec/moxml/attribute_resolver_spec.rb
 - spec/moxml/attribute_spec.rb
+- spec/moxml/builder_namespaces_spec.rb
 - spec/moxml/builder_spec.rb
 - spec/moxml/c14n/adapter_delegation_spec.rb
 - spec/moxml/c14n/api_spec.rb
@@ -531,6 +532,7 @@ files:
 - spec/moxml/plan_spec.rb
 - spec/moxml/processing_instruction_spec.rb
 - spec/moxml/readonly_parse_spec.rb
+- spec/moxml/recover_mode_spec.rb
 - spec/moxml/sax/namespace_splitter_spec.rb
 - spec/moxml/sax_entity_parity_spec.rb
 - spec/moxml/sax_spec.rb