moxml 0.1.26 → 0.2.0

data/lib/moxml/entity.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Moxml
+  # Entity-reference round-trip pipeline.
+  #
+  # XML libraries split into two camps: those that preserve named
+  # entity references natively (nokogiri) and those that expand or
+  # reject them at parse (ox, rexml, oga, libxml, leptris). Moxml
+  # bridges the camps with one pipeline, owned here and delegated to
+  # by Adapter::Base:
+  #
+  # 1. Parse time — .preprocess_entities rewrites non-standard
+  #    entity references to a two-character marker (see MARKER) so
+  #    the reference survives native parsing verbatim. The five
+  #    standard entities (& < > " ') are NOT
+  #    converted.
+  # 2. Read time — marker-bearing text is split into text and
+  #    Entity::Reference nodes (adapters whose natives cannot hold
+  #    references), or decoded in place (.decode_entities covers the
+  #    five standard entities plus numeric character references).
+  # 3. Serialize time — .restore_entities maps markers back to named
+  #    references, including markers a native serializer already
+  #    rendered as character references.
+  #
+  # How references are STORED between parse and serialize is
+  # adapter-shaped (in-tree value objects for ox, attachment
+  # sequences for rexml/libxml, text markers for oga/leptris); the
+  # marker lifecycle and the Entity::Reference value type are the
+  # shared, single-sourced parts.
+  module Entity
+    autoload :Reference, "moxml/entity/reference"
+
+    # Marker for adapters that resolve entities during parsing.
+    # U+FFFC (Object Replacement Character) + U+FEFF (BOM) is a
+    # two-character sentinel chosen because this exact sequence
+    # followed by a valid entity name pattern is vanishingly unlikely
+    # in real XML content.
+    MARKER = "\u{FFFC}\u{FEFF}"
+    NAME_PATTERN = "[a-zA-Z_][\\w.:-]*"
+    NAME_RE = /&(#{NAME_PATTERN});/
+    MARKER_RE = /\u{FFFC}\u{FEFF}(#{NAME_PATTERN});/
+    SERIALIZED_MARKER_RE = /(#{NAME_PATTERN});/
+    STANDARD_ENTITIES = %w[amp lt gt quot apos].freeze
+
+    NAMED_DECODE_MAP = {
+      "amp" => "&", "lt" => "<", "gt" => ">",
+      "quot" => '"', "apos" => "'"
+    }.freeze
+    private_constant :NAMED_DECODE_MAP
+
+    DECODE_RE = /&(?:(amp|lt|gt|quot|apos)|#(?:(\d+)|[xX]([0-9a-fA-F]+)));/
+    private_constant :DECODE_RE
+
+    module_function
+
+    # Replace non-standard entity references with markers before
+    # parsing. Always returns a UTF-8 encoded string.
+    def preprocess_entities(xml)
+      return "" if xml.nil?
+
+      str = if xml.encoding == Encoding::BINARY
+              # Binary strings are assumed to be UTF-8. If the bytes are
+              # not valid UTF-8, fall back to encoding as UTF-8 with
+              # replacement to avoid raising on gsub.
+              dup = xml.dup.force_encoding("UTF-8")
+              if dup.valid_encoding?
+                dup
+              else
+                xml.dup.encode("UTF-8",
+                               "ASCII-8BIT", invalid: :replace, undef: :replace)
+              end
+            elsif xml.encoding == Encoding::UTF_8
+              xml
+            else
+              xml.encode("UTF-8")
+            end
+      # Fast path: no `&` means no entity references to mark — skip
+      # the regex scan and string allocation entirely. The vast
+      # majority of XML payloads contain no entity references.
+      return str unless str.include?("&")
+
+      str.gsub(NAME_RE) do |match|
+        STANDARD_ENTITIES.include?(::Regexp.last_match(1)) ? match : "#{MARKER}#{::Regexp.last_match(1)};"
+      end
+    end
+
+    # Resolve numeric (&#NN; / &#xNN;) and the five standard named
+    # (&amp; &lt; &gt; &quot; &apos;) XML entity references in one
+    # single pass. The resulting characters are data; no further
+    # decoding is applied. Numeric refs producing invalid UTF-8
+    # (NUL, surrogate halves, > U+10FFFF) are preserved verbatim
+    # to avoid silently emitting malformed bytes.
+    def decode_entities(text)
+      return text unless text.is_a?(String) && text.include?("&")
+
+      text.gsub(DECODE_RE) do
+        if (named = ::Regexp.last_match(1))
+          NAMED_DECODE_MAP[named]
+        else
+          code = ::Regexp.last_match(2) ? ::Regexp.last_match(2).to_i : ::Regexp.last_match(3).to_i(16)
+          if code.zero? || code.between?(0xD800, 0xDFFF) || code > 0x10FFFF
+            ::Regexp.last_match(0)
+          else
+            [code].pack("U")
+          end
+        end
+      end
+    end
+
+    # Restore entity markers back to named entity references.
+    def restore_entities(text)
+      return text unless text.is_a?(String)
+
+      # Force UTF-8 encoding since markers are UTF-8 characters
+      str = text.encoding == Encoding::UTF_8 ? text : text.dup.force_encoding("UTF-8")
+      # Fast path: the vast majority of documents carry no entity
+      # markers — two C-level scans beat two regex passes.
+      return str unless str.include?(MARKER) ||
+        str.include?("&#xFFFC;")
+
+      result = str.gsub(MARKER_RE, '&\1;')
+      result.gsub(SERIALIZED_MARKER_RE, '&\1;')
+    end
+  end
+end

data/lib/moxml/node.rb

@@ -55,6 +55,8 @@ module Moxml
       refreshed = adapter.actual_native(node.native, @native)
       node.refresh_native!(refreshed) if refreshed && refreshed != node.native
       node.parent_node = self
+      # The adopted subtree's in-scope namespaces changed
+      node.invalidate_namespace_cache!
       invalidate_children_cache!
       self
     end
@@ -77,9 +79,15 @@ module Moxml
       invalidate_parent_children_cache!
       adapter.remove(@native)
       invalidate_children_cache!
+      # The detached subtree left its declaring ancestors behind
+      invalidate_namespace_cache!
       self
     end
 
+    # Namespace-scope caches live on Element; the base no-op lets tree
+    # mutations invalidate uniformly without type checks.
+    def invalidate_namespace_cache!; end
+
     def replace(node)
       node = prepare_node(node)
       invalidate_parent_children_cache!
@@ -103,7 +111,10 @@ module Moxml
     end
 
     def xpath(expression, namespaces = {})
-      NodeSet.new(adapter.xpath(@native, expression, namespaces), context)
+      result = adapter.xpath(@native, expression, namespaces)
+      # Adapter contract: Array<native> | scalar. Scalars (count(),
+      # string-length(), booleans) pass through unwrapped.
+      result.is_a?(Array) ? NodeSet.new(result, context) : result
     end
 
     def at_xpath(expression, namespaces = {})
@@ -186,6 +197,69 @@ module Moxml
       children.each(&block)
     end
 
+    # Returns all ancestor nodes from the parent up to and including
+    # the document node.
+    #
+    # @return [NodeSet] ancestors ordered nearest-first
+    def ancestors
+      return NodeSet.new([], context) if document?
+
+      natives = []
+      current = parent
+      while current
+        natives << current.native
+        break if current.document?
+
+        current = current.parent
+      end
+      NodeSet.new(natives, context)
+    end
+
+    # Returns all descendant nodes (children, grandchildren, and so on),
+    # excluding the node itself.
+    #
+    # @return [NodeSet] descendants in document order
+    def descendants
+      natives = []
+      each_node { |node| natives << node.native }
+      NodeSet.new(natives, context)
+    end
+
+    # Returns an XPath expression that uniquely locates this node within
+    # its document. Positional predicates are emitted only when sibling
+    # elements share the same qualified name, keeping paths minimal.
+    #
+    # @return [String] XPath expression
+    # @raise [Moxml::NotImplementedError] for node types other than
+    #   element and document
+    def path
+      return "/" if document?
+
+      unless element?
+        raise Moxml::NotImplementedError.new(
+          "path is only supported for element and document nodes",
+          feature: "path",
+        )
+      end
+
+      segments = []
+      current = self
+      while current && !current.document?
+        segments.unshift(path_segment_for(current))
+        current = current.parent
+      end
+      "/#{segments.join('/')}"
+    end
+
+    # Returns the 1-based line number where this node appears in the
+    # source XML, or nil when the underlying adapter does not track
+    # source positions.
+    #
+    # @return [Integer, nil]
+    def line_number
+      adapter.line_number(@native)
+    end
+
     def outer_xml
       to_xml
     end
@@ -286,6 +360,21 @@ module Moxml
 
     private
 
+    # XPath segment for an element: the qualified name, plus a positional
+    # predicate only when same-named element siblings make it ambiguous.
+    def path_segment_for(element)
+      name = element.name
+      parent = element.parent
+      return name unless parent
+
+      same_name = parent.children.select do |child|
+        child.element? && child.name == name
+      end
+      return name if same_name.size == 1
+
+      "#{name}[#{same_name.find_index(element) + 1}]"
+    end
+
     def prepare_node(node)
       case node
       when String then Text.new(adapter.create_text(node), context)

data/lib/moxml/sax/namespace_splitter.rb

@@ -9,6 +9,8 @@ module Moxml
     # attribute. This module provides a single implementation.
     module NamespaceSplitter
       # @param attributes [Hash, Array<Array>] attributes as a hash or array of pairs
+      # @yieldparam value [Object] raw attribute/namespace value
+      # @yieldreturn [Object] transformed value to store
       # @return [Array(Hash, Hash)] [regular_attrs, namespaces]
       def split_attributes_and_namespaces(attributes)
         attrs = {}
@@ -16,11 +18,12 @@ module Moxml
 
         each_attribute(attributes) do |name, value|
           name_s = name.to_s
+          v = block_given? ? yield(value) : value
           if name_s == "xmlns" || name_s.start_with?("xmlns:")
             prefix = name_s == "xmlns" ? nil : name_s.sub("xmlns:", "")
-            ns[prefix] = value
+            ns[prefix] = v
           else
-            attrs[name_s] = value
+            attrs[name_s] = v
           end
         end
 

data/lib/moxml/signature/model/key/dsa_key_value.rb

@@ -10,7 +10,7 @@ module Moxml
         class DSAKeyValue
           attr_accessor :p, :q, :g, :y, :j, :seed, :pgen_counter
 
-          # rubocop:disable Naming/MethodParameterName -- P/Q/G/Y/J are W3C spec names
+          # rubocop:disable-next Naming/MethodParameterName -- P/Q/G/Y/J are W3C spec names
           def initialize(p:, q:, y:, g: nil, j: nil, seed: nil,
                          pgen_counter: nil)
             @p = p
@@ -21,7 +21,6 @@ module Moxml
             @seed = seed
             @pgen_counter = pgen_counter
           end
-          # rubocop:enable Naming/MethodParameterName
         end
       end
     end

data/lib/moxml/version.rb

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

data/lib/moxml/xml_emitter.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Moxml
+  # Single source of XML emission knowledge: character escaping,
+  # CDATA end-sequence segmentation, and declaration/DOCTYPE
+  # rendering. Adapters keep their tree walks (those are
+  # adapter-shaped) but stop re-deriving the wire format:
+  #
+  # - text escapes & < >; attribute values also escape " —
+  #   apostrophes stay literal (moxml-canonical form)
+  # - a CDATA section's end sequence is split into adjacent sections
+  # - the moxml declaration shape is <?xml version="..."
+  #   encoding="..." standalone="..."?> with only the set attributes
+  # - DOCTYPE renders PUBLIC and SYSTEM external identifiers
+  module XmlEmitter
+    TEXT_ESCAPE_RE = /[<>&]/
+    TEXT_ESCAPE_MAP = {
+      "<" => "&lt;", ">" => "&gt;", "&" => "&amp;"
+    }.freeze
+    ATTRIBUTE_ESCAPE_RE = /[<>&"]/
+    ATTRIBUTE_ESCAPE_MAP = {
+      "<" => "&lt;", ">" => "&gt;", "&" => "&amp;", '"' => "&quot;"
+    }.freeze
+    CDATA_END = "]]>"
+    CDATA_END_SPLIT = "]]]]><![CDATA[>"
+
+    module_function
+
+    # @return [String] text with & < > escaped
+    def escape_text(text)
+      str = text.is_a?(String) ? text : text.to_s
+      return str unless str.match?(TEXT_ESCAPE_RE)
+
+      str.gsub(TEXT_ESCAPE_RE, TEXT_ESCAPE_MAP)
+    end
+
+    # @return [String] attribute value with & < > " escaped
+    def escape_attribute(value)
+      str = value.is_a?(String) ? value : value.to_s
+      return str unless str.match?(ATTRIBUTE_ESCAPE_RE)
+
+      str.gsub(ATTRIBUTE_ESCAPE_RE, ATTRIBUTE_ESCAPE_MAP)
+    end
+
+    # @return [String] a CDATA section, splitting any embedded end
+    #   sequence into adjacent sections
+    def cdata(content)
+      "<![CDATA[#{content.to_s.gsub(CDATA_END, CDATA_END_SPLIT)}]]>"
+    end
+
+    # @return [String] an XML declaration with only the set attributes
+    def declaration_xml(version, encoding, standalone)
+      output = %(<?xml version="#{version}")
+      output << %( encoding="#{encoding}") if encoding && !encoding.to_s.empty?
+      output << %( standalone="#{standalone}") unless standalone.nil?
+      output << "?>"
+    end
+
+    # @return [String] a DOCTYPE with its external identifier
+    def doctype_xml(name, public_id, system_id)
+      output = "<!DOCTYPE #{name}"
+      if public_id && !public_id.to_s.empty?
+        output << %( PUBLIC "#{public_id}")
+        output << %( "#{system_id}") if system_id
+      elsif system_id && !system_id.to_s.empty?
+        output << %( SYSTEM "#{system_id}")
+      end
+      output << ">"
+    end
+  end
+end

data/lib/moxml/xpath/compiler.rb

@@ -425,15 +425,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 +451,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 +529,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 +573,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
@@ -977,10 +1031,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

@@ -76,6 +76,7 @@ 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"
@@ -83,9 +84,11 @@ module Moxml
   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 = [
@@ -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