moxml 0.1.23 → 0.1.25

data/spec/moxml/adapter/platform_spec.rb

@@ -2,69 +2,87 @@
 
 require "spec_helper"
 
-RSpec.describe Moxml::Adapter, ".platform_adapters" do
-  it "includes all known adapters under MRI" do
-    expect(described_class.platform_adapters).to include(:nokogiri, :oga,
-                                                         :rexml, :ox)
-  end
-
-  it "uses the AVAILABLE_ADAPTERS constant under MRI" do
-    expect(described_class.platform_adapters).to eq(Moxml::Adapter::AVAILABLE_ADAPTERS)
-  end
-end
-
-RSpec.describe Moxml::Adapter, ".available?" do
-  it "returns true for :oga" do
-    expect(described_class.available?(:oga)).to be true
-  end
+RSpec.describe Moxml::Adapter do
+  describe ".platform_adapters" do
+    it "includes all known adapters under MRI" do
+      expect(described_class.platform_adapters).to include(:nokogiri, :oga,
+                                                           :rexml, :ox)
+    end
 
-  it "returns true for :nokogiri under MRI" do
-    expect(described_class.available?(:nokogiri)).to be true
+    it "uses the AVAILABLE_ADAPTERS constant under MRI" do
+      expect(described_class.platform_adapters).to eq(Moxml::Adapter::AVAILABLE_ADAPTERS)
+    end
   end
 
-  context "when Opal platform adapters are in effect" do
-    before do
-      allow(described_class).to receive(:platform_adapters)
-        .and_return(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS)
+  describe ".available?" do
+    it "returns true for :oga" do
+      expect(described_class.available?(:oga)).to be true
     end
 
-    it "returns false for :nokogiri" do
-      expect(described_class.available?(:nokogiri)).to be false
+    it "returns true for :nokogiri under MRI" do
+      expect(described_class.available?(:nokogiri)).to be true
     end
 
-    it "returns true for :rexml" do
-      expect(described_class.available?(:rexml)).to be true
+    context "when Opal platform adapters are in effect" do
+      before do
+        allow(described_class).to receive(:platform_adapters)
+          .and_return(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS)
+      end
+
+      it "returns false for :nokogiri" do
+        expect(described_class.available?(:nokogiri)).to be false
+      end
+
+      it "returns true for :oga" do
+        expect(described_class.available?(:oga)).to be true
+      end
+
+      it "returns true for :rexml" do
+        expect(described_class.available?(:rexml)).to be true
+      end
     end
   end
-end
 
-RSpec.describe Moxml::Adapter, ".load" do
-  context "when Opal platform adapters are in effect" do
-    before do
-      allow(described_class).to receive(:platform_adapters)
-        .and_return(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS)
-    end
+  describe ".load" do
+    context "when Opal platform adapters are in effect" do
+      before do
+        allow(described_class).to receive(:platform_adapters)
+          .and_return(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS)
+      end
 
-    it "raises AdapterError for :nokogiri" do
-      expect { described_class.load(:nokogiri) }.to raise_error(
-        Moxml::AdapterError, /not available on this platform/
-      )
+      it "raises AdapterError for :nokogiri" do
+        expect { described_class.load(:nokogiri) }.to raise_error(
+          Moxml::AdapterError, /not available on this platform/
+        )
+      end
     end
   end
-end
 
-RSpec.describe "Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS" do
-  it "contains only :rexml" do
-    expect(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS).to eq(%i[rexml])
+  describe "OPAL_AVAILABLE_ADAPTERS" do
+    it "lists :oga as the primary Opal adapter, with :rexml as opt-in" do
+      expect(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS).to eq(%i[oga rexml])
+    end
   end
-end
 
-RSpec.describe "Moxml::Adapter::CONST_NAME_MAP" do
-  it "maps :headed_ox to HeadedOx" do
-    expect(Moxml::Adapter::CONST_NAME_MAP[:headed_ox]).to eq("HeadedOx")
+  describe "CONST_NAME_MAP" do
+    it "maps :headed_ox to HeadedOx" do
+      expect(Moxml::Adapter::CONST_NAME_MAP[:headed_ox]).to eq("HeadedOx")
+    end
+
+    it "falls back to capitalize for unmapped adapters" do
+      expect(Moxml::Adapter::CONST_NAME_MAP[:nokogiri]).to be_nil
+    end
   end
 
-  it "falls back to capitalize for unmapped adapters" do
-    expect(Moxml::Adapter::CONST_NAME_MAP[:nokogiri]).to be_nil
+  describe "default adapter / available list invariants" do
+    it "DEFAULT_ADAPTER is a member of AVAILABLE_ADAPTERS" do
+      expect(Moxml::Adapter::AVAILABLE_ADAPTERS)
+        .to include(Moxml::Config::DEFAULT_ADAPTER)
+    end
+
+    it "OPAL_DEFAULT_ADAPTER is a member of OPAL_AVAILABLE_ADAPTERS" do
+      expect(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS)
+        .to include(Moxml::Config::OPAL_DEFAULT_ADAPTER)
+    end
   end
 end

data/spec/moxml/attribute_spec.rb

@@ -27,4 +27,20 @@ RSpec.describe Moxml::Attribute do
       expect(attr.to_s).to match(/\w+="\w+"/)
     end
   end
+
+  describe "#element" do
+    it "returns wrapped Element" do
+      attr = element.attributes.find { |a| a.name == "id" }
+      parent = attr.element
+      expect(parent).to be_a(Moxml::Element)
+      expect(parent.name).to eq("root")
+    end
+  end
+
+  describe "#content" do
+    it "returns attribute value" do
+      attr = element.attributes.find { |a| a.name == "id" }
+      expect(attr.content).to eq("123")
+    end
+  end
 end

data/spec/moxml/context_spec.rb

@@ -25,4 +25,18 @@ RSpec.describe Moxml::Context do
       expect(context.config.adapter.ancestors).to include(Moxml::Adapter::Base)
     end
   end
+
+  describe "#build" do
+    it "creates a document via builder DSL" do
+      doc = context.build do
+        element("root") do
+          element("child") do
+            text("hello")
+          end
+        end
+      end
+      expect(doc).to be_a(Moxml::Document)
+      expect(doc.root.name).to eq("root")
+    end
+  end
 end

data/spec/moxml/moxml_spec.rb

@@ -52,4 +52,17 @@ RSpec.describe Moxml do
       expect(Moxml::Config::VALID_ADAPTERS).to include(Moxml::Config.runtime_default_adapter)
     end
   end
+
+  describe ".parse" do
+    it "parses XML with shorthand" do
+      doc = described_class.parse("<root>hello</root>")
+      expect(doc).to be_a(Moxml::Document)
+      expect(doc.root.text).to eq("hello")
+    end
+
+    it "accepts adapter option" do
+      doc = described_class.parse("<root/>", adapter: :rexml)
+      expect(doc).to be_a(Moxml::Document)
+    end
+  end
 end

data/spec/moxml/node_spec.rb

@@ -34,4 +34,62 @@ RSpec.describe Moxml::Node do
       expect(node.children).to be_empty
     end
   end
+
+  describe "#each" do
+    it "yields direct children" do
+      children = node.map { |c| c }
+      expect(children.size).to eq(1)
+      expect(children.first).to be_a(Moxml::Element)
+    end
+
+    it "includes Enumerable" do
+      expect(node.map(&:name)).to eq(["child"])
+    end
+  end
+
+  describe "#outer_xml" do
+    it "returns same as to_xml" do
+      child = node.children.first
+      expect(child.outer_xml).to eq(child.to_xml)
+    end
+  end
+
+  describe "#before" do
+    it "adds a node before self" do
+      child = node.children.first
+      child.before("before")
+      siblings = node.children.map(&:content).join
+      expect(siblings).to include("before")
+    end
+  end
+
+  describe "#after" do
+    it "adds a node after self" do
+      child = node.children.first
+      child.after("after")
+      expect(node.children.size).to be >= 2
+    end
+  end
+
+  describe "#blank?" do
+    it "returns true for whitespace-only text" do
+      doc2 = context.parse("<root>   </root>")
+      expect(doc2.root).to be_blank
+    end
+
+    it "returns false for non-blank content" do
+      expect(node).not_to be_blank
+    end
+  end
+
+  describe "#content" do
+    it "returns empty string on base Node" do
+      expect(described_class.new(nil, context).content).to eq("")
+    end
+
+    it "returns text on Element" do
+      child = node.children.first
+      expect(child.content).to eq("text")
+    end
+  end
 end

data/spec/moxml/opal_oga_adapter_spec.rb

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

data/spec/moxml/opal_oga_features_spec.rb

@@ -0,0 +1,212 @@
+# 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

@@ -0,0 +1,35 @@
+# 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/xpath/functions/node_functions_spec.rb

@@ -57,7 +57,7 @@ RSpec.describe "XPath Node Functions" do
       result = proc.call(doc)
 
       # Depending on adapter, may include ns: prefix
-      expect(result).to match(/item/)
+      expect(result).to include("item")
     end
 
     it "returns empty string when no node matched" do

data/spec/moxml/xpath/ruby/node_spec.rb

@@ -113,13 +113,13 @@ RSpec.describe Moxml::XPath::Ruby::Node do
   describe "#is_a?" do
     it "creates a :send node for is_a? method call" do
       node = described_class.new(:lit, ["obj"])
-      result = node.is_a?(String)
+      klass_node = described_class.new(:const, ["String"])
+      result = node.is_a?(klass_node)
 
       expect(result.type).to eq(:send)
       expect(result.to_a[0]).to eq(node)
       expect(result.to_a[1]).to eq("is_a?")
-      expect(result.to_a[2].type).to eq(:lit)
-      expect(result.to_a[2].to_a[0]).to eq("String")
+      expect(result.to_a[2]).to eq(klass_node)
     end
   end
 

data/spec/spec_helper.rb

@@ -101,7 +101,7 @@ RSpec.configure do |config|
 end
 
 Moxml.configure do |config|
-  config.adapter = RUBY_ENGINE == "opal" ? :rexml : :nokogiri
+  config.adapter = RUBY_ENGINE == "opal" ? Moxml::Config::OPAL_DEFAULT_ADAPTER : Moxml::Config::DEFAULT_ADAPTER
   config.strict_parsing = true
   config.default_encoding = "UTF-8"
   config.entity_load_mode = :optional if RUBY_ENGINE == "opal"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.1.23
+  version: 0.1.25
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-01 00:00:00.000000000 Z
+date: 2026-06-26 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -28,6 +28,7 @@ files:
 - ".github/workflows/release.yml"
 - ".github/workflows/round-trip.yml"
 - ".gitignore"
+- ".gitmodules"
 - ".rspec"
 - ".rspec-opal"
 - ".rubocop.yml"
@@ -98,6 +99,7 @@ files:
 - examples/web_scraper/README.md
 - examples/web_scraper/example_page.html
 - examples/web_scraper/web_scraper.rb
+- lib/compat/opal/moxml_boot.rb
 - lib/compat/opal/rexml/namespace.rb
 - lib/compat/opal/rexml/parsers/baseparser.rb
 - lib/compat/opal/rexml/source.rb
@@ -351,6 +353,9 @@ files:
 - spec/moxml/node_set_spec.rb
 - spec/moxml/node_spec.rb
 - spec/moxml/node_type_map_spec.rb
+- spec/moxml/opal_oga_adapter_spec.rb
+- spec/moxml/opal_oga_features_spec.rb
+- spec/moxml/opal_oga_smoke_spec.rb
 - spec/moxml/opal_rexml_adapter_spec.rb
 - spec/moxml/opal_smoke_spec.rb
 - spec/moxml/processing_instruction_spec.rb