moxml 0.5.177 → 0.6.0

data/lib/moxml/native_attachment/opal.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Moxml
-  class NativeAttachment
-    # Opal adapter nodes are Ruby objects, so instance variables are sufficient
-    # for Moxml-owned attachments without relying on Monitor/Thread support.
-    class Opal
-      def get(native, key)
-        native.instance_variable_get(attachment_ivar_name(key))
-      end
-
-      def set(native, key, value)
-        native.instance_variable_set(attachment_ivar_name(key), value)
-      end
-
-      def none_set?(native, keys)
-        keys.none? { |key| native.instance_variable_defined?(attachment_ivar_name(key)) }
-      end
-
-      def key?(native, key)
-        native.instance_variable_defined?(attachment_ivar_name(key))
-      end
-
-      def delete(native, key)
-        ivar_name = attachment_ivar_name(key)
-        return unless native.instance_variable_defined?(ivar_name)
-
-        native.remove_instance_variable(ivar_name)
-      end
-
-      private
-
-      def attachment_ivar_name(key)
-        :"@moxml_attachment_#{key}"
-      end
-    end
-  end
-end

data/spec/moxml/native_attachment/opal_spec.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Moxml::NativeAttachment::Opal do
-  subject(:attachments) { described_class.new }
-
-  let(:native) { Object.new }
-  let(:other_native) { Object.new }
-
-  it "stores and reads attachments by native object and key" do
-    attachments.set(native, :entity_refs, ["amp"])
-    attachments.set(native, :doctype, "html")
-    attachments.set(other_native, :entity_refs, ["lt"])
-
-    aggregate_failures do
-      expect(attachments.get(native, :entity_refs)).to eq(["amp"])
-      expect(attachments.get(native, :doctype)).to eq("html")
-      expect(attachments.get(other_native, :entity_refs)).to eq(["lt"])
-      expect(attachments.key?(native, :entity_refs)).to be(true)
-      expect(attachments.key?(native, :missing)).to be(false)
-    end
-  end
-
-  it "preserves explicit nil attachments" do
-    attachments.set(native, :xml_declaration, nil)
-
-    aggregate_failures do
-      expect(attachments.get(native, :xml_declaration)).to be_nil
-      expect(attachments.key?(native, :xml_declaration)).to be(true)
-    end
-  end
-
-  it "deletes attachments" do
-    attachments.set(native, :entity_refs, ["amp"])
-
-    expect(attachments.delete(native, :entity_refs)).to eq(["amp"])
-
-    aggregate_failures do
-      expect(attachments.get(native, :entity_refs)).to be_nil
-      expect(attachments.key?(native, :entity_refs)).to be(false)
-      expect(attachments.delete(native, :entity_refs)).to be_nil
-    end
-  end
-
-  it "stores attachments in Moxml-owned instance variables" do
-    attachments = described_class.new
-    native = Object.new
-
-    attachments.set(native, :entity_refs, ["amp"])
-
-    expect(native.instance_variable_get(:@moxml_attachment_entity_refs))
-      .to eq(["amp"])
-  end
-
-  it "removes the attachment instance variable on delete" do
-    attachments = described_class.new
-    native = Object.new
-
-    attachments.set(native, :entity_refs, ["amp"])
-    attachments.delete(native, :entity_refs)
-
-    expect(native.instance_variable_defined?(:@moxml_attachment_entity_refs))
-      .to be(false)
-  end
-end

data/spec/moxml/opal_oga_adapter_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "moxml/adapter/shared_examples/adapter_contract"
-
-# The describe resolves the adapter constant at load time — under
-# MRI nothing loads the Opal compat shim, so the whole describe must
-# sit behind the engine check (the `if:` metadata alone still
-# evaluates the constant reference).
-if RUBY_ENGINE == "opal"
-  RSpec.describe Moxml::Adapter::Oga do
-    around do |example|
-      Moxml.with_config(:oga, true, "UTF-8") do
-        example.run
-      end
-    end
-
-    it_behaves_like "xml adapter"
-  end
-end

data/spec/moxml/opal_oga_features_spec.rb

@@ -1,212 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-# Exercises feature areas under Opal that are not covered by the shared
-# adapter contract (opal_oga_adapter_spec.rb) or the basic smoke spec
-# (opal_oga_smoke_spec.rb). Targets the default Opal adapter (:oga).
-# Uses an explicit :oga context so leaked global config from other specs
-# cannot flip the adapter under test.
-RSpec.describe "Moxml Opal oga feature coverage", if: RUBY_ENGINE == "opal" do
-  let(:context) { Moxml.new(:oga) }
-
-  describe "builder DSL" do
-    it "builds a document with the block DSL" do
-      doc = Moxml::Builder.new(context).build do
-        root do
-          child "text"
-        end
-      end
-
-      expect(doc.root.name).to eq("root")
-      expect(doc.root.children.first.name).to eq("child")
-      expect(doc.root.children.first.text).to eq("text")
-    end
-
-    it "creates nested elements via blocks" do
-      doc = Moxml::Builder.new(context).build do
-        library do
-          book(id: "1") { title "A" }
-          book(id: "2") { title "B" }
-        end
-      end
-
-      books = doc.root.children.grep(Moxml::Element)
-      expect(books.length).to eq(2)
-      expect(books.map { |b| b["id"] }).to eq(%w[1 2])
-    end
-
-    it "supports method_missing DSL with attributes and text" do
-      doc = Moxml::Builder.new(context).build do
-        person(name: "Alice", age: "30") { email "alice@example.com" }
-      end
-
-      person = doc.root
-      expect(person.name).to eq("person")
-      expect(person["name"]).to eq("Alice")
-      expect(person["age"]).to eq("30")
-      expect(person.children.first.name).to eq("email")
-      expect(person.children.first.text).to eq("alice@example.com")
-    end
-
-    it "strips trailing underscore for reserved-name tags" do
-      doc = Moxml::Builder.new(context).build do
-        class_ { name "Foo" }
-      end
-
-      expect(doc.root.name).to eq("class")
-    end
-
-    it "attaches namespace declarations" do
-      builder = Moxml::Builder.new(context)
-      doc = builder.build do
-        root("xmlns:dc": "http://purl.org/dc/elements/1.1/") do
-          builder.element("dc:title") { builder.text "Hello" }
-        end
-      end
-
-      title = doc.root.children.find { |c| c.is_a?(Moxml::Element) }
-      expect(title.name).to eq("dc:title")
-      expect(doc.to_xml).to include("xmlns:dc")
-      expect(doc.to_xml).to include("dc:title")
-    end
-  end
-
-  describe "XML declaration preservation" do
-    it "does not add a declaration when the input has none" do
-      doc = context.parse("<root><child/></root>")
-      output = doc.to_xml
-
-      expect(output).not_to include("<?xml")
-      expect(doc.has_xml_declaration).to be false
-    end
-
-    it "preserves the declaration when the input has one" do
-      xml = '<?xml version="1.0" encoding="UTF-8"?><root/>'
-      doc = context.parse(xml)
-
-      expect(doc.has_xml_declaration).to be true
-      expect(doc.to_xml).to include("<?xml")
-      expect(doc.to_xml).to include('version="1.0"')
-    end
-
-    it "forces the declaration on with declaration: true" do
-      doc = context.parse("<root/>")
-      expect(doc.to_xml(declaration: true)).to include("<?xml")
-    end
-
-    it "forces the declaration off with declaration: false" do
-      doc = context.parse('<?xml version="1.0"?><root/>')
-      expect(doc.to_xml(declaration: false)).not_to include("<?xml")
-    end
-
-    it "preserves standalone attribute" do
-      xml = '<?xml version="1.0" standalone="yes"?><root/>'
-      doc = context.parse(xml)
-      expect(doc.to_xml).to include("standalone")
-    end
-  end
-
-  describe "doctype handling" do
-    it "parses a SIMPLE doctype" do
-      doc = context.parse("<!DOCTYPE root><root/>")
-      doctype = doc.children.find { |c| c.is_a?(Moxml::Doctype) }
-      expect(doctype).not_to be_nil
-      expect(doctype.name).to eq("root")
-    end
-
-    it "parses a PUBLIC doctype with external and system ids" do
-      xml = '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"><html/>'
-      doc = context.parse(xml)
-      doctype = doc.children.find { |c| c.is_a?(Moxml::Doctype) }
-
-      expect(doctype).not_to be_nil
-      expect(doctype.name).to eq("html")
-      expect(doctype.external_id).to eq("-//W3C//DTD HTML 4.01//EN")
-      expect(doctype.system_id).to eq("http://www.w3.org/TR/html4/strict.dtd")
-    end
-
-    it "round-trips the doctype through serialization" do
-      xml = "<!DOCTYPE root><root/>"
-      doc = context.parse(xml)
-      expect(doc.to_xml).to include("DOCTYPE")
-      expect(doc.to_xml).to include("root")
-    end
-  end
-
-  describe "round-trip stability" do
-    it "round-trips a document with mixed content" do
-      xml = <<~XML.strip
-        <root attr="value">
-          <child>text</child>
-          <!-- comment -->
-          <nested><deep>data</deep></nested>
-        </root>
-      XML
-
-      doc1 = context.parse(xml)
-      serialized1 = doc1.to_xml
-      doc2 = context.parse(serialized1)
-      serialized2 = doc2.to_xml
-
-      expect(serialized2).to eq(serialized1)
-    end
-
-    it "round-trips a document with namespaces" do
-      xml = '<root xmlns:ns="http://example.com/ns"><ns:child>content</ns:child></root>'
-      doc1 = context.parse(xml)
-      serialized1 = doc1.to_xml
-
-      doc2 = context.parse(serialized1)
-      child = doc2.root.children.find { |c| c.is_a?(Moxml::Element) }
-      expect(child.name).to eq("child")
-      expect(child.namespace_prefix).to eq("ns")
-      expect(doc2.to_xml).to include("xmlns:ns")
-    end
-
-    it "round-trips a document with CDATA" do
-      xml = "<root><![CDATA[<unparsed>content</unparsed>]]></root>"
-      doc1 = context.parse(xml)
-      serialized1 = doc1.to_xml
-
-      expect(serialized1).to include("<![CDATA[")
-      doc2 = context.parse(serialized1)
-      expect(doc2.to_xml).to include("<![CDATA[")
-    end
-  end
-
-  describe "XPath under Opal" do
-    it "evaluates element-only XPath" do
-      doc = context.parse("<root><a><b>1</b></a><a><b>2</b></a></root>")
-      results = doc.xpath("//a/b")
-      expect(results.length).to eq(2)
-      expect(results.map(&:text)).to eq(%w[1 2])
-    end
-
-    it "supports attribute predicates" do
-      doc = context.parse('<root><item id="x">1</item><item id="y">2</item></root>')
-      found = doc.xpath("//item").find { |i| i["id"] == "y" }
-      expect(found.text).to eq("2")
-    end
-
-    it "supports at_xpath" do
-      doc = context.parse("<root><a>1</a><a>2</a></root>")
-      first = doc.at_xpath("//a")
-      expect(first.text).to eq("1")
-    end
-  end
-
-  describe "comment and processing instruction handling" do
-    it "preserves comments through parse/serialize" do
-      xml = "<root><!-- my comment --></root>"
-      doc = context.parse(xml)
-      expect(doc.to_xml).to include("my comment")
-    end
-
-    it "preserves processing instructions through parse/serialize" do
-      xml = "<?pi-target pi-data?><root/>"
-      doc = context.parse(xml)
-      expect(doc.to_xml).to include("pi-target")
-    end
-  end
-end

data/spec/moxml/opal_oga_smoke_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-# Verifies that the Opal default adapter (:oga, set in Moxml::Config)
-# loads correctly via the Opal-compatible oga fork. The fork's
-# lib/oga.rb dispatches `require 'liboga'` to `require 'oga/native/lexer'`
-# under Opal, which resolves to the pure-Ruby lexer vendored at
-# vendor/opal-oga/ext/pureruby/.
-RSpec.describe "Moxml Opal oga default", if: RUBY_ENGINE == "opal" do
-  let(:context) { Moxml.new }
-
-  it "defaults to :oga under Opal" do
-    expect(Moxml::Config::OPAL_DEFAULT_ADAPTER).to eq(:oga)
-  end
-
-  it "parses XML through the oga adapter" do
-    doc = context.parse("<root><child>text</child></root>")
-    expect(doc.root.name).to eq("root")
-    expect(doc.root.children.first.name).to eq("child")
-  end
-
-  it "decodes entities single-pass" do
-    doc = context.parse("<root>&amp;#38;</root>")
-    expect(doc.root.text).to eq("&#38;")
-  end
-
-  it "serializes back to XML" do
-    xml = '<person name="Alice"><age>30</age></person>'
-    doc = context.parse(xml)
-    serialized = doc.to_xml
-    expect(serialized).to include("person")
-    expect(serialized).to include("Alice")
-  end
-end

data/spec/moxml/opal_rexml_adapter_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "moxml/adapter/shared_examples/adapter_contract"
-
-RSpec.describe Moxml::Adapter::Rexml, if: RUBY_ENGINE == "opal" do
-  around do |example|
-    Moxml.with_config(:rexml, true, "UTF-8") do
-      example.run
-    end
-  end
-
-  it_behaves_like "xml adapter"
-end

data/spec/moxml/opal_smoke_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "Moxml Opal smoke test", if: RUBY_ENGINE == "opal" do
-  let(:context) { Moxml.new(:rexml) }
-
-  it "parses XML string to document" do
-    doc = context.parse("<root><child>text</child></root>")
-    expect(doc).not_to be_nil
-    root = doc.root
-    expect(root.name).to eq("root")
-    expect(root.children.first.name).to eq("child")
-  end
-
-  it "round-trips parse and serialize" do
-    xml = '<person name="Alice"><age>30</age></person>'
-    doc = context.parse(xml)
-    serialized = doc.to_xml
-    expect(serialized).to include("person")
-    expect(serialized).to include("Alice")
-    expect(serialized).to include("30")
-  end
-
-  it "builds XML document from scratch" do
-    doc = context.create_document
-    root = doc.create_element("root")
-    root["attr"] = "value"
-    text = doc.create_text("hello")
-    root.add_child(text)
-    doc.add_child(root)
-
-    expect(doc.to_xml).to include('attr="value"')
-    expect(doc.to_xml).to include("hello")
-  end
-
-  it "handles namespaces" do
-    xml = '<root xmlns:ns="http://example.com"><ns:child>data</ns:child></root>'
-    doc = context.parse(xml)
-    expect(doc.to_xml).to include("ns:child")
-  end
-
-  it "handles CDATA sections" do
-    xml = "<root><![CDATA[<script>alert('xss')</script>]]></root>"
-    doc = context.parse(xml)
-    expect(doc.to_xml).to include("<script>")
-  end
-
-  it "handles comments" do
-    xml = "<root><!-- a comment --><child/></root>"
-    doc = context.parse(xml)
-    expect(doc.to_xml).to include("a comment")
-  end
-
-  it "handles processing instructions" do
-    xml = '<?xml version="1.0"?><?pi-target pi-data?><root/>'
-    doc = context.parse(xml)
-    serialized = doc.to_xml
-    expect(serialized).to include("pi-target")
-  end
-end

data/spec/moxml/reference_opal_spec.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-# The engine-free lane (TODO.sota/03): the reference is pure Ruby and
-# answers the model where no native engine exists. This spec proves it
-# transpiles and runs under Opal.
-RSpec.describe "Moxml::Reference under Opal", if: RUBY_ENGINE == "opal" do
-  it "parses, answers faces, and writes without a native engine" do
-    document = Moxml::Reference.parse(
-      '<r a="1"><b>t&amp;u</b><![CDATA[c]]><?pi d?></r>',
-    )
-    expect(Moxml::Reference.element_names(document)).to eq(%w[r b])
-    expect(Moxml::Reference.child_element_names(document)).to eq([["b"], []])
-    element = document.root.children.find(&:element?)
-    expect(element.children.map(&:kind)).to eq([:text])
-    expect(element.children.first.data).to eq("t&u")
-    expect(document.root.text).to eq("t&uc")
-    expect(Moxml::Reference.processing_instructions(document))
-      .to eq([["pi", "d"]])
-    expect(Moxml::Reference.to_xml(document))
-      .to include("<r a=\"1\">", "<b>t&amp;u</b>", "<![CDATA[c]]>")
-  end
-
-  it "raises a named ParseError for malformed input" do
-    expect { Moxml::Reference.parse("<r><c></r>") }
-      .to raise_error(Moxml::ParseError)
-  end
-end

data/spec/moxml/signature_autoload_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "open3"
-require "rbconfig"
-require "tempfile"
-require "opal"
-
-RSpec.describe "Signature autoload boundary", :native_fs do
-  let(:lib) { File.expand_path("../../lib", __dir__) }
-
-  it "keeps the native signature module lazy and usable on Ruby" do
-    source = <<~RUBY_CODE
-      require "moxml"
-      abort "signature was loaded eagerly" if $LOADED_FEATURES.any? { |path| path.end_with?("moxml/signature.rb") }
-      abort "signature autoload missing" unless Moxml.autoload?(:Signature) == "moxml/signature"
-      abort "signature module unavailable" unless Moxml::Signature::DSIG_NS == "http://www.w3.org/2000/09/xmldsig#"
-      abort "OpenSSL unavailable" unless defined?(OpenSSL::PKey::RSA)
-      puts "native signature available"
-    RUBY_CODE
-    output, error, status = Open3.capture3(RbConfig.ruby, "-I", lib, "-e", source)
-    expect(status.success?).to be(true), error
-    expect(output).to include("native signature available")
-  end
-
-  it "does not compile the native OpenSSL dependency into Opal" do
-    # Compile the actual entrypoint declaration. This isolates the optional
-    # signature boundary from the other modules loaded by the Opal boot file.
-    declaration = File.readlines(File.join(lib, "moxml.rb"))
-      .find { |line| line.include?('autoload :Signature, "moxml/signature"') }
-    expect(declaration).not_to be_nil
-
-    builder = Opal::Builder.new
-    builder.append_paths(lib)
-    builder.build("opal")
-    builder.build_str(<<~RUBY_CODE, "signature-autoload-boundary")
-      module Moxml
-        #{declaration}
-      end
-      raise "native Signature loaded under Opal" if Moxml.const_defined?(:Signature, false)
-      puts "Opal signature boundary passed"
-    RUBY_CODE
-
-    Tempfile.create(["moxml-signature-boundary", ".js"]) do |file|
-      file.write(builder.to_s)
-      file.flush
-      output, error, status = Open3.capture3("node", file.path)
-      expect(status.success?).to be(true), error
-      expect(output).to include("Opal signature boundary passed")
-    end
-  end
-end

data/spec/support/opal.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-# Opal runtime patches for moxml specs.
-#
-# Moxml already handles Opal-specific behavior internally
-# (NativeAttachment::Opal, Config::OPAL_DEFAULT_ADAPTER, EntityRegistry::OPAL_ENTITY_DATA).
-# This file is loaded only under Opal for any additional test-environment patches.
-
-# Under Opal, moxml uses REXML adapter (Opal reimplements strscan/stringio
-# in its stdlib, enabling REXML to compile to JavaScript).
-Moxml.configure do |config|
-  config.adapter = :rexml
-  config.strict_parsing = false
-  config.default_encoding = "UTF-8"
-  config.entity_load_mode = :optional
-end