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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4e0a5a8d4b5c1410b934712637a882a703f34ded60d92ed1d8f0a6465974396
-  data.tar.gz: 35bf6a1a075f68f35c682a3cfdde6bd5166523535491a74f1cb3473abcfaacec
+  metadata.gz: 177a3443a2daa5ff1848fb31a5136ea7eb05986005590c5938b0ae88874b3ef2
+  data.tar.gz: 4eeb9f9a26023aa610e821951febd68b5ef5a30db366eeeef07d595e67097557
 SHA512:
-  metadata.gz: 7dcd7c3d8f91d1ef5fa1ab296e4f922b435b04b70a06d184e6d2449d32a270bf31b14f352523686921072aac37bd0f91e0b6f62a6d44c28349b04ca7079092ed
-  data.tar.gz: ff8bc5531169fa3dace613d7369e656fdc2418f559adf3b527722e80144fd5a7aaa2db28da23979b2e3b8bc5af31132dca631e955a454d6262ad6a3ddf459b77
+  metadata.gz: 6d1a4ad6d0ec70be65ed8e8773c92feda1f63ec623ff59ee4e15a92683e762fa7ed9fc687391d8456731cfe6120c1ef144971422002ecdc9dfe40dfb5482959a
+  data.tar.gz: fa1d3d71d2dd96d24ac9e4804a8be54ecfbe02b8fd460a329f0ae6aa2366838670ed5242a3bb3f3d94b5e325dc6494902a94223a94a9ef377374f8ac8baf8fc3

data/README.adoc

@@ -229,6 +229,48 @@ id.exclude(:year, :part).to_s
 # => "ISO 9001"
 ----
 
+=== Matching a Partial Reference
+
+The `===` operator is a subset match. It returns true when the candidate holds
+every part that the reference states. A part that the reference omits matches
+any value. The receiver is the reference, so the operator is not symmetric:
+
+[source,ruby]
+----
+require 'pubid/iso'
+
+reference = Pubid::Iso.parse("ISO 9001")
+reference === Pubid::Iso.parse("ISO 9001:2015")
+# => true
+reference === Pubid::Iso.parse("ISO/DIS 9001")
+# => false (a default value, here the published stage, is stated)
+
+catalogue.grep(reference)
+# => every edition of ISO 9001 in the catalogue
+----
+
+Some flavors state a part even when it is nil, because the document really
+has none. Those classes declare it strict, so the reference does not widen:
+
+[source,ruby]
+----
+Pubid::Ecma.parse("ECMA-418") === Pubid::Ecma.parse("ECMA-418-1")
+# => false (ECMA-418 has no part)
+Pubid::Ecma.parse("ECMA-418-1") === Pubid::Ecma.parse("ECMA-418-1 ed1")
+# => true
+----
+
+A reference asks for every part of a document with `all_parts`:
+
+[source,ruby]
+----
+Pubid::Iso.parse("ISO 9001 (all parts)") === Pubid::Iso.parse("ISO 9001-1:2015")
+# => true
+----
+
+See `docs/SUBSET_MATCH.md` for the full rules and the list of strict
+attributes.
+
 === Comparing Editions
 
 The `new_edition_of?` method checks if an identifier is a newer edition of the same document:
@@ -1148,7 +1190,7 @@ ASME BPVC.CC.BPV-2021              # Case Code BPV
 
 Special Variants:
 ASME BPVC COMPLETE CODE BIND-2019  # Complete code set
-ASME BPVC-CC-BPV-2019              # Dash notation variant
+ASME BPVC-CC-BPV-2019              # Dash notation; ASME lists it apart from BPVC.CC.BPV
 ----
 
 .BPVC Components

data/data/ieee/update_codes.yaml

@@ -157,15 +157,15 @@ ISO/IEC/IEEE CD P26513/D1, August 2015: ISO/IEC/IEEE P26513/D1, August 2015
 "ISO/IEC/IEEE/P16085_DIS, March 2020": "ISO/IEC/IEEE DIS P16085-2020-03"
 "ANSI/IEEE Std: Outdoor Apparatus Bushings": "ANSI/IEEE Std 21-1976-11"
 "Draft National Electrical Safety Code, January 2016": "IEEE PC2-2016-01"
-"International Standard ISO/IEC 8802-9: 1996(E) ANSI/IEEE Std 802.9, 1996 Edition": "ISO/IEC/IEEE Std 802.9-1996"
-"ISO/IEC13210: 1994 (E) ANSI/IEEE Std 1003.3-1991": "ISO/IEC/IEEE 13210-1994"
+"International Standard ISO/IEC 8802-9: 1996(E) ANSI/IEEE Std 802.9, 1996 Edition": "ISO/IEC 8802-9:1996(E); ANSI/IEEE Std 802.9, 1996 Edition"
+"ISO/IEC13210: 1994 (E) ANSI/IEEE Std 1003.3-1991": "ISO/IEC 13210:1994 (E); ANSI/IEEE Std 1003.3-1991"
 "J-STD-016-1995": "IEEE 016-1995"
 "Nuclear EQ Sourcebook and Supplement": "IEEE 7438946"
 "PC37.30.2/D043 Rev 18, May 2015": "IEEE PC37.30-2/D-043/R-18-2015"
 "IEEE/IEC P62582 CD2 proposal, May 2017": "IEEE/IEC CD2 P62582-2017-05"
-"ISO/IEC/IEEE P16326:201x WD.4a, July 2017": "ISO/IEC/IEEE P16326/D-4a-2017-07"
+"ISO/IEC/IEEE P16326:201x WD.4a, July 2017": "ISO/IEC/IEEE P16326:2017/D=WD.4a"
 "ISO/IEC/IEEE CD.1 P21839, October 2017": "ISO/IEC/IEEE CD1 P21839-2017-10"
-"ISO/IEC/IEEE P16326:201x WD5, December 2017": "ISO/IEC/IEEE P16326/D-5-2017-12"
+"ISO/IEC/IEEE P16326:201x WD5, December 2017": "ISO/IEC/IEEE P16326:2017/D=WD.5"
 "IEEE/ISO/IEC P42010.CD1-V1.0, April 2020": "IEEE/ISO/IEC CD1 P42010-2020-04"
 "Unapproved Draft Std ISO/IEC FDIS 15288:2007(E) IEEE P15288/D3,": "ISO/IEC/IEEE FDIS Std P15288/D-3-2007"
 "IS0/IEC/IEEE 8802-11:2012/Amd.5:2015(E) (Adoption of IEEE Std 802.11af-2014)": "ISO/IEC/IEEE 802.11/Amd5-2012"
@@ -208,3 +208,16 @@ ISO/IEC/IEEE CD P26513/D1, August 2015: ISO/IEC/IEEE P26513/D1, August 2015
 "ISO/IEC/IEEE/ P12207.2/D-3_FDIS-2020": "ISO/IEC/IEEE FDIS P12207.2-2020/D3"
 "ISO/IEC/IEEE/ P24748.3/D-IS-2019": "ISO/IEC/IEEE DIS P24748.3-2019"
 "P1635/D10/ASHARE 21/D-10-2016": "IEEE P1635/D10-2016"
+# The joint-publisher underscore drafts ("ISO /IEC/IEEE P24774_D1, February
+# 2020") are the slash spellings ("/D1") of rows the ledger already pins
+# as project drafts; the underscore form parsed through the printed-joint
+# family and flipped the classification (pubid#430). Applied after the
+# exact one-off rules above so their targets stay reachable.
+# Dated: the trailing text date rides in the draft clause with the long
+# comma the project-draft route pins ("...D1, February, 2020").
+# Undated.
+# Dated: the trailing text date rides in the draft clause with the long
+# comma the project-draft route pins ("...D1, February, 2020").
+/\b(ISO ?\/ ?IEC ?\/ ?IEEE|IEC ?\/ ?IEEE) (P\d+)_D(\d+), ([A-Z][a-z]+.?) (\d{4})\b/: "\\1 \\2/D\\3, \\4, \\5"
+# Undated.
+/\b(ISO ?\/ ?IEC ?\/ ?IEEE|IEC ?\/ ?IEEE) (P\d+)_D(\d+)\b/: "\\1 \\2/D\\3"

data/data/nist/update_codes.yaml

@@ -38,6 +38,8 @@ NIST AI NIST AI 100-2e2023 ipd: NIST AI 100-2e2023 ipd
 NBS CIRC 154suprev: NBS CIRC 154r1sup
 NBS CIRC supJun1925-Jun1926: NBS CIRC 24e7sup2
 NBS CIRC supJun1925-Jun1927: NBS CIRC 24e7sup3
+NBS.CIRC.supJun1925-Jun1926: NBS CIRC 24e7sup2
+NBS.CIRC.supJun1925-Jun1927: NBS CIRC 24e7sup3
 /^NBS CIRC sup$/: NBS CIRC 24e7sup
 NBS CIRC 25sup-1924: NBS CIRC 25sup
 NIST SP 260-126 rev 2013: NIST SP 260-126r2013
@@ -63,6 +65,7 @@ NIST AMS 300-8r1/upd: NIST AMS 300-8r1/Upd1-202102
 NIST IR 8115r1-upd: NIST IR 8115r1/Upd1-202103
 NIST IR 8170-upd: NIST IR 8170/Upd1-202003
 NIST TN 2150-upd: NIST TN 2150/Upd1-202102
+NIST.TN.2150-upd: NIST.TN.2150-upd1-202102
 NBS IR 73-197r: NBS IR 73-197r1
 NBS.HB.105-1r1990: NIST.HB.105-1r1990
 NBS.HB.28p11969: NBS.HB.28-1969pt1
@@ -97,6 +100,7 @@ NIST SP 500-281-v1 0: NIST SP 500-281v1.0
 NIST SP 800-63v1 0 1: NIST SP 800-63v1.0.1
 NIST SP 800-63v1 0 2: NIST SP 800-63v1.0.2
 NIST SP 955 Suppl: NIST SP 955sup
+NIST.SP.955.Suppl: NIST.SP.955-S.uppl
 NIST SP 984 4: NIST SP 984-4
 NISTPUB 0413171251: NIST TN 1648-2009
 /\-draft$/: " (Draft)"
@@ -109,9 +113,9 @@ NIST IR 8413-upd1: NIST IR 8413/Upd1-202207
 NIST IR 85-3273-37-upd1: NIST IR 85-3273-37/Upd1-202205
 /NBS CRPL-F-B(?=\d+)/: "NBS CRPL-F-B "
 "NIST.AMS.300-8r1/upd": NIST.AMS.300-8r1-upd1
-NIST.hb.150-1-2017: NIST HB 105-1r2017
-nbs.tn.671: NBS TN 671
-NIST.TN.1648_2009: NIST TN 1648-2009
+NIST.hb.150-1-2017: NIST.HB.105-1r2017
+nbs.tn.671: NBS.TN.671
+NIST.TN.1648_2009: NIST.TN.1648e2009
 NBS NSRDS: NSRDS-NBS
 nist ir: NIST IR
 /(?<=\d)es/: (spa)

data/lib/pubid/adobe/builder.rb

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

data/lib/pubid/all_parts.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "pubid"
+module Pubid
+  # Every part of one document, e.g. "ISO 9000 (all parts)".
+  #
+  # The class that includes this module holds part identifiers of one
+  # document in `identifiers`, in natural order and without duplicates. A
+  # member with no part stands for the whole document; it is permitted only
+  # as the sole member.
+  #
+  # A flavor includes it in a subclass of its own `Identifier`, so the
+  # all-parts identifier of a flavor is an identifier of that flavor
+  # (`Pubid::Iso::Identifiers::AllParts < Pubid::Iso::Identifier`). The
+  # subclass names its own suffix or URN; everything else comes from here.
+  # A flavor with no such class uses {Pubid::AllPartsIdentifier}.
+  #
+  # `==` compares the members. `===` compares the document only: the first
+  # member without its part and its edition (see #identity).
+  module AllParts
+    SUFFIX = " (all parts)"
+
+    # The members hold the whole identity, so the hash carries nothing else.
+    # Without the key_value block the serializer reads every inherited
+    # attribute, and the derived #number below would be written too.
+    def self.included(base)
+      base.attribute :identifiers, ::Pubid::Identifier, polymorphic: true,
+                                                        collection: true,
+                                                        initialize_empty: true
+      declare_key_value(base)
+      base.extend(ClassMethods)
+    end
+
+    # lutaml MERGES a subclass block onto the flavor's own block, so the
+    # derived #number below would be written as a top-level key. A no-op
+    # converter keeps it out.
+    def self.declare_key_value(base)
+      base.key_value do
+        map "_type", to: :_type
+        map "identifiers", to: :identifiers
+        map "number", with: { to: :number_to_kv, from: :number_from_kv }
+      end
+    end
+
+    module ClassMethods
+      # lutaml's from_hash builds the object with no attributes and assigns
+      # `identifiers` after #initialize, so it normalizes here too.
+      def from_hash(data, options = {})
+        super.tap do |id|
+          id.send(:normalize_identifiers!) if id.is_a?(::Pubid::AllParts)
+        end
+      end
+    end
+
+    def initialize(attrs = {}, options = {})
+      super
+      normalize_identifiers!
+    end
+
+    # The members hold the number, so it is neither written nor read.
+    def number_to_kv(_model, _doc); end
+
+    def number_from_kv(_model, _value); end
+
+    # @param other [Object] a candidate identifier
+    # @return [Boolean] true when +other+ is any part of the same document,
+    #   in any edition
+    def ===(other)
+      return false unless other.is_a?(::Pubid::Identifier) && identity
+
+      identity === document_of(other)
+    end
+
+    # Another all-parts identifier with +other+ added. The receiver does not
+    # change.
+    # @param other [Pubid::Identifier] a part of the same document, or
+    #   another all-parts identifier of it
+    # @return [Pubid::Identifier] an all-parts identifier of the same class
+    # @raise [ArgumentError] for a different document, an identifier with no
+    #   part, or a part that is already a member
+    def +(other)
+      members = other.is_a?(::Pubid::AllParts) ? other.identifiers : [other]
+      members.each { |member| validate_member!(member) }
+      self.class.new(identifiers: identifiers + members)
+    end
+
+    def to_s(**opts)
+      return "" unless identity
+
+      annotate_plain_render(
+        "#{identity.to_s(**opts.except(:annotated))}#{self.class::SUFFIX}",
+        **opts,
+      )
+    end
+
+    # The all-parts attributes are empty, so the flavor renderers cannot
+    # print it. Only the human form exists yet; `to_mr_string` and `to_slug`
+    # come through here and raise too.
+    def render(format: :human, **opts)
+      return to_s(**opts) if format == :human
+
+      raise NotImplementedError,
+            "an all-parts identifier has no #{format} form yet"
+    end
+
+    def to_urn
+      raise NotImplementedError, "an all-parts identifier has no URN yet"
+    end
+
+    def to_all_parts
+      self
+    end
+
+    def root
+      identifiers.first&.root
+    end
+
+    # The document number, e.g. "9000". The index keys on it.
+    def number
+      identity&.number
+    end
+
+    # True here and false for every other identifier, so a caller that reads
+    # the old flag still works.
+    # rubocop:disable Naming/PredicateMethod
+    def all_parts
+      true
+    end
+    # rubocop:enable Naming/PredicateMethod
+
+    def all_parts?
+      true
+    end
+
+    def base_document
+      identifiers.first&.base_document
+    end
+
+    protected
+
+    # The document: the first member without its part, its subpart and its
+    # edition. #document_of reads it from another all-parts identifier, so it
+    # is protected and not private.
+    # @return [Pubid::Identifier, nil]
+    def identity
+      first = identifiers.first
+      first && document_of(first)
+    end
+
+    private
+
+    # The document of +id+: +id+ without its part and its edition.
+    def document_of(id)
+      return id.identity if id.is_a?(::Pubid::AllParts)
+
+      id.without_parts(*id.class.all_parts_edition_keys)
+    end
+
+    def validate_member!(id)
+      unless id.is_a?(::Pubid::Identifier)
+        raise ArgumentError, "not an identifier: #{id.inspect}"
+      end
+
+      raise ArgumentError, "#{id} is not a part of #{self}" unless self === id
+      raise ArgumentError, "#{id} has no part" unless id.part?
+      return unless identifiers.any? { |member| same_member?(member, id) }
+
+      raise ArgumentError, "#{id} is already a member of #{self}"
+    end
+
+    def same_member?(one, other)
+      one.normalized_copy == other.normalized_copy
+    end
+
+    # Sort, remove duplicates, and drop the whole-document member when a
+    # part is present. `==` and `to_hash` depend on this order.
+    def normalize_identifiers!
+      members = unique_members
+      parts = members.select(&:part?)
+      self.identifiers = sorted(parts.empty? ? members : parts)
+    end
+
+    def unique_members
+      identifiers.each_with_object([]) do |member, acc|
+        acc << member unless acc.any? { |kept| same_member?(kept, member) }
+      end
+    end
+
+    # One member needs no sort, and #to_s raises on an abstract class.
+    def sorted(members)
+      return members if members.size < 2
+
+      members.sort_by { |member| natural_key(member.to_s) }
+    end
+
+    # "ISO 9000-10" sorts after "ISO 9000-2".
+    def natural_key(str)
+      str.split(/(\d+)/).map { |s| s.match?(/\A\d+\z/) ? [0, s.to_i] : [1, s] }
+    end
+  end
+end

data/lib/pubid/all_parts_identifier.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "pubid"
+module Pubid
+  # The all-parts identifier of a flavor that has no class of its own.
+  # A flavor that prints "(all parts)" or has a series URN gives its own
+  # class instead: see {Pubid::AllParts} and `Identifier.all_parts_class`.
+  class AllPartsIdentifier < Identifier
+    include AllParts
+
+    # This class belongs to no flavor, so its name carries no flavor segment
+    # and {TypeResolver} resolves it directly.
+    def self.polymorphic_name
+      return super unless self == ::Pubid::AllPartsIdentifier
+
+      "pubid:all-parts"
+    end
+  end
+end

data/lib/pubid/amca/CLAUDE.md

@@ -0,0 +1,47 @@
+# AMCA flavor notes
+
+AMCA index key and MR slug.
+
+These notes were part of the root `CLAUDE.md`. Read them before you change `lib/pubid/amca/` or `spec/pubid/amca/`. The root file keeps the cross-flavor contract that every flavor obeys.
+
+## From the root note "AMCA / ASME / ASTM index key (`root.number`): three flavors, three different shapes"
+
+**(1) AMCA — flat `:string` columns on the leaves, and a latent `==` bug fixed with them.** `code` is deleted and each of the three leaves declares `attribute :number, :string`. An earlier draft kept the inherited `Components::Code` instead (AMCA's own `Components::Code` resolved to `Pubid::Components::Code` — there is no `lib/pubid/amca/components/code.rb` — so nothing needed retyping, the CSA case); that works too, and the serialized bytes are identical either way, but the flat string matches the other flavors here and lets the custom `key_value` converters go entirely. **The converters were what hid a real bug.** `year` was declared `Components::Date`, yet the builder assigns a String and lutaml does not cast it — so the **parse** path held a String while **from_hash** produced a `Components::Date`. `to_hash` and `to_s` agreed, because `year_to_kv` normalised both shapes to a scalar, so the relaton index gate (`from_hash(to_hash) == to_hash`) passed — while **`parse(x) == from_hash(parse(x).to_hash)` was false for every AMCA id**, breaking `#matches?`, which is built on `==`. `year` is now `:string` too, both `with:` converters are gone (every mapped attribute is a plain scalar, and the canonical `to_hash` already drops empty and default values), and a spec asserts round-trip **equality**, not just hash equality — the stronger check that would have caught it. **Lesson: a `with:` converter that normalises two possible runtime shapes is a signal that the attribute type is wrong, not a fix.** The serialized key moved `code` → `number` (no consumer). **AMCA's `Publication` and `Interpretation` also lost hand-written keyword `initialize` methods** that assigned ivars directly and bypassed lutaml — costing them their `_type` (so `from_hash` could not route back), their `publisher` default, and the serialization of `revision`/`interpretation_code`, which were `attr_reader`s `to_hash` dropped. Both are now ordinary lutaml attributes; the builder already called `new(**attributes)` exactly as it does for `Standard`, which never had the problem. This is the AIEE/IRE/NESC migration applied again.
+
+## Revision, rendering and URN (hand-off `asme-bpvc-and-amca-residue`)
+
+**The publication revision never reached the object.** The grammar captured only `01` of `Rev. 01-23`, and `Builder#build_publication` read it under `parsed[:revision]`, where the grammar did not put it. The grammar now captures the whole `01-23` as `:revision`, so `revision`, `to_hash`, `to_s` and the URN (`rev.01-23`) carry it.
+
+**The renderer lost text.** It printed `AMCA Publication 211 -22` (a space before the year), `AMCA 99 – JW` (no `Interp`), and `(2010)` for `(R2010)`. Every parseable AMCA fixture id now renders as it was written, except the real normalizations (`ANSI/AMCA 220-21` → `ANSI/AMCA Standard 220-21`).
+
+**Every AMCA URN held a Ruby Hash.** `urn_type` interpolated the `type` metadata Hash (`copub.amca:{key: :publication, ...}`); it now reads `type[:key]`, the source `mr_type` reads. The URN also carries the interpretation code (`interp.jw`), so the interpretations of one standard no longer share a URN. `UrnParser` reads every token back (type, copublisher, interpretation code, revision, reaffirmation), so all 50 parseable fixture ids come back `==` from their URN; before, it rebuilt a bare `AMCA <number>-<year>` Standard.
+
+**Not fixed, pre-existing:** `AMCA 204 – 1` and `ANSI/AMCA Standard 210-25 / ASHRAE 51-25` do not parse. `ANSI/AMCA 210-16 /ASHRAE 51-16` parses but silently drops `/ASHRAE 51-16`, because `additional_copublisher` has no capture. The `suffix` rule of `standard_identifier` has no capture either, so `suffix` is never set on a `Standard`.
+
+## `all_parts_edition_keys`: Publication's `revision`, then the shared `reaffirmed`
+
+`Identifier.all_parts_edition_keys` defaults to `%i[date year edition
+version]`. A first pass fixed `Identifiers::Publication#revision` (the
+`Rev. 01-23` token), a separate discriminator that list never covered, so
+`"AMCA Publication 211-22 (Rev. 01-23)".to_all_parts` did not collapse
+onto another revision of the same publication under `#to_all_parts`/`#===`.
+Fixed with `Identifiers::Publication.all_parts_edition_keys` (`super +
+%i[revision]`), declared on `Publication` itself rather than the shared
+`Pubid::Amca::Identifier` base — `Standard`/`Interpretation` don't carry
+`revision`.
+
+Code review of that same change found a second, wider gap it had missed:
+`reaffirmed` (the `"(R2010)"` year) is declared on the shared
+`Pubid::Amca::Identifier` base (`identifiers/base.rb`), not on
+`Publication`, and `Renderer#render_base` reads it for **every** leaf —
+`Standard` as well as `Publication` — so `"AMCA 210-16 (R2010)"` failed to
+collapse onto `"AMCA 210-16 (R2015)"` even though neither is a
+`Publication`. Fixed on the shared base itself:
+`Pubid::Amca::Identifier.all_parts_edition_keys` is `super +
+%i[reaffirmed]`; `Publication`'s own override chains through `super` and
+picks it up automatically. **Lesson**: a discriminator declared on a
+shared base needs the override on that base, not repeated per leaf — and,
+per the IEEE entry above, finding one missed attribute is not proof the
+audit is complete. Not part of the original hand-off's audit list (which
+didn't cover AMCA); found during code review of the OGC/3GPP/NIST fix.
+Locked by `spec/pubid/all_parts_edition_keys_audit_spec.rb`.

data/lib/pubid/amca/builder.rb

@@ -154,11 +154,7 @@ module Pubid
 
         # Extract revision (Rev. 01-23)
         if parsed[:revision]
-          revision_data = parsed[:revision]
-          if revision_data && revision_data[:revision_year]
-            attributes[:revision] =
-              extract_value(revision_data[:revision_year])
-          end
+          attributes[:revision] = extract_value(parsed[:revision])
         end
 
         Identifiers::Publication.new(**attributes)
@@ -174,3 +170,5 @@ module Pubid
     end
   end
 end
+
+Pubid::Amca::Builder.prepend(Pubid::Builder::AllPartsWrap)

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

@@ -87,6 +87,16 @@ module Pubid
       def mr_year
         year&.to_s
       end
+
+      # `reaffirmed` (the "(R2010)" year, read by Renderer#render_base — used
+      # for Standard as well as Publication) is a discriminator the default
+      # %i[date year edition version] list misses, shared by every leaf that
+      # inherits this class. Declared here, not per-leaf, so Standard's own
+      # reaffirmations collapse too; Publication's revision (see
+      # publication.rb) is layered on top via `super`.
+      def self.all_parts_edition_keys
+        super + %i[reaffirmed]
+      end
     end
   end
 end

data/lib/pubid/amca/identifiers/publication.rb

@@ -28,6 +28,19 @@ module Pubid
         def self.type
           { key: :publication, title: "Publication", short: nil }
         end
+
+        # `revision` is Publication's edition/version discriminator and is
+        # not in the default %i[date year edition version] list, so
+        # #to_all_parts/#=== failed to collapse two revisions of the same
+        # publication (e.g. "AMCA Publication 211-22 (Rev. 01-23)" vs
+        # "... (Rev. 02-23)"). Declared here, not on the shared
+        # Pubid::Amca::Identifier base, because `revision` is
+        # Publication-only — Standard and Interpretation don't carry it.
+        # `super` also picks up `reaffirmed`, added on the shared base
+        # (identifiers/base.rb) since Standard carries that one too.
+        def self.all_parts_edition_keys
+          super + %i[revision]
+        end
       end
     end
   end

data/lib/pubid/amca/parser.rb

@@ -62,7 +62,8 @@ module Pubid
 
       # Publication revision (Rev. 01-23)
       rule(:revision) do
-        lparen >> str("Rev") >> dot.maybe >> space >> digits.as(:revision_year) >> dash >> digits >> rparen
+        lparen >> str("Rev") >> dot.maybe >> space >>
+          (digits >> dash >> digits).as(:revision) >> rparen
       end
 
       # Interpretation code (JW, KB, RG, AW, AH, or just a number)

data/lib/pubid/amca/renderer.rb

@@ -29,53 +29,42 @@ module Pubid
       private
 
       def render_base(id)
-        parts = []
-        parts << id.copublisher if id.copublisher
         t = id.class.respond_to?(:type) ? id.class.type : nil
-        if t.is_a?(Hash) && t[:title]
-          parts << t[:title].to_s
-        end
-        parts << id.number.to_s
-        parts << "-#{id.year}" if id.year
-
-        result = parts.compact.join(" ")
-
-        if id.copublisher&.include?("/") && id.year
-          type_title = t.is_a?(Hash) ? t[:title].to_s : ""
-          result = "#{id.copublisher} #{type_title} #{id.number}-#{id.year}"
-        end
-
-        result += " (#{id.reaffirmed})" if id.reaffirmed
-
+        title = t[:title].to_s if t.is_a?(Hash) && t[:title]
+        result = document(id, title)
+        result += " (R#{id.reaffirmed})" if id.reaffirmed
         result
       end
 
+      # The revision and the reaffirmation are separate optional groups in
+      # the grammar, so either or both can appear.
       def render_publication(id)
-        parts = []
-        parts << id.copublisher if id.copublisher
-        parts << "Publication"
-        parts << id.number.to_s
-        parts << "-#{id.year}" if id.year
-        parts << " (Rev. #{id.revision})" if id.revision
-        parts << " (#{id.reaffirmed})" if id.reaffirmed && !id.revision
-
-        parts.join(" ").squeeze(" ")
+        result = document(id, "Publication")
+        result += " (Rev. #{id.revision})" if id.revision
+        result += " (R#{id.reaffirmed})" if id.reaffirmed
+        result
       end
 
       def render_interpretation(id)
-        parts = []
-        parts << id.copublisher if id.copublisher
-        parts << id.number.to_s
+        result = [id.copublisher, id.number.to_s].compact.join(" ")
 
         if id.interpretation_code
-          parts << "– #{id.interpretation_code}"
+          result += " #{id.interpretation_code} Interp"
         elsif id.year
-          parts << "-#{id.year}"
+          result += " – #{id.year}"
+        else
+          result += " Interp"
         end
 
-        parts << " #{id.suffix}" if id.suffix
+        result += " #{id.suffix}" if id.suffix
+        result
+      end
 
-        parts.join(" ").squeeze(" ")
+      # "AMCA Standard 803-02": the year joins the number with a bare dash.
+      def document(id, title)
+        result = [id.copublisher, title, id.number.to_s].compact.join(" ")
+        result += "-#{id.year}" if id.year
+        result
       end
     end
   end

data/lib/pubid/amca/urn_generator.rb

@@ -27,9 +27,26 @@ module Pubid
         "copub.#{identifier.copublisher.to_s.downcase}" if identifier.copublisher
       end
 
+      # Identity-bearing: "AMCA 99 JW Interp" and "AMCA 99 KB Interp" are
+      # different documents.
+      def urn_interpretation
+        return nil unless identifier.respond_to?(:interpretation_code)
+
+        code = identifier.interpretation_code
+        "interp.#{code.downcase}" if code
+      end
+
+      def urn_revision
+        revision = identifier.revision if identifier.respond_to?(:revision)
+        "rev.#{revision}" if revision
+      end
+
+      # `type` is a metadata Hash; interpolating it put a Ruby Hash literal
+      # into every AMCA URN. The key is the source Identifier#mr_type reads.
       def urn_type
-        (identifier.class.respond_to?(:type) ? identifier.class.type : nil)
-          &.to_s&.downcase
+        return nil unless identifier.class.respond_to?(:type)
+
+        identifier.class.type[:key]&.to_s
       end
 
       def generate
@@ -37,6 +54,8 @@ module Pubid
         parts << urn_number if urn_number
         parts << urn_year if urn_year
         parts << urn_suffix if urn_suffix
+        parts << urn_interpretation if urn_interpretation
+        parts << urn_revision if urn_revision
         parts << urn_reaffirmed if urn_reaffirmed
         parts << urn_copublisher if urn_copublisher