pubid 2.0.0.pre.alpha.12 → 2.0.0.pre.alpha.13

data/lib/pubid/sae/components/type.rb

@@ -8,6 +8,8 @@ module Pubid
       # Type component for SAE document types
       # AMS, AIR, ARP, AS, MA
       class Type < Lutaml::Model::Serializable
+        include ::Pubid::SubsetMatch
+
         attribute :abbr, :string
 
         def to_s

data/lib/pubid/subset_match.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Pubid
+  # Subset match: `reference === candidate`.
+  #
+  # The match is true when every part that +reference+ states matches
+  # +candidate+. A part that +reference+ leaves nil or empty is a wildcard.
+  # relaton uses it to match a partial user reference against index rows, so
+  # the caller does not have to name the parts to ignore, as `#matches?`
+  # requires.
+  #
+  #   reference = Pubid::Iso.parse("ISO 9001")
+  #   dated = Pubid::Iso.parse("ISO 9001:2015")
+  #   reference === dated # => true
+  #   dated === reference # => false
+  #
+  # The operator is NOT symmetric: the receiver is the reference. Ruby calls
+  # `===` for `case` and `Enumerable#grep`, so `catalogue.grep(reference)`
+  # returns the entries that match the reference. RSpec calls it too: the
+  # fuzzy matchers (`include`, `match`, `contain_exactly`, `have_attributes`)
+  # and mock argument matchers (`with`) try `expected === actual` when `==` is
+  # false. So an expectation with a partial identifier on the expected side
+  # passes against a fuller one. Use `eq` when a spec needs exact equality.
+  #
+  # Rules:
+  # - The two objects must be instances of the same class. A reference never
+  #   falls back to the base document of a wrapper: `BS 7273-4` does not match
+  #   `BS 7273-4:2015+A1:2021`.
+  # - A default value is stated. `ISO 9001` means the published stage, so it
+  #   does not match `ISO/DIS 9001`.
+  # - A collection matches by position, and the reference can be shorter:
+  #   `ISO/IEC 9001` matches `ISO/IEC/IEEE 9001`, `ISO/IEEE 9001` does not.
+  # - A STRICT attribute is exempt from both wildcards: the reference always
+  #   states it, so a nil value means "this document has none" and a stated
+  #   collection is not a prefix. A class declares one with `subset_strict`.
+  # - A reference that sets +all_parts+ matches every part of the document:
+  #   `part`, `parts`, `subpart` and `all_parts` itself are skipped.
+  # - A nested identifier or component that includes this module is compared
+  #   with its own `===`. Any other value is compared with `==`.
+  # - `#==` does not change. An error from an attribute reader propagates.
+  #
+  # The match walks the attributes of the objects, not their `to_hash`, so a
+  # class can change the rule for its own attributes:
+  # - `subset_strict` names attributes the reference always states, for
+  #   example an ECMA `part` or an ETSI `parts` list.
+  # - `self.subset_ignored_attributes` names attributes that `===` skips, for
+  #   example a value that `from_hash` cannot restore (NIST build artifacts).
+  # - `#subset_attribute_match?` decides one attribute; an override calls
+  #   `super` for the attributes it does not handle.
+  #
+  # Every identifier and every component class includes this module. A new
+  # component class must include it too; `spec/pubid/subset_match_spec.rb`
+  # fails otherwise.
+  module SubsetMatch
+    # The parts of a document, which a reference with +all_parts+ does not
+    # restrict. `all_parts` itself is here so that an all-parts reference
+    # matches a candidate that states one part.
+    ALL_PARTS_ATTRIBUTES = %i[part parts subpart all_parts].freeze
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Class-level hooks.
+    module ClassMethods
+      # Declare attributes that the reference always states. A nil or empty
+      # value then means "this document has none", and a stated collection
+      # must match in full instead of as a prefix.
+      #
+      #   class Pubid::Ecma::Identifier < Pubid::Identifier
+      #     subset_strict :part
+      #   end
+      #
+      # A caller that does want every part of a document sets `all_parts` on
+      # the reference, or keeps using `#matches?(other, ignore:)`.
+      #
+      # @param names [Array<Symbol>] the attributes of this class
+      # @return [Array<Symbol>] the attributes this class itself declares
+      def subset_strict(*names)
+        @subset_strict_own = subset_strict_own | names.map(&:to_sym)
+      end
+
+      # @return [Array<Symbol>] the attributes that `===` compares exactly,
+      #   this class's own declarations and every one it inherits
+      def subset_strict_attributes
+        inherited = if superclass.respond_to?(:subset_strict_attributes)
+                      superclass.subset_strict_attributes
+                    else
+                      []
+                    end
+        inherited | subset_strict_own
+      end
+
+      # @return [Array<Symbol>] the attributes that `===` skips
+      def subset_ignored_attributes
+        []
+      end
+
+      private
+
+      def subset_strict_own
+        @subset_strict_own ||= []
+      end
+    end
+
+    # @param other [Object] the candidate
+    # @return [Boolean] true when +other+ holds every part that self states
+    def ===(other)
+      return true if equal?(other)
+      return false unless other.instance_of?(self.class)
+
+      ignored = subset_skipped_attributes
+      self.class.attributes.each_key.all? do |name|
+        ignored.include?(name) || subset_attribute_match?(
+          name, public_send(name), other.public_send(name)
+        )
+      end
+    end
+
+    # @return [Array<Symbol>] the attributes this match does not compare
+    def subset_skipped_attributes
+      ignored = self.class.subset_ignored_attributes
+      return ignored unless subset_all_parts_wildcard?
+
+      ignored | ALL_PARTS_ATTRIBUTES
+    end
+
+    # True when the reference asks for every part of the document.
+    # `Pubid::Identifier` overrides it to read its +all_parts+ attribute; a
+    # component never holds a document's parts.
+    # @return [Boolean]
+    def subset_all_parts_wildcard?
+      false
+    end
+
+    # @param name [Symbol] the attribute name
+    # @param mine [Object] the value of the reference
+    # @param theirs [Object] the value of the candidate
+    # @return [Boolean] true when +theirs+ satisfies +mine+
+    def subset_attribute_match?(name, mine, theirs)
+      return SubsetMatch.exact_match?(mine, theirs) if
+        self.class.subset_strict_attributes.include?(name)
+
+      SubsetMatch.value_match?(mine, theirs)
+    end
+
+    # @return [Boolean] true when +theirs+ satisfies the reference value +mine+
+    def self.value_match?(mine, theirs)
+      return true if blank?(mine)
+
+      case mine
+      when ::Array then collection_match?(mine, theirs)
+      when SubsetMatch then mine === theirs
+      else mine == theirs
+      end
+    end
+
+    # A strict attribute is compared exactly: nil and empty are the same
+    # value, so a parsed identifier still matches the index row that
+    # `from_hash` rebuilds from a hash that dropped the empty attribute; a
+    # collection must match in full, element by element.
+    #
+    # Exactness composes rather than flattening: a nested value that
+    # includes this module is matched in BOTH directions with its own
+    # `===`, so the class that owns it keeps its rule. A plain `==` would
+    # override it — `Components::TypedStage` ignores `original_abbr`
+    # (the input spelling, `Amd` against `AMD`), and CEN/CENELEC declares
+    # `typed_stage` strict.
+    # @return [Boolean]
+    def self.exact_match?(mine, theirs)
+      return true if blank?(mine) && blank?(theirs)
+
+      case mine
+      when ::Array then exact_collection_match?(mine, theirs)
+      when SubsetMatch then mine === theirs && theirs === mine
+      else mine == theirs
+      end
+    end
+
+    # A strict collection matches in full, never as a prefix.
+    def self.exact_collection_match?(mine, theirs)
+      theirs.is_a?(::Array) && mine.size == theirs.size &&
+        mine.each_with_index.all? { |value, i| exact_match?(value, theirs[i]) }
+    end
+
+    # A shorter reference collection matches the leading elements.
+    def self.collection_match?(mine, theirs)
+      theirs.is_a?(::Array) && mine.size <= theirs.size &&
+        mine.each_with_index.all? { |value, i| value_match?(value, theirs[i]) }
+    end
+
+    # @return [Boolean] true for nil and for an empty string or collection
+    def self.blank?(value)
+      value.nil? || Lutaml::Model::Utils.empty?(value)
+    end
+  end
+end

data/lib/pubid/tgpp/CLAUDE.md

@@ -0,0 +1,43 @@
+# 3GPP flavor notes
+
+3GPP (`Pubid::Tgpp`) module naming and partial references.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/tgpp/` or `spec/pubid/tgpp/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **Digit-leading flavor names (`3gpp`/`Pubid::Tgpp`)**: a relaton flavor whose name starts with a digit can't be a Ruby constant, so the module is spelled out (`Pubid::Tgpp`, files under `lib/pubid/tgpp/`) while the **external contract stays the digit form** everywhere it's observed: the registry key (`Pubid::Registry.register(:"3gpp", …)`), the polymorphic `_type` (`pubid:3gpp:…`), and the URN namespace (`urn:3gpp:…`). Three overrides bridge the gap — (1) `Identifier.polymorphic_name` post-processes the auto-derived name (`super&.sub(/\Apubid:tgpp:/, "pubid:3gpp:")`) so `_type`/`TGPP_TYPE_MAP` agree; (2) `UrnParser#flavor_name` returns `"3gpp"` so `strip_namespace` accepts `urn:3gpp:`; (3) the export layer registers `:tgpp` (NOT `:"3gpp"`) in `Export::Exporter::FLAVORS` because `FlavorExporter` maps the symbol via `Pubid.const_get(camelize(sym))`, and it reads fixtures from `spec/fixtures/tgpp/` — so this flavor's on-disk paths (`spec/pubid/tgpp/`, `spec/fixtures/tgpp/`) follow the module, not the digit name. `PREFIXES = ["3GPP"]` (the printed docidentifier is `3GPP TS …`; the parser also accepts the bare index form). Any future digit-leading flavor mirrors this split.
+
+- **3GPP partial references — both trailing qualifiers are optional**: a 3GPP identifier is `[3GPP ]<TR|TS> <NN.NNN>[suffix][-part…][:<release>][/<version>]`. The release segment was already `.maybe` (a handful of legacy records omit it, e.g. `TS 29.215/2.0.0`) but the **version was mandatory**, so the bare reference a person actually types — `3GPP TS 23.207` — failed to parse. Every one of the 88,464 published `relaton-data-3gpp` index rows carries both, so the corpus never exercised the gap; it blocks the *consumer*, which must parse a user query to search that index. The fix is the ETSI three-step pattern verbatim — parser `(str("/") >> version).maybe`, builder `data[:version]&.to_s` (never `""`, so the no-defaults `to_hash` drops it), renderer appending each qualifier only when present — plus the URN pair. `type` and `number_core` stay required, and `version` still demands three dotted digit groups, so `TS`, `TS foo`, `TS 23.207/4.0`, `TS 23.207/` and `TS 23.207:` are all still rejected. **URN decision: only TRAILING empty segments are dropped, never interior ones.** A bare reference gets the clean `urn:3gpp:ts:23.207` instead of a malformed `urn:3gpp:ts:23.207::`, while the pre-existing release-less form keeps the URN it has always published (`TS 29.215/2.0.0` → `urn:3gpp:ts:29.215::2.0.0`, an interior empty segment `UrnParser` already reads back). Generator and parser are exact inverses for all four present/absent combinations. **One guard the optionality forced**: the `release` rule is deliberately generic (`match["^/:"].repeat(1)`), so once the version became optional a mistyped separator — `TS 23.207:2.0.0` — silently parsed with the *version* misfiled as the release, where it was structurally impossible before. `release` now carries a `(version_core >> any.absent?).absent?` lookahead, rejecting a trailing segment shaped exactly like a version. It is anchored at **end of input**, so a real release still wins whenever a version follows (`TS 23.207:Release 2000/9.0.0`); the empirical warrant is that **none** of the 27 distinct releases in the 88,464 published rows contains a dot at all. **Landmine in the trailing-strip loop**: a bare `Array#any?` tests element *truthiness*, so `[nil, nil].any?` is `false` and strips nothing — the loop guard must be `until segments.empty? || !blank?(segments.last)`. **Nothing about the stored shape changed**: `attribute :version, :string` and the `key_value` map stay as they are, only `nil` becomes reachable, so no index migration follows and no relaton index needs regenerating. `number` was already a plain `:string` and already the relaton bsearch key — there is no IANA/BIPM/W3C-style `root.number` defect here. Verified over the whole published corpus: `to_s`, `to_urn` and the URN round-trip are **byte-identical on all 88,464 rows** before and after, with 0 empty `root.number`. 3GPP's `spec/pubid/partial_ref_spec.rb` entry moved from the laggard `omits: []` to `{ ref: "3GPP TS 23.207", omits: %i[release version] }`, leaving **AMCA as the only remaining laggard**. The new bare/partial forms are NORMALIZING for the `3GPP ` prefix (`3GPP TS 23.207` renders back as `TS 23.207`, since `with_publisher` defaults to false to match the relaton index id), so per the `CIPM/2005-06(REV)` precedent they live in `spec/pubid/tgpp/identifier_spec.rb`, **not** in the byte-exact `spec/fixtures/tgpp/identifiers/pass/`. **Pre-existing and out of scope:** `Pubid.parse` resolves only `:urn` and `:mr_string` inputs and raises for a human string in *every* flavor, so `Pubid.parse("3GPP TS 23.207")` does not route — consumers call `Pubid::Tgpp::Identifier.parse` (or pass `pubid_class:`) directly. (hand-off: tgpp-bare-reference-parse; consumer follow-up: relaton__relaton__3gpp-consume-index-v2.)
+
+## `all_parts_edition_keys` missed `release`
+
+`Identifier.all_parts_edition_keys` defaults to `%i[date year edition
+version]`. 3GPP's edition/version identity is split across two
+attributes: `version` is in the default list, but `release` (e.g.
+`"REL-4"`) is not, so `"3GPP TS 23.207:REL-4/4.0.0".to_all_parts` kept the
+release token and failed to match `"3GPP TS 23.207:REL-5/5.0.0"` under
+`#===`. Fixed with `Pubid::Tgpp::Identifier.all_parts_edition_keys` (`super
++ %i[release]`) — unlike OGC's `year`, nothing else 3GPP declares needs to
+come OUT of the default list, so this is a pure addition. Locked by
+`spec/pubid/tgpp/all_parts_spec.rb` and
+`spec/pubid/all_parts_edition_keys_audit_spec.rb`.
+
+## Related rule in the root file
+
+3GPP's `parts` attribute produced the rule that a `collection: true` attribute needs `initialize_empty: true`. That rule applies to every flavor, so it stays in the root `CLAUDE.md`, not here.
+
+## Subset match: strict attributes
+
+Read `docs/SUBSET_MATCH.md` first. `===` reads a nil part of the reference as
+a wildcard, which is wrong for the attributes below: the flavor models a nil
+value as "this document has none". They are declared with `subset_strict`, so
+`===` compares them exactly and a stated collection is not a prefix. A caller
+that does want every part of a document sets `all_parts` on the reference, or
+keeps `#matches?(other, ignore:)`.
+
+- **`suffix` and `parts` are strict** (`lib/pubid/tgpp/identifier.rb`).
+  `TS 29.198 === TS 29.198-04-1` and `TR 00.01 === TR 00.01U` are both
+  false. `parts` is the flavor's `collection: true, initialize_empty: true`
+  attribute, so a part-less identifier holds `[]` on both construction
+  paths and the strict comparison treats that `[]` and a nil alike — the
+  same asymmetry the `initialize_empty` note above is about, seen from the
+  matching side. relaton had two committed specs breaking on this.

data/lib/pubid/tgpp/builder.rb

@@ -39,3 +39,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Tgpp::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/tgpp/identifier.rb

@@ -27,6 +27,20 @@ module Pubid
       # Three-part version string, e.g. "2.0.0".
       attribute :version, :string
 
+      # 3GPP's edition/version identity is split across `release` and
+      # `version`. `version` is already in the default
+      # `%i[date year edition version]` list; `release` is not, so it
+      # survived without_parts untouched and leaked into an "all parts"
+      # identity built via #to_all_parts.
+      def self.all_parts_edition_keys
+        super + %i[release]
+      end
+
+      # A nil `suffix` and an empty `parts` mean the document has neither:
+      # `TS 29.198` is not `TS 29.198-04-1`, and `TR 00.01` is not
+      # `TR 00.01U`. A stated list is not a prefix either.
+      subset_strict :suffix, :parts
+
       # Polymorphic type map for lutaml::Model key_value (de)serialization.
       # Keys are the `pubid:3gpp:…` names produced by polymorphic_name (below).
       TGPP_TYPE_MAP = {

data/lib/pubid/type_resolver.rb

@@ -15,6 +15,9 @@ module Pubid
   class TypeResolver
     TYPE_PREFIX = "pubid:"
     SEGMENT_SEPARATOR = ":"
+    # Types of classes that belong to no flavor, so they carry no flavor
+    # segment. Class names are strings, so the lookup triggers the autoload.
+    SHARED_TYPES = { "pubid:all-parts" => "Pubid::AllPartsIdentifier" }.freeze
 
     class << self
       # @param type [String, nil] Polymorphic _type, e.g. "pubid:iso:technical-report".
@@ -23,6 +26,17 @@ module Pubid
       def resolve(type)
         return nil unless type.is_a?(String)
 
+        shared_class(type) || flavor_class(type)
+      end
+
+      private
+
+      def shared_class(type)
+        name = SHARED_TYPES[type]
+        name && Object.const_get(name)
+      end
+
+      def flavor_class(type)
         flavor_name = flavor_segment(type)
         return nil unless flavor_name
 
@@ -43,8 +57,6 @@ module Pubid
         nil
       end
 
-      private
-
       # The registered flavor whose module constant gives +segment+.
       # Identifier.polymorphic_name takes the segment from the module name
       # ("Pubid::CenCenelec" -> "cencenelec"), and a flavor can be registered

data/lib/pubid/un/builder.rb

@@ -40,3 +40,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Un::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pubid
-  VERSION = "2.0.0.pre.alpha.12"
+  VERSION = "2.0.0.pre.alpha.13"
 end

data/lib/pubid/w3c/CLAUDE.md

@@ -0,0 +1,7 @@
+# W3C flavor notes
+
+W3C slug attribute and index key.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/w3c/` or `spec/pubid/w3c/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **W3C renamed its slug attribute `code` → `number` (index key)**: a W3C identifier is a flat slug plus an optional verbatim date, and the slug used to live in `attribute :code, :string` while the `number` inherited from `::Pubid::Identifier` (a `Components::Code`) was never set. `Relaton::Index::Type#candidates_by_number` sorts and bsearches every row on `id.root.number.to_s`, so all **16,336** published `relaton-data-w3c` rows shared the empty key `""` and the binary search degenerated to a linear scan — silently, with no error. The slug *is* the key, so the attribute was **renamed** rather than shadowed by a derived reader: `attribute :number, :string` on `Pubid::W3c::Identifier`, `map "number", to: :number` in the `key_value` block, and the three readers moved (`Builder#build`'s `new(number:)`, `Renderer#render`, `UrnGenerator#generate`). **`code` is dropped with no alias** — one name for one value. Serialized vocabulary is `{_type, number}` / `{_type, number, date}`; `to_s` and the URN shape (`urn:w3c:<type>:<slug>[:<date>]`) are byte-identical, verified over the whole published corpus (0 empty/mismatched keys, 0 round-trip failures, 1933 buckets — was 1). **Why the declaration sits on the shared base here, when IEEE/IETF/IANA put theirs on the leaves**: this still redefines the parent's `attribute :number, Components::Code` as `:string` on a class the 11 concrete `Identifiers::*` inherit from — the recorded landmine — but the mechanism shows the hazard is load-order, not inheritance: lutaml's `inherited` hook **deep-dups** the parent's attribute table into each subclass at class-definition time (`serialize/initialization.rb#initialize_attrs`), so a subclass holds a **snapshot**, not a live view. A base-level override is therefore safe iff every subclass body opens *after* the base body has run — and Ruby resolves the superclass constant (autoloading `w3c/identifier.rb` and running it to completion) before opening any leaf body. W3C's base is **one file, one class body, never reopened**, so this holds in every load order; the `date` override of the parent's `Components::Date` has relied on the same property since the flavor landed. IEEE is the counter-shape: its `identifier.rb` defines nothing and the class body lives in `identifiers/base.rb`, so the base is reachable through two paths and a leaf can snapshot it half-built. **Split this base across two files and the landmine comes back.** `spec/pubid/w3c/root_number_spec.rb` carries the structural tripwire (the base *and* all 11 leaves must resolve `number` to `Lutaml::Model::Type::String`) and is only meaningful under the full `bundle exec rake`. **relaton note**: there is no alias and no published W3C pubid index yet, so nothing needs migrating — but `relaton/relaton`'s in-flight migration off the hand-rolled `Relaton::W3c::PubId` must read `id.number`, and its `DataFetcher`-built index must be crawled *after* this lands or every row keys on `""` again. **Known gap, deliberately NOT fixed here and recorded as a separate hand-off (w3c-mr-string):** `to_mr_string` **raises `NoMethodError` for every dated W3C id** — the base `mr_year` calls `date.year`, but W3C's `date` is a plain `:string` (opaque digit runs of varying width; the flavor already works around this for its public `#year` reader, but not for `mr_year`), and `mr_type`/`mr_publisher` are always nil (`Builder` never sets `typed_stage`; the publisher is a constant). This is pre-existing on `main`, untouched by the rename, and is a *second* identity surface — `to_slug` is an output **filename**. Measured over the 16,336 published rows: a year-only `mr_year` gives **1,936 collisions**; the whole verbatim `date` plus BIPM-style charset sanitisation (the corpus needs `/` and `+`) gives **16,336 distinct, filename-safe slugs, 0 collisions**. (hand-off: w3c-index-number; consumer follow-up: relaton__relaton__w3c-pubid-number-rename.)

data/lib/pubid/w3c/builder.rb

@@ -53,3 +53,5 @@ module Pubid
     end
   end
 end
+
+Pubid::W3c::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/xsf/CLAUDE.md

@@ -0,0 +1,11 @@
+# XSF flavor notes
+
+XSF named documents (`XEP README`, `XEP xxxx`).
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/xsf/` or `spec/pubid/xsf/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+- **The XEP number is not always a number**: the whole XSF grammar is four rules, and the number used to be `match["0-9"].repeat(1)`. The XMPP extensions repository publishes two documents whose name is a word — the editor README (`xep-README.html`) and the template (`xep-xxxx.html`) — and both reach pubid as **real primary docids**, `XEP README` and `XEP xxxx`. They are rows of the published `relaton-data-xsf/index-v1.yaml`, backed by `data/xep-readme.yaml` (title "XEP Editor README") and `data/xep-xxxx.yaml` (title "XEP Template"). The digits-only rule rejected both at char 5, which cost two repositories a permanent workaround: `Relaton::Xsf::DataFetcher` carried `NON_DOCUMENTS = ["XEP README", "XEP xxxx"]` to swallow the parse failure in `add_to_index`, and `relaton-data-xsf/build_index_v1.rb` documented that its `index-v1` is deliberately **two rows longer** than `index-v2` (520 against 518) — one unparseable row makes `Relaton::Index` declare the whole file corrupt, delete it, and hand back an empty index, so the two rows could never enter v2. The grammar now admits the two names beside the digits: `(digits | special_number).as(:number)`, with `SPECIAL_NUMBERS = %w[README xxxx]` on `Pubid::Xsf::Parser`.
+- **Two literals, not a slug rule, and the exact case only.** `XEP foo`, `XEP readme`, `XEP XXXX`, `XEP xxx` and `XEP xxxxx` all still raise `Pubid::Errors::ParseError`, pinned one by one in `spec/pubid/xsf/identifier_spec.rb`. Widening the number to any alphanumeric run would have been one character shorter and would have made XSF an anything-goes flavor after its prefix — the shape `Pubid.parse` probes for with `accepts_anything?` and then refuses to use as a fallback. A case-insensitive match would have made the parse *normalizing* (`XEP readme` → `XEP README`), so `to_s` would no longer equal the input and the fixture round-trip spec would need the `!input!rendered` marker for a form the corpus does not contain.
+- **Nothing outside the parser changed, and that is the reason to store the name in `number`.** `number` is already `attribute :number, :string` on `Pubid::Xsf::Identifier` (a string to keep the zero padding), so `"README"` stores as it arrives; `Renderer#render` interpolates it, so `to_s` gives back `XEP README`; `UrnGenerator` gives `urn:xsf:xep:README` and `UrnParser` rebuilds the printed string and re-parses it, so the URN round-trip closes; `key_value` already maps `number`, so `from_hash(to_hash) == parse`; and `root.number` is non-empty, so the index key is sound for both. A separate attribute for the name would have broken every one of those.
+- **relaton note**: once this ships, `Relaton::Xsf::DataFetcher` can drop `NON_DOCUMENTS` and the rescue branch that reads it, `relaton-data-xsf` needs its `index-v2` regenerated to carry all 520 rows, and the `build_index_v1.rb` comment asserting the two-row difference is then wrong. (hand-off: `relaton__relaton__xsf-named-documents-are-parseable`.)
+- **Pre-existing gaps, untouched here.** XSF's MR slug carries no publisher segment — `Pubid::Xsf.parse("XEP 0001").to_slug == "0001"` — so it collides with any other flavor's bare-number slug; `lib/pubid/iana/CLAUDE.md` records XSF among the slug-only flavors that would surface this if `mr_string_spec` were made registry-driven. The fixture corpus is one hand-written file, `spec/fixtures/xsf/identifiers/pass/xep.txt`: XSF has no `identifiers/full/` directory and no `validation:classify` entry, so that file is edited by hand — the root `CLAUDE.md` rule against hand-editing `pass/` covers the classifier-driven flavors, which XSF is not. There is no `fail/` corpus at all.

data/lib/pubid/xsf/builder.rb

@@ -15,3 +15,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Xsf::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid.rb

@@ -143,7 +143,10 @@ module Pubid
   autoload :Parser, "pubid/parser"
   autoload :Components, "pubid/components"
   autoload :BundledIdentifier, "pubid/bundled_identifier"
+  autoload :AllParts, "pubid/all_parts"
+  autoload :AllPartsIdentifier, "pubid/all_parts_identifier"
   autoload :Identifier, "pubid/identifier"
+  autoload :SubsetMatch, "pubid/subset_match"
   autoload :IdentifierMetadata, "pubid/identifier_metadata"
   autoload :Rendering, "pubid/rendering"
   autoload :Renderers, "pubid/renderers"
@@ -486,15 +489,25 @@ module Pubid
   private_class_method :routing_table
 
   # True when +string+ starts with +prefix+ at a token boundary, so "ISO" does
-  # not claim "ISOFIX" and "BS" does not claim "BSI".
-  # @api private
+  # not claim "ISOFIX" and "BS" does not claim "BSI". A boundary is the end
+  # of the string or any non-alphanumeric character, so a registered prefix
+  # can be followed by a space ("ISO 9001") or by a slash attaching a type
+  # token ("ISO/TR 25901-1:2016").
+  #
+  # Public (not +@api private+) so a flavor's own prefix routing - GOST's
+  # foreign-adoption lookup, currently the only caller outside this file -
+  # can reuse the exact boundary rule {parse_by_prefix} uses, rather than
+  # keeping a second copy that can drift out of sync.
+  #
+  # @param string [String]
+  # @param prefix [String]
+  # @return [Boolean]
   def self.prefix_match?(string, prefix)
     return false unless string.start_with?(prefix)
 
     rest = string[prefix.length]
     rest.nil? || !/[A-Za-z0-9]/.match?(rest)
   end
-  private_class_method :prefix_match?
 
   def self.detect_flavor_from_urn(urn)
     # urn:iso:std:... → "iso"