moxml 0.1.26 → 0.3.0

data/lib/moxml/xpath/compiler.rb

@@ -294,6 +294,12 @@ module Moxml
 
         handler = axis_name.gsub("-", "_")
 
+        unless respond_to?(:"on_axis_#{handler}", true)
+          raise XPath::Error.new(
+            "XPath axis #{axis_name.inspect} is not supported by this engine",
+          )
+        end
+
         send(:"on_axis_#{handler}", test, input, &block)
       end
 
@@ -362,6 +368,78 @@ module Moxml
         end
       end
 
+      # AXIS: ancestor - all ancestors up to the document
+      def on_axis_ancestor(ast, input)
+        ancestor = unique_literal(:ancestor)
+
+        document_or_node(input).if_true do
+          input.ancestors.each.add_block(ancestor) do
+            condition = process(ast, ancestor)
+            if block_given?
+              condition.if_true { yield ancestor }
+            else
+              condition.if_true { ancestor }
+            end
+          end
+        end
+      end
+
+      # AXIS: ancestor-or-self - the context node and its ancestors
+      def on_axis_ancestor_or_self(ast, input)
+        ancestor = unique_literal(:ancestor)
+
+        document_or_node(input).if_true do
+          self_result = process(ast, input)
+          self_collection = if block_given?
+                              self_result.if_true { yield input }
+                            else
+                              self_result.if_true { input }
+                            end
+          self_collection.followed_by do
+            input.ancestors.each.add_block(ancestor) do
+              condition = process(ast, ancestor)
+              if block_given?
+                condition.if_true { yield ancestor }
+              else
+                condition.if_true { ancestor }
+              end
+            end
+          end
+        end
+      end
+
+      # AXIS: following-sibling - siblings after the context node
+      def on_axis_following_sibling(ast, input)
+        sibling = unique_literal(:sibling)
+
+        document_or_node(input).if_true do
+          input.following_siblings.each.add_block(sibling) do
+            condition = process(ast, sibling)
+            if block_given?
+              condition.if_true { yield sibling }
+            else
+              condition.if_true { sibling }
+            end
+          end
+        end
+      end
+
+      # AXIS: preceding-sibling - siblings before the context node
+      def on_axis_preceding_sibling(ast, input)
+        sibling = unique_literal(:sibling)
+
+        document_or_node(input).if_true do
+          input.preceding_siblings.each.add_block(sibling) do
+            condition = process(ast, sibling)
+            if block_given?
+              condition.if_true { yield sibling }
+            else
+              condition.if_true { sibling }
+            end
+          end
+        end
+      end
+
       # AXIS: descendant-or-self - Enables // operator
       def on_axis_descendant_or_self(ast, input)
         node = unique_literal(:descendant)
@@ -425,15 +503,22 @@ module Moxml
         end
       end
 
-      # AXIS: attribute - Enables @attribute syntax
+      # AXIS: attribute - Enables @attribute syntax. Name tests share
+      # the resolver's expanded-name semantics (Namespaces 1.0): bare
+      # names match no-namespace attributes only; prefixed names match
+      # by namespace URI, never by prefix spelling.
       def on_axis_attribute(ast, input)
         elem_class = const_ref("Moxml", "Element")
         attribute = unique_literal(:attribute)
 
         input.is_a?(elem_class).if_true do
           input.attributes.each.add_block(attribute) do
-            # Use process to handle both :test and :wildcard nodes
-            condition = process(ast, attribute)
+            condition = if ast.type == :test
+                          attribute_test_condition(ast, input, attribute)
+                        else
+                          # Wildcards and node types keep the generic path
+                          process(ast, attribute)
+                        end
 
             if block_given?
               condition.if_true { yield attribute }
@@ -444,6 +529,34 @@ module Moxml
         end
       end
 
+      # Attribute node-test condition built on AttributeResolver. The
+      # XPath context's prefix mapping (when provided) wins over the
+      # document's own declarations and is resolved at compile time.
+      # Returns nil for the both-wildcard test (@*): no name constraint.
+      def attribute_test_condition(ast, element, attribute)
+        resolver = const_ref("Moxml", "AttributeResolver")
+        ns = ast.value[:namespace]
+        name = ast.value[:name]
+
+        return nil if name == STAR && (!ns || ns == STAR)
+
+        local = name == STAR ? self_nil : string(name)
+
+        if ns && ns != STAR && @namespaces && (uri = @namespaces[ns])
+          return resolver.attribute_test_uri?(element, attribute,
+                                              string(uri.to_s), local)
+        end
+
+        prefix = if ns.nil?
+                   self_nil
+                 elsif ns == STAR
+                   symbol(:any)
+                 else
+                   string(ns)
+                 end
+        resolver.attribute_test?(element, attribute, prefix, local)
+      end
+
       # AXIS: descendant - All descendant nodes (without self)
       def on_axis_descendant(ast, input)
         node = unique_literal(:descendant)
@@ -494,6 +607,13 @@ module Moxml
         when "node"
           # node() matches everything — use a truthy literal
           Ruby::Node.new(:lit, ["true"])
+        when "text"
+          # CDATA sections are text nodes in the XPath data model
+          text_class = const_ref("Moxml", "Text")
+          cdata_class = const_ref("Moxml", "Cdata")
+          input.is_a?(text_class).or(input.is_a?(cdata_class))
+        when "comment"
+          input.is_a?(const_ref("Moxml", "Comment"))
         else element_or_attribute(input)
         end
       end
@@ -531,9 +651,21 @@ module Moxml
         # Match namespace if specified
         if ns && ns != STAR
           if @namespaces && @namespaces[ns]
-            # Resolve prefix to URI using namespace mappings
+            # Resolve prefix to URI using namespace mappings. An empty
+            # URI binding ("xmlns" => "") selects elements in no
+            # namespace, e.g. after an xmlns="" undeclaration.
             ns_uri = @namespaces[ns]
-            ns_match = input.namespace.and(input.namespace.uri.eq(string(ns_uri)))
+            ns_match = if ns_uri.to_s.empty?
+                         input.namespace.nil?.or(input.namespace.uri.eq(string("")))
+                       else
+                         input.namespace.and(input.namespace.uri.eq(string(ns_uri)))
+                       end
+          elsif ns == "xmlns"
+            # Nokogiri-compatible reserved prefix: xmlns:name addresses
+            # elements in the default namespace (no prefix).
+            ns_match = input.namespace.and(
+              input.namespace.prefix.to_s.eq(string("")),
+            )
           else
             # No mapping provided - check against element's namespace prefix
             # Need to ensure input.namespace exists first
@@ -569,7 +701,11 @@ module Moxml
 
       # Parent node (..)
       def on_parent(_ast, input)
-        input.parent
+        if block_given?
+          yield input.parent
+        else
+          input.parent
+        end
       end
 
       # ===== OPERATORS =====
@@ -977,10 +1113,9 @@ module Moxml
           conversions << conversion.to_string(arg_var)
         end
 
-        # rubocop:disable Style/RedundantSum, Performance/Sum
+        # rubocop:disable-next Performance/Sum
         concatted = assigns.inject(:followed_by)
           .followed_by(conversions.inject(:+))
-        # rubocop:enable Style/RedundantSum, Performance/Sum
 
         block_given? ? concatted.empty?.if_false { yield concatted } : concatted
       end

data/lib/moxml/xpath/parser.rb

@@ -327,11 +327,18 @@ module Moxml
       def parse_relative_path
         steps = [parse_step]
 
-        while match?(:slash) && !at_end?
+        # Continue on both step separators: "/step" and the
+        # descendant-or-self shorthand "//step". A "//" arrives as a
+        # single :dslash (".//step", "a//step") or occasionally as a
+        # :slash/:slash or :slash/:dslash pair.
+        while !at_end? && match?(:slash, :dslash)
+          is_dslash = match?(:dslash)
           advance
-          if match?(:slash)
-            # Double slash within path: expands to descendant-or-self::node()
+          if !is_dslash && match?(:slash, :dslash)
             advance
+            is_dslash = true
+          end
+          if is_dslash
             steps << AST::Node.axis("descendant-or-self", AST::Node.node_type("node"))
           end
           steps << parse_step unless at_end? || match?(:pipe, :rbracket,
@@ -352,14 +359,10 @@ module Moxml
           return AST::Node.parent
         elsif match?(:at)
           advance
-          # Attribute: @name or @*
-          if match?(:star)
-            advance
-            node_test = AST::Node.wildcard
-          else
-            name = consume(:name, "Expected attribute name after @")
-            node_test = AST::Node.test(nil, name[1])
-          end
+          # Attribute: @name, @prefix:name, @prefix:* or @* (XPath 1.0
+          # §3.2, NameTest). parse_node_test handles prefixed and
+          # wildcard names; bare names land in its plain-name branch.
+          node_test = parse_node_test
           step = AST::Node.axis("attribute", node_test)
           return parse_predicates(step)
         end
@@ -385,14 +388,18 @@ module Moxml
         if match?(:star)
           advance
           return AST::Node.wildcard
-        elsif match?(:node_type)
+        elsif match?(:node_type) && peek_is?(:lparen)
           type_name = current_value
           advance
           consume(:lparen, "Expected '(' after node type")
           consume(:rparen, "Expected ')' after node type")
           return AST::Node.node_type(type_name)
-        elsif match?(:name, :and, :or, :mod, :div)
-          # Accept keywords as valid element names (they're valid XML names)
+        elsif match?(:name, :node_type, :and, :or, :mod, :div)
+          # Accept keywords as valid element names (they're valid XML
+          # names). Node-type words (text, comment, node) also land here
+          # when not followed by '(' — they name elements, either alone
+          # ("//text") or as the local part of a prefixed name
+          # ("//svg:text").
           name = current_value
           advance
 
@@ -402,7 +409,7 @@ module Moxml
             if match?(:star)
               advance
               return AST::Node.test(name, "*")
-            elsif match?(:name, :and, :or, :mod, :div)
+            elsif match?(:name, :node_type, :and, :or, :mod, :div)
               # Accept keywords as local names too
               local_name = current_value
               advance

data/lib/moxml.rb

@@ -26,7 +26,6 @@ module Moxml
         default_indent: original.default_indent,
         default_line_ending: original.default_line_ending,
         entity_load_mode: original.entity_load_mode,
-        entity_encoding: original.entity_encoding,
         restore_entities: original.restore_entities,
         namespace_validation_mode: original.namespace_validation_mode,
         entity_restoration_mode: original.entity_restoration_mode,
@@ -48,7 +47,6 @@ module Moxml
         config.default_indent = saved_values[:default_indent]
         config.default_line_ending = saved_values[:default_line_ending]
         config.entity_load_mode = saved_values[:entity_load_mode]
-        config.entity_encoding = saved_values[:entity_encoding]
         config.restore_entities = saved_values[:restore_entities]
         config.namespace_validation_mode = saved_values[:namespace_validation_mode]
         config.entity_restoration_mode = saved_values[:entity_restoration_mode]
@@ -76,16 +74,18 @@ module Moxml
   autoload :Cdata, "moxml/cdata"
   autoload :Comment, "moxml/comment"
   autoload :Attribute, "moxml/attribute"
+  autoload :AttributeResolver, "moxml/attribute_resolver"
   autoload :ProcessingInstruction, "moxml/processing_instruction"
   autoload :Declaration, "moxml/declaration"
   autoload :Namespace, "moxml/namespace"
   autoload :Doctype, "moxml/doctype"
   autoload :EntityReference, "moxml/entity_reference"
-  autoload :DocumentBuilder, "moxml/document_builder"
   autoload :Builder, "moxml/builder"
+  autoload :Entity, "moxml/entity"
   autoload :EntityRegistry, "moxml/entity_registry"
   autoload :NativeAttachment, "moxml/native_attachment"
   autoload :XmlUtils, "moxml/xml_utils"
+  autoload :XmlEmitter, "moxml/xml_emitter"
   autoload :Adapter, "moxml/adapter"
   autoload :XPath, "moxml/xpath"
   autoload :SAX, "moxml/sax"

data/spec/examples/readme_examples_spec.rb

@@ -110,10 +110,6 @@ RSpec.shared_examples "README Examples" do
   describe "Error handling example" do
     it "handles errors as shown in README" do
       context = Moxml.new
-      if context.config.adapter_name == :ox
-        pending "Ox doesn't have a native XPath"
-      end
-
       expect do
         context.parse("<invalid>")
       end.to raise_error(Moxml::ParseError)

data/spec/examples/xpath_examples_spec.rb

@@ -24,20 +24,12 @@ RSpec.shared_examples "XPath Examples" do
     end
 
     it "finds nodes with namespaces" do
-      if context.config.adapter_name == :ox
-        pending "Ox doesn't have a native XPath"
-      end
-
       titles = doc.xpath("//dc:title",
                          "dc" => "http://purl.org/dc/elements/1.1/")
       expect(titles.map(&:text)).to eq(%w[First Second])
     end
 
     it "finds nodes by attributes" do
-      if %i[ox headed_ox].include?(context.config.adapter_name)
-        pending "Ox doesn't have native XPath, HeadedOx parser doesn't support .// syntax yet"
-      end
-
       book = doc.at_xpath('//book[@id="2"]')
       expect(book).not_to be_nil
       title = book.at_xpath(".//dc:title",
@@ -46,9 +38,6 @@ RSpec.shared_examples "XPath Examples" do
     end
 
     it "finds nested attributes efficiently" do
-      if %i[ox headed_ox].include?(context.config.adapter_name)
-        pending "Ox doesn't have native XPath, HeadedOx parser doesn't support .// syntax yet"
-      end
       # More efficient - specific path
       titles1 = doc.xpath("//book/dc:title")
 

data/spec/integration/all_adapters_spec.rb

@@ -1,5 +1,18 @@
 # frozen_string_literal: true
 
+# Leptris needs the unreleased programmatic-document-construction C
+# API; skip its integration matrix until the binding ships it.
+#
+# const_defined? only — deliberately NO require here: loading a native
+# gem at example-group definition time is a load-order side effect
+# (and the only new load-time behavior on this branch). The leptris
+# adapter spec is what loads the gem in its own process.
+def leptris_ready?
+  return false unless Object.const_defined?(:Leptris)
+
+  Leptris::XML::Document.respond_to?(:create)
+end
+
 RSpec.describe "Cross-adapter integration" do
   # Integration shared examples - use the names as defined in the files
   all_shared_examples = [
@@ -18,7 +31,7 @@ RSpec.describe "Cross-adapter integration" do
     "Moxml::EntityReference",
     "Moxml::Context",
     "Moxml::Builder",
-    "Moxml::DocumentBuilder",
+    "Moxml::Parse Behavior",
     "Moxml Integration",
     "Moxml Edge Cases",
     "Attribute Examples",
@@ -41,6 +54,10 @@ RSpec.describe "Cross-adapter integration" do
         end
       end
 
+      if adapter_name == :leptris && !leptris_ready?
+        before { skip "requires leptris with Leptris::XML::Document.create (unreleased C API)" }
+      end
+
       all_shared_examples.each do |shared_example_name|
         it_behaves_like shared_example_name
       end

data/spec/integration/sax_parity_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# SAX event parity across adapters: every bridge must translate its
+# native SAX stream into the same Moxml event sequence — same element
+# names (qualified), same attribute/declaration split (nil key = the
+# default namespace), same characters.
+RSpec.describe "SAX parity across adapters" do
+  let(:xml) do
+    <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <root xmlns="http://d.org" xmlns:p="http://p.org" kind="a"><p:child id="1">text</p:child></root>
+    XML
+  end
+
+  def recorded_events(adapter_name)
+    events = []
+    handler = Class.new(Moxml::SAX::Handler) do
+      define_method(:track) { |*event| events << event }
+      define_method(:on_start_document) { track(:start_document) }
+      define_method(:on_end_document) { track(:end_document) }
+      define_method(:on_start_element) { |n, a, ns| track(:start_element, n, a, ns) }
+      define_method(:on_end_element) { |n| track(:end_element, n) }
+      define_method(:on_characters) { |t| track(:characters, t) }
+    end
+    Moxml.new(adapter_name).sax_parse(xml, handler.new)
+    events
+  end
+
+  def assert_parity(adapter_name)
+    # REXML and Oga report document-level whitespace (between the
+    # declaration and the root) as characters; parity is over the
+    # meaningful event stream.
+    events = recorded_events(adapter_name)
+      .reject { |event| event[0] == :characters && event[1].to_s.strip.empty? }
+
+    expect(events.first).to eq([:start_document])
+    expect(events[1]).to eq(
+      [:start_element, "root",
+       { "kind" => "a" },
+       { nil => "http://d.org", "p" => "http://p.org" }],
+    )
+    expect(events[2]).to eq([:start_element, "p:child", { "id" => "1" }, {}])
+    expect(events).to include([:characters, "text"])
+    expect(events).to include([:end_element, "p:child"])
+    expect(events).to include([:end_element, "root"])
+    expect(events.last).to eq([:end_document])
+  end
+
+  adapters = %i[nokogiri oga rexml ox headed_ox libxml]
+  adapters << :leptris if Object.const_defined?(:Leptris) &&
+    Leptris::XML::Document.respond_to?(:create)
+
+  adapters.each do |adapter_name|
+    it "emits the same event stream via #{adapter_name}" do
+      assert_parity(adapter_name)
+    end
+  end
+end

data/spec/integration/shared_examples/edge_cases.rb

@@ -80,9 +80,6 @@ RSpec.shared_examples "Moxml Edge Cases" do
 
   describe "namespace edge cases" do
     it "handles default namespace changes" do
-      if context.config.adapter_name == :ox
-        pending "Ox doesn't have a native XPath"
-      end
       if context.config.adapter_name == :headed_ox
         skip "HeadedOx limitation: Namespace methods not implemented in adapter. Requires Ox namespace API enhancement. See docs/_pages/headed-ox-limitations.adoc"
       end
@@ -106,9 +103,6 @@ RSpec.shared_examples "Moxml Edge Cases" do
     end
 
     it "handles recursive namespace definitions" do
-      if context.config.adapter_name == :ox
-        pending "Ox doesn't have a native XPath"
-      end
       if context.config.adapter_name == :headed_ox
         skip "HeadedOx limitation: Namespace methods not implemented in adapter. Requires Ox namespace API enhancement. See docs/_pages/headed-ox-limitations.adoc"
       end
@@ -132,10 +126,6 @@ RSpec.shared_examples "Moxml Edge Cases" do
       if context.config.adapter_name == :headed_ox
         skip "HeadedOx limitation: Namespace-prefixed attribute access needs Ox namespace API enhancement. See docs/_pages/headed-ox-limitations.adoc"
       end
-      if context.config.adapter_name == :ox
-        skip "Ox doesn't have a native XPath"
-      end
-
       xml = <<~XML
         <root xmlns:a="http://a.org" xmlns:b="http://b.org">
           <element a:id="1" b:id="2"/>

data/spec/integration/shared_examples/high_level/{document_builder_behavior.rb → parse_behavior.rb}

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
-RSpec.shared_examples "Moxml::DocumentBuilder" do
+RSpec.shared_examples "Moxml::Parse Behavior" do
   let(:context) { Moxml.new }
-  let(:builder) { Moxml::DocumentBuilder.new(context) }
 
   describe "#build" do
     it "builds a document model from native document" do

data/spec/integration/shared_examples/integration_workflows.rb

@@ -56,9 +56,6 @@ RSpec.shared_examples "Moxml Integration" do
     end
 
     it "handles xpath queries" do
-      if context.config.adapter_name == :ox
-        pending "Ox doesn't support namespace-aware XPath with predicates"
-      end
       if context.config.adapter_name == :headed_ox
         skip "HeadedOx limitation: Namespace-aware XPath with predicates needs investigation. See docs/_pages/headed-ox-limitations.adoc"
       end
@@ -76,9 +73,6 @@ RSpec.shared_examples "Moxml Integration" do
 
   describe "namespace handling" do
     it "handles complex namespace scenarios" do
-      if context.config.adapter_name == :ox
-        pending "Ox doesn't have a native XPath"
-      end
       if context.config.adapter_name == :headed_ox
         skip "HeadedOx limitation: Namespace methods not implemented in adapter. Requires Ox namespace API enhancement. See docs/_pages/headed-ox-limitations.adoc"
       end
@@ -125,10 +119,6 @@ RSpec.shared_examples "Moxml Integration" do
       if context.config.adapter_name == :headed_ox
         skip "HeadedOx limitation: Parent setter not implemented. Requires Ox node reparenting API. See docs/_pages/headed-ox-limitations.adoc"
       end
-      if context.config.adapter_name == :ox
-        skip "Ox doesn't have a native XPath"
-      end
-
       # Move nodes
       b_node = doc.at_xpath("//b")
       a_node = doc.at_xpath("//a")

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

@@ -65,6 +65,65 @@ RSpec.shared_examples "Moxml::Attribute" do
         expect(attribute.namespace.prefix).to eq("other")
         expect(attribute.to_s).to eq('other:attr="value"')
       end
+
+      it "replaces by expanded name across prefix spellings" do
+        element["ns:attr"] = "first"
+        element.add_namespace("alias", "http://example.org")
+        element["alias:attr"] = "second"
+
+        expect(element["ns:attr"]).to eq("second")
+        expect(element.attributes.size).to eq(1)
+      end
+    end
+
+    describe "expanded-name writes (AttributeResolver)" do
+      before do
+        element.add_namespace("p", "http://x.org")
+        element.add_namespace("q", "http://x.org")
+        element["q:type"] = "namespaced"
+        element["type"] = "bare"
+      end
+
+      it "does not clobber a namespaced attribute sharing the local name" do
+        element["type"] = "changed"
+
+        expect(element["type"]).to eq("changed")
+        expect(element["q:type"]).to eq("namespaced")
+      end
+
+      it "overwrites by expanded name regardless of prefix spelling" do
+        element["p:type"] = "overwritten"
+
+        expect(element["q:type"]).to eq("overwritten")
+        expect(element.attributes.size).to eq(2)
+      end
+
+      it "stores writes through undeclared prefixes raw for later resolution" do
+        element["z:type"] = "value"
+
+        # No declaration in scope: the read resolves to nothing, but
+        # the attribute is stored (detached builds attach under the
+        # declaring ancestor later).
+        expect(element["z:type"]).to be_nil
+        expect(element.attributes.size).to eq(3)
+
+        element.add_namespace("z", "http://z.org")
+        expect(element["z:type"]).to eq("value")
+      end
+
+      it "removes the bare attribute without touching the namespaced one" do
+        element.remove_attribute("type")
+
+        expect(element["type"]).to be_nil
+        expect(element["q:type"]).to eq("namespaced")
+      end
+
+      it "removes by expanded name regardless of prefix spelling" do
+        element.remove_attribute("p:type")
+
+        expect(element["q:type"]).to be_nil
+        expect(element["type"]).to eq("bare")
+      end
     end
 
     describe "manipulation" do
@@ -162,4 +221,43 @@ RSpec.shared_examples "Moxml::Attribute" do
       end
     end
   end
+
+  describe "unified XML-correct name resolution" do
+    let(:context) { Moxml.new }
+    let(:doc) do
+      context.parse(
+        %(<root xmlns:p="urn:1"><child xmlns:q="urn:1" q:type="v" type="plain" xml:lang="en"/></root>),
+      )
+    end
+    let(:child) { doc.root.children.find(&:element?) }
+
+    it "matches prefixed lookups by expanded name across redeclared prefixes" do
+      # p and q both bind urn:1; the attribute is written q:type
+      expect(child["p:type"]).to eq("v")
+      expect(child["q:type"]).to eq("v")
+    end
+
+    it "keeps bare and namespaced attributes distinct" do
+      expect(child["type"]).to eq("plain")
+      expect(child[:type]).to eq("plain")
+    end
+
+    it "resolves the prebound xml prefix without any declaration" do
+      expect(child["xml:lang"]).to eq("en")
+    end
+
+    it "returns nil for undeclared prefixes — no prefix-string fallback" do
+      expect(child["undeclared:type"]).to be_nil
+    end
+
+    it "never treats namespace declarations as attributes" do
+      expect(child["xmlns:q"]).to be_nil
+      expect(child["xmlns"]).to be_nil
+    end
+
+    it "attribute(name) agrees with []" do
+      expect(child.attribute("p:type").value).to eq("v")
+      expect(child.attribute("undeclared:type")).to be_nil
+    end
+  end
 end

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

@@ -170,6 +170,32 @@ RSpec.shared_examples "Moxml::Namespace" do
         expect(prefixes).to include("xs")
       end
 
+      it "sees ancestor declarations made after a first read (cache invalidation)" do
+        root = doc.create_element("root")
+        root.add_namespace("a", "http://a.org")
+        child = doc.create_element("child")
+        root.add_child(child)
+        child.in_scope_namespaces # materialize the scope cache
+
+        root.add_namespace("b", "http://b.org")
+
+        expect(child.in_scope_namespaces.map(&:prefix)).to include("b")
+      end
+
+      it "recomputes the scope after the subtree is reparented" do
+        source = doc.create_element("source")
+        source.add_namespace("s", "http://s.org")
+        child = doc.create_element("child")
+        source.add_child(child)
+        child.in_scope_namespaces # materialize the scope cache
+
+        target = doc.create_element("target")
+        child.remove
+        target.add_child(child)
+
+        expect(child.in_scope_namespaces.map(&:prefix)).not_to include("s")
+      end
+
       it "collects namespaces from multiple ancestor levels" do
         root = doc.create_element("root")
         root.add_namespace("xs", "http://www.w3.org/2001/XMLSchema")