moxml 0.1.16 → 0.1.17

data/spec/moxml/entity_registry_spec.rb

@@ -181,4 +181,72 @@ RSpec.describe Moxml::EntityRegistry do
       expect(registry.load_all).to be(registry)
     end
   end
+
+  describe "#standard_entity?" do
+    it "returns true for the 5 standard XML entities" do
+      registry = described_class.new
+      expect(registry.standard_entity?(0x26)).to be true  # amp
+      expect(registry.standard_entity?(0x3C)).to be true  # lt
+      expect(registry.standard_entity?(0x3E)).to be true  # gt
+      expect(registry.standard_entity?(0x22)).to be true  # quot
+      expect(registry.standard_entity?(0x27)).to be true  # apos
+    end
+
+    it "returns false for non-standard codepoints" do
+      registry = described_class.new
+      expect(registry.standard_entity?(0xA0)).to be false   # nbsp
+      expect(registry.standard_entity?(0xA9)).to be false   # copy
+      expect(registry.standard_entity?(0x30)).to be false   # '0'
+    end
+  end
+
+  describe "#should_restore?" do
+    it "always restores the 5 standard XML entities regardless of config" do
+      registry = described_class.new
+      config = Moxml::Config.new(:nokogiri)
+      config.restore_entities = false
+      expect(registry.should_restore?(0x26, config: config)).to be true  # amp
+      expect(registry.should_restore?(0x3C, config: config)).to be true  # lt
+    end
+
+    it "restores non-standard entities when restore_entities is true and mode is lenient" do
+      registry = described_class.new
+      config = Moxml::Config.new(:nokogiri)
+      config.restore_entities = true
+      config.entity_restoration_mode = :lenient
+      expect(registry.should_restore?(0xA0, config: config)).to be true  # nbsp
+      expect(registry.should_restore?(0xA9, config: config)).to be true  # copy
+    end
+
+    it "does not restore non-standard entities when restore_entities is false" do
+      registry = described_class.new
+      config = Moxml::Config.new(:nokogiri)
+      config.restore_entities = false
+      expect(registry.should_restore?(0xA0, config: config)).to be false
+    end
+
+    it "returns false for codepoints not in the registry" do
+      registry = described_class.new(mode: :disabled)
+      config = Moxml::Config.new(:nokogiri)
+      config.restore_entities = true
+      expect(registry.should_restore?(0x30, config: config)).to be false # '0'
+    end
+  end
+
+  describe "#restorable_codepoints" do
+    it "returns the set of codepoints that could be restored" do
+      registry = described_class.new
+      codepoints = registry.restorable_codepoints
+      expect(codepoints).to be_a(Set)
+      expect(codepoints).to include(0x26)  # amp
+      expect(codepoints).to include(0xA0)  # nbsp
+      expect(codepoints.size).to be > 100
+    end
+
+    it "returns only standard codepoints for empty registry" do
+      registry = described_class.new(mode: :disabled)
+      codepoints = registry.restorable_codepoints
+      expect(codepoints).to eq(described_class::STANDARD_CODEPOINTS)
+    end
+  end
 end

data/spec/moxml/xpath/axes_spec.rb

@@ -222,7 +222,6 @@ RSpec.describe "XPath Axes" do
     end
 
     it "combines attribute axis with wildcards" do
-      skip "HeadedOx limitation: Attribute wildcard (@*) not supported by XPath parser. See docs/_pages/headed-ox-limitations.adoc"
       ast = Moxml::XPath::Parser.parse("//book/@*")
       proc = Moxml::XPath::Compiler.compile_with_cache(ast)
       result = proc.call(book_doc)

data/spec/moxml/xpath/compiler_spec.rb

@@ -153,7 +153,6 @@ RSpec.describe Moxml::XPath::Compiler do
     end
 
     it "works with wildcards" do
-      skip "HeadedOx limitation: Wildcard count differs due to Ox's DOM structure. See docs/_pages/headed-ox-limitations.adoc"
       ast = Moxml::XPath::Parser.parse("//*")
       proc = described_class.compile_with_cache(ast)
       result = proc.call(nested_doc)
@@ -189,7 +188,6 @@ RSpec.describe Moxml::XPath::Compiler do
     end
 
     it "works with wildcards" do
-      skip "HeadedOx limitation: Attribute wildcard (@*) not supported by XPath parser. See docs/_pages/headed-ox-limitations.adoc"
       ast = Moxml::XPath::Parser.parse("/root/book/@*")
       proc = described_class.compile_with_cache(ast)
       result = proc.call(attr_doc)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.1.16
+  version: 0.1.17
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-22 00:00:00.000000000 Z
+date: 2026-04-24 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -34,16 +34,6 @@ files:
 - LICENSE.md
 - README.adoc
 - Rakefile
-- TODO.remaining/1-entity-reference-adapter-support.md
-- TODO.remaining/2-entity-restoration-model-driven.md
-- TODO.remaining/3-entity-reference-test-coverage.md
-- TODO.remaining/4-lenient-entities-mode.md
-- TODO.remaining/5-fixture-integrity.md
-- TODO.remaining/6-ox-element-ordering-bug.md
-- TODO.remaining/7-headed-ox-limitations.md
-- TODO.remaining/8-xpath-predicate-gaps.md
-- TODO.remaining/9-cleanup-hygiene.md
-- TODO.remaining/README.md
 - benchmarks/.gitignore
 - benchmarks/generate_report.rb
 - bin/console
@@ -277,6 +267,7 @@ files:
 - spec/integration/all_adapters_spec.rb
 - spec/integration/headed_ox_integration_spec.rb
 - spec/integration/shared_examples/edge_cases.rb
+- spec/integration/shared_examples/entity_reference_whitespace.rb
 - spec/integration/shared_examples/high_level/.gitkeep
 - spec/integration/shared_examples/high_level/builder_behavior.rb
 - spec/integration/shared_examples/high_level/context_behavior.rb
@@ -302,6 +293,7 @@ files:
 - spec/moxml/adapter/.gitkeep
 - spec/moxml/adapter/README.md
 - spec/moxml/adapter/base_spec.rb
+- spec/moxml/adapter/entity_restoration_spec.rb
 - spec/moxml/adapter/headed_ox_spec.rb
 - spec/moxml/adapter/libxml_spec.rb
 - spec/moxml/adapter/nokogiri_spec.rb
@@ -325,6 +317,8 @@ files:
 - spec/moxml/document_builder_spec.rb
 - spec/moxml/document_spec.rb
 - spec/moxml/element_spec.rb
+- spec/moxml/entity_preservation_spec.rb
+- spec/moxml/entity_reference_spec.rb
 - spec/moxml/entity_registry_spec.rb
 - spec/moxml/error_spec.rb
 - spec/moxml/lazy_parse_spec.rb

data/TODO.remaining/1-entity-reference-adapter-support.md

@@ -1,157 +0,0 @@
-# TODO 1: EntityReference Adapter Support for Ox, Oga, REXML, LibXML, HeadedOx
-
-## Problem
-
-Only the Nokogiri adapter implements `create_native_entity_reference` and maps
-its native type to `:entity_reference` in `node_type`. The other 5 adapters
-will raise `NotImplementedError` if `restore_entities` is enabled or if any
-code path calls `create_entity_reference`. This makes the entire
-EntityReference feature **non-functional** outside Nokogiri.
-
-## Current State (verified)
-
-| Adapter   | `create_native_entity_reference` | `node_type` mapping | Serialization | Status |
-|-----------|----------------------------------|---------------------|---------------|--------|
-| Nokogiri  | Done (`Nokogiri::XML::EntityReference.new`) | Done | Native | Working |
-| Ox        | Missing | Missing | Uses `Ox.dump` (C-level, won't handle custom types) | Broken |
-| HeadedOx  | Missing (inherits Ox) | Missing | Same as Ox | Broken |
-| Oga       | Missing | Missing | Uses `CustomizedOga::XmlGenerator` | Broken |
-| REXML     | Missing | Missing | Uses REXML's `write` | Broken |
-| LibXML    | Missing | Missing | Uses custom serializer with wrapper detection | Broken |
-
-## Architecture
-
-EntityReference follows the same pattern as other non-native node types in Moxml:
-a **wrapper class** that represents what the underlying library cannot express natively.
-
-Each adapter needs three things:
-1. **Wrapper class** (`CustomizedXxx::EntityReference`) — holds the entity name
-2. **`node_type` mapping** — so `Node.wrap` can create the correct Moxml type
-3. **Serialization** — so `to_xml` outputs `&name;`
-
-The existing pattern: `CustomizedOx::Text` extends `::Ox::Node`,
-`CustomizedOx::Attribute` extends `::Ox::Node`. EntityReference should follow suit.
-
-### Serialization Challenge for Ox
-
-Ox's `serialize` calls `::Ox.dump(node)` which is C-level — it only handles
-Ox native types. For EntityReference wrappers to survive serialization, we need
-one of:
-
-- **Option A**: Custom serialization in the adapter that walks the tree manually,
-  detecting EntityReference wrappers and emitting `&name;` directly.
-- **Option B**: Convert EntityReferences to their text equivalent before calling
-  `Ox.dump`, restoring them in a post-processing step. This is fragile.
-- **Option C**: Override `serialize` for Element nodes to handle children
-  individually, using `Ox.dump` for native children but handling wrappers
-  directly.
-
-**Recommended: Option A** — it's how `CustomizedOga::XmlGenerator` already works
-for Oga. A similar tree-walking serializer for Ox gives full control.
-
-For LibXML, the existing serializer already checks `node.respond_to?(:to_xml)`
-for wrapper classes, so adding an EntityReference wrapper with `to_xml` returning
-`"&#{name};"` should integrate cleanly.
-
-## Implementation Steps
-
-### Ox Adapter
-
-1. Create `lib/moxml/adapter/customized_ox/entity_reference.rb`:
-   ```ruby
-   module Moxml::Adapter::CustomizedOx
-     class EntityReference < ::Ox::Node
-       attr_reader :name
-
-       def initialize(name)
-         @name = name
-         super()  # Ox::Node requires no args or a value
-       end
-
-       def to_xml
-         "&#{@name};"
-       end
-       alias to_s to_xml
-     end
-   end
-   ```
-
-2. Add to `lib/moxml/adapter/ox.rb`:
-   - `create_native_entity_reference(name)` → `CustomizedOx::EntityReference.new(name)`
-   - `node_type`: add `when CustomizedOx::EntityReference then :entity_reference`
-   - `patch_node`: handle EntityReference wrapper in child list
-   - `entity_reference_name(node)`: return `node.name`
-   - Serialization: handle EntityReference children when walking the tree
-
-3. Add to `lib/moxml/adapter/ox.rb` `unpatch_node`: return wrapper as-is
-   (it extends Ox::Node so it can stay in the tree)
-
-### HeadedOx Adapter
-
-HeadedOx inherits from Ox, so it gets Ox's EntityReference support
-automatically once Ox is done. Verify that the XPath engine doesn't
-break when encountering EntityReference nodes in the tree.
-
-### Oga Adapter
-
-1. Create `lib/moxml/adapter/customized_oga/entity_reference.rb`:
-   ```ruby
-   module Moxml::Adapter::CustomizedOga
-     class EntityReference
-       attr_reader :name
-
-       def initialize(name)
-         @name = name
-       end
-
-       def to_xml
-         "&#{@name};"
-       end
-     end
-   end
-   ```
-
-2. Add to `lib/moxml/adapter/oga.rb`:
-   - `create_native_entity_reference(name)` → `CustomizedOga::EntityReference.new(name)`
-   - `node_type`: add `when CustomizedOga::EntityReference then :entity_reference`
-   - Update `CustomizedOga::XmlGenerator` to handle EntityReference children
-   - `entity_reference_name(node)`: return `node.name`
-
-### REXML Adapter
-
-1. Investigate: REXML has `REXML::Entity` and `REXML::EntityRef` classes.
-   Check if they can be used as native entity reference nodes, or if a
-   wrapper is needed.
-
-2. Add to `lib/moxml/adapter/rexml.rb`:
-   - `create_native_entity_reference(name)` — native or wrapper
-   - `node_type`: add mapping
-   - `entity_reference_name(node)`
-
-### LibXML Adapter
-
-1. Investigate: LibXML Ruby has `LibXML::XML::Node::ENTITY_REF_NODE` constant
-   (value 5). Check if native entity reference nodes can be created.
-
-2. Create `lib/moxml/adapter/customized_libxml/entity_reference.rb` if needed.
-
-3. Add to `lib/moxml/adapter/libxml.rb`:
-   - `create_native_entity_reference(name)`
-   - `node_type`: add `ENTITY_REF_NODE` mapping or wrapper mapping
-   - `entity_reference_name(node)`
-   - The existing serializer already handles wrappers with `to_xml` —
-     verify EntityReference works in this path.
-
-## Files to Create/Modify
-
-### New Files
-- `lib/moxml/adapter/customized_ox/entity_reference.rb`
-- `lib/moxml/adapter/customized_oga/entity_reference.rb`
-- Possibly: `lib/moxml/adapter/customized_libxml/entity_reference.rb`
-
-### Modified Files
-- `lib/moxml/adapter/ox.rb` — create_native_entity_reference, node_type, serialization
-- `lib/moxml/adapter/oga.rb` — create_native_entity_reference, node_type, XmlGenerator
-- `lib/moxml/adapter/rexml.rb` — create_native_entity_reference, node_type
-- `lib/moxml/adapter/libxml.rb` — create_native_entity_reference, node_type
-- `lib/moxml/adapter/headed_ox.rb` — verify inheritance works (likely no changes)

data/TODO.remaining/2-entity-restoration-model-driven.md

@@ -1,169 +0,0 @@
-# TODO 2: Model-Driven Entity Restoration
-
-## Problem
-
-The `restore_entities` feature in `DocumentBuilder` is hardcoded to only handle
-the 5 standard XML entities (amp, lt, gt, quot, apos). It ignores the
-EntityRegistry entirely — despite EntityRegistry knowing 2125+ entities from
-the W3C HTML/MathML set. This means non-standard entities like ` `,
-`©`, `—` are never restored, which is the core round-trip problem
-that motivated the entire entity feature.
-
-Additionally, the restoration logic lives in DocumentBuilder with hardcoded
-knowledge that belongs in the model layer.
-
-## Current State (verified)
-
-`lib/moxml/document_builder.rb:80-110` — `restore_entities_in_text`:
-```ruby
-entity_chars = {
-  "<" => "lt", ">" => "gt", "&" => "amp",
-  '"' => "quot", "'" => "apos",
-}
-```
-
-This is a hardcoded lookup that duplicates knowledge already in EntityRegistry.
-It only triggers for characters `<`, `>`, `&`, `"`, `'` — the regex guard
-`/[<>&"']/` on line 73 prevents it from ever seeing characters like U+00A0
-(non-breaking space, `&nbsp;`).
-
-**Critical**: Because only Nokogiri has `create_native_entity_reference`
-(see TODO 1), `restore_entities` raises `NotImplementedError` on all other
-adapters even for the 5 standard entities.
-
-## XML Entity Model
-
-XML has a clear entity model:
-
-1. **5 predefined entities** (amp, lt, gt, quot, apos) — always available per
-   XML spec. These characters MUST be entity-encoded in certain contexts
-   (e.g., `<` and `&` in text content).
-
-2. **DTD-declared entities** — declared via `<!ENTITY name "value">` in the
-   document's DOCTYPE internal subset or external subset.
-
-3. **API-supplied entities** — registered by the user via
-   `EntityRegistry.register` or `entity_provider` callback.
-
-4. **Bundled detection set** — the W3C HTML/MathML entities bundled in
-   `data/w3c_entities.json`. These are not "declared" in any DTD but are
-   recognized by Moxml for restoration purposes.
-
-The EntityRegistry already knows about categories 1, 3, and 4. Category 2
-(DTD parsing) is future work.
-
-## Design: Model-Driven Restoration
-
-EntityRegistry should be THE source of truth for "should this character become
-an entity reference?" The restoration policy should be:
-
-```ruby
-# In EntityRegistry (or a cooperating policy object)
-STANDARD_CODEPOINTS = [0x26, 0x3C, 0x3E, 0x22, 0x27].freeze  # amp, lt, gt, quot, apos
-
-def should_restore?(codepoint, config:)
-  name = primary_name_for_codepoint(codepoint)
-  return false unless name
-
-  # 1. The 5 standard XML entities are ALWAYS restored.
-  #    These are syntactically required — the XML wouldn't be well-formed
-  #    without encoding them.
-  return true if STANDARD_CODEPOINTS.include?(codepoint)
-
-  # 2. Non-standard entities: only if restore_entities is enabled.
-  return false unless config.restore_entities
-
-  # 3. In the future, strict vs lenient mode will gate this further.
-  #    Strict: only if declared in DTD (not yet implemented).
-  #    Lenient: any known entity name.
-  true
-end
-```
-
-### Changes to DocumentBuilder
-
-Replace the hardcoded hash with delegation to the registry:
-
-```ruby
-def visit_text(node)
-  prepared = adapter.prepare_for_new_document(node, @current_doc.native)
-  content = adapter.text_content(node)
-
-  if should_restore_entities?(content)
-    restore_entities_in_text(content)
-  else
-    @node_stack.last&.add_child(Text.new(prepared, context))
-  end
-end
-
-private
-
-def should_restore_entities?(content)
-  return false unless context.config.restore_entities
-  # Scan for any character that the registry knows about
-  content.to_s.chars.any? { |c| context.entity_registry.should_restore?(c.ord, config: context.config) }
-end
-
-def restore_entities_in_text(content)
-  parent = @node_stack.last
-  return unless parent
-
-  content.to_s.chars.each do |char|
-    codepoint = char.ord
-    name = context.entity_registry.primary_name_for_codepoint(codepoint)
-
-    if context.entity_registry.should_restore?(codepoint, config: context.config)
-      entity_node = adapter.create_entity_reference(name)
-      parent.add_child(EntityReference.new(entity_node, context))
-    else
-      text_node = adapter.create_text(char)
-      parent.add_child(Text.new(text_node, context))
-    end
-  end
-end
-```
-
-**Note**: This splits each text node into per-character nodes. For documents
-with few entity references, this creates unnecessary overhead. A future
-optimization should buffer consecutive non-entity characters into a single
-text node.
-
-### Performance Optimization (deferred)
-
-Instead of character-by-character processing:
-1. Scan the text for characters that have entity names in the registry
-2. Split only at those positions, keeping runs of plain characters together
-3. This reduces node count dramatically for typical documents
-
-```ruby
-def restore_entities_in_text(content)
-  parent = @node_stack.last
-  return unless parent
-
-  buffer = +""
-  content.to_s.chars.each do |char|
-    codepoint = char.ord
-    name = context.entity_registry.primary_name_for_codepoint(codepoint)
-
-    if name && context.entity_registry.should_restore?(codepoint, config: context.config)
-      # Flush buffer before entity
-      if !buffer.empty?
-        parent.add_child(Text.new(adapter.create_text(buffer), context))
-        buffer.clear
-      end
-      parent.add_child(EntityReference.new(adapter.create_entity_reference(name), context))
-    else
-      buffer << char
-    end
-  end
-  # Flush remaining buffer
-  if !buffer.empty?
-    parent.add_child(Text.new(adapter.create_text(buffer), context))
-  end
-end
-```
-
-## Files to Modify
-
-- `lib/moxml/entity_registry.rb` — add `should_restore?` method
-- `lib/moxml/document_builder.rb` — replace hardcoded entity_chars with registry-driven logic

data/TODO.remaining/3-entity-reference-test-coverage.md

@@ -1,170 +0,0 @@
-# TODO 3: EntityReference Test Coverage
-
-## Problem
-
-There are zero tests for EntityReference node behavior, zero tests for
-entity round-trip preservation, and zero adapter-level tests for entity
-reference creation or serialization. Only `EntityRegistry` has tests
-(`spec/moxml/entity_registry_spec.rb`).
-
-This means the entire EntityReference feature is untested — including the
-`restore_entities` config, `create_entity_reference` factory, `visit_entity_reference`
-in DocumentBuilder, and the `entity_reference` Builder DSL method.
-
-## Required Test Coverage
-
-### 1. EntityReference Node Tests
-
-**File**: `spec/moxml/entity_reference_spec.rb`
-
-```ruby
-RSpec.describe Moxml::EntityReference do
-  # Test per adapter (use shared examples)
-  %i[nokogiri].each do |adapter|  # expand as adapters gain support
-    context "with #{adapter} adapter" do
-      let(:ctx) { Moxml.new(adapter) }
-
-      it "creates an entity reference node" do
-        doc = ctx.create_document
-        ref = doc.create_entity_reference("nbsp")
-        expect(ref).to be_a(Moxml::EntityReference)
-        expect(ref.name).to eq("nbsp")
-      end
-
-      it "has empty text content" do
-        doc = ctx.create_document
-        ref = doc.create_entity_reference("amp")
-        expect(ref.text).to eq("")
-        expect(ref.content).to eq("")
-      end
-
-      it "serializes to entity syntax" do
-        doc = ctx.create_document
-        ref = doc.create_entity_reference("mdash")
-        expect(ref.to_xml).to eq("—")
-      end
-
-      it "is recognized as entity_reference type" do
-        doc = ctx.create_document
-        ref = doc.create_entity_reference("copy")
-        expect(ref.entity_reference?).to be true
-      end
-
-      it "survives add_child and retrieval" do
-        doc = ctx.create_document
-        root = doc.create_element("p")
-        doc.root = root
-        ref = doc.create_entity_reference("nbsp")
-        root.add_child(ref)
-        expect(root.children.first).to be_a(Moxml::EntityReference)
-        expect(root.children.first.name).to eq("nbsp")
-      end
-
-      it "validates entity reference name" do
-        doc = ctx.create_document
-        expect {
-          doc.create_entity_reference("123invalid")
-        }.to raise_error(Moxml::ValidationError)
-      end
-    end
-  end
-end
-```
-
-### 2. Builder DSL Tests
-
-**File**: `spec/moxml/builder_spec.rb` (add to existing or create new section)
-
-```ruby
-it "creates entity references via DSL" do
-  doc = Moxml::Builder.new(ctx).build do
-    element("p") { entity_reference("nbsp") }
-  end
-  expect(doc.root.children.first).to be_a(Moxml::EntityReference)
-  expect(doc.to_xml).to include(" ")
-end
-```
-
-### 3. Restore Entities Integration Tests
-
-**File**: `spec/moxml/adapter/entity_restoration_spec.rb` (shared examples)
-
-```ruby
-RSpec.shared_examples "entity restoration" do |adapter_name|
-  context "with #{adapter_name}" do
-    let(:ctx) { Moxml.new(adapter_name, restore_entities: true) }
-
-    it "restores standard XML entities" do
-      doc = ctx.parse("<p>a &amp; b</p>")
-      output = doc.to_xml
-      expect(output).to include("&amp;")
-    end
-
-    it "restores non-standard entities from registry" do
-      # nbsp (U+00A0) is in the bundled W3C entity set
-      doc = ctx.parse("<p>\u00A0</p>")
-      output = doc.to_xml
-      expect(output).to include("&nbsp;")
-    end
-
-    it "preserves entity syntax through round-trip" do
-      doc = ctx.parse("<p>&nbsp;&copy;&mdash;</p>")
-      output = doc.to_xml
-      reparsed = ctx.parse(output)
-      # Text content should be identical after round-trip
-      expect(reparsed.root.text).to eq(doc.root.text)
-    end
-
-    it "does not restore entities when restore_entities is false" do
-      ctx_no_restore = Moxml.new(adapter_name, restore_entities: false)
-      doc = ctx_no_restore.parse("<p>a &amp; b</p>")
-      output = doc.to_xml
-      # Standard entities may still appear as &amp; due to XML escaping,
-      # but no EntityReference nodes should be created
-      expect(doc.root.children).not_to include(a_kind_of(Moxml::EntityReference))
-    end
-  end
-end
-```
-
-### 4. Cross-Adapter Consistency Tests
-
-**File**: `spec/consistency/entity_reference_consistency_spec.rb`
-
-Verify that EntityReference behavior is consistent across all adapters that
-support it:
-- Same entity name produces same serialization
-- Same text content after round-trip
-- Children enumeration includes EntityReference nodes
-
-### 5. EntityRegistry.should_restore? Tests
-
-**File**: Add to `spec/moxml/entity_registry_spec.rb`
-
-```ruby
-describe "#should_restore?" do
-  it "always restores the 5 standard XML entities" do
-    registry = described_class.new
-    config = Moxml::Config.new(:nokogiri)
-    expect(registry.should_restore?(0x26, config: config)).to be true  # amp
-    expect(registry.should_restore?(0x3C, config: config)).to be true  # lt
-  end
-
-  it "restores non-standard entities only when restore_entities is true" do
-    registry = described_class.new
-    config_on = Moxml::Config.new(:nokogiri)
-    config_on.restore_entities = true
-    config_off = Moxml::Config.new(:nokogiri)
-    config_off.restore_entities = false
-
-    expect(registry.should_restore?(0xA0, config: config_on)).to be true   # nbsp
-    expect(registry.should_restore?(0xA0, config: config_off)).to be false
-  end
-end
-```
-
-## Dependencies
-
-- TODO 1 must be partially complete (at least one adapter working) before
-  adapter-level tests can pass
-- TODO 2 must be complete before non-standard entity restoration tests can pass