pubid 2.0.12 → 2.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58015cc01e426fd158cdfb240253372da45722a1cd2b9dc7a725993bf0a75e86
-  data.tar.gz: 7f501c8c4d994d31cddca28c6d6a4b98ed0b3dce039941375b9f2ecd5a4600f5
+  metadata.gz: 9c7661b8db16717e43163b2e4cfde8d3f3a922589ac9d075dddecdc529526f2e
+  data.tar.gz: f7564b3039961555f1d54287638c4c3bec2e8efd9e3786e481be99c369c078fa
 SHA512:
-  metadata.gz: 6d4a780dce2975889f1be570cfa59573efcb5b0ad54bfc038fdb1f80c4f80e8798186be172f406bce72fc35a91d01aa5095da5c676a5c9a23e9e3375b7a1eaad
-  data.tar.gz: 75599585a088af0b03aaa29d6dda8cf4e84a45debaa8a3c81687854697ce132a422c5432f586e7f95fd8248f28cd8102951949cb22efaa8f5a323e32326cd081
+  metadata.gz: e54ac7d08d541dedb44056a36f256ef1fe113a8ae3d97a91d6bb23de145931aeb7dbfcdac5ec34445afcff1f811591321f2c4c37b9303859f68dbb40139e58b5
+  data.tar.gz: 0b87dd3af21db4708d6d9784a98f051fdfc338e3de106bd4982b508a95433f8b968caf005067febd01aa598420a89b070838ba5bcba39c017f21372ab35fb3b1

data/lib/pubid/cie/identifier.rb

@@ -12,6 +12,10 @@ module Pubid
     # It defaults to "current" (the dominant value), so canonicalize_hash drops
     # it from the majority of rows and from_hash restores it.
     class Identifier < ::Pubid::Identifier
+      # Spelling-only values, the facets of the pubid-scheme URN: `==`,
+      # `hash` and `===` skip them (Pubid::EqualityIgnored, issue #656).
+      equality_ignored :s_prefix, :part_separator, :d_prefix
+
       attribute :style, :string, default: -> { "current" }
 
       def self.parse(input)

data/lib/pubid/components/edition.rb

@@ -8,11 +8,16 @@ module Pubid
     # URN render: "ed-#{number}" per RFC 5141-bis.
     class Edition < Lutaml::Model::Serializable
       include ::Pubid::SubsetMatch
+      include ::Pubid::EqualityIgnored
 
       attribute :year, :string
       attribute :number, Lutaml::Model::Type::Value
       attribute :original_text, :string
 
+      # The input spelling ("Ed 13"): the `edsrc` facet of the pubid-scheme
+      # URN, so `==`, `hash` and `===` skip it (issue #656).
+      equality_ignored :original_text
+
       def to_s
         number_value = number.is_a?(Components::Code) ? number.value : number
         number_value ? "ED#{number_value}" : nil

data/lib/pubid/components/language.rb

@@ -8,6 +8,7 @@ module Pubid
     # URN render: lowercase ISO 639-1 code (RFC 5141-bis).
     class Language < Lutaml::Model::Serializable
       include ::Pubid::SubsetMatch
+      include ::Pubid::EqualityIgnored
 
       CHAR_MAP = {
         "R" => "ru",
@@ -21,6 +22,17 @@ module Pubid
       attribute :code, :string, values: CHAR_MAP.values
       attribute :original_code, :string
 
+      # The input spelling ("E" for "en"): the `langsrc` facet of the
+      # pubid-scheme URN, so `==`, `hash` and `===` skip it (issue #656).
+      equality_ignored :original_code
+
+      # An unmapped one-letter code ("X") is built with no +code+: then the
+      # spelling is the only value that holds the language, so it is
+      # identity and nothing is ignored.
+      def equality_ignored_attributes
+        code.nil? ? [] : super
+      end
+
       def to_s(lang_single: false)
         if !lang_single && original_code&.length == 1
           code

data/lib/pubid/csa/CLAUDE.md

@@ -46,8 +46,12 @@ Moved from the root `CLAUDE.md`'s `#exclude` bullet (`metanorma__pubid__exclude-
 (`[[urn-csa]]`). The spelling/format cluster of the year — `year_format`,
 `year_prefix`, `publisher_prefix`, `has_publisher`,
 `original_reaffirmation_4digit`, `original_year_4digit`, `separator`,
-`series_prefix`, `french` — is facets, so the same document printed two
-ways merges only spellings; everything else is an atom. An adoption's
+`series_prefix` — is facets, so the same document printed two ways merges
+only spellings; everything else is an atom. `french` was a facet when the
+schema landed; it became the `french-` atom, because the French edition is
+another publication and a facet is skipped by `==` and `===`
+(`equality_ignored` on `Pubid::Csa::Identifier`). `#exclude(:year)` still
+clears it with the rest of the year cluster. An adoption's
 document goes along `base` and keeps its own flavor's schema (`CSA
 ISO/IEC 8824-1:22` is
 `urn:pubid:csa:iso.is:8824:co-IEC:part-1:year-2022:ca2`).

data/lib/pubid/csa/identifier.rb

@@ -10,6 +10,12 @@ module Pubid
     # containers used to be separate Lutaml::Model types, which is what made
     # `root.number` raise rather than return the relaton index key.
     class Identifier < ::Pubid::Identifier
+      # Spelling-only values, the facets of the pubid-scheme URN: `==`,
+      # `hash` and `===` skip them (Pubid::EqualityIgnored, issue #656).
+      equality_ignored :year_format, :year_prefix, :publisher_prefix,
+                       :has_publisher, :original_reaffirmation_4digit,
+                       :original_year_4digit, :separator, :series_prefix
+
       def self.parse(input)
         unless input.is_a?(String)
           raise Pubid::Errors::InvalidInputError,

data/lib/pubid/csa/pubid_urn_schema.rb

@@ -10,7 +10,7 @@ module Pubid
     # The current urn:csa:… form of #to_urn is pubid-invented and stays
     # there. The spelling/format cluster of the CSA year (`year_format`,
     # `year_prefix`, the publisher prefix it is printed with, the
-    # original-digit spellings of a reaffirmation, the French marker) is
+    # original-digit spellings of a reaffirmation) is
     # facets — the same document prints two ways; everything else is an
     # atom. A combined identifier carries its members in `identifiers`, a
     # bundled one in `bundled_with` (both bracketed lists); the adopted
@@ -31,6 +31,10 @@ module Pubid
       atom "package_materials", "packagematerials"
       atom "identifiers", "ids", kind: :ids
       atom "bundled_with", "bundledwith", kind: :ids
+      # The French edition ("CSA B149.1:F20") is another publication than
+      # the English one, so it is identity, not a facet (issue #656). The
+      # "F" it is printed with stays the year_prefix facet.
+      atom "french", "french", kind: :bool
 
       facet "year_format", "yearformat"
       facet "year_prefix", "yearprefix"
@@ -40,7 +44,6 @@ module Pubid
       facet "original_year_4digit", "origyear4", kind: :bool
       facet "separator", "separator"
       facet "series_prefix", "seriesprefix"
-      facet "french", "french", kind: :bool
 
       type "pubid:csa:amendment", "amd"
       type "pubid:csa:base", "base"

data/lib/pubid/equality_ignored.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Pubid
+  # Attributes that are not part of an identifier's identity: `==`, `eql?`,
+  # `hash` and the subset match `===` skip them.
+  #
+  # The main case is a spelling-only value: the input wrote the same
+  # document in another way (`Rev. 5` or `r5`, `(E)` or `(en)`, a
+  # different separator). It renders the original spelling again, so
+  # `to_s` and `to_hash` keep it, but a search must find the document
+  # whatever the spelling. Every facet of the pubid-scheme URN (the
+  # trailing `f` group) is such a value; `spec/pubid/pubid_urn_contract_spec.rb`
+  # checks that an id whose facets are cut is still `==` and `===` to the
+  # original (issue #656).
+  #
+  #   class Pubid::Components::Language < Lutaml::Model::Serializable
+  #     include ::Pubid::EqualityIgnored
+  #     equality_ignored :original_code
+  #   end
+  #
+  # The declaration goes on the class that owns the attribute, and a
+  # subclass inherits it. A class that writes its own `==` must skip
+  # `equality_ignored_attributes` there too; the subset match reads the
+  # list itself (`SubsetMatch#subset_skipped_attributes`).
+  #
+  # Include it explicitly. There is no `inherited` or `prepend` hook, per
+  # the annotated-rendering lesson in CLAUDE.md.
+  module EqualityIgnored
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Class-level declaration.
+    module ClassMethods
+      # @param names [Array<Symbol>] attributes of this class
+      # @return [Array<Symbol>] the attributes this class itself declares
+      def equality_ignored(*names)
+        @equality_ignored_own = equality_ignored_own | names.map(&:to_sym)
+      end
+
+      # @return [Array<Symbol>] this class's declarations and every one it
+      #   inherits
+      def equality_ignored_attributes
+        inherited = if superclass.respond_to?(:equality_ignored_attributes)
+                      superclass.equality_ignored_attributes
+                    else
+                      []
+                    end
+        inherited | equality_ignored_own
+      end
+
+      private
+
+      def equality_ignored_own
+        @equality_ignored_own ||= []
+      end
+    end
+
+    # A value with no identity left: a component whose every attribute is
+    # ignored or empty. "ISO 22610:2006 Ed" holds an Edition with only the
+    # spelling "Ed"; with the facets cut, the edition is nil. The two must
+    # compare equal, so `==` and `===` read such a value as nil.
+    #
+    # @return [Boolean]
+    def self.identity_blank?(value)
+      value.respond_to?(:identity_blank?) && value.identity_blank?
+    end
+
+    # The attributes this instance does not compare: the class's list. A
+    # class overrides it when a declared attribute carries identity in some
+    # instances (Components::Language: an unmapped one-letter code has no
+    # +code+, so its spelling is the language).
+    #
+    # @return [Array<Symbol>]
+    def equality_ignored_attributes
+      self.class.equality_ignored_attributes
+    end
+
+    # @return [Boolean] true when every attribute that is not ignored is
+    #   nil or empty (never true for an instance that ignores nothing)
+    def identity_blank?
+      ignored = equality_ignored_attributes
+      return false if ignored.empty?
+
+      (self.class.attributes.keys - ignored).all? do |name|
+        SubsetMatch.blank?(public_send(name))
+      end
+    end
+
+    # lutaml's attribute walk, without the ignored attributes, and with a
+    # value that has no identity left read as nil.
+    def ==(other)
+      return true if equal?(other)
+      return false unless other.instance_of?(self.class)
+
+      # Only what both sides ignore, so the comparison stays symmetric.
+      ignored = equality_ignored_attributes & other.equality_ignored_attributes
+      self.class.attributes.each_key.all? do |name|
+        ignored.include?(name) || identity_equal?(name, other)
+      end
+    end
+
+    # @return [Boolean] true when attribute +name+ of self and +other+ is
+    #   the same, a value with no identity left read as nil
+    def identity_equal?(name, other)
+      EqualityIgnored.identity_value(public_send(name)) ==
+        EqualityIgnored.identity_value(other.public_send(name))
+    end
+
+    # @return [Object, nil] nil for a value with no identity left, else
+    #   the value itself
+    def self.identity_value(value)
+      identity_blank?(value) ? nil : value
+    end
+
+    # The second parameter is lutaml's (see Pubid::Identifier#eql?).
+    def eql?(other, _compared_objects = nil)
+      self == other
+    end
+
+    def hash
+      ignored = equality_ignored_attributes
+      return super if ignored.empty?
+
+      names = self.class.attributes.keys - ignored
+      [self.class, *names.map { |name| public_send(name) }].hash
+    end
+  end
+end

data/lib/pubid/evs/CLAUDE.md

@@ -60,8 +60,11 @@
 ## pubid-scheme URN (issue #670)
 
 `lib/pubid/evs/pubid_urn_schema.rb`; rulings in `docs/URN-SCHEMES.adoc`
-(`[[urn-evs]]`). The separators and the draft marker are facets; the
-amendment/corrigendum columns are atoms. An adoption of a European
+(`[[urn-evs]]`). The separators are facets; the draft marker and the
+amendment/corrigendum columns are atoms. `draft_prefix` was a facet when the
+schema landed; it became the `draftprefix-` atom because `prEVS-EN 100:2026`
+is a draft, another document than the published standard, and a facet is
+skipped by `==` and `===` (`equality_ignored` on `Pubid::Evs::Identifier`). An adoption of a European
 document carries it along `base` and it keeps the CEN/CENELEC schema
 (`EVS-EN 18216:2026` is
 `urn:pubid:evs:cencenelec.en:18216:year-2026:na`); `intlorg-` covers an

data/lib/pubid/evs/identifier.rb

@@ -18,6 +18,11 @@ module Pubid
     # ("+X" a full standard plus the supplement, "/X" the supplement only)
     # and are preserved as captured.
     class Identifier < ::Pubid::Identifier
+      # Spelling-only values, the facets of the pubid-scheme URN: `==`,
+      # `hash` and `===` skip them (Pubid::EqualityIgnored, issue #656).
+      equality_ignored :separator, :amd_separator, :cor_separator,
+                       :na_separator
+
       attribute :base, ::Pubid::Identifier, polymorphic: true
       # "-" or " " — preserves the printed separator ("EVS-EN" vs "EVS EN")
       attribute :separator, :string, default: -> { "-" }

data/lib/pubid/evs/pubid_urn_schema.rb

@@ -18,13 +18,14 @@ module Pubid
       atom "evs_type", "evstype"
       atom "intl_org", "intlorg"
       atom "na_year", "nayear"
-
+      # The "pr" of "prEVS-EN 100:2026": a draft is another document than
+      # the published standard, so it is identity, not a facet (issue #656).
+      atom "draft_prefix", "draftprefix", kind: :bool
 
       facet "separator", "separator"
       facet "amd_separator", "amdseparator"
       facet "cor_separator", "corseparator"
       facet "na_separator", "naseparator"
-      facet "draft_prefix", "draftprefix", kind: :bool
 
       type "pubid:evs:estonian-standard", "es"
       type "pubid:evs:identifier", "id"

data/lib/pubid/identifier.rb

@@ -4,6 +4,8 @@ module Pubid
   class Identifier < Lutaml::Model::Serializable
     # `reference === candidate`: a subset match (see Pubid::SubsetMatch).
     include SubsetMatch
+    # Attributes that `==`, `hash` and `===` skip (see Pubid::EqualityIgnored).
+    include EqualityIgnored
 
     # Components that serialize as a bare scalar when they carry only their
     # single significant field: attribute name => the key the scalar is emitted

data/lib/pubid/ieee/identifiers/base.rb

@@ -10,6 +10,11 @@ module Pubid
     # Pubid::Ieee::Identifier. IEEE
     # builds its identifiers as instances of this class directly.
     class Identifier < ::Pubid::Identifier
+      # Spelling-only values, the facets of the pubid-scheme URN: `==`,
+      # `hash` and `===` skip them (Pubid::EqualityIgnored, issue #656).
+      equality_ignored :separator, :separators, :rev_sep, :year_sep,
+                       :date_separator, :original_format
+
       # Generate URN for this identifier
       #
       # @return [String] URN representation

data/lib/pubid/itu/components/code.rb

@@ -21,6 +21,12 @@ module Pubid
       # (dash-separated).
       class Code < Lutaml::Model::Serializable
         include ::Pubid::SubsetMatch
+        include ::Pubid::EqualityIgnored
+
+        # The spacing flags are spelling only (facets of the pubid-scheme
+        # URN): `==` below does not compare them, and `hash` and `===`
+        # skip them through this declaration (issue #656).
+        equality_ignored :series_suffix_spaced, :qualifier_glued
 
         attribute :imp_marker, :string
         attribute :number, :string

data/lib/pubid/itu/identifiers/base.rb

@@ -4,6 +4,10 @@ module Pubid
   module Itu
     # Base class for all ITU identifiers. Canonical name Pubid::Itu::Identifier.
     class Identifier < ::Pubid::Identifier
+      # Spelling-only values, the facets of the pubid-scheme URN: `==`,
+      # `hash` and `===` skip them (Pubid::EqualityIgnored, issue #656).
+      equality_ignored :number_glued, :slash_joined
+
       # Parse an ITU identifier string into an identifier object.
       def self.parse(identifier)
         unless identifier.is_a?(String)

data/lib/pubid/legacy_tree_value.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Pubid
+  # The digit-node emission of the parsanol 1.3.111 edition-2 named-tree
+  # dialect: a grammar capture whose tree is a repetition of a `digit`
+  # sub-rule serialized as the node list alone, dropping every unnamed
+  # literal between the nodes (the dots of a version run, the " beta" of an
+  # OMG version tail). The relaton-data crawlers of that era wrote the
+  # emission into their published index rows, so those rows deserialize
+  # carrying the raw node list — as the Ruby inspect string
+  # `[{"digit" => "3"}, …]` renders (`[{digit: "3"}, {digit: "0"}, …]`) or,
+  # after a JSON/YAML hop, as a real array of one-key hashes.
+  #
+  # Rendered verbatim such a row prints the node hashes instead of the
+  # assembled number, and the print never re-parses (the relaton corpus
+  # gate's Law 1a). Each affected flavor assembles the digits back into its
+  # own scalar on deserialization; this module is the one definition of the
+  # emission's shape.
+  module LegacyTreeValue
+    # One `{digit: "N"}` node, in the Ruby-inspect shorthand (`digit: "3"`)
+    # or the hash-rocket spelling (`"digit" => "3"`), keys optionally quoted.
+    NODE_RE = /\{\s*["']?digit["']?\s*(?::|=>)\s*["']?(\d+)["']?\s*\}/
+
+    module_function
+
+    # The digit values an emission carries: an Array of single-element
+    # strings ("3", "0", …), or nil when +value+ is not the emission. Accepts
+    # the inspect string and the real array of node hashes; any other shape
+    # (a plain "3.0.0", a nil, a hash) answers nil so callers leave it alone.
+    def digit_values(value)
+      case value
+      when ::String
+        return nil unless value.match?(/\A\[#{NODE_RE.source}(?:,\s*#{NODE_RE.source})*\]\z/)
+
+        value.scan(NODE_RE).flatten
+      when ::Array
+        return nil if value.empty?
+
+        nodes = value.filter_map do |node|
+          next unless node.is_a?(::Hash)
+
+          node["digit"] || node[:digit]
+        end
+        return nil unless nodes.size == value.size
+
+        nodes.map(&:to_s)
+      end
+    end
+  end
+end

data/lib/pubid/nist/CLAUDE.md

@@ -93,3 +93,22 @@ Read this before you change `lib/pubid/nist/` or `spec/pubid/nist/`. The root
   sweep of `full/` and the spec literals, so sweep those too when a schema
   changes. Found in passing, not fixed:
   `NIST.IR.8259Apt` parses as `NIST IR 8259(por)` and loses the `A`.
+- **The from_hash shape residual (part letter suffix and SP subseries)**:
+  the parse path builds two shapes the stored rows lost on the way through
+  the wire, and the relaton corpus gate's Law 1b
+  (parse(render(x)).to_hash == x.to_hash) failed for every affected row
+  (run 42204581379, 16–22 NEW nist-structure per slice; the class the
+  relaton manifest describes as "the n+UPPER token's structural placement
+  differs between the parsed and deserialized forms"). (1) A `part` hash
+  without a `type` is the letter suffix — the parse of the printed face
+  ("NIST NCSTAR 1A") carries `type: ""`; left nil the component fell back
+  to the annex face and rendered "1nA", a different document (the true
+  faces are in the relaton-data-nist document records: NIST NCSTAR 1A, NBS
+  HR 1-1A). Every type-less part value in the published index is a single
+  letter, so the inference is safe. This also repaired the three
+  nist-fidelity rows ("NIST SP 1075-NCNnR", "NIST SP 1113-BFRnL",
+  "NIST SP 1113-PERMInS"). (2) An SP row's `subseries` is derived metadata
+  ("800" from "800-53", Appendix A.2) that parse always recomputes;
+  `from_hash` now derives it by the Builder's own condition and rules
+  (`derive_subseries_code`, sharing SP_SUBSERIES). Locked by
+  `spec/pubid/nist/from_hash_shapes_spec.rb`.

data/lib/pubid/nist/components/edition.rb

@@ -30,6 +30,12 @@ module Pubid
       #   Edition.new(type: "r", id: "5", original_prefix: " Rev. ").to_s    # => "Rev. 5"
       class Edition < Lutaml::Model::Serializable
         include ::Pubid::SubsetMatch
+        include ::Pubid::EqualityIgnored
+
+        # The `edprefix` facet of the pubid-scheme URN. `==` and `hash`
+        # below skip it by hand; this declaration makes `===` skip it too
+        # (issue #656).
+        equality_ignored :original_prefix
 
         attribute :type, :string            # "-", "e", or "r"
         attribute :id, :string              # Edition ID (number or year)

data/lib/pubid/nist/identifiers/base.rb

@@ -36,7 +36,53 @@ module Pubid
       # do the real work. Nested `base` documents are expanded recursively by
       # their own from_hash via apply_mappings, so only this level is touched.
       def self.from_hash(data, options = {})
-        super(expand_compact_hash(data), options)
+        id = super(normalize_deserialized_shapes(expand_compact_hash(data)),
+                   options)
+        derive_subseries(id)
+        id
+      end
+
+      # The parse path builds a shape the stored rows lost on the way
+      # through the wire, and Law 1b (parse(render(x)).to_hash == x.to_hash)
+      # needs it restored on deserialization: a `part` hash without a `type`
+      # is the letter suffix — the parse of the printed face ("NIST NCSTAR
+      # 1A") carries `type: ""`, and Part#to_s renders just the letter for
+      # it; left nil the component fell back to the annex face ("1nA")
+      # instead, a different document. Every type-less value in the published
+      # index is a single letter, so the inference is safe.
+      def self.normalize_deserialized_shapes(data)
+        return data unless data.is_a?(::Hash)
+
+        part = data["part"]
+        return data unless part.is_a?(::Hash) && !part.key?("type") && !part.key?(:type)
+
+        out = data.dup
+        out[out.key?("part") ? "part" : :part] = { **part, "type" => "" }
+        out
+      end
+
+      # An SP row's `subseries` is derived metadata ("800" from "800-53",
+      # Appendix A.2), computed by the Builder on parse but absent from rows
+      # written before that derivation existed — parse always recomputes it,
+      # so from_hash must too, by the Builder's own condition.
+      def self.derive_subseries(id)
+        return unless id.is_a?(Identifiers::SpecialPublication) && id.subseries.nil?
+
+        code = derive_subseries_code(id.number.to_s)
+        id.subseries = Components::Code.new(value: code) if code
+      end
+
+      # The SP subseries code of a report-num-like first number ("800-53" →
+      # "800", "1190GB-12" → "1190GB"), or nil. The same two rules the
+      # Builder applies on parse (Identifiers::SpecialPublication).
+      def self.derive_subseries_code(number)
+        first = number.to_s.split("-").first.to_s
+        if Identifiers::SpecialPublication::SP_SUBSERIES.include?(first)
+          first
+        elsif (m = first.match(/\A(\d+GB)\b/)) &&
+            Identifiers::SpecialPublication::SP_SUBSERIES.include?(m[1])
+          m[1]
+        end
       end
 
       # Expand a compact hash in place-safe fashion: a scalar series/number
@@ -203,38 +249,29 @@ module Pubid
         # See lib/pubid/nist/builder.rb lines 368-472 for compound number logic
       end
 
-      # Attributes that are build artifacts or rendering aliases, not part
-      # of an identifier's logical identity. They diverge between equally-
-      # valid spellings of the same id (e.g. long "Rev. 1" vs short "r1"):
+      # Attributes that are not part of an identifier's logical identity, so
+      # `==`, `hash` and `===` skip them (Pubid::EqualityIgnored). They
+      # diverge between equally-valid spellings of the same id (e.g. long
+      # "Rev. 1" vs short "r1"):
       #   - first_number/second_number: decomposed parts of the canonical
       #     :number, retained from the parse for building
-      #   - parsed_format: records the input format for round-trip rendering
       #   - subseries: derived from series+number (which SP subseries the
       #     document belongs to); populated by the Builder for known SP
-      #     subseries codes. Ignored in equality so a manually-built id
-      #     without subseries set still equals a parsed one.
+      #     subseries codes. Ignored so a manually-built id without
+      #     subseries set still equals a parsed one. Derived, not spelled,
+      #     so it stays an atom of the pubid-scheme URN.
+      #   - parsed_format: records the input format for round-trip rendering
+      # `#weight` and the older `#matches?` read this list too.
       EQUALITY_IGNORED_ATTRS = %i[
         first_number second_number parsed_format subseries
       ].freeze
 
-      # Logical identity comparison: equal when every attribute except the
-      # build artifacts/aliases above matches. (Edition#== already ignores
-      # its rendering-only original_prefix.)
-      def ==(other)
-        return false unless other.instance_of?(self.class)
-
-        self.class.attributes.each_key.all? do |name|
-          EQUALITY_IGNORED_ATTRS.include?(name) || public_send(name) == other.public_send(name)
-        end
-      end
-
-      alias eql? ==
-
-      # A subset match skips the same attributes: `to_hash` drops the build
-      # artifacts, so an index row rebuilt by `from_hash` never has them.
-      def self.subset_ignored_attributes
-        EQUALITY_IGNORED_ATTRS
-      end
+      # The list above, plus the other input spellings that are facets of
+      # the pubid-scheme URN (issue #656): publisher_was_parsed and
+      # translation. (Edition ignores its rendering-only original_prefix
+      # the same way.)
+      equality_ignored(*EQUALITY_IGNORED_ATTRS, :publisher_was_parsed,
+                       :translation)
 
       # `edition` is the primary edition/revision carrier and is already in
       # the default %i[date year edition version] list. `update`/
@@ -254,13 +291,6 @@ module Pubid
         super + %i[update update_component]
       end
 
-      def hash
-        vals = self.class.attributes.each_key.reject do |name|
-          EQUALITY_IGNORED_ATTRS.include?(name)
-        end.map { |name| public_send(name) }
-        [self.class, *vals].hash
-      end
-
       # Wildcard / partial-identifier match. Treats +self+ as a QUERY pattern
       # and +candidate+ as a concrete document: every ID part SET on the query
       # must equal the candidate's, while parts left unset (nil/empty) are

data/lib/pubid/ogc/CLAUDE.md

@@ -32,3 +32,13 @@ These notes were part of the root `CLAUDE.md`. Read them before you change `lib/
   silently skips a name a class doesn't declare. Locked by
   `spec/pubid/ogc/all_parts_spec.rb` and
   `spec/pubid/all_parts_edition_keys_audit_spec.rb`.
+- **`exclude(:year)` is a no-op**: the "<yy>" token is the document's core
+  identity — the grammar's printed form is `<yy>-<nnn>` and its parse demands
+  the year run — so excluding it cannot leave a valid identifier. The base
+  `#exclude` nilled the year and the renderer printed the dangling separator
+  (`"-000"`, `"-002r1"`), which never re-parsed: the relaton corpus gate's
+  114 ogc-fuzz failures (run 42204581379). An exclusion that would leave the
+  identifier unprintable is not a mutation, so `#exclude` drops `:year` from
+  its args — the same reasoning that keeps `year` out of
+  `all_parts_edition_keys`. Every other key behaves as the base does.
+  Locked by `spec/pubid/ogc/exclude_year_spec.rb`.

data/lib/pubid/ogc/identifier.rb

@@ -69,6 +69,17 @@ module Pubid
       # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
       # OGC_TYPE_MAP remains as the key_value polymorphic_map.
 
+      # The "<yy>" token is the document's core identity: the grammar's
+      # printed form is `<yy>-<nnn>` and its parse demands the year run, so a
+      # year-less form ("-000") is not a reference any OGC grammar can read.
+      # An exclusion that would leave the identifier unprintable is not a
+      # mutation, so :year is a no-op here — the same reasoning that keeps it
+      # out of all_parts_edition_keys. Every other key behaves as the base
+      # #exclude does.
+      def exclude(*args)
+        super(*(args - [:year]))
+      end
+
       # Parse an OGC identifier string into an identifier object.
       # @param identifier [String] The OGC identifier string to parse
       # @return [Identifier] The document identifier object

data/lib/pubid/oiml/identifier.rb

@@ -3,6 +3,10 @@
 module Pubid
   module Oiml
     class Identifier < Pubid::Identifier
+      # Spelling-only values, the facets of the pubid-scheme URN: `==`,
+      # `hash` and `===` skip them (Pubid::EqualityIgnored, issue #656).
+      equality_ignored :parsed_format, :space_separator
+
       # Maps each concrete identifier's polymorphic_name => class name, so
       # key_value (de)serialization can re-instantiate the correct subclass
       # from the `_type` discriminator. Kept in sync with the Identifiers

data/lib/pubid/omg/CLAUDE.md

@@ -13,3 +13,16 @@ These notes were part of the root `CLAUDE.md`. Read them before you change `lib/
 - **`root.number` is nil for every OMG identifier, and so is the MR slug. Neither moved here, and nothing depends on either yet.** OMG models `acronym`/`version`/`part` and never sets the `number` it inherits, so the index key the root file requires of every leaf is empty and `to_mr_string` is `""` for every identifier — both were already true before this branch and both are unchanged by it (the base `mr_number_with_part` reads `number`, not `part`, so adding the part does not populate the slug). OMG has **no index and no `relaton-data-omg`** — it is scraped from `www.omg.org/spec` with Mechanize — and the relaton migration hand-off explicitly forbids adding one, so the binary-search degradation the root file describes cannot bite today. Do not "fix" it by mirroring `acronym` into `number` without checking the renderer first: that is the precondition the BIPM entry names, and the NIST attempt recorded in the root file is what happens when it does not hold.
 - **The fixture corpus is hand-written.** OMG has no `spec/fixtures/omg/identifiers/full/` tree and no entry in `spec/fixtures/classify_fixtures.rb`, so `validation:classify` never rewrites `pass/` or `fail/` and the root file's rule against hand-editing them does not apply. `spec/pubid/omg/fixtures_spec.rb` skips `#` lines, so the files carry comments.
 - **relaton note**: `relaton/relaton` moves its OMG flavor off the hand-written regex at `lib/relaton/omg/scraper.rb:19` onto this flavor. Both blockers it named are fixed. Its probe expected `OMG DDS 1.4/PDF` to round-trip byte for byte; it now sees a normalizing parse, which is harmless there because the flavor reads `acronym` and `version` off the parsed object and keeps the document part out of the request URL. (hand-offs: `metanorma__pubid__omg-document-part-and-bare-beta`, `relaton__relaton__omg-pubid-migration`.)
+- **The legacy named-tree version emission (from_hash)**: the parsanol 1.3.111
+  era wrote five relaton-data-omg rows (the beta documents, e.g. DPROD
+  `version: '[{digit: "2"}]'` for "1.0 beta 2") with the parse tree's node
+  list in place of the version, because that emission drops every unnamed
+  literal and only the beta tail's `digit` nodes are named in the grammar's
+  version rule. The version body is lost information; the one faithful
+  recovery is the digits themselves (the IEEE builder's per-token join), so
+  `Identifier.from_hash` assembles the emission into the joined scalar and
+  the row renders "OMG DPROD 2" — a print that re-parses to the same
+  structure (the relaton corpus gate's omg-fidelity failures). Plain
+  "1.0 beta 2"-style scalars pass through untouched. The emission shape is
+  defined once in `Pubid::LegacyTreeValue`. Locked by
+  `spec/pubid/omg/legacy_tree_version_spec.rb`.

data/lib/pubid/omg/identifier.rb

@@ -61,6 +61,28 @@ module Pubid
         parsed = Pubid::Parg::Model.bound(:omg, identifier)
         Builder.build(parsed)
       end
+
+      # A legacy named-tree version emission (see {Pubid::LegacyTreeValue}) —
+      # the parsanol 1.3.111 era wrote five relaton-data-omg rows (the beta
+      # documents, `version: '[{digit: "2"}]'` for "1.0 beta 2") with the
+      # node list in place of the version, because that emission drops every
+      # unnamed literal and only the beta tail's `digit` nodes are named in
+      # the grammar's version rule. The version body is lost information; the
+      # one faithful recovery is the digits themselves (the IEEE builder's
+      # per-token join), which re-parse as a version and keep the print
+      # stable. Current parses are unaffected — only those rows deserialize
+      # through here.
+      def self.from_hash(data, options = {})
+        return super unless data.is_a?(::Hash)
+
+        value = data["version"] || data[:version]
+        digits = LegacyTreeValue.digit_values(value)
+        return super unless digits
+
+        out = data.dup
+        out[data.key?("version") ? "version" : :version] = digits.join
+        super(out, options)
+      end
     end
   end
 end

data/lib/pubid/subset_match.rb

@@ -37,7 +37,10 @@ module Pubid
   #   `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.
+  # - Subset match leaves `#==` as it is. An error from an attribute reader
+  #   propagates.
+  # - An attribute declared with `equality_ignored` (Pubid::EqualityIgnored)
+  #   is skipped, as `==` and `hash` skip it.
   #
   # The match walks the attributes of the objects, not their `to_hash`, so a
   # class can change the rule for its own attributes:
@@ -120,6 +123,9 @@ module Pubid
     # @return [Array<Symbol>] the attributes this match does not compare
     def subset_skipped_attributes
       ignored = self.class.subset_ignored_attributes
+      if respond_to?(:equality_ignored_attributes)
+        ignored |= equality_ignored_attributes
+      end
       return ignored unless subset_all_parts_wildcard?
 
       ignored | ALL_PARTS_ATTRIBUTES
@@ -189,9 +195,11 @@ module Pubid
         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
+    # @return [Boolean] true for nil, for an empty string or collection, and
+    #   for a component with no identity left (EqualityIgnored.identity_blank?)
     def self.blank?(value)
-      value.nil? || Lutaml::Model::Utils.empty?(value)
+      value.nil? || Lutaml::Model::Utils.empty?(value) ||
+        EqualityIgnored.identity_blank?(value)
     end
   end
 end

data/lib/pubid/tgpp/CLAUDE.md

@@ -43,3 +43,26 @@ keeps `#matches?(other, ignore:)`.
   matching side. relaton had two committed specs breaking on this.
 
 - **The flavor key is `:"3gpp"`, not the derived `:tgpp` (pubid#644)**: `PrefixesSupport#prefix_flavor_key` derives the key from the Ruby constant's name (`Pubid::Tgpp` → `:tgpp`), but the external key is "3gpp" — the registry registration, the `pubid:3gpp:*` `_type` namespace and the `urn:3gpp:` URN namespace all spell it with the digit. The derived mismatch made `Pubid.prefix_flavors` attribute the "3GPP" prefix to a key **nothing is registered under**, so the router's routing table resolved `Registry.get(:tgpp)` to `nil`, `candidates_by_prefix`'s `compact` silently dropped the owner, and `Pubid.parse("3GPP TS 38.101")` — which `Pubid::Tgpp.parse` handles fine (the prefixed spelling is a normalizing parse; canonical render drops the publisher, `with_publisher: true` puts it back) — lost its prefix-owner fallback and raised. The fix is a one-line `prefix_flavor_key` override in `lib/pubid/tgpp.rb` returning `:"3gpp"`; `Pubid.prefix_flavors["3GPP"]` now reads `[:\"3gpp\"]` and `Registry.canonical_name(Pubid::Tgpp)` answers the real key. The registry-driven tripwire `spec/pubid/parse_routing_spec.rb` ("resolves every prefix table entry to a registered flavor module") is the guard that turns any future key/registry mismatch of this shape red at the table level.
+
+## The legacy named-tree version emission (from_hash)
+
+The parsanol 1.3.111 edition-2 emission serialized the grammar's per-digit
+`version` tree as the node list alone — the unnamed "." literals never
+reached the stored row — and the 3gpp crawler of that era wrote ~89,000
+published `relaton-data-3gpp` rows with
+`version: '[{digit: "3"}, {digit: "0"}, {digit: "0"}]'` where the document's
+version is `3.0.0`. Rendered verbatim the row printed the node hashes and the
+print never re-parsed (the relaton corpus gate's Law 1a; run 42204581379,
+~22,000 NEW 3gpp fidelity failures). `Identifier.from_hash` now assembles the
+digits back into the three-segment version (see `Pubid::LegacyTreeValue` for
+the emission shape and `assemble_legacy_tree_version` for the rule): the
+release names the version major for the legacy year-releases (REL-99 → 3.x.y)
+and for `REL-<n>`; otherwise a two-digit leading pair wins when it is a
+plausible major (≤ REL-21) and a leading zero is always the minor's. The
+segmentation was validated against the index's own clean rows — the crawler
+wrote both forms per document, 89,223 pairs, 165 irrecoverable (identical
+digit tuples whose documents genuinely differ, e.g. `1.10.0` vs `11.0.0`
+from `[1,1,0,0]`); the deterministic choice there still parses and
+round-trips. Current parses are unaffected: the runtime binds `version` as a
+scalar, so only deserialization of those legacy rows reaches the assembly.
+Locked by `spec/pubid/tgpp/legacy_tree_version_spec.rb`.

data/lib/pubid/tgpp/identifier.rb

@@ -116,6 +116,111 @@ module Pubid
         parsed = Pubid::Parg::Model.bound(:tgpp, identifier)
         Builder.build(parsed)
       end
+
+      # The version run the grammar binds is `1*digit "." 1*digit "." 1*digit`,
+      # whose named-tree materialization is per-digit `digit` nodes joined by
+      # unnamed "." literals. The parsanol 1.3.111 edition-2 emission serialized
+      # that tree as the node list alone — the dots were unnamed, so they never
+      # reached the stored row, and ~89,000 published relaton-data-3gpp rows
+      # carry `version: '[{digit: "3"}, {digit: "0"}, {digit: "0"}]'` (the
+      # node list's inspect) where the document's version is `3.0.0`. Rendered
+      # verbatim the row prints the node hashes and the print never re-parses
+      # (the relaton corpus gate's Law 1a). Current parses are unaffected —
+      # only deserialization of those legacy rows needs the assembly.
+      #
+      # The dots are lost information, so the segmentation is a deterministic
+      # reconstruction, validated against the index's own clean rows (the
+      # crawler wrote both forms per document): the release names the version
+      # major for the legacy year-releases (REL-99 documents carry version
+      # 3.x.y) and for `REL-<n>`; otherwise a two-digit leading pair wins when
+      # it is a plausible major (the largest 3GPP release is REL-21) and a
+      # leading zero is always the minor's. The residue — identical digit
+      # tuples whose documents genuinely differ, e.g. `1.10.0` vs `11.0.0`
+      # from `[1,1,0,0]` — is unrecoverable from the row; any 3-segment choice
+      # still parses and round-trips.
+      LEGACY_RELEASE_MAJORS = {
+        # The 3GPP release numbering starts Release 1999 = version 3.x.y; the
+        # earlier year-releases continue the ETSI sequence backwards.
+        "REL-96" => "5", "REL-97" => "6", "REL-98" => "7", "REL-99" => "3",
+        "UMTS" => "3", "Ph1" => "3", "Ph2" => "4"
+      }.freeze
+
+      def self.from_hash(data, options = {})
+        super(normalize_legacy_tree_version(data), options)
+      end
+
+      # Assemble a legacy named-tree version emission (see
+      # {Pubid::LegacyTreeValue}) back into the dotted scalar. Leaves every
+      # other value untouched; answers nil when +value+ is not the emission.
+      def self.assemble_legacy_tree_version(value, release)
+        digits = LegacyTreeValue.digit_values(value)
+        return nil unless digits
+
+        major = release_major(release)
+        if major
+          head = digits[0, major.length].join
+          rest = digits.drop(major.length)
+          if head == major && rest.length.between?(2, 4)
+            return assemble_version_segments(major, rest)
+          end
+        end
+
+        assemble_version_segments(nil, digits)
+      end
+
+      # The version major a release row names, when the release spelling maps
+      # to one ("REL-18" → "18", the legacy year-releases per the table).
+      def self.release_major(release)
+        return nil unless release.is_a?(::String)
+
+        LEGACY_RELEASE_MAJORS.fetch(release) do
+          release.match?(/\AREL-\d+\z/) ? release.delete_prefix("REL-") : nil
+        end
+      end
+
+      # Split a digit run into the three version segments. +major+ pins the
+      # first segment when the release names it; the run then carries the
+      # minor and patch digits, which the observed corpus always splits as
+      # two-digit-minor (`18.1.0`), one-digit-minor/two-digit-patch
+      # (`8.1.10`-era rows do not occur) or singles (`3.0.0`).
+      def self.assemble_version_segments(major, rest)
+        if major
+          case rest.length
+          when 2 then "#{major}.#{rest[0]}.#{rest[1]}"
+          when 3 then "#{major}.#{rest[0]}#{rest[1]}.#{rest[2]}"
+          when 4 then "#{major}.#{rest[0]}#{rest[1]}.#{rest[2]}#{rest[3]}"
+          end
+        else
+          case rest.length
+          when 3 then rest.join(".")
+          when 4
+            pair = rest[0] + rest[1]
+            if rest[0] == "0"
+              "0.#{rest[1]}#{rest[2]}.#{rest[3]}"
+            elsif pair.to_i <= 21
+              "#{pair}.#{rest[2]}.#{rest[3]}"
+            else
+              "#{rest[0]}.#{rest[1]}#{rest[2]}.#{rest[3]}"
+            end
+          when 5 then "#{rest[0]}#{rest[1]}.#{rest[2]}.#{rest[3]}#{rest[4]}"
+          else rest.join(".")
+          end
+        end
+      end
+
+      def self.normalize_legacy_tree_version(data)
+        return data unless data.is_a?(::Hash)
+
+        release = data["release"] || data[:release]
+        assembled = assemble_legacy_tree_version(
+          data["version"] || data[:version], release,
+        )
+        return data unless assembled
+
+        out = data.dup
+        out[data.key?("version") ? "version" : :version] = assembled
+        out
+      end
     end
   end
 end

data/lib/pubid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pubid
-  VERSION = "2.0.12"
+  VERSION = "2.0.13"
 end

data/lib/pubid.rb

@@ -142,11 +142,13 @@ module Pubid
   autoload :Errors, "pubid/errors"
   autoload :Parser, "pubid/parser"
   autoload :Components, "pubid/components"
+  autoload :LegacyTreeValue, "pubid/legacy_tree_value"
   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 :EqualityIgnored, "pubid/equality_ignored"
   autoload :IdentifierMetadata, "pubid/identifier_metadata"
   autoload :Rendering, "pubid/rendering"
   autoload :Renderers, "pubid/renderers"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.12
+  version: 2.0.13
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-11-06 00:00:00.000000000 Z
+date: 2026-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -476,6 +476,7 @@ files:
 - lib/pubid/ecma/renderer.rb
 - lib/pubid/ecma/urn_generator.rb
 - lib/pubid/ecma/urn_parser.rb
+- lib/pubid/equality_ignored.rb
 - lib/pubid/errors.rb
 - lib/pubid/etsi.rb
 - lib/pubid/etsi/CLAUDE.md
@@ -842,6 +843,7 @@ files:
 - lib/pubid/jis/supplement_identifier.rb
 - lib/pubid/jis/urn_generator.rb
 - lib/pubid/jis/urn_parser.rb
+- lib/pubid/legacy_tree_value.rb
 - lib/pubid/lutaml/no_store_registration.rb
 - lib/pubid/nist.rb
 - lib/pubid/nist/CLAUDE.md