moxml 0.5.149 → 0.5.150

data/lib/moxml/node.rb

@@ -36,6 +36,11 @@ module Moxml
       self
     end
 
+    # Document-derived wrapper state (the entity-marker verdict) flows
+    # parent -> child during prewrapped traversal; adapters that keep
+    # no per-wrapper document state carry nothing.
+    def inherit_document_state(_parent); end
+
     def refresh_native!(new_native)
       unless new_native.equal?(@native)
         # Cache-stable binding nodes carry the wrapper in an ivar
@@ -226,7 +231,8 @@ module Moxml
     def attach_previous_sibling(node)
       context.bump_children_generation
       node = prepare_node(node)
-      adapter.add_previous_sibling(@native, node.native)
+      inserted = adapter.add_previous_sibling(@native, node.native)
+      refresh_inserted_native(node, inserted)
       # Invalidate the parent's memoized children list. The wrapper-side
       # @parent_node link is only set when this node was yielded through a
       # parent-aware NodeSet; nodes obtained via at()/xpath() carry no such
@@ -239,12 +245,20 @@ module Moxml
     def attach_next_sibling_to(anchor, node)
       context.bump_children_generation
       node = prepare_node(node)
-      adapter.add_next_sibling(anchor.native, node.native)
+      inserted = adapter.add_next_sibling(anchor.native, node.native)
+      refresh_inserted_native(node, inserted)
       anchor.parent&.invalidate_children_cache!
       anchor.invalidate_parent_children_cache!
       self
     end
 
+    def refresh_inserted_native(node, inserted)
+      return unless adapter.add_sibling_returns_inserted?
+      return if inserted.nil? || inserted.equal?(node.native)
+
+      node.refresh_native!(inserted)
+    end
+
     def remove
       # Nokogiri parity: unlinking an already-detached node is a
       # no-op returning self. Re-attach idioms like
@@ -296,6 +310,21 @@ module Moxml
     end
 
     def to_xml(options = {})
+      # Element-level indentation is a declared capability: engines
+      # that ignore it must not answer unindented output silently
+      # (D-09). indent: 0 and the no-option path stay common.
+      indent = options[:indent]
+      if !is_a?(Document) && indent.is_a?(Integer) && indent.positive? &&
+          !adapter.element_indent_supported?
+        raise Moxml::AdapterError.new(
+          "element-level indentation is not supported by the " \
+          "#{adapter.name.split('::').last} adapter; serialize the " \
+          "document or use indent: 0",
+          adapter: adapter.name,
+          operation: "serialize",
+        )
+      end
+
       # Determine if we should include XML declaration
       # For Document nodes: check native then wrapper, unless explicitly overridden
       # For other nodes: default to no declaration unless explicitly set
@@ -367,14 +396,26 @@ module Moxml
       Materializer.materialize_fields(self, &block)
     end
 
-    # Sugar over xpath: the first node of a node-set; scalar results
-    # (count(), string(), boolean()) pass through unwrapped and
-    # uniform across adapters.
+    # The first node of a node-set; scalar results (count(), string(),
+    # boolean()) pass through unwrapped and uniform across adapters.
+    # Adapters with a native first-only face use it (see
+    # Document#at_xpath).
     def at_xpath(expression, namespaces = {})
+      if adapter.native_at_xpath?
+        result = adapter.at_xpath(@native, expression, namespaces)
+        return result if scalar_result?(result)
+
+        return Moxml::Node.wrap(result, context)
+      end
       result = xpath(expression, namespaces)
       result.is_a?(NodeSet) ? result.first : result
     end
 
+    def scalar_result?(result)
+      result.is_a?(Numeric) || result.is_a?(String) ||
+        result == true || result == false || result.nil?
+    end
+
     # Nokogiri-compatible sugar: at/search/at_css/css. Nokogiri's
     # at/search auto-detect XPath vs CSS; the XPath-first fallback
     # covers the dominant caller shape (XPath expression strings)
@@ -906,6 +947,16 @@ module Moxml
       # input native keeps its registration so later wraps of the
       # same base object hit the cache instead of re-minting.
       if (extended = adapter.wrap_native(node, type, context))
+        # A native that already carries the contract IS the wrapper
+        # (leptris C mint): prime it in place and skip the WeakMap
+        # round trip — the primed @native-identity answers every
+        # later wrap through the fast path above.
+        if extended.equal?(node) && extended.is_a?(Node)
+          extended.prime_contract(extended, context, adapter, type) unless
+            extended.instance_variable_defined?(:@context)
+          return extended
+        end
+
         extended.prime_contract(extended, context, adapter, type)
         context.register_wrapper(node, extended)
         context.register_wrapper(extended, extended) unless extended.equal?(node)

data/lib/moxml/node_set.rb

@@ -39,12 +39,18 @@ module Moxml
     # nodes: Array of natives, or an adapter's LazyNodeSet — the
     # native set is held unmaterialized until an operation needs an
     # Array (#+, #<<, #delete, Range slices).
-    def initialize(nodes, context, parent_node = nil)
+    #
+    # prewrapped: the adapter vouches the entries are already
+    # contract-carrying wrappers (the leptris C-mint children face),
+    # so the walk path skips the wrapped-buffer allocation and the
+    # per-child wrap dispatch.
+    def initialize(nodes, context, parent_node = nil, prewrapped: false)
       @nodes = nodes.is_a?(Array) ? nodes : nil
       @lazy = @nodes ? nil : nodes
       @context = context
       @wrapped = nil
       @parent_node = parent_node
+      @prewrapped = prewrapped
     end
 
     # The raw native nodes — adapter-internal work only (issue #26).
@@ -59,6 +65,13 @@ module Moxml
     def each
       return to_enum(:each) unless block_given?
 
+      if @prewrapped
+        (@nodes || @lazy).each do |node|
+          yield adopt_prewrapped(node)
+        end
+        return self
+      end
+
       wrapped = wrapped_buffer
       index = 0
       (@nodes || @lazy).each do |node|
@@ -227,5 +240,22 @@ module Moxml
       end
       wrapped
     end
+
+    # The prewrapped entry path: prime a not-yet-primed C-minted
+    # wrapper in place (one ivar check), attach the traversal parent,
+    # and hand the document's marker verdict down the tree.
+    def adopt_prewrapped(node)
+      unless node.is_a?(Moxml::Node)
+        node = Moxml::Node.wrap(node, @context)
+      end
+      unless node.instance_variable_defined?(:@context)
+        node.prime_contract(node, @context, Moxml::Node.adapter(@context))
+      end
+      if @parent_node
+        node.parent_node = @parent_node
+        node.inherit_document_state(@parent_node)
+      end
+      node
+    end
   end
 end

data/lib/moxml/relaxng.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Moxml
+  # RELAX NG schema validation (TODO.sota/05): a facade for engines
+  # that ship an RNG validator. Engines without one raise the named
+  # Moxml::NotImplementedError — the face is never silently absent.
+  #
+  #     ctx    = Moxml.new(:leptris)
+  #     schema = ctx.relaxng_file("schema.rng")
+  #     schema.valid?(doc)            # => true/false
+  #     schema.validate_errors(doc)   # => [] or [{line:, column:, message:}]
+  #     schema.validate(doc)          # => [] or ["line:col: error: message"]
+  #
+  # Adapters without an engine raise at compile; RelaxNG.supported?
+  # answers without raising (the XSD facade's pattern).
+  module RelaxNG
+    class << self
+      # Whether the context's adapter ships a RELAX NG validator.
+      def supported?(context)
+        adapter = context.config.adapter
+        adapter.const_defined?(:RELAXNG_SUPPORTED) &&
+          adapter.const_get(:RELAXNG_SUPPORTED)
+      end
+    end
+
+    # A compiled schema (adapter-owned handle).
+    class Schema
+      def initialize(handle, context)
+        @handle = handle
+        @context = context
+      end
+
+      def valid?(document)
+        @context.config.adapter.relaxng_valid?(@handle, native(document))
+      end
+
+      # Structured report: [{line:, column:, message:}] (empty = valid).
+      def validate_errors(document)
+        @context.config.adapter
+          .relaxng_validate_errors(@handle, native(document))
+      end
+
+      # Nokogiri shape: error strings (empty = valid).
+      def validate(document)
+        validate_errors(document).map do |error|
+          line = error[:line]
+          if line&.to_i&.positive?
+            "#{line}:#{error[:column]}: error: #{error[:message]}"
+          else
+            error[:message]
+          end
+        end
+      end
+
+      private
+
+      def native(document)
+        document.is_a?(Moxml::Document) ? document.native : document
+      end
+    end
+  end
+end

data/lib/moxml/sax/block_handler.rb

@@ -191,6 +191,13 @@ module Moxml
       def on_warning(message)
         @handlers[:warning]&.call(message)
       end
+
+      # A block handler subscribes to a family only when its DSL block
+      # was registered — it overrides every callback, so method
+      # ownership cannot answer interest here.
+      def handles?(family)
+        @handlers.key?(family)
+      end
     end
   end
 end

data/lib/moxml/sax/handler.rb

@@ -98,6 +98,26 @@ module Moxml
         raise error
       end
 
+      # SAX event families that engines may or may not report as
+      # distinct events, with their handler methods. An engine that
+      # cannot report a family must raise the named error when the
+      # handler subscribes — never fold the events silently.
+      EVENT_METHODS = {
+        cdata: :on_cdata,
+        comment: :on_comment,
+        processing_instruction: :on_processing_instruction,
+      }.freeze
+
+      # Whether this handler subscribes to an event family: the
+      # callback was overridden (class handlers) or registered (block
+      # handlers).
+      #
+      # @param family [Symbol] one of EVENT_METHODS keys
+      # @return [Boolean]
+      def handles?(family)
+        method(EVENT_METHODS.fetch(family)).owner != Moxml::SAX::Handler
+      end
+
       # Called when a non-fatal warning occurs
       #
       # Default implementation ignores warnings.

data/lib/moxml/version.rb

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

data/lib/moxml/xpath.rb

@@ -26,5 +26,33 @@ module Moxml
       autoload :Node, "moxml/xpath/ruby/node"
       autoload :Generator, "moxml/xpath/ruby/generator"
     end
+
+    module_function
+
+    # Evaluate an expression through the pure-Ruby XPath 1.0 engine —
+    # the model's reference lane. Adapters route shapes their native
+    # engine cannot answer here (the `xmlns:` idiom, `text()` node
+    # tests, ...). Returns the engine's answer: an Array of wrapped
+    # nodes in document order, a NodeSet, or a scalar.
+    def evaluate(node, expression, namespaces = {}, adapter: nil)
+      context = node.is_a?(Moxml::Node) ? node.context : ::Moxml::Context.new(adapter)
+      wrapped = node.is_a?(Moxml::Node) ? node : Moxml::Node.wrap(node, context)
+      compiled = Compiler.compile_with_cache(Parser.parse(expression),
+                                             namespaces: namespaces)
+      compiled.call(wrapped)
+    end
+
+    # The adapter-contract form of #evaluate: Array<native> | scalar.
+    def evaluate_natives(node, expression, namespaces = {}, adapter: nil)
+      result = evaluate(node, expression, namespaces, adapter: adapter)
+      case result
+      when Array
+        result.map { |n| n.is_a?(Moxml::Node) ? n.native : n }
+      when NodeSet
+        result.to_a.map(&:native)
+      else
+        result
+      end
+    end
   end
 end

data/lib/moxml.rb

@@ -105,6 +105,7 @@ module Moxml
   autoload :Reference, "moxml/reference"
   autoload :XSLT, "moxml/xslt"
   autoload :XSD, "moxml/xsd"
+  autoload :RelaxNG, "moxml/relaxng"
 
   # Error hierarchy — each subclass autoloads from the same file
   autoload :Error, "moxml/error"

data/spec/consistency/adapter_parity_spec.rb

@@ -5,6 +5,28 @@
 RSpec.describe "Adapter Examples" do
   let(:xml) { "<root><child>text</child></root>" }
 
+  describe "Document children listing" do
+    it "never lists the XML declaration as a child" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter|
+        doc = Moxml.new(adapter)
+          .parse(%(<?xml version="1.0"?><r/>))
+        expect(doc.children.map(&:node_type)).to eq([:element]),
+                                                 "#{adapter}: declaration leaked " \
+                                                 "into children (model: state, not a node)"
+        expect(doc.has_xml_declaration).to be(true),
+                                           "#{adapter}: declaration state lost"
+      end
+    end
+
+    it "lists the doctype per the Nokogiri contract" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter|
+        doc = Moxml.new(adapter).parse(%(<!DOCTYPE r><r/>))
+        expect(doc.children.map(&:node_type)).to eq(%i[doctype element]),
+                                                 "#{adapter}: doctype listing"
+      end
+    end
+  end
+
   describe "Serialization consistency" do
     it "produces equivalent XML across adapters",
        skip: "No easy way to exclude the declaration from Nokogiri documents" do

data/spec/consistency/citation_hygiene_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Citation hygiene (TODO.sota/07): a spec or doc that calls a
+# divergence "pre-existing" or "documented" must resolve it to a
+# register ID (D-NN) on the same line. The register is the only place
+# such a claim is allowed to stand on its own.
+CITATION_PHRASE = /(?:\bpre-existing\b|\bpreexisting\b|\bdocumented (?:divergence|limitation)\b)/i
+
+RSpec.describe "divergence citations" do
+  def offenses(paths)
+    paths.flat_map do |path|
+      File.readlines(path).each_with_index.filter_map do |line, idx|
+        claim = line.match?(CITATION_PHRASE)
+        cited = line.match?(/D-\d+/)
+        "#{path}:#{idx + 1}: #{line.strip}" if claim && !cited
+      end
+    end
+  end
+
+  it "resolves every pre-existing/documented divergence claim to a register ID" do
+    paths = (Dir.glob("spec/**/*.rb") + Dir.glob("docs/**/*.adoc"))
+      .reject { |path| path.end_with?("citation_hygiene_spec.rb") }
+    found = offenses(paths)
+    expect(found).to be_empty,
+                     "name a D-NN (docs/_pages/divergences.adoc) or drop " \
+                     "the claim:\n#{found.join("\n")}"
+  end
+end

data/spec/consistency/model_coverage_audit_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require "support/model_coverage"
 
 # Model coverage matrix (TODO.model/03): every face family of the
 # processing model is governed for every adapter — covered by a pin
@@ -8,84 +9,13 @@ require "spec_helper"
 # a registered divergence (adapter => D-ID), or loud (adapter =>
 # the named error class). An unpinned family is an ungoverned cell:
 # this audit fails until it has one of the three.
-# See docs/_references/processing-model.adoc for the model itself.
+#
+# The matrix itself lives in spec/support/model_coverage.rb: the same
+# data drives this audit, the model document's pin lists, and the
+# published coverage page. See docs/_references/processing-model.adoc
+# for the model itself.
 RSpec.describe "model coverage matrix" do
-  MODEL_MATRIX = { # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
-    "document order and children listing" => {
-      section: "Document order and traversal",
-      pin: "spec/consistency/adapter_parity_spec.rb",
-    },
-    "name resolution" => {
-      section: "Names and namespaces",
-      pin: "spec/consistency/xpath_idioms_spec.rb",
-    },
-    "namespace resolution and bindings normalization" => {
-      section: "Names and namespaces",
-      pin: "spec/consistency/xpath_idioms_spec.rb",
-    },
-    "attribute access" => {
-      section: "Access semantics",
-      pin: "spec/moxml/attribute_resolver_spec.rb",
-    },
-    "text/content/raw_content" => {
-      section: "Access semantics",
-      pin: "spec/moxml/text_spec.rb",
-    },
-    "parsing modes and diagnostics" => {
-      section: "Parsing",
-      pin: "spec/moxml/document_parse_diagnostics_spec.rb",
-    },
-    "EOL normalization" => {
-      section: "Parsing",
-      pin: "spec/consistency/eol_normalization_spec.rb",
-      exempt: { oga: "D-02", ox: "D-03" },
-    },
-    "entity modes" => {
-      section: "Parsing",
-      pin: "spec/moxml/entity_spec.rb",
-    },
-    "XPath evaluation and declared idioms" => {
-      section: "XPath evaluation",
-      pin: "spec/consistency/xpath_idioms_spec.rb",
-      exempt: { oga: "D-01" },
-    },
-    "serialization shapes (xml/html/xhtml)" => {
-      section: "Serialization",
-      pin: "spec/moxml/xhtml_output_spec.rb",
-    },
-    "indentation knobs" => {
-      section: "Serialization",
-      pin: "spec/moxml/to_html_spec.rb",
-      exempt: { oga: "D-09", ox: "D-09", headed_ox: "D-09",
-                libxml: "D-09", leptris: "D-09" },
-    },
-    "canonicalization" => {
-      section: "Canonicalization",
-      pin: "spec/moxml/c14n/adapter_delegation_spec.rb",
-      exempt: { oga: "D-04", ox: "D-05", headed_ox: "D-05" },
-    },
-    "XSLT" => {
-      section: "XSLT",
-      pin: "spec/consistency/xslt_spec.rb",
-      loud: { oga: "Moxml::NotImplementedError",
-              ox: "Moxml::NotImplementedError",
-              headed_ox: "Moxml::NotImplementedError",
-              rexml: "Moxml::NotImplementedError",
-              libxml: "Moxml::NotImplementedError" },
-    },
-    "SAX" => {
-      section: "SAX",
-      pin: "spec/moxml/sax_spec.rb",
-    },
-    "materialization" => {
-      section: "Materialization",
-      pin: "spec/moxml/plan_conformance_spec.rb",
-    },
-    "loud capability contracts" => {
-      section: "Errors and loud degradation",
-      pin: "spec/consistency/loud_degradation_spec.rb",
-    },
-  }.freeze
+  MODEL_MATRIX = ModelCoverage::MODEL_COVERAGE_MATRIX # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
 
   def register_ids
     File.readlines("docs/_pages/divergences.adoc")
@@ -134,12 +64,7 @@ RSpec.describe "model coverage matrix" do
   # section vanished fails too.
   MODEL_DOC = "docs/_references/processing-model.adoc" # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
 
-  NON_FACE_SECTIONS = [ # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
-    "Status and precedence",
-    "Mission and invariant",
-    "Object model",
-    "Performance: a declared, non-semantic channel",
-  ].freeze
+  NON_FACE = ModelCoverage::MODEL_COVERAGE_NON_FACE # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
 
   def model_sections
     File.readlines(MODEL_DOC).filter_map do |line|
@@ -147,6 +72,24 @@ RSpec.describe "model coverage matrix" do
     end.uniq
   end
 
+  # Document-side pin lists (TODO.sota/07): every section carries a
+  # `Pins::` line naming the specs that enforce it (`Pins:: none` for
+  # non-face sections). Parsed as section => [paths] or nil when the
+  # line is missing.
+  def model_pin_lists
+    lists = {}
+    current = nil
+    File.readlines(MODEL_DOC).each do |line|
+      if (heading = line[/\A=== (\S.*)$/, 1])
+        current = heading.strip
+        lists[current] = nil
+      elsif current && (entry = line[/\APins:: (.*)$/, 1])
+        lists[current] = entry.scan(/`([^`]+)`/).flatten
+      end
+    end
+    lists
+  end
+
   it "cites an existing model section for every face family" do
     sections = model_sections
     unknown = MODEL_MATRIX.filter_map do |family, cell|
@@ -162,7 +105,7 @@ RSpec.describe "model coverage matrix" do
   it "covers or declares every model section" do
     cited = MODEL_MATRIX.values.filter_map { |cell| cell[:section] }
     uncovered = model_sections.reject do |section|
-      cited.include?(section) || NON_FACE_SECTIONS.include?(section)
+      cited.include?(section) || NON_FACE.include?(section)
     end
     expect(uncovered).to be_empty,
                          "model sections with no coverage matrix family " \
@@ -170,11 +113,43 @@ RSpec.describe "model coverage matrix" do
   end
 
   it "declares non-face sections that actually exist in the model doc" do
-    stale = NON_FACE_SECTIONS.reject { |s| model_sections.include?(s) }
+    stale = NON_FACE.reject { |s| model_sections.include?(s) }
     expect(stale).to be_empty,
                      "non-face declarations citing missing sections: #{stale.join('; ')}"
   end
 
+  it "gives every model section a Pins line" do
+    missing = model_pin_lists.select { |_, pins| pins.nil? }.keys
+    expect(missing).to be_empty,
+                       "model sections without a Pins line: #{missing.join('; ')}"
+  end
+
+  it "matches the model doc's face-section pin lists to the matrix" do
+    lists = model_pin_lists
+    drift = ModelCoverage.sections.filter_map do |section|
+      expected = ModelCoverage.pins_for(section)
+      got = lists[section]
+      "#{section}: doc #{got.inspect} vs matrix #{expected.inspect}" if got != expected
+    end
+    expect(drift).to be_empty,
+                     "model-doc pin lists drift from the matrix: #{drift.join('; ')}"
+  end
+
+  it "leaves non-face sections without pins" do
+    lists = model_pin_lists
+    pinned = NON_FACE.select { |section| lists[section]&.any? }
+    expect(pinned).to be_empty,
+                      "non-face sections must declare Pins:: none: #{pinned.join('; ')}"
+  end
+
+  it "points every model-doc pin at an existing spec" do
+    missing = model_pin_lists.values.compact.flatten.uniq.reject do |path|
+      File.exist?(path)
+    end
+    expect(missing).to be_empty,
+                       "model-doc pins missing on disk: #{missing.join(', ')}"
+  end
+
   # Bidirectional linkage (TODO.sota/03): the model doc, the pins, and
   # the reference form one checkable triangle. Every pin cites the
   # section it enforces; every citation names a section that exists.
@@ -213,7 +188,7 @@ RSpec.describe "model coverage matrix" do
       File.exist?(path) ? pin_citations(path) : []
     end
     uncovered = model_sections.reject do |section|
-      cited.include?(section) || NON_FACE_SECTIONS.include?(section)
+      cited.include?(section) || NON_FACE.include?(section)
     end
     expect(uncovered).to be_empty,
                          "model sections no pin cites: #{uncovered.join('; ')}"

data/spec/consistency/published_docs_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/model_coverage"
+require "json"
+
+# Published documentation is part of the specification apparatus
+# (TODO.sota/07): generated blocks must be views of committed data. A
+# data change without regeneration fails here, so the published
+# coverage proof and scoreboard can never claim more than the tests do.
+RSpec.describe "published documentation" do
+  it "keeps the model-coverage page in sync with the matrix" do
+    page = File.read("docs/_pages/model-coverage.adoc")
+    block = page[/MODEL-COVERAGE:BEGIN\n(.*?)\n?\/\/ MODEL-COVERAGE:END/m, 1]
+    expect(block).not_to be_nil, "coverage page is missing its markers"
+
+    expect(block).to eq(ModelCoverage.render_page_block),
+                     "model-coverage page is stale: run rake docs:coverage"
+  end
+
+  it "keeps every published scoreboard row in sync with the JSON data" do
+    data = JSON.parse(File.read("benchmark/scoreboard.json"))
+    page = File.read("docs/_pages/performance.adoc")
+    block = page[/SCOREBOARD:BEGIN(.*?)SCOREBOARD:END/m, 1]
+    expect(block).not_to be_nil, "performance page is missing its markers"
+
+    data["rows"].each do |row|
+      expect(block).to include(
+        "| `#{row['row']}` | #{format('%.2f', row['ratio'])}x | " \
+        "#{row['kind']} |",
+      ), "scoreboard row #{row['row']} is stale against scoreboard.json"
+    end
+
+    expect(block.scan(/\| `[^`]+` \| \d+\.\d\dx \|/).size)
+      .to eq(data["rows"].size), "scoreboard row count differs"
+  end
+
+  it "names the measured engine version in the scoreboard metadata" do
+    data = JSON.parse(File.read("benchmark/scoreboard.json"))
+    protocol = data["protocol"]
+    page = File.read("docs/_pages/performance.adoc")
+    block = page[/SCOREBOARD:BEGIN(.*?)SCOREBOARD:END/m, 1]
+
+    expect(block).to include("#{protocol['adapter']} " \
+                             "#{protocol['adapter_version']}"),
+                     "scoreboard metadata does not name the measured engine"
+    expect(block).to include("nokogiri #{protocol['nokogiri']}")
+  end
+end