pubid 2.0.8 → 2.0.10

data/lib/pubid/oasis/pubid_urn_schema.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oasis
+    # The pubid-scheme URN of oasis (issue #656; docs/URN-SCHEMES.adoc).
+    #
+    # Declared from the doc's section: the atom, facet and type tables
+    # below are the doc's design, conforming token-for-token.
+    PubidUrnSchema = Pubid::PubidUrn.define("oasis") do
+      atom "part", "part"
+      atom "version", "v"
+      atom "stage", "stage"
+      atom "label", "label"
+      atom "original", "original"
+
+
+      type "pubid:oasis:identifier", "id"
+      type "pubid:oasis:standard", "std"
+    end
+  end
+end

data/lib/pubid/oasis.rb

@@ -17,6 +17,7 @@ module Pubid
     autoload :Renderer, "#{__dir__}/oasis/renderer"
     autoload :UrnGenerator, "#{__dir__}/oasis/urn_generator"
     autoload :UrnParser, "#{__dir__}/oasis/urn_parser"
+    autoload :PubidUrnSchema, "#{__dir__}/oasis/pubid_urn_schema"
 
     # Parse an OASIS identifier string
     def self.parse(identifier)

data/lib/pubid/ogc/pubid_urn_schema.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ogc
+    # The pubid-scheme URN of ogc (issue #656; docs/URN-SCHEMES.adoc).
+    #
+    # Declared from the doc's section: the atom, facet and type tables
+    # below are the doc's design, conforming token-for-token.
+    PubidUrnSchema = Pubid::PubidUrn.define("ogc") do
+      atom "year", "year"
+      atom "revision", "rev"
+
+
+      type "pubid:ogc:document", "document"
+      type "pubid:ogc:identifier", "id"
+    end
+  end
+end

data/lib/pubid/ogc.rb

@@ -20,6 +20,7 @@ module Pubid
     autoload :Renderer, "#{__dir__}/ogc/renderer"
     autoload :UrnGenerator, "#{__dir__}/ogc/urn_generator"
     autoload :UrnParser, "#{__dir__}/ogc/urn_parser"
+    autoload :PubidUrnSchema, "#{__dir__}/ogc/pubid_urn_schema"
 
     # Parse an OGC identifier string
     def self.parse(identifier)

data/lib/pubid/plateau/CLAUDE.md

@@ -0,0 +1,13 @@
+# PLATEAU flavor notes
+
+Read this before you change `lib/pubid/plateau/` or `spec/pubid/plateau/`. The
+root `CLAUDE.md` keeps the cross-flavor contract that every flavor obeys.
+
+## pubid-scheme URN (issue #656)
+
+`lib/pubid/plateau/pubid_urn_schema.rb`; rulings in `docs/URN-SCHEMES.adoc`
+(`[[urn-plateau]]`). PLATEAU is the one flavor whose `number` stays an
+Integer, so its core is `:int` (`core: [["number", :int]]`): `#00` is the core
+`0`, and `00` in a URN is not canonical. The Annex type has no `number`; it
+has no core, its document comes first along `base`, and its `letter` is an
+atom. No input makes an Annex today, so the spec builds one by hand.

data/lib/pubid/plateau/pubid_urn_schema.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    # The pubid-scheme URN of PLATEAU (issue #656; docs/URN-SCHEMES.adoc).
+    #
+    #   PLATEAU Handbook #00 第1.0版  ->  urn:pubid:plateau:hb:0:ed-1.0
+    #
+    # PLATEAU keeps +number+ as an Integer (the one flavor the String retype
+    # left out), so it is an :int core. An Annex has no number of its own:
+    # its document comes first, along +base+, and its letter is an atom.
+    PubidUrnSchema = Pubid::PubidUrn.define("plateau") do
+      atom "publisher", "pub"
+      atom "edition", "ed"
+      atom "annex", "annex", kind: :int
+
+      number = [["number", :int]]
+      type "pubid:plateau:annex", "annex", core: [],
+                                           atoms: [%w[letter letter]]
+      type "pubid:plateau:handbook", "hb", core: number
+      type "pubid:plateau:identifier", "id", core: number
+      type "pubid:plateau:technical-report", "tr", core: number
+    end
+  end
+end

data/lib/pubid/plateau.rb

@@ -13,6 +13,7 @@ module Pubid
     autoload :Identifier, "#{__dir__}/plateau/identifiers/base"
     autoload :Identifiers, "#{__dir__}/plateau/identifiers"
     autoload :Parser, "#{__dir__}/plateau/parser"
+    autoload :PubidUrnSchema, "#{__dir__}/plateau/pubid_urn_schema"
     autoload :Renderer, "#{__dir__}/plateau/renderer"
     autoload :SupplementIdentifier, "#{__dir__}/plateau/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/plateau/urn_generator"

data/lib/pubid/pubid_urn/decoder.rb

@@ -62,18 +62,24 @@ module Pubid
       end
 
       def decode_core(tokens, index, node, schema)
-        schema.core.each do |parts|
+        schema.core.each_with_index do |parts, i|
           break if index >= tokens.size
 
           token = tokens[index]
           break if PubidUrn.structural?(token)
 
-          Paths.put(node, parts, Escape.decode(token)) unless token == NULL
+          unless token == NULL
+            Paths.put(node, parts, core_value(token, schema.core_kinds[i]))
+          end
           index += 1
         end
         index
       end
 
+      def core_value(token, kind)
+        kind == :int ? integer(token) : Escape.decode(token)
+      end
+
       def decode_atoms(tokens, index, node, schema)
         last = -1
         while index < tokens.size &&

data/lib/pubid/pubid_urn/encoder.rb

@@ -69,11 +69,23 @@ module Pubid
       def core_segments(node, schema)
         values = schema.core.map { |parts| Paths.take(node, parts) }
         values.pop while !values.empty? && values.last.nil?
-        values.map do |value|
-          value.nil? ? NULL : core_value(value, schema)
+        values.each_with_index.map do |value, i|
+          next NULL if value.nil?
+          next core_integer(value, schema, i) if schema.core_kinds[i] == :int
+
+          core_value(value, schema)
         end
       end
 
+      # A decimal never has the shape of structure, so it needs no escape.
+      def core_integer(value, schema, index)
+        return value.to_s if value.is_a?(Integer)
+
+        raise Errors::InvalidInputError,
+              "#{schema.type} #{schema.core[index].join('.')}: " \
+              "#{value.inspect} is not int"
+      end
+
       # A core value that has the shape of structure (PubidUrn::STRUCTURE)
       # gets its first character escaped.
       def core_value(value, schema)

data/lib/pubid/pubid_urn/schema.rb

@@ -48,13 +48,15 @@ module Pubid
 
     # The URN shape of one concrete identifier type.
     class TypeSchema
-      attr_reader :flavor, :type, :token, :core, :atoms, :facets
+      attr_reader :flavor, :type, :token, :core, :core_kinds, :atoms, :facets
 
+      # +core+ is a list of [path, kind] pairs; kind is :string or :int.
       def initialize(flavor:, type:, token:, core:, atoms:, facets:)
         @flavor = flavor
         @type = type
         @token = token
-        @core = core.map { |path| path.split(".") }.freeze
+        @core = core.map { |path, _| path.split(".") }.freeze
+        @core_kinds = core.map { |_, kind| kind }.freeze
         @atoms = atoms.freeze
         @facets = facets.freeze
         @atom_index = atoms.each_with_index.to_h { |atom, i| [atom.prefix, i] }
@@ -86,6 +88,7 @@ module Pubid
       NAME = /\A[a-z][a-z0-9]*\z/
       KINDS = %i[string list bool bools int id ids].freeze
       FACET_KINDS = %i[string list bool bools].freeze
+      CORE_KINDS = %i[string int].freeze
       # "f" opens the facet group; "type" is the type-metadata URN
       # (Pubid::IdentifierMetadata, "urn:pubid:<flavor>:type:<key>").
       RESERVED_TOKENS = %w[f type].freeze
@@ -110,7 +113,9 @@ module Pubid
 
       # @param type [String] the +_type+ the class serializes
       # @param token [String] the short type token of the URN
-      # @param core [Array<String>] the positional core paths
+      # @param core [Array<String, Array>] the positional core paths; an
+      #   entry is a path (a String value) or [path, kind], kind :string or
+      #   :int
       # @param atoms [Array<Array>] extra atoms: [path, prefix, kind]
       # @param facets [Array<Array>] extra facets: [path, name, kind]
       def type(type, token, core: %w[number], atoms: [], facets: [])
@@ -126,7 +131,8 @@ module Pubid
         check_unique!(all_facets.map(&:name), "facet name", type)
 
         schema = TypeSchema.new(flavor: flavor, type: type, token: token,
-                                core: core, atoms: all_atoms,
+                                core: core.map { |spec| build_core(*spec) },
+                                atoms: all_atoms,
                                 facets: all_facets)
         @types[type] = schema
         @tokens[token] = schema
@@ -142,6 +148,14 @@ module Pubid
 
       private
 
+      def build_core(path, kind = :string)
+        unless CORE_KINDS.include?(kind)
+          raise ArgumentError, "unknown core kind #{kind.inspect}"
+        end
+
+        [path, kind]
+      end
+
       def build_atom(path, prefix, kind = nil)
         check_name!(prefix, "atom prefix")
         Atom.new(path, prefix, check_kind!(path, kind, KINDS, "atom"))

data/lib/pubid/pubid_urn.rb

@@ -106,6 +106,46 @@ module Pubid
         string.is_a?(String) && string.b[0, PREFIX.length].downcase == PREFIX
       end
 
+      # The slug form (relaton#441): the URN wearing HTTP-path clothes.
+      # Each ":" segment becomes a "/" segment, after the "urn:pubid:"
+      # prefix is cut — "urn:pubid:iso:is:9001:year-2015" is
+      # "iso/is/9001/year-2015". The contract's path-safety gate
+      # guarantees no segment carries a "/", so the transform is
+      # bijective: {from_slug} rebuilds the exact URN.
+      #
+      # @param source [Identifier, String] an identifier or its
+      #   pubid-scheme URN
+      # @return [String] the slug, with no leading or trailing "/"
+      # @raise [Errors::InvalidInputError] when a String is not a
+      #   canonical pubid-scheme URN
+      def to_slug(source)
+        urn = source.respond_to?(:to_pubid_urn) ? source.to_pubid_urn : source
+        parse(urn) unless source.respond_to?(:to_pubid_urn)
+        urn.delete_prefix(PREFIX).tr(":", "/")
+      end
+
+      # The slug parse side: "/"-joined segments rebuild the URN and
+      # parse through the canonical gate, so a slug of a landed flavor
+      # round-trips by +to_hash+ exactly like its URN.
+      #
+      # @param string [String] the slug
+      # @return [Identifier]
+      # @raise [Errors::InvalidInputError] when +string+ is not a String
+      #   or is longer than MAX_LENGTH
+      # @raise [Errors::UrnParseError] for a malformed, unknown or
+      #   non-canonical slug
+      def from_slug(string)
+        unless string.is_a?(String)
+          raise Errors::InvalidInputError, Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+        raise Errors::InvalidInputError,
+              "slug exceeds #{MAX_LENGTH} characters" if string.length > MAX_LENGTH
+        raise Errors::UrnParseError, "slug has empty segments" if
+          string.split("/", -1).any?(&:empty?)
+
+        parse("#{PREFIX}#{string.tr('/', ':')}")
+      end
+
       # @return [FlavorSchema, nil]
       def flavor_schema(flavor)
         return @schemas[flavor] if @schemas.key?(flavor)

data/lib/pubid/sae/CLAUDE.md

@@ -0,0 +1,78 @@
+# SAE flavor notes
+
+## Source of the codes: SAE's Crossref deposits
+
+relaton indexes every SAE standard from Crossref (prefix `10.4271`, type
+`standard`). The DOI suffix is SAE's own edition code, lower-case and without
+hyphens: `10.4271/j3016_202104` is `SAE J3016_202104`, `10.4271/amsqqa250_4b`
+is `SAE AMS-QQ-A-250/4B`. relaton upper-cases the suffix and prefixes `SAE `,
+so pubid must read the hyphen-free spelling as well as the printed one.
+
+Measured on the full deposit list (2026-11-04, 47,692 DOIs): **46,726
+parse**, and every parsed code round-trips through `to_s`, `from_hash` and
+the URN, with **0 `to_hash` collisions**. The 966 that do not parse are:
+
+- **791 CP\*** (`CPGM`, `CPFD`, `CPKW`, …): collected-paper products, not
+  standards. Out of scope by decision.
+- **175 one-offs**, none more than 32 of a kind: `SUP1` supplements
+  (`AS4468SUP1A`, `ARP4737SUP1`), language tails (`AS9101F_PTBR`,
+  `IA9137_DEDE`), `J2534-2/10_5_00`, `_4Q2012`, type-less `SAE6857`,
+  `_MMYYYY` dates (`CS1939_042012`, `J2012DA_012013` — the builder's
+  month check refuses the J ones, which would otherwise read as year 120,
+  month 13), `ISO/SAE21434`, `IEEE/EIA12207`, and ~30 families of 1–8
+  documents whose printed form is unknown (`HEB`, `EQB`, `TAHB`, `AMSLP`,
+  `AMSHHG`, …). Add a family by adding it to `Components::Type::TYPES` and
+  re-baking the grammar (below).
+
+## Model
+
+| attribute | example | `===` |
+|---|---|---|
+| `type.abbr` (printed form) | `AMS`, `AMS-QQ-A`, `GEIA-STD` | stated |
+| `number` | `4121`, `0001`, `1939DA`, `174M`, `1939-71` | stated |
+| `part` | `2` of `J2337/2`, `H1025` of `AMS5622/H1025` | strict |
+| `revision` | `J` of `AMS4121J`, `6` of `USCAR2-6` | wildcard |
+| `amendment` | `1` of `AS5259/7A_A1` | strict |
+| `date` (`year`, `month`) | `J3016_202104` | month is a wildcard |
+
+The grammar only segments the code; `builder.rb` decides what each segment
+means, because the meaning depends on the family:
+
+- **A one-letter tail is the revision** (`AMS4121J`, `AS22520/45A`), so every
+  revision of a document shares one `number` bucket and `SAE AMS4121 ===`
+  each of them. relaton then picks the highest revision.
+- **Except the `M` of a J or JA report**, which marks the metric document
+  (`J174M`) and stays in `number`. AMS revisions do reach `M` (`AMS2400M`),
+  so the exception is per family (`Type::METRIC_SUFFIX`).
+- **A longer tail is another document** (`J1939DA` digital annex,
+  `J2735SET`) and stays in `number`, in its own bucket.
+- **A dash number is part of `number`** (`J1939-71`, `EIA649-2`; the DOI
+  writes some of them `_1`: `EIA649_1A` → `EIA-649-1A`). For USCAR the dash
+  is the revision (`USCAR2-6` is USCAR-2 Revision 6, `Type::DASH_REVISION`).
+- **`part` and `amendment` are `subset_strict`**: `SAE J2337` does not match
+  `SAE J2337/2`, and `SAE AS5259/7A` does not match `SAE AS5259/7A_A1`.
+
+Rendering follows SAE: no space after the type (`SAE J3016`, the old
+`SAE J 3016` still parses), a hyphen after a family that kept a military or
+industry series hyphen (`Type::TYPES` holds the separator), `_YYYYMM` when
+the month is known and `:YYYY` otherwise. The amendment tail `_A1` has no
+known printed form and keeps the DOI's.
+
+## The grammar is baked here from a hand-off source
+
+`data/parg/sae.json` was compiled with the pinned parsanol from the source
+recorded in hand-off `pubid__pubid-grammar__sae-crossref-coverage` (the same
+text sits in the artifact's `source` field). Until pubid-grammar lands it,
+`pubid-grammar/grammars/sae.parg` is the OLD grammar, so `parsanol parg
+check` against it reports stale. To change the grammar, extract the source
+(`jq -r .source data/parg/sae.json`), edit, and re-bake:
+
+```bash
+bundle exec parsanol parg compile sae.parg -o data/parg/sae.json
+bundle exec parsanol parg test data/parg/sae.json
+```
+
+The `doc_type` alternatives are the `Type::TYPES` keys plus their
+hyphen-free spellings, longest first (PEG commits to the first match, so
+`AMS` comes after every `AMS…`). `spec/pubid/sae/type_table_spec.rb` fails
+when the two lists drift or an alternative shadows a longer one.

data/lib/pubid/sae/builder.rb

@@ -2,31 +2,109 @@
 
 module Pubid
   module Sae
+    # Builds a Pubid::Sae::Identifier from the grammar's bound captures.
+    #
+    # The grammar only segments the code (data/parg/sae.json):
+    # +type number [dash] [tail] [/part [part_tail]] [_A amendment] [date]+.
+    # The meaning of each segment is decided here, because it depends on the
+    # family:
+    #
+    # * +type+ is stored in its printed form (+AMSQQA+ -> +AMS-QQ-A+).
+    # * A one-letter +tail+ or +part_tail+ is the revision (+AMS4121J+,
+    #   +AS22520/45A+), except the +M+ of a J or JA report, which marks the
+    #   metric document (+J174M+) and stays in the number.
+    # * A longer tail names another document (+J1939DA+, the digital annex;
+    #   +J2735SET+) and stays in the number, so it keeps its own index bucket.
+    # * A +dash+ is a USCAR revision (+USCAR2-6+); in every other family it
+    #   is part of the number (+J1939-71+, +EIA649-2+).
     class Builder < Pubid::Builder::Base
       def self.build(parsed_data)
         new.build(parsed_data)
       end
 
+      def build(data)
+        data = flatten_array(data) if data.is_a?(Array)
+        data = data.transform_keys(&:to_sym)
+        Identifier.new(**attributes_for(data))
+      end
+
       private
 
       def default_identifier_class
         Identifier
       end
 
-      def cast(type, value)
-        case type
-        when :publisher
-          "SAE"
-        when :type
-          Components::Type.new(abbr: value.to_s)
-        when :number
-          value.to_s
-        when :year
-          { date: Components::Date.new(year: value.to_i) }
+      def attributes_for(data)
+        abbr = Components::Type.canonical(data[:type])
+        attrs = { type: Components::Type.new(abbr: abbr),
+                  number: data[:number].to_s }
+        apply_dash(attrs, abbr, data[:dash])
+        apply_tail(attrs, abbr, data[:tail], part: data[:part])
+        apply_part(attrs, data[:part], data[:part_tail])
+        attrs[:amendment] = data[:amendment].to_s if data[:amendment]
+        attrs[:date] = date_for(data) if data[:year]
+        attrs
+      end
+
+      def apply_dash(attrs, abbr, dash)
+        return unless dash
+
+        if Components::Type::DASH_REVISION.include?(abbr)
+          attrs[:revision] = dash.to_s
+        else
+          attrs[:number] += "-#{dash}"
+        end
+      end
+
+      # A one-letter tail before a part (AMS4121J/2) or after a USCAR dash
+      # revision (USCAR2-6A) has no place in the model: no SAE code has that
+      # shape, and storing it in `number` would split the index bucket and
+      # print a string that does not parse back. Such input is refused.
+      def apply_tail(attrs, abbr, tail, part:)
+        return unless tail
+
+        tail = tail.to_s
+        if !revision_letter?(abbr, tail)
+          attrs[:number] += tail
+        elsif part || attrs[:revision]
+          refuse("a revision letter #{tail} before a part or after a " \
+                 "dash revision")
+        else
+          attrs[:revision] = tail
+        end
+      end
+
+      def apply_part(attrs, part, part_tail)
+        return unless part
+
+        attrs[:part] = part.to_s
+        return unless part_tail
+
+        if part_tail.to_s.length == 1
+          attrs[:revision] = part_tail.to_s
         else
-          value
+          attrs[:part] += part_tail.to_s
         end
       end
+
+      def revision_letter?(abbr, tail)
+        return false unless tail.length == 1
+
+        !(tail == "M" && Components::Type::METRIC_SUFFIX.include?(abbr))
+      end
+
+      def date_for(data)
+        month = data[:month]&.to_i
+        refuse("month #{data[:month]}") if month && !(1..12).cover?(month)
+
+        Components::Date.new(year: data[:year].to_i, month: month)
+      end
+
+      def refuse(what)
+        raise Pubid::Errors::ParseError.new(
+          "SAE identifier with #{what} is not supported", nil, flavor: "sae"
+        )
+      end
     end
   end
 end

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

@@ -5,12 +5,18 @@ require "lutaml/model"
 module Pubid
   module Sae
     module Components
-      # Date component for SAE standards
-      # SAE uses year only (e.g., 2024, 2022)
+      # The edition date of an SAE document.
+      #
+      # SAE dates a J report by year and month: its edition code is
+      # +J3016_202104+, the April 2021 edition. A reference may state the
+      # year alone (+SAE J3016:2021+); the month is then nil, and nil is a
+      # wildcard under +===+, so the year-only reference matches every
+      # edition of that year.
       class Date < Lutaml::Model::Serializable
         include ::Pubid::SubsetMatch
 
         attribute :year, :integer
+        attribute :month, :integer
 
         def present?
           !year.nil?
@@ -20,8 +26,11 @@ module Pubid
           render
         end
 
+        # +202104+ with a month (SAE's edition code), +2021+ without.
         def render(context: nil)
-          year.to_s
+          return year.to_s unless month
+
+          format("%<year>04d%<month>02d", year: year, month: month)
         end
       end
     end

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

@@ -5,13 +5,65 @@ require "lutaml/model"
 module Pubid
   module Sae
     module Components
-      # Type component for SAE document types
-      # AMS, AIR, ARP, AS, MA
+      # The SAE document family: the letters before the number.
+      #
+      # +abbr+ holds the printed form (+AMS-QQ-A+). SAE's DOI suffixes drop
+      # the hyphens (+10.4271/amsqqa250_4b+), so the parser reads both
+      # spellings and the builder stores the printed one (see
+      # +.canonical+).
       class Type < Lutaml::Model::Serializable
         include ::Pubid::SubsetMatch
 
+        # Printed form => the separator SAE prints between it and the number.
+        # A family transferred from a military or industry series keeps that
+        # series' hyphen (+AMS-QQ-A-250+, +GEIA-STD-0001+, +EIA-649+); the
+        # SAE-native families print the number glued (+AMS4121J+, +J3016+).
+        # The grammar's +doc_type+ alternatives list exactly these keys plus
+        # their hyphen-free spellings; +spec/pubid/sae/type_table_spec.rb+
+        # keeps the two in step.
+        TYPES = {
+          "AMS" => "", "AS" => "", "J" => "", "ARP" => "", "AIR" => "",
+          "MA" => "", "MAM" => "", "MAP" => "", "JA" => "", "MS" => "",
+          "ARD" => "", "TSB" => "", "CMB" => "", "SSB" => "",
+          "CRP" => "-", "USCAR" => "-",
+          "EIA" => "-", "EIA-IS" => "-", "EIA-STD" => "-",
+          "GEIA" => "-", "GEIA-STD" => "-", "GEIA-HB" => "-", "GEIA-OP" => "-",
+          "GEIA-TB" => "-",
+          "AMS-STD" => "-", "AMS-DTL" => "-", "AMS-WW-T" => "-",
+          "AMS-QQ-A" => "-", "AMS-QQ-C" => "-", "AMS-QQ-N" => "-",
+          "AMS-QQ-P" => "-", "AMS-QQ-S" => "-", "AMS-QQ-W" => "-",
+          "AMS-PRF" => "-",
+          "AMS-A" => "-", "AMS-B" => "-", "AMS-C" => "-", "AMS-D" => "-",
+          "AMS-F" => "-",
+          "AMS-G" => "-", "AMS-H" => "-", "AMS-I" => "-", "AMS-L" => "-",
+          "AMS-M" => "-", "AMS-P" => "-", "AMS-R" => "-", "AMS-S" => "-",
+          "AMS-T" => "-", "AMS-W" => "-"
+        }.freeze
+
+        # Hyphen-free spelling => printed form.
+        CANONICAL = TYPES.keys.to_h { |abbr| [abbr.delete("-"), abbr] }.freeze
+
+        # The families whose revision is a dash number (+USCAR2-6+ is
+        # USCAR-2 Revision 6), not a letter.
+        DASH_REVISION = %w[USCAR].freeze
+
+        # The families whose trailing +M+ marks the metric edition of a
+        # document (+J174M+), not a revision.
+        METRIC_SUFFIX = %w[J JA].freeze
+
         attribute :abbr, :string
 
+        # @param spelling [String] +AMSQQA+, +AMS-QQ-A+ or +ams-qq-a+
+        # @return [String, nil] the printed form, nil for an unknown family
+        def self.canonical(spelling)
+          CANONICAL[spelling.to_s.upcase.delete("-")]
+        end
+
+        # The separator printed between this family and its number.
+        def separator
+          TYPES.fetch(abbr.to_s, "")
+        end
+
         def to_s
           render
         end

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

@@ -4,7 +4,7 @@ module Pubid
   module Sae
     # Base SAE Identifier. Canonical name Pubid::Sae::Identifier. SAE has a single identifier class that IS the
     # document type, so this class is both the base and the only concrete type.
-    # Handles all SAE document types (AMS, AIR, ARP, AS, MA).
+    # Handles every SAE document family (Components::Type::TYPES).
     class Identifier < ::Pubid::Identifier
       def self.parse(input)
         unless input.is_a?(String)
@@ -26,8 +26,19 @@ module Pubid
       # a bare alias of the shared component and never carried more than
       # `value`, so this is a representation change only.
       attribute :number, :string
+      # The revision letter (AMS4121J -> "J"), or USCAR's revision number
+      # (USCAR2-6 -> "6"). Kept out of `number`, so every revision of a
+      # document shares one index bucket and a reference without a revision
+      # matches them all under `===`.
+      attribute :revision, :string
+      # The amendment of a revision: AS5259/7A_A1 -> "1".
+      attribute :amendment, :string
       attribute :date, Sae::Components::Date
 
+      # A part (J2337/2) and an amendment (_A1) are other documents: a
+      # reference without one names the document that has none.
+      subset_strict :part, :amendment
+
       def self.type
         { key: :base, web: :standard, title: "Standard", short: "SAE" }
       end
@@ -44,6 +55,48 @@ module Pubid
       def mr_type
         type&.abbr&.to_s&.downcase
       end
+
+      # The code after the type and its separator, without the date:
+      # "4121J", "22520/45A", "5259/7A_A1", "2-6" (USCAR-2 Revision 6).
+      # The renderer prints it after the type; the URN carries it as one
+      # segment.
+      def designation
+        dash = dash_revision?
+        code = number.to_s
+        code += "-#{revision}" if revision && dash
+        code += "/#{part}" if part
+        code += revision.to_s if revision && !dash
+        code += "_A#{amendment}" if amendment
+        code
+      end
+
+      # A revision after a part (AS22520/45A) is the part document's
+      # revision, so dropping the part drops it too. Without this,
+      # `exclude(:part)` would turn it into revision A of the base document
+      # (AS22520A) and `matches?(other, ignore: [:part])` would pair the two.
+      def exclude(*args)
+        args += [:revision] if part && args.include?(:part)
+        super
+      end
+
+      # A numbered revision of a USCAR family (USCAR-2-6). A letter revision
+      # (USCAR3A) prints glued, as in every other family.
+      def dash_revision?
+        Sae::Components::Type::DASH_REVISION.include?(type&.abbr.to_s) &&
+          revision.to_s.match?(/\A\d+\z/)
+      end
+
+      # Each segment carries a letter, so a dash number (J1939-71 ->
+      # "1939-71") never collides with a part (J1939/71 -> "1939-p71").
+      def mr_number_with_part
+        return nil unless number
+
+        segments = [number]
+        segments << "p#{part}" if part
+        segments << "r#{revision}" if revision
+        segments << "a#{amendment}" if amendment
+        segments.join("-").downcase
+      end
     end
 
   end