moxml 0.1.18 → 0.1.20

data/lib/moxml/native_attachment/opal.rb

@@ -0,0 +1,34 @@
+# 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 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/lib/moxml/native_attachment.rb

@@ -1,65 +1,35 @@
 # frozen_string_literal: true
 
 module Moxml
-  # Stores Moxml-specific state associated with native adapter objects
-  # without polluting their internals.
-  #
-  # Uses object_id as key with GC finalizer cleanup to prevent memory leaks.
-  # Thread-safe via Monitor (reentrant-safe).
-  #
-  # Replaces the anti-pattern of using instance_variable_set/get on
-  # foreign library objects (Nokogiri, REXML, Oga, Ox, LibXML nodes).
-  #
-  # @example
-  #   attachments = NativeAttachment.new
-  #   attachments.set(native_element, :entity_refs, [])
-  #   refs = attachments.get(native_element, :entity_refs)
-  #   attachments.key?(native_element, :doctype) #=> false
   class NativeAttachment
-    def initialize
-      @data = {}
-      @finalizer_registered = {}
-      @monitor = Monitor.new
+    autoload :Opal, "moxml/native_attachment/opal"
+    autoload :Native, "moxml/native_attachment/native"
+
+    def self.default_backend
+      constant = RUBY_ENGINE == "opal" ? :Opal : :Native
+      const_get(constant).new
+    end
+
+    attr_reader :backend
+
+    def initialize(backend: self.class.default_backend)
+      @backend = backend
     end
 
     def get(native, key)
-      @monitor.synchronize { @data[native.object_id]&.[](key) }
+      @backend.get(native, key)
     end
 
     def set(native, key, value)
-      id = native.object_id
-      @monitor.synchronize do
-        @data[id] ||= {}
-        @data[id][key] = value
-        register_finalizer(native, id) unless @finalizer_registered[id]
-      end
+      @backend.set(native, key, value)
     end
 
     def key?(native, key)
-      @monitor.synchronize { @data[native.object_id]&.key?(key) || false }
+      @backend.key?(native, key)
     end
 
     def delete(native, key)
-      @monitor.synchronize { @data[native.object_id]&.delete(key) }
-    end
-
-    private
-
-    def register_finalizer(native, id)
-      @finalizer_registered[id] = true
-      ObjectSpace.define_finalizer(native, finalizer_for(id))
-    end
-
-    def finalizer_for(id)
-      data = @data
-      registered = @finalizer_registered
-      # Finalizers must NOT use Mutex/Monitor (can't be called from trap context).
-      # Direct Hash operations are safe here since finalizers run sequentially
-      # and the GC'd object's id won't be accessed by any other thread.
-      proc do
-        data.delete(id)
-        registered.delete(id)
-      end
+      @backend.delete(native, key)
     end
   end
 end

data/lib/moxml/text.rb

@@ -15,5 +15,9 @@ module Moxml
     def content=(text)
       adapter.set_text_content(@native, normalize_xml_value(text))
     end
+
+    def to_s
+      content
+    end
   end
 end

data/lib/moxml/version.rb

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

data/lib/moxml/xpath/compiler.rb

@@ -1758,7 +1758,8 @@ module Moxml
           current = visit.pop
 
           # Function name is stored in :value field, not children
-          if (current.type == :call || current.type == :function) && current.value == name
+          if %i[call
+                function].include?(current.type) && current.value == name
             return true
           end
 

data/spec/integration/shared_examples/edge_cases.rb

@@ -170,7 +170,9 @@ RSpec.shared_examples "Moxml Edge Cases" do
   describe "whitespace text node preservation" do
     # Ox/HeadedOx do not generate whitespace-only text nodes in their parser,
     # so these tests only apply to adapters that do (Nokogiri, OGA, REXML, LibXML)
-    let(:preserves_ws) { !%i[ox headed_ox].include?(context.config.adapter_name) }
+    let(:preserves_ws) do
+      !%i[ox headed_ox].include?(context.config.adapter_name)
+    end
 
     it "preserves whitespace-only text nodes between sibling elements" do
       unless preserves_ws
@@ -196,7 +198,7 @@ RSpec.shared_examples "Moxml Edge Cases" do
       expect(ws_nodes).not_to be_empty
 
       # Element children should still be accessible
-      elements = children.select { |c| c.is_a?(Moxml::Element) }
+      elements = children.grep(Moxml::Element)
       expect(elements.map(&:name)).to eq(%w[a b c])
     end
 

data/spec/integration/shared_examples/entity_reference_whitespace.rb

@@ -116,7 +116,7 @@ RSpec.shared_examples "Entity Reference Whitespace Preservation" do
       children = doc.root.children
 
       # Whitespace text nodes between elements are preserved
-      elements = children.select { |c| c.is_a?(Moxml::Element) }
+      elements = children.grep(Moxml::Element)
       expect(elements.length).to eq(2)
       expect(elements.map(&:name)).to eq(%w[child1 child2])
     end

data/spec/integration/shared_examples/high_level/document_builder_behavior.rb

@@ -38,7 +38,9 @@ RSpec.shared_examples "Moxml::DocumentBuilder" do
       expect(non_ws_children[1]).to be_a(Moxml::Element)
       expect(non_ws_children[1].name).to eq("child")
       expect(non_ws_children[1]["id"]).to eq("1")
-      expect(non_ws_children[1].children.find { |c| c.is_a?(Moxml::Cdata) }).to be_a(Moxml::Cdata)
+      expect(non_ws_children[1].children.find do |c|
+        c.is_a?(Moxml::Cdata)
+      end).to be_a(Moxml::Cdata)
       expect(non_ws_children[2]).to be_a(Moxml::ProcessingInstruction)
     end
   end

data/spec/integration/shared_examples/node_wrappers/entity_reference_behavior.rb

@@ -129,16 +129,20 @@ RSpec.shared_examples "Moxml::EntityReference" do
 
   describe "entity restoration" do
     it "restores standard XML entities when enabled" do
-      ctx_restore = Moxml.new(context.config.adapter_name) { |c| c.restore_entities = true }
+      ctx_restore = Moxml.new(context.config.adapter_name) do |c|
+        c.restore_entities = true
+      end
       doc = ctx_restore.parse("<p>a&amp;b</p>")
       output = doc.to_xml
       expect(output).to include("&amp;")
     end
 
     it "does not create entity references when disabled" do
-      ctx_no_restore = Moxml.new(context.config.adapter_name) { |c| c.restore_entities = false }
+      ctx_no_restore = Moxml.new(context.config.adapter_name) do |c|
+        c.restore_entities = false
+      end
       doc = ctx_no_restore.parse("<p>text</p>")
-      refs = doc.root.children.select { |c| c.is_a?(Moxml::EntityReference) }
+      refs = doc.root.children.grep(Moxml::EntityReference)
       expect(refs).to be_empty
     end
   end
@@ -197,7 +201,9 @@ RSpec.shared_examples "Moxml::EntityReference" do
 
     it "rejects invalid modes" do
       cfg = Moxml::Config.new(context.config.adapter_name)
-      expect { cfg.entity_restoration_mode = :bogus }.to raise_error(ArgumentError)
+      expect do
+        cfg.entity_restoration_mode = :bogus
+      end.to raise_error(ArgumentError)
     end
 
     it "restores non-standard entities in lenient mode" do

data/spec/integration/shared_examples/node_wrappers/node_set_behavior.rb

@@ -42,7 +42,7 @@ RSpec.shared_examples "Moxml::NodeSet" do
 
       it "compares nodes" do
         xpath_results = doc.xpath("//child")
-        element_children = doc.root.children.select { |c| c.is_a?(Moxml::Element) }
+        element_children = doc.root.children.grep(Moxml::Element)
         expect(xpath_results.map(&:native)).to eq(element_children.map(&:native))
       end
     end

data/spec/moxml/adapter/headed_ox_spec.rb

@@ -145,7 +145,7 @@ RSpec.describe Moxml::Adapter::HeadedOx do
     it "returns first matching node" do
       result = adapter.at_xpath(doc, "//book")
 
-      expect(result).to be_a(::Ox::Element)
+      expect(result).to be_a(Ox::Element)
       expect(result.name).to eq("book")
     end
 

data/spec/moxml/lazy_parse_spec.rb

@@ -86,7 +86,7 @@ RSpec.describe "Moxml lazy parse" do
 
       it "round-trips through serialize" do
         doc = ctx.parse(xml)
-        serialized = doc.to_xml
+        serialized = doc.to_xml(indent: 0)
         doc2 = ctx.parse(serialized)
         expect(doc2.root.name).to eq("root")
         expect(doc2.root.children.to_a.size).to eq(2)

data/spec/moxml/moxml_spec.rb

@@ -2,28 +2,6 @@
 
 # spec/moxml_spec.rb
 RSpec.describe Moxml do
-  around do |example|
-    original_default = Moxml::Config.instance_variable_get(:@default)
-    original_default_adapter = Moxml::Config.instance_variable_get(:@default_adapter)
-
-    Moxml::Config.remove_instance_variable(:@default) if Moxml::Config.instance_variable_defined?(:@default)
-    Moxml::Config.remove_instance_variable(:@default_adapter) if Moxml::Config.instance_variable_defined?(:@default_adapter)
-
-    example.run
-  ensure
-    if original_default.nil?
-      Moxml::Config.remove_instance_variable(:@default) if Moxml::Config.instance_variable_defined?(:@default)
-    else
-      Moxml::Config.instance_variable_set(:@default, original_default)
-    end
-
-    if original_default_adapter.nil?
-      Moxml::Config.remove_instance_variable(:@default_adapter) if Moxml::Config.instance_variable_defined?(:@default_adapter)
-    else
-      Moxml::Config.instance_variable_set(:@default_adapter, original_default_adapter)
-    end
-  end
-
   it "has a version number" do
     expect(Moxml::VERSION).not_to be_nil
   end
@@ -45,7 +23,6 @@ RSpec.describe Moxml do
 
   describe ".configure" do
     around do |example|
-      # preserve the original config because it may be changed in examples
       described_class.with_config { example.run }
     end
 
@@ -56,23 +33,6 @@ RSpec.describe Moxml do
       expect(context.config.adapter_name).to eq(:nokogiri)
     end
 
-    it "defaults to oga on Opal" do
-      stub_const("RUBY_ENGINE", "opal")
-
-      context = described_class.new
-      expect(context.config.adapter_name).to eq(:oga)
-    end
-
-    it "prefers ox when it is already loaded" do
-      allow(Object).to receive(:const_defined?).and_call_original
-      allow(Object).to receive(:const_defined?).with(:Nokogiri).and_return(false)
-      allow(Object).to receive(:const_defined?).with(:Ox).and_return(true)
-      allow(Object).to receive(:const_defined?).with(:Oga).and_return(false)
-
-      context = described_class.new
-      expect(context.config.adapter_name).to eq(:ox)
-    end
-
     it "uses configured options from the block" do
       described_class.configure do |config|
         config.default_adapter = :oga
@@ -86,4 +46,10 @@ RSpec.describe Moxml do
       expect(context.config.default_encoding).to eq("US-ASCII")
     end
   end
+
+  describe "Config.runtime_default_adapter" do
+    it "returns a valid adapter for the current runtime" do
+      expect(Moxml::Config::VALID_ADAPTERS).to include(Moxml::Config.runtime_default_adapter)
+    end
+  end
 end

data/spec/moxml/native_attachment/native_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require_relative "shared_examples"
+
+RSpec.describe Moxml::NativeAttachment::Native do
+  it_behaves_like "an attachment backend"
+
+  it "stores attachments outside native object instance variables" do
+    attachments = described_class.new
+    native = Object.new
+
+    attachments.set(native, :entity_refs, ["amp"])
+
+    aggregate_failures do
+      expect(attachments.get(native, :entity_refs)).to eq(["amp"])
+      expect(native.instance_variables).to be_empty
+    end
+  end
+
+  it "registers one finalizer per native object that clears sidecar storage" do
+    attachments = described_class.new
+    native = Object.new
+    other_native = Object.new
+    finalizers = {}.compare_by_identity
+
+    expect(ObjectSpace).to receive(:define_finalizer)
+      .with(native, kind_of(Proc)).once do |object, finalizer|
+        finalizers[object] = finalizer
+      end
+    expect(ObjectSpace).to receive(:define_finalizer)
+      .with(other_native, kind_of(Proc)).once do |object, finalizer|
+        finalizers[object] = finalizer
+      end
+
+    attachments.set(native, :entity_refs, ["amp"])
+    attachments.set(native, :doctype, "html")
+    attachments.set(other_native, :entity_refs, ["lt"])
+
+    native_id = native.object_id
+    data = attachments.instance_variable_get(:@data)
+    registered = attachments.instance_variable_get(:@finalizer_registered)
+
+    aggregate_failures do
+      expect(data).to have_key(native_id)
+      expect(registered).to have_key(native_id)
+    end
+
+    finalizers.fetch(native).call
+
+    aggregate_failures do
+      expect(data).not_to have_key(native_id)
+      expect(registered).not_to have_key(native_id)
+      expect(attachments.get(other_native, :entity_refs)).to eq(["lt"])
+    end
+  end
+end

data/spec/moxml/native_attachment/opal_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require_relative "shared_examples"
+
+RSpec.describe Moxml::NativeAttachment::Opal do
+  it_behaves_like "an attachment backend"
+
+  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/native_attachment/shared_examples.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "an attachment backend" 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
+end

data/spec/moxml/native_attachment_spec.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "open3"
+require "rbconfig"
+require "spec_helper"
+
+RSpec.describe Moxml::NativeAttachment do
+  describe ".default_backend" do
+    it "uses the Opal backend under Opal" do
+      stub_const("RUBY_ENGINE", "opal")
+
+      expect(described_class.default_backend).to be_a(described_class::Opal)
+    end
+
+    it "uses the native backend under non-Opal Ruby engines" do
+      stub_const("RUBY_ENGINE", "ruby")
+
+      expect(described_class.default_backend).to be_a(described_class::Native)
+    end
+  end
+
+  describe "facade" do
+    subject(:attachments) { described_class.new }
+
+    let(:native) { Object.new }
+
+    it "delegates storage calls to the configured backend" do
+      backend = Class.new do
+        attr_reader :calls
+
+        def initialize
+          @calls = []
+        end
+
+        def get(native, key)
+          @calls << [:get, native, key]
+          :stored_value
+        end
+
+        def set(native, key, value)
+          @calls << [:set, native, key, value]
+        end
+
+        def key?(native, key)
+          @calls << [:key?, native, key]
+          true
+        end
+
+        def delete(native, key)
+          @calls << [:delete, native, key]
+          :stored_value
+        end
+      end.new
+      attachments = described_class.new(backend: backend)
+
+      expect(attachments.get(native, :entity_refs)).to eq(:stored_value)
+      attachments.set(native, :entity_refs, ["amp"])
+      expect(attachments.key?(native, :entity_refs)).to be(true)
+      expect(attachments.delete(native, :entity_refs)).to eq(:stored_value)
+
+      expect(backend.calls).to eq(
+        [
+          [:get, native, :entity_refs],
+          [:set, native, :entity_refs, ["amp"]],
+          [:key?, native, :entity_refs],
+          [:delete, native, :entity_refs],
+        ],
+      )
+    end
+
+    it "uses the selected runtime backend" do
+      expected_class = if RUBY_ENGINE == "opal"
+                         described_class::Opal
+                       else
+                         described_class::Native
+                       end
+
+      expect(attachments.backend).to be_a(expected_class)
+    end
+  end
+
+  describe "loader" do
+    let(:lib_dir) { File.expand_path("../../lib", __dir__) }
+    let(:ruby) { RbConfig.ruby }
+
+    it "loads NativeAttachment through the top-level moxml entrypoint" do
+      stdout, stderr, status = Open3.capture3(
+        ruby,
+        "-I",
+        lib_dir,
+        "-e",
+        'require "moxml"; puts Moxml::NativeAttachment.new.respond_to?(:set)',
+      )
+
+      expect(status.success?).to be(true), stderr
+      expect(stdout).to eq("true\n")
+    end
+
+    it "loads NativeAttachment through the internal facade file" do
+      stdout, stderr, status = Open3.capture3(
+        ruby,
+        "-I",
+        lib_dir,
+        "-e",
+        'require "moxml/native_attachment"; puts Moxml::NativeAttachment.new.respond_to?(:set)',
+      )
+
+      expect(status.success?).to be(true), stderr
+      expect(stdout).to eq("true\n")
+    end
+
+    it "registers backend implementations with require-style autoload paths" do
+      stdout, stderr, status = Open3.capture3(
+        ruby,
+        "-I",
+        lib_dir,
+        "-e",
+        <<~RUBY,
+          require "moxml/native_attachment"
+
+          puts Moxml::NativeAttachment.autoload?(:Opal)
+          puts Moxml::NativeAttachment.autoload?(:Native)
+        RUBY
+      )
+
+      expect(status.success?).to be(true), stderr
+      expect(stdout).to eq(
+        "moxml/native_attachment/opal\n" \
+        "moxml/native_attachment/native\n",
+      )
+    end
+
+    it "loads the native backend lazily when selected" do
+      stdout, stderr, status = Open3.capture3(
+        ruby,
+        "-I",
+        lib_dir,
+        "-e",
+        <<~'RUBY',
+          require "moxml/native_attachment"
+
+          puts $LOADED_FEATURES.grep(%r{/native_attachment/native\.rb\z}).empty?
+          puts Moxml::NativeAttachment.new.backend.class
+          puts !$LOADED_FEATURES.grep(%r{/native_attachment/native\.rb\z}).empty?
+          puts $LOADED_FEATURES.grep(%r{/native_attachment/opal\.rb\z}).empty?
+        RUBY
+      )
+
+      expect(status.success?).to be(true), stderr
+      expect(stdout).to eq(
+        "true\n" \
+        "Moxml::NativeAttachment::Native\n" \
+        "true\n" \
+        "true\n",
+      )
+    end
+
+    it "does not load the native backend when Opal is selected" do
+      stdout, stderr, status = Open3.capture3(
+        ruby,
+        "-I",
+        lib_dir,
+        "-e",
+        <<~'RUBY',
+          Object.send(:remove_const, :RUBY_ENGINE)
+          RUBY_ENGINE = "opal"
+
+          require "moxml/native_attachment"
+
+          puts Moxml::NativeAttachment.autoload?(:Native)
+          puts Moxml::NativeAttachment.new.backend.class
+          puts $LOADED_FEATURES.grep(%r{/native_attachment/native\.rb\z}).empty?
+        RUBY
+      )
+
+      expect(status.success?).to be(true), stderr
+      expect(stdout).to eq(
+        "moxml/native_attachment/native\n" \
+        "Moxml::NativeAttachment::Opal\n" \
+        "true\n",
+      )
+    end
+  end
+end

data/spec/moxml/text_spec.rb

@@ -19,6 +19,29 @@ RSpec.describe Moxml::Text do
       text = doc.root.children.first
       expect(text.to_xml).to eq("plain text")
     end
+
+    it "escapes XML special characters" do
+      escaped_doc = context.parse("<root>a &lt; b &amp; c</root>")
+      text = escaped_doc.root.children.first
+      expect(text.to_xml).to eq("a &lt; b &amp; c")
+    end
+  end
+
+  describe "#to_s" do
+    it "returns text content" do
+      text = doc.root.children.first
+      expect(text.to_s).to eq("plain text")
+    end
+
+    it "is consistent across adapters" do
+      Moxml::Adapter::AVALIABLE_ADAPTERS.each do |adapter_name|
+        ctx = Moxml.new(adapter_name)
+        d = ctx.parse("<root>hello world</root>")
+        text = d.root.children.first
+        expect(text.to_s).to eq("hello world"),
+                             "Text#to_s for #{adapter_name} adapter"
+      end
+    end
   end
 
   describe "creation" do