relaton 3.0.0.pre.alpha.1 → 3.0.0.pre.alpha.2

data/lib/relaton/nist/scraper.rb

@@ -64,9 +64,12 @@ module Relaton
         # @param hit [Hash]
         # @return [Array<Bib::Docidentifier>]
         def fetch_docid(hit)
-          ids = [Bib::Docidentifier.new(content: hit[:code], type: "NIST", primary: true)]
+          # All ids share the Nist::Docidentifier collection type so YAML
+          # serialization stays valid; the DOI is not canonical NIST pubid form,
+          # so the class keeps it as the raw string (see Docidentifier#content=).
+          ids = [Docidentifier.new(content: hit[:code], type: "NIST", primary: true)]
           doi = hit[:json]["doi"]&.split("/")&.last
-          ids << Bib::Docidentifier.new(content: doi, type: "DOI") if doi
+          ids << Docidentifier.new(content: doi, type: "DOI") if doi
           ids
         end
 
@@ -262,7 +265,7 @@ module Relaton
             t = "obsoletes"
           else t = type
           end
-          ids = [Bib::Docidentifier.new(content: ref, type: "NIST", primary: true)]
+          ids = [Docidentifier.new(content: ref, type: "NIST", primary: true)]
           link = [Bib::Uri.new(type: "src", content: uri)]
           bib = ItemData.new(formattedref: Bib::Formattedref.new(content: ref), source: link, docidentifier: ids)
           Relation.new(type: t, description: descr, bibitem: bib)

data/lib/relaton/oasis/bibliography.rb

@@ -7,11 +7,18 @@ module Relaton
     module Bibliography
       ENDPOINT = "https://raw.githubusercontent.com/relaton/relaton-data-oasis/refs/heads/v2/"
 
+      # The publisher token every OASIS printed id starts with, and the one
+      # thing `Pubid::Oasis`'s grammar requires. See #parse_ref.
+      PREFIX = "OASIS "
+
+      # The components a reference may omit. `number` (the specification name)
+      # is deliberately absent — see #ignored.
+      OPTIONAL = %i[version stage part label].freeze
+
       class << self
         def search(text, _year = nil, _opts = {}) # rubocop:disable Metrics/MethodLength
           Util.info "Fetching from Relaton repository ...", key: text
-          /^(?:OASIS\s)?(?<code>.+)/ =~ text
-          row = find_index_entry(code)
+          row = find_index_entry(text)
           unless row
             Util.info "Not found.", key: text
             return
@@ -33,11 +40,145 @@ module Relaton
 
         private
 
-        def find_index_entry(code)
-          index = Relaton::Index.find_or_create(
-            :oasis, url: "#{ENDPOINT}#{INDEXFILE}.zip"
+        #
+        # The pubid `index-v2`. `pubid_class:` is what makes `Relaton::Index`
+        # deserialize the rows into identifiers, sort them by
+        # `id.root.number`, and let `Type#search` bsearch; `file:` names the
+        # local cache, and `Processor#remove_index_file` must name the same
+        # one, or `Db#clear` leaves this cache in place.
+        #
+        # @return [Relaton::Index::Type]
+        #
+        def index
+          Relaton::Index.find_or_create(
+            :oasis, url: "#{ENDPOINT}#{INDEXFILE}.zip",
+            file: "#{INDEXFILE}.yaml",
+            pubid_class: ::Pubid::Oasis::Identifier
           )
-          index.search(code).min_by { |r| r[:id] }
+        end
+
+        #
+        # Find the row that best answers a reference.
+        #
+        # **Pass the pubid, not the string.** `Type#search_candidates` narrows
+        # only when the argument is not a `String`, so passing the reference
+        # text would disable the binary search however the index was built.
+        #
+        # Selection is `Type#search`'s default with no block — pubid's
+        # asymmetric subset match (`Pubid::SubsetMatch`): the reference on the
+        # left, and a component it omits (`version`, `stage`, `part`, `label`)
+        # matches any value, which is what `#ranking_key` then orders.
+        #
+        # A reference pubid cannot parse finds nothing, and there is no
+        # substring fallback. `#parse_ref` supplies the publisher token, so
+        # after normalization the only unparseable inputs are a blank string
+        # and one over pubid's 1000-character cap — and a substring scan for
+        # `""` matches every row in the index, which is worse than a miss.
+        # This is also the v1 -> v2 semantic change IANA recorded: v1 matched
+        # by substring, so `OASIS amqp` resolved to some `amqp-core` record;
+        # v2 matches identifiers, so a partial name no longer resolves.
+        #
+        # @param text [String] the reference as the caller wrote it
+        # @return [Hash, nil] the index row, or nil
+        #
+        def find_index_entry(text)
+          pubid = parse_ref text
+          return unless pubid
+
+          rows = index.search(pubid)
+          rows.max_by { |row| ranking_key pubid, row[:id] }
+        end
+
+        #
+        # An OASIS printed id carries the publisher token, and pubid rejects a
+        # bare slug — but a caller may well write one ("mqtt-v5.0"), and
+        # `Db#fetch` hands the reference through verbatim. Supplying the token
+        # is normalization, not identification, so it happens here rather than
+        # in the grammar.
+        #
+        # The token is stripped **case-insensitively** and re-added in its
+        # canonical form. pubid's grammar matches the literal `OASIS `, so a
+        # lowercase `oasis stix` would otherwise keep its own token, be given a
+        # second one, and search for the specification named `oasis stix`.
+        # Everything after the token stays verbatim: an OASIS slug is
+        # case-sensitive (`STIX`, `amqp-core`, `OpenDocument`).
+        #
+        # An unrecognized reference **raises**; like ISO, ETSI and 3GPP we let it
+        # propagate. relaton-cli rescues `Pubid::Errors::Error` and renders
+        # `"..." is not a recognized standards identifier`
+        # (`gems/relaton-cli/lib/relaton/cli/command.rb:324`), and `Db#fetch`
+        # logs it through the `StandardError` arm at `lib/relaton/db.rb:122`.
+        # Rescuing here would collapse "this identifier is malformed" into "no
+        # such document", leaving a caller unable to tell them apart.
+        #
+        # @param text [String]
+        # @return [Pubid::Oasis::Identifier]
+        # @raise [Pubid::Errors::ParseError]
+        #
+        def parse_ref(text)
+          slug = text.to_s.strip.sub(/\A#{Regexp.escape PREFIX}/i, "")
+          ::Pubid::Oasis::Identifier.parse "#{PREFIX}#{slug}"
+        end
+
+        #
+        # The components the reference left out, which the row may therefore
+        # carry freely. `#find_index_entry` no longer needs this list — pubid's
+        # `===` reads the omission from the reference itself — but
+        # `#ranking_key` still counts the components the caller did not ask for.
+        # `number` — the specification name — is never optional: it is the whole
+        # identity of an OASIS record and the key the index bsearches on.
+        #
+        # @param pubid [Pubid::Oasis::Identifier]
+        # @return [Array<Symbol>]
+        #
+        def ignored(pubid)
+          OPTIONAL.select { |attr| pubid.public_send(attr).nil? }
+        end
+
+        #
+        # Order the matched rows. Ignoring a component means "don't care", so a
+        # loose reference matches the more specific rows too and this key
+        # decides between them:
+        #
+        # 1. an **exact printed id** always wins. Five published records are a
+        #    bare specification name that also has versioned siblings — `OASIS
+        #    EDXL`, `OData`, `OSLC`, `SAML`, `WSS` — and each is a real
+        #    document in its own right. Without this key the "newest version"
+        #    rule below answers a request for the bare record with its newest
+        #    sibling; three of the five did exactly that. Published ids are
+        #    unique (0 duplicates in 605 rows), so at most one row scores here;
+        # 2. then the **newest version**, segments compared as integers —
+        #    `v2.1` beats `v1.2.1`, and `v10` beats `v9`, which a string
+        #    compare gets wrong;
+        # 3. then the **least specific** row, i.e. the fewest components the
+        #    reference did not ask for — a bare `OASIS STIX` wants `STIX-v2.1`,
+        #    not `STIX-v2.1-CS02`, and `OASIS STIX-v1.2.1-CS01` wants that
+        #    record itself, not its `-Pt3-Core` part;
+        # 4. then the **later stage revision** (`CS02` over `CS01`). Only the
+        #    digits are compared: OASIS stage letters have no ranking this code
+        #    is entitled to invent;
+        # 5. then the printed id, so the result never depends on index order.
+        #
+        # Checked against every published row: all 605 resolve to their own
+        # record, with and without the publisher token.
+        #
+        # @param pubid [Pubid::Oasis::Identifier] the parsed reference
+        # @param id [Pubid::Oasis::Identifier] a matched row's id
+        # @return [Array]
+        #
+        def ranking_key(pubid, id)
+          exact = id.to_s == pubid.to_s ? 1 : 0
+          extra = ignored(pubid).count { |attr| id.public_send(attr) }
+          [exact, digits(id.version), -extra, digits(id.stage), id.to_s]
+        end
+
+        # Integer segments of a version or stage token, for numeric ordering
+        # ("v1.2.1" -> [1, 2, 1], "CS02" -> [2], nil -> []).
+        #
+        # @param token [String, nil]
+        # @return [Array<Integer>]
+        def digits(token)
+          token.to_s.scan(/\d+/).map(&:to_i)
         end
 
         def fetch_yaml(uri)

data/lib/relaton/oasis/data_fetcher.rb

@@ -48,9 +48,13 @@ module Relaton
         end
       end
 
+      # `pubid_class:` on the producer too: FileIO#save only calls `to_hash`
+      # for instances of it, so without it the crawl writes v1-shaped rows
+      # under a v2 name, silently.
       def index
         @index ||= Relaton::Index.find_or_create(
-          :oasis, file: "#{INDEXFILE}.yaml"
+          :oasis, file: "#{INDEXFILE}.yaml",
+          pubid_class: ::Pubid::Oasis::Identifier
         )
       end
 
@@ -68,16 +72,48 @@ module Relaton
 
       def save_doc(doc) # rubocop:disable Metrics/AbcSize
         id = doc.docidentifier.find(&:primary) || doc.docidentifier.first
-        file = output_file(id.content)
+        # Distinct docids can sanitize to one filename; take a path of our own
+        # rather than overwriting the other document (Core#unique_output_file).
+        file = unique_output_file(id.content)
         if @files.include? file
+          # Same reserved path == same docid: a genuine duplicate. Checked FIRST,
+          # because a disambiguated path stays != output_file forever.
           Util.warn "File #{file} already exists. Document: #{id.content}"
-        else
-          @files << file
+        elsif file != output_file(id.content)
+          Util.warn "File #{output_file id.content} already exists. " \
+                    "Document: #{id.content}. Writing #{file} instead."
         end
-        index.add_or_update id.content, file
+        @files << file
+        add_to_index id, file
         File.write file, serialize(doc), encoding: "UTF-8"
       end
 
+      #
+      # Index the document, or record why it could not be indexed.
+      #
+      # An id pubid cannot parse is recorded in `@errors` — the inherited
+      # `report_errors` logs a String value as the message — and the row is
+      # skipped rather than indexed unparsed: `Relaton::Index` rejects the WHOLE
+      # index if a single row fails to deserialize, and its sort calls
+      # `.root.number` on every id. The data file is still written by the
+      # caller, so the document is unindexed, never lost. (The ECMA/W3C/3GPP
+      # shape.)
+      #
+      # `DataParserUtils#record_unparseable_id` already recorded this id when it
+      # was built, under the SAME key — the id string. This entry overwrites it
+      # with the same sentence plus the output file, so a saved document reports
+      # one line, the more informative one. Keep the two keys identical.
+      #
+      # @param id [Relaton::Oasis::Docidentifier] primary document identifier
+      # @param file [String] path the document is written to
+      #
+      def add_to_index(id, file)
+        return index.add_or_update(id.pubid, file) if id.pubid
+
+        @errors[id.content.to_s] =
+          "Unparseable primary id `#{id.content}` was not indexed (#{file})"
+      end
+
       def to_xml(bib)
         bib.to_xml(bibdata: true)
       end

data/lib/relaton/oasis/data_parser_utils.rb

@@ -240,16 +240,50 @@ module Relaton
       #
       # Parse document identifier.
       #
-      # @return [Array<Bib::Docidentifier>] document identifier
+      # @return [Array<Relaton::Oasis::Docidentifier>] document identifier
       #
       def parse_docid
         id = "OASIS #{parse_docnumber}"
-        result = [Bib::Docidentifier.new(type: "OASIS", content: id,
-                                         primary: true)]
+        docid = Docidentifier.new(type: "OASIS", content: id, primary: true)
+        record_unparseable_id docid
+        result = [docid]
         @errors[:docid] &&= result.empty?
         result
       end
 
+      #
+      # Surface an id pubid could not parse through the shared error-reporting
+      # machinery, so the crawl's "Error fetching documents" GitHub issue names
+      # it instead of dropping it silently in the action log.
+      #
+      # `Core::DataFetcher#report_errors` logs a **String** value verbatim as
+      # the message (a boolean means "this field failed for every record" and
+      # takes its message from the key), and the parsers share the fetcher's own
+      # `@errors` hash, so an entry written here reaches the issue unchanged.
+      #
+      # **Why here and not only in the fetcher.** W3C, 3GPP and ISO record this
+      # at index time, where the output file is known. OASIS records it at build
+      # time as well, because this is the one place EVERY id is built — the part
+      # ids that only ever become a relation's `formattedref`
+      # (`DataParser#parse_relation`, `DataPartParser#parse_relation`) never
+      # reach `DataFetcher#save_doc`, so an index-time hook alone cannot see
+      # them. `DataFetcher#add_to_index` keys its own entry on the same id
+      # string, so a document that IS saved reports once, through the fetcher's
+      # message, which additionally names the file.
+      #
+      # The docidentifier is returned either way: the document is still written,
+      # it is only left out of the index — `Relaton::Index` rejects the WHOLE
+      # index if a single row fails to deserialize.
+      #
+      # @param docid [Relaton::Oasis::Docidentifier] the id just built
+      #
+      def record_unparseable_id(docid)
+        return if docid.pubid
+
+        content = docid.content.to_s
+        @errors[content] = "Unparseable primary id `#{content}` was not indexed"
+      end
+
       #
       # Parse document type.
       #

data/lib/relaton/oasis/docidentifier.rb

@@ -0,0 +1,54 @@
+module Relaton
+  module Oasis
+    # Structured OASIS document identifier. The docid string is the printed
+    # form, which carries the "OASIS " publisher token
+    # (e.g. "OASIS OSLC-CoreShapes-3.0-PS01-Pt8"), and it is parsed into a
+    # `Pubid::Oasis::Identifier` kept in `@pubid` while the lutaml `content`
+    # attribute stays a plain string for serialization.
+    #
+    # Parsing is **soft**: `content=` lazily requires pubid and rescues
+    # `LoadError`/`StandardError`, so a missing pubid gem or non-OASIS content
+    # leaves `@pubid` nil rather than raising. A reference without the publisher
+    # token ("amqp-core") is not an OASIS printed id, so it leaves `@pubid` nil
+    # too; `DataFetcher` always builds the token-carrying form.
+    #
+    # ## Why the three mutators stay no-ops
+    #
+    # `Pubid::Oasis::Renderer` echoes the verbatim slug held in `original`, so
+    # clearing `part`, `version` or `stage` cannot change the printed id — the
+    # mutation would be invisible, and rewriting `original` would invent a
+    # reference form OASIS does not publish. OASIS slugs are free-form with an
+    # inconsistent internal structure, and no OASIS citation drops a part or a
+    # version; there is no "all parts" or "most recent" spelling to render.
+    #
+    # So this class deliberately does NOT override `remove_part!`,
+    # `remove_date!` or `to_all_parts!`. Since `dfbd26c72` the `Bib::Docidentifier`
+    # defaults are no-ops rather than `NotImplementedError` raises, so
+    # `Bib::ItemData#to_all_parts` and `#to_most_recent_reference` return the
+    # item unchanged instead of blowing up. That is the honest OASIS answer.
+    # (Contrast `Relaton::Ogc::Docidentifier`, whose components really do
+    # render, so its mutators re-render the content.)
+    class Docidentifier < Bib::Docidentifier
+      attr_reader :pubid
+
+      def initialize(attrs = {}, options = {})
+        pubid = attrs.is_a?(Hash) ? attrs.delete(:pubid) : nil
+        attrs[:content] ||= pubid.to_s if pubid
+        super
+        @pubid = pubid if pubid
+      end
+
+      def content=(value)
+        super
+        return unless value
+
+        @pubid = begin
+          require "pubid"
+          ::Pubid::Oasis::Identifier.parse(value.to_s)
+        rescue LoadError, StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/relaton/oasis/item.rb

@@ -1,3 +1,4 @@
+require_relative "docidentifier"
 require_relative "ext"
 
 module Relaton
@@ -5,6 +6,8 @@ module Relaton
     class Item < Bib::Item
       model ItemData
 
+      attribute :docidentifier, Docidentifier, collection: true,
+                                               initialize_empty: true
       attribute :ext, Ext
     end
   end

data/lib/relaton/oasis/processor.rb

@@ -11,6 +11,7 @@ module Relaton
         @defaultprefix = %r{^OASIS\s}
         @idtype = "OASIS"
         @datasets = %w[oasis-open]
+        @pubid_flavor = :Oasis
       end
 
       # @param code [String]
@@ -59,9 +60,14 @@ module Relaton
       #
       # Remove index file
       #
+      # `url: true` names the cached file. No `pubid_class:`: `Type#remove_file`
+      # deletes the file and never reads the index.
+      #
       def remove_index_file
         require_relative "../oasis"
-        Relaton::Index.find_or_create(:oasis, file: "#{INDEXFILE}.yaml").remove_file
+        Relaton::Index.find_or_create(
+          :oasis, url: true, file: "#{INDEXFILE}.yaml"
+        ).remove_file
       end
     end
   end

data/lib/relaton/oasis.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+# Not lazy: DataFetcher names ::Pubid::Oasis::Identifier as the index
+# `pubid_class:`, and Docidentifier parses every docid through it.
+# (The IANA/IHO/IALA/OGC/ECMA form; spec/relaton/lazy_loading_spec.rb guards
+# that this file is not itself loaded when a Db is built.)
+require "pubid"
 require "relaton/index"
 require "relaton/bib"
 require_relative "version"
@@ -12,7 +17,15 @@ require_relative "oasis/bibliography"
 
 module Relaton
   module Oasis
-    INDEXFILE = "index-v1"
+    # The pubid index, both written and read: rows are
+    # `Pubid::Oasis::Identifier` hashes (`_type: pubid:oasis:standard`), built
+    # and read with `pubid_class: ::Pubid::Oasis::Identifier`.
+    #
+    # This gem does not produce `index-v1` any more; `relaton-data-oasis`'s
+    # crawler derives it from the v2 rows for relaton v2 consumers (the
+    # IANA/BIPM/W3C/ECMA shape).
+    INDEXFILE = "index-v2".freeze
+
     class Error < StandardError; end
     # Your code goes here...
 

data/lib/relaton/ogc/data_fetcher.rb

@@ -23,7 +23,12 @@ module Relaton
       end
 
       def index
-        @index ||= Relaton::Index.find_or_create :ogc, file: "#{INDEXFILE}.yaml"
+        # `pubid_class:` on the producer too: FileIO#save only calls `to_hash`
+        # when the value is an instance of it, so without it the crawl writes
+        # v1-shaped rows under a v2 name, silently.
+        @index ||= Relaton::Index.find_or_create(
+          :ogc, file: "#{INDEXFILE}.yaml", pubid_class: ::Pubid::Ogc::Identifier
+        )
       end
 
       def fetch(_source = nil) # rubocop:disable Metrics/AbcSize
@@ -60,10 +65,26 @@ module Relaton
 
         @docids << docid
         file = file_name bib
-        index.add_or_update docid, file
+        index.add_or_update index_id(docid), file
         File.write file, serialize(bib), encoding: "UTF-8"
       end
 
+      #
+      # The index key. Stored as a `Pubid::Ogc::Identifier` so the published
+      # index-v2 rows are pubid hashes the consumer can narrow on. A docid
+      # pubid rejects is logged and indexed as the plain string, so one bad
+      # record never aborts a crawl.
+      #
+      # @param docid [String]
+      # @return [Pubid::Ogc::Identifier, String]
+      #
+      def index_id(docid)
+        ::Pubid::Ogc::Identifier.parse docid
+      rescue StandardError => e
+        Util.warn "Failed to parse pubid `#{docid}`: #{e.message}"
+        docid
+      end
+
       def file_name(bib)
         name = bib.docidentifier[0].content.upcase.gsub(/[\s:.]/, "_")
         "#{@output}/#{name}.#{@ext}"

data/lib/relaton/ogc/docidentifier.rb

@@ -1,6 +1,111 @@
 module Relaton
   module Ogc
+    # Structured OGC document identifier. The docid string is the canonical
+    # printed form, which carries no publisher token (e.g. "19-025r1"), and it
+    # is parsed into a `Pubid::Ogc::Identifier` kept in `@pubid` while the
+    # lutaml `content` attribute stays a plain string for serialization.
+    #
+    # Parsing is **soft**: `content=` lazily requires pubid and rescues
+    # `LoadError`/`StandardError`, so a missing pubid gem or non-OGC content
+    # leaves `@pubid` nil rather than raising.
+    #
+    # Before this class had a body it inherited `Bib::Docidentifier`, whose
+    # `remove_part!` / `remove_date!` / `to_all_parts!` each raise
+    # `NotImplementedError` — and `Bib::ItemData` broadcasts all three to every
+    # docidentifier, so `#to_all_parts` and `#to_most_recent_reference` raised
+    # on **every** OGC item. `NotImplementedError` descends from `ScriptError`,
+    # so a caller's `rescue => e` did not even catch it.
     class Docidentifier < Bib::Docidentifier
+      attr_reader :pubid
+
+      # Capture the inherited (LocalizedMarkedUpString) content setter before
+      # overriding #content=, so #refresh_content! can write the re-rendered
+      # string back WITHOUT re-parsing (a re-parse would rebuild @pubid from the
+      # string and discard in-place mutations such as `all_parts = true`).
+      alias_method :store_content, :content=
+
+      def initialize(attrs = {}, options = {})
+        pubid = attrs.is_a?(Hash) ? attrs.delete(:pubid) : nil
+        attrs[:content] ||= pubid.to_s if pubid
+        super
+        @pubid = pubid if pubid
+      end
+
+      def content=(value)
+        super
+        return unless value
+
+        @pubid = begin
+          require "pubid"
+          ::Pubid::Ogc::Identifier.parse(value)
+        rescue LoadError, StandardError
+          nil
+        end
+      end
+
+      # `Pubid::Ogc::Identifier` models only `year`/`number`/`revision`, so the
+      # mapping is OGC-specific:
+      #
+      # - **`remove_date!` → clears `revision`.** OGC carries no date component;
+      #   `revision` is its version discriminator — the same component a
+      #   reference may omit, which `HitCollection#best_match` then treats as a
+      #   wildcard — so clearing it yields
+      #   the version-agnostic ("most recent") reference: `12-128r19` →
+      #   `12-128`.
+      # - **`year` is never cleared.** It looks date-like but is half the
+      #   document number (`12-128`), not a publication qualifier; dropping it
+      #   would leave `-128`, which identifies nothing.
+      # - **`remove_part!` → clears the (unused) `part`/`subpart` attributes.**
+      #   A no-op for the rendered string today: OGC has no part component.
+      #   Implemented anyway so it never raises, and it starts working
+      #   automatically if pubid-ogc ever models one. (The IALA precedent.)
+      # - **`to_all_parts!` → both, then wraps `@pubid` in pubid's `AllParts`.**
+      #   `content` stays the plain stripped id — OGC's own renderer has no
+      #   "(all parts)" marker, and `content` is cached from the pre-wrap
+      #   pubid on purpose. `#pubid` itself, read directly, now answers
+      #   `all_parts? == true` and renders WITH pubid's generic marker
+      #   (`#to_s`), since it's the wrapper.
+      #
+      # All three no-op safely when `@pubid` is nil, so `Bib::ItemData`'s
+      # `#to_all_parts` / `#to_most_recent_reference` never raise on OGC items.
+      #
+      # `refresh_content!` renders a bare `to_s`: the OGC printed form has no
+      # publisher token and the stored `content` does not carry one either, so
+      # unlike 3GPP this must NOT pass `with_publisher: true`.
+
+      def remove_part!
+        clear_attr!(:part)
+      end
+
+      def remove_date!
+        clear_attr!(:revision)
+      end
+
+      def to_all_parts!
+        return if !@pubid || @pubid.all_parts?
+
+        # `#exclude` (no args) rebuilds a full independent copy — `remove_part!`
+        # / `remove_date!` mutate `@pubid` in place, so a bare reference here
+        # would lose the original revision to that mutation too.
+        original = @pubid.exclude
+        remove_part!
+        remove_date!
+        @pubid = original.to_all_parts
+      end
+
+      private
+
+      def clear_attr!(attr)
+        return unless @pubid && @pubid.respond_to?("#{attr}=")
+
+        @pubid.public_send("#{attr}=", nil)
+        @pubid.subpart = nil if attr == :part && @pubid.respond_to?(:subpart=)
+        refresh_content!
+      end
+
+      def refresh_content!
+        store_content(@pubid.to_s) if @pubid
+      end
     end
   end
 end