moxml 0.1.18 → 0.1.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1daf227e9effc582c66e780516135481aa48e467226a4267974633a4673f786
-  data.tar.gz: 5b230e79a208eb4b1c5e32175df364e5b42f9e766c4c8189eb18fcad09bb79bf
+  metadata.gz: 76508cc0d2699469ade87f48e38ea73289abc4f95cb7a313f6d71548477248f3
+  data.tar.gz: 1752cb433953a869cedd1d88fc565c53f77bd08201c5977247150e1e7b75a386
 SHA512:
-  metadata.gz: e39941f6f51567655c246f1e8d6225c6ab572c68958fd9ca4a74ca191af4493e1bf74ff0feed84792cc87e5681cce1d8ae291533e992d07b70fdfb1063d96a67
-  data.tar.gz: 41ca4a3954bf2e713703124758309e5d1e056d44826cdacf3b4693c5bf37c463579462a6c0ecb3aa65e4c3cafaeef1e2ad0d8a5af9ebe2e1b9f4a695e7678ff4
+  metadata.gz: a4219577f2e00a9e4f00f1ce1bbaf4f03d6c841dfe8adb9983162a6389b1e276725984dc010f451cac55fbd8049a81451d641fc073fc1cf8417f90ee6e50cdf5
+  data.tar.gz: 44f3e08b174e2689fed3a60ee3ef0b805fdc14cbeeb905ebde15e5241be3e3f168441dc95afe99dd244fc1047c581fce912ec3e061299e4e101f63329f00def9

data/README.adoc

@@ -33,7 +33,7 @@ Moxml supports the following XML libraries:
 REXML:: https://github.com/ruby/rexml[REXML], a pure Ruby XML parser
 distributed with standard Ruby. Not the fastest, but always available.
 
-Nokogiri:: (default) https://github.com/sparklemotion/nokogiri[Nokogiri], a
+Nokogiri:: https://github.com/sparklemotion/nokogiri[Nokogiri], a
 widely used implementation which wraps around the performant
 https://github.com/GNOME/libxml2[libxml2] C library.
 
@@ -47,6 +47,29 @@ LibXML:: https://github.com/xml4r/libxml-ruby[libxml-ruby], Ruby bindings
 for the performant https://github.com/GNOME/libxml2[libxml2] C library.
 Alternative to Nokogiri with similar performance characteristics.
 
+==== Default adapter selection
+
+When no adapter is explicitly specified, Moxml selects one automatically based on
+the runtime environment:
+
+. If running on Opal (`RUBY_ENGINE == "opal"`), Oga is used (pure Ruby, no C extensions)
+. Otherwise, Moxml detects already-loaded XML libraries in this order:
+  .. Nokogiri
+  .. Ox
+  .. Oga
+. If none of the above are loaded, Nokogiri is the fallback default
+
+[source,ruby]
+----
+# Automatic detection — picks the best available adapter
+ctx = Moxml.new
+ctx.config.adapter_name  # => :nokogiri (or :oga on Opal)
+
+# Explicit override — always takes precedence
+ctx = Moxml.new(:ox)
+ctx.config.adapter_name  # => :ox
+----
+
 === Feature table
 
 Moxml exercises its best effort to provide a consistent interface across basic

data/lib/moxml/config.rb

@@ -21,7 +21,7 @@ module Moxml
       end
 
       def default_adapter
-        @default_adapter ||= runtime_default_adapter
+        @default_adapter || runtime_default_adapter
       end
 
       def runtime_default_adapter

data/lib/moxml/native_attachment/native.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Moxml
+  class NativeAttachment
+    # 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 Native
+      def initialize
+        @data = {}
+        @finalizer_registered = {}
+        @monitor = Monitor.new
+      end
+
+      def get(native, key)
+        @monitor.synchronize { @data[native.object_id]&.[](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
+      end
+
+      def key?(native, key)
+        @monitor.synchronize { @data[native.object_id]&.key?(key) || false }
+      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
+      end
+    end
+  end
+end

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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.1.18"
+  VERSION = "0.1.19"
 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/xpath/functions/node_functions_spec.rb

@@ -127,7 +127,7 @@ RSpec.describe "XPath Node Functions" do
     it "inherits language from parent element" do
       ast = Moxml::XPath::Parser.parse('lang("en")')
       proc = Moxml::XPath::Compiler.compile_with_cache(ast)
-      child = doc_with_lang.root.children.first
+      child = doc_with_lang.root.children.select { |c| c.is_a?(Moxml::Element) }.first
       result = proc.call(child)
 
       expect(result).to be true
@@ -136,7 +136,8 @@ RSpec.describe "XPath Node Functions" do
     it "uses closest xml:lang attribute" do
       ast = Moxml::XPath::Parser.parse('lang("fr")')
       proc = Moxml::XPath::Compiler.compile_with_cache(ast)
-      other = doc_with_lang.root.children[1]
+      elements = doc_with_lang.root.children.select { |c| c.is_a?(Moxml::Element) }
+      other = elements[1]
       result = proc.call(other)
 
       expect(result).to be true

data/spec/performance/benchmark_spec.rb

@@ -30,7 +30,7 @@ RSpec.shared_examples "Performance Examples" do
           rexml: { parser: 0, serializer: 5 },
           ox: { parser: 2, serializer: 1000 },
           headed_ox: { parser: 2, serializer: 1000 },
-          libxml: { parser: 10, serializer: 30 },
+          libxml: { parser: 2, serializer: 3 },
         }
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.1.18
+  version: 0.1.19
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-27 00:00:00.000000000 Z
+date: 2026-05-01 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -141,6 +141,8 @@ files:
 - lib/moxml/error.rb
 - lib/moxml/namespace.rb
 - lib/moxml/native_attachment.rb
+- lib/moxml/native_attachment/native.rb
+- lib/moxml/native_attachment/opal.rb
 - lib/moxml/node.rb
 - lib/moxml/node_set.rb
 - lib/moxml/processing_instruction.rb
@@ -325,6 +327,10 @@ files:
 - spec/moxml/moxml_spec.rb
 - spec/moxml/namespace_spec.rb
 - spec/moxml/namespace_uri_validation_spec.rb
+- spec/moxml/native_attachment/native_spec.rb
+- spec/moxml/native_attachment/opal_spec.rb
+- spec/moxml/native_attachment/shared_examples.rb
+- spec/moxml/native_attachment_spec.rb
 - spec/moxml/node_cache_spec.rb
 - spec/moxml/node_set_cache_spec.rb
 - spec/moxml/node_set_spec.rb