pubid 1.15.21 → 2.0.0.alpha.10

data/data/nist/update_codes.yaml

@@ -0,0 +1,122 @@
+# NIST pre-parser normalization rules.
+#
+# This file is applied to every NIST identifier string BEFORE any Ruby
+# preprocessing (see lib/pubid/nist/preprocessor.rb). Each entry is one
+# of:
+#
+#   "plain string": "replacement"
+#       Full-line match (^...$), literal. Use for specific malformed IDs
+#       that have a single canonical form.
+#
+#   "/regex/": "replacement"          (no flags)
+#   "/regex/imx": "replacement"       (i = IGNORECASE, m = MULTILINE,
+#                                       x = EXTENDED)
+#       Applied via gsub. Use for general patterns that are pure
+#       string→string substitutions.
+#
+# Design split (MECE):
+#   - This file: data-driven lookups and pure subs that any maintainer
+#     (including non-Rubyists) can extend safely.
+#   - Preprocessor (Ruby): stateful or interdependent transformations
+#     where stage order, conditional logic, or external state (e.g.,
+#     Roman numeral conversion, year-range reverts) make YAML unsuitable.
+#
+# Reorder entries with care — later entries often match patterns produced
+# by earlier ones. Run `bundle exec rspec spec/pubid/nist/` after edits.
+NBS MN: NBS MONO
+NIST MN: NIST MONO
+# Long-form series names — normalize to the abbreviated form the parser expects.
+/\bMonograph\b/: MONO
+# Citation-form comma before long parameter prefixes — strip so the parser's
+# " Rev. " / " Part. " / " Vol. " prefix rules match (issue #197).
+'/,\s+(Rev\.|Part\.|Vol\.|Revision|Volume|Part)(?=\s|\d)/': ' \1'
+NIST MP: NBS MP
+NIST SP 260-162 2006ed.: NIST SP 260-162e2006
+# Doubled publisher+series prefix — an error in the NIST Tech Pubs source data
+# (pubid/pubid#152). Collapse the repeated "NIST AI" so the remainder parses.
+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 sup$/: NBS CIRC 24e7sup
+NBS CIRC 25sup-1924: NBS CIRC 25sup
+NIST SP 260-126 rev 2013: NIST SP 260-126r2013
+NIST CSRC White Paper: NIST CSWP
+NIST SP 800-56ar: NIST SP 800-56Ar1
+NIST.LCIRC: NIST.LC
+NBS.LCIRC: NBS.LC
+NIST LCIRC: NIST LC
+NBS LCIRC: NBS LC
+NIST SP 800-57Pt3r1: NIST SP 800-57pt3r1
+NISTIR: NIST IR
+NIST FIPS: FIPS
+NIST.CSWP.01162020pt: NIST.CSWP.01162020(por)
+/^NBS FIPS 11-1-Sep30$/: NBS FIPS 11-1-Sep30/1977
+/^NBS FIPS 89-Sep1$/: NBS FIPS 89-Sep1981
+/^FIPS PUB 54-1-Jan15$/: FIPS 54-1
+/^FIPS 54-1-Jan15$/: FIPS 54-1
+/^FIPS 54-1-Jan17$/: FIPS 54-1-Jan17/1991
+FIPS PUB: FIPS
+NBS CRPL c4-4: NBS CRPL 4-4
+NIST AMS 300-8r1 (February 2021 update): NIST AMS 300-8r1/Upd1-202102
+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
+NBS IR 73-197r: NBS IR 73-197r1
+NBS.HB.105-1r1990: NIST.HB.105-1r1990
+NBS.HB.28p11969: NBS.HB.28-1969pt1
+NIST HB 105-1-1990: NIST HB 105-1r1990
+NBS.FIPS.100-1-1991: NIST.FIPS.100-1-1991
+NBS.LC.1088sp: NBS.LC.1088.spa
+NBS LC 1088sp: NBS LC 1088 spa
+#NBS.LC.145r11/1925: NBS.LC.145/Upd1-192511
+#NBS.LC.118sup12/1926: NBS.LC.118sup/Upd1-192612
+NIST SP 955 Suppl.: NIST SP 955sup
+NIST SP 800-38e: NIST SP 800-38E
+NIST SP 782-1995-96: NIST SP 782-1995
+NIST FIPS 54-Jan15: NIST FIPS 54
+NBS report ;: NBS RPT
+NBS TN 467p1adde1: NBS TN 467pt1-add
+NIST SP 1011-II-1.0: NIST SP 1011v2ver1.0
+NIST SP 1011-II-1 0: NIST SP 1011v2ver1.0
+NIST SP 1011-I-2.0: NIST SP 1011v1ver2.0
+NIST SP 1011-I-2 0: NIST SP 1011v1ver2.0
+NIST SP 500-281-v1.0: NIST SP 500-281v1.0
+NIST IR 8259Aes: NIST IR 8259A(spa)
+NIST IR 8259Apt: NIST IR 8259A(por)
+NIST IR 8211-upd: NIST IR 8211/Upd1-2021
+NIST IR 8115r1/upd: NIST IR 8115r1/Upd1-2021
+NBS CS v: NBS CSM v
+NIST SP 800-57p1r2006: NIST SP 800-57pt1r1
+NIST SP 800-57p1r2007: NIST SP 800-57pt1r2
+NIST SP 500-268v1 1: NIST SP 500-268v1.1
+NIST SP 500-270v1 1: NIST SP 500-270v1.1
+NIST SP 500-280v2 1: NIST SP 500-280v2.1
+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 984 4: NIST SP 984-4
+NISTPUB 0413171251: NIST TN 1648-2009
+/\-draft$/: " (Draft)"
+/\-draft2$/: " 2pd"
+NIST HB 135e2022-upd1: NIST HB 135e2022/Upd1-202205
+NIST SP 1900-206-upd1: NIST SP 1900-206/Upd1-202202
+NIST TN 2207-upd1: NIST TN 2207/Upd1-202205
+NIST IR 8290-upd1: NIST IR 8290/Upd1-202205
+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
+NBS NSRDS: NSRDS-NBS
+nist ir: NIST IR
+/(?<=\d)es/: (spa)
+/(?<=\d)chi/: (zho)
+/(?<=\d)viet/: (vie)
+/(?<=\d)port/: (por)
+/(?<=\d)(pt)(?!\d)/: (por)
+/(?<=\d)id/: (ind)

data/data/plateau/update_codes.yaml

@@ -0,0 +1,6 @@
+"PLATEAU Handbook #11 第1.0版（民間活用編）": "PLATEAU Handbook #06 第1.0版"
+"PLATEAU Handbook #11 第1.0版（公共活用編）": "PLATEAU Handbook #04 第1.0版"
+"PLATEAU Handbook #11 第2.0版（民間活用編）": "PLATEAU Handbook #06 第2.0版"
+"PLATEAU Handbook #11 第2.0版（公共活用編）": "PLATEAU Handbook #04 第2.0版"
+"PLATEAU Handbook #11 第3.0版（民間活用編）": "PLATEAU Handbook #06 第3.0版"
+"PLATEAU Handbook #11 第3.0版（公共活用編）": "PLATEAU Handbook #04 第3.0版"

data/lib/pubid/adobe/builder.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Adobe
+    # Builds an Adobe identifier object from the Parslet parse tree.
+    class Builder
+      def build(parsed)
+        return build_tech_note(parsed[:tech_note]) if parsed[:tech_note]
+        return build_tech_note_bare(parsed[:tech_note_bare]) if parsed[:tech_note_bare]
+        return build_publication_version(parsed[:publication_version]) if parsed[:publication_version]
+        return build_publication(parsed[:slug]) if parsed[:slug]
+
+        raise ArgumentError, "Unrecognized Adobe parse tree: #{parsed.inspect}"
+      end
+
+      def self.build(parsed)
+        new.build(parsed)
+      end
+
+      private
+
+      def build_tech_note(hash)
+        Identifiers::TechNote.new(
+          number: stringify(hash[:number]),
+          slug:   stringify(hash[:slug]),
+        )
+      end
+
+      def build_tech_note_bare(number_hash)
+        Identifiers::TechNote.new(number: stringify(number_hash))
+      end
+
+      def build_publication(slug_value)
+        Identifiers::Publication.new(slug: stringify(slug_value))
+      end
+
+      def build_publication_version(hash)
+        Identifiers::Publication.new(
+          slug:    stringify(hash[:slug]),
+          version: stringify(hash[:version]),
+        )
+      end
+
+      def stringify(value)
+        return nil if value.nil?
+
+        str = value.to_s
+        str.empty? ? nil : str
+      end
+    end
+  end
+end

data/lib/pubid/adobe/identifier.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Adobe
+    # Base class for all Adobe identifiers. Canonical name
+    # Pubid::Adobe::Identifier; every concrete Adobe identifier
+    # (Identifiers::*) descends from it.
+    #
+    # Adobe identifiers come in two shapes:
+    #
+    #   * TechNote    — `Adobe Technical Note #<number>` / `ATN<number>`
+    #                   e.g. `Adobe Technical Note #5014`, `ATN5014`.
+    #   * Publication — slug-keyed named specs that have no number
+    #                   e.g. `adobe-glyph-list`, `adobe-japan1-7`.
+    class Identifier < ::Pubid::Identifier
+      # Parse an Adobe identifier string into an identifier object.
+      # @param identifier [String]
+      # @return [Pubid::Adobe::Identifier]
+      # @raise [Pubid::Errors::ParseError] If parsing fails
+      def self.parse(identifier)
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      end
+
+      attribute :publisher, :string, default: "Adobe"
+
+      ADOBE_TYPE_MAP = {
+        "pubid:adobe:tech-note"   => "Pubid::Adobe::Identifiers::TechNote",
+        "pubid:adobe:publication" => "Pubid::Adobe::Identifiers::Publication",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: ADOBE_TYPE_MAP
+      end
+
+      def to_urn
+        UrnGenerator.new(self).generate
+      end
+
+      # Short type code (e.g. "ATN", nil for Publication) — convenience
+      # accessor used by Renderer and UrnGenerator.
+      def type_short
+        self.class.type[:short]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Adobe
+    module Identifiers
+      # Adobe named publication. Slug-keyed specs that have no tech-note
+      # number — Adobe Glyph List, PostScript Language, character
+      # collections, etc.
+      #
+      # Surface forms:
+      #   * slug `adobe-glyph-list`, `adobe-postscript-language`
+      #   * versioned character collections: `adobe-japan1` + version `7`
+      #   * human render is the slug title-cased (`Adobe Glyph List`,
+      #     `Adobe-Japan1-7`); the full publication title lives in the
+      #     data repo's title attribute, not here.
+      class Publication < Identifier
+        attribute :slug,    :string   # "adobe-glyph-list", "adobe-japan1"
+        attribute :version, :string   # "7", "3", nil
+
+        key_value do
+          map "slug",    to: :slug
+          map "version", to: :version
+        end
+
+        def self.type
+          { key: :publication, title: "Publication", short: nil }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/adobe/identifiers/tech_note.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Adobe
+    module Identifiers
+      # Adobe Technical Note. Numbered 4-digit (5xxx series observed).
+      #
+      # Surface forms:
+      #   * `Adobe Technical Note #5014` — formal citation form
+      #   * `ATN5014`                    — short alias used in Metanorma
+      #                                    anchor ids ([[atn5014,…]])
+      #   * filename `5014.CIDFont_Spec.pdf` (data repo splits filename
+      #     into number + slug before calling the parser)
+      #
+      # The optional `slug` carries the filename's title segment
+      # (`CIDFont_Spec`) so round-trip through the data repo is lossless.
+      class TechNote < Identifier
+        attribute :number, :string   # "5014", "5902"
+        attribute :slug,   :string   # "CIDFont_Spec", "AFM_Spec", nil
+
+        key_value do
+          map "number", to: :number
+          map "slug",   to: :slug
+        end
+
+        def self.type
+          { key: :"tech-note", title: "Technical Note", short: "ATN" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/adobe/identifiers.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Adobe
+    module Identifiers
+      autoload :TechNote,    "#{__dir__}/identifiers/tech_note"
+      autoload :Publication, "#{__dir__}/identifiers/publication"
+    end
+  end
+end

data/lib/pubid/adobe/parser.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Adobe
+    # Parslet grammar for Adobe identifiers.
+    #
+    # Canonical citation forms (what the renderer produces):
+    #
+    #   Adobe TN 5014                  (tech note; replaces the older
+    #                                    "Adobe Technical Note #5014")
+    #   Adobe Publication adobe-glyph-list
+    #   Adobe Publication adobe-japan1-7
+    #
+    # The parser also accepts these legacy forms for back-compat:
+    #
+    #   Adobe Technical Note #5014
+    #   Adobe Technical Note 5014
+    #   Adobe TN5014                   (no space)
+    #   ATN5014                        (short alias)
+    #   5014                           (bare number; data-repo context)
+    #   adobe-glyph-list               (bare slug)
+    class Parser < ::Pubid::Parser::Grammar
+      include ::Pubid::Parser::CommonParseRules
+
+      root :identifier
+
+      rule(:space)  { str(" ") }
+      rule(:space?) { space.maybe }
+      rule(:hash)   { str("#") }
+      rule(:dot)    { str(".") }
+      rule(:dash)   { str("-") }
+
+      # Canonical short prefix: "Adobe TN" with optional trailing space.
+      # Matches both "Adobe TN 5014" and "Adobe TN5014".
+      rule(:tech_note_tn_prefix) do
+        str("Adobe") >> space >> str("TN") >> space?.maybe
+      end
+
+      # Legacy long prefix: "Adobe Technical Note" with optional "#".
+      rule(:tech_note_long_prefix) do
+        str("Adobe") >> space >> str("Technical") >> space >> str("Note") >>
+          (space? >> hash.maybe >> space?).maybe
+      end
+
+      # Legacy short alias: "ATN" with optional trailing space.
+      rule(:tech_note_atn_prefix) do
+        str("ATN") >> space?.maybe
+      end
+
+      rule(:tech_note_prefix) do
+        tech_note_tn_prefix | tech_note_long_prefix | tech_note_atn_prefix
+      end
+
+      rule(:digits) do
+        match("[0-9]").repeat(1)
+      end
+
+      # 4-digit tech note number, optionally followed by ".<Slug>" from
+      # the filename form. The slug is captured but not required.
+      rule(:slug_chars) do
+        match("[A-Za-z0-9_]").repeat(1)
+      end
+
+      rule(:tech_note) do
+        (tech_note_prefix >>
+          digits.as(:number) >>
+          (dot >> slug_chars.as(:slug)).maybe).as(:tech_note)
+      end
+
+      # Bare number form (e.g. when the data repo passes just "5014"
+      # extracted from a filename). Not advertised in user docs; used
+      # internally by AdobeFetcher::Docid.
+      rule(:bare_number) do
+        digits.as(:number).as(:tech_note_bare)
+      end
+
+      # "Adobe Publication " prefix. Matched literally then discarded —
+      # the publication slug/version is parsed by the inner rule.
+      rule(:publication_prefix) do
+        str("Adobe") >> space >> str("Publication") >> space
+      end
+
+      # Publication slug. Lowercase ASCII letters and digits joined by `-`.
+      # Each segment starts with a letter (so a trailing `-<digits>` is
+      # unambiguously a version suffix, not part of the slug).
+      rule(:slug_segment) do
+        match("[a-z]") >> match("[a-z0-9]").repeat
+      end
+
+      rule(:slug_inner) do
+        slug_segment >> (dash >> slug_segment).repeat
+      end
+
+      rule(:publication_with_version) do
+        (slug_inner.as(:slug) >> dash >> digits.as(:version)).as(:publication_version)
+      end
+
+      rule(:publication_slug_or_version) do
+        # Try with-version first so `adobe-japan1-7` doesn't get captured
+        # as slug `adobe-japan1-7` with no version. The flat `:slug` form
+        # is the fallback for unversioned slugs.
+        publication_with_version | slug_inner.as(:slug)
+      end
+
+      rule(:publication) do
+        # Optional "Adobe Publication " prefix. The prefix is consumed
+        # but not captured — the inner rule produces :slug or
+        # :publication_version as before.
+        publication_prefix.maybe >> publication_slug_or_version
+      end
+
+      rule(:identifier) do
+        tech_note | bare_number | publication
+      end
+
+      # Parse a string and return the raw parslet tree.
+      # @param string [String]
+      # @return [Hash]
+      def self.parse(string)
+        unless string.is_a?(String)
+          raise ::Pubid::Errors::InvalidInputError,
+                ::Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if string.length > ::Pubid::MAX_INPUT_LENGTH
+          raise ::Pubid::Errors::InvalidInputError,
+                ::Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        new.parse(string.strip)
+      end
+    end
+  end
+end

data/lib/pubid/adobe/renderer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Adobe
+    # Human-readable renderer for Adobe identifiers.
+    #
+    # Produces the canonical citation forms:
+    #   "Adobe TN 5014"                       (tech note)
+    #   "Adobe Publication adobe-glyph-list"  (publication, slug)
+    #   "Adobe Publication adobe-japan1-7"    (publication, slug + version)
+    #
+    # The data repo (AdobeFetcher::Docid) overrides #to_s for publications
+    # to use the title from metadata instead of the slug, producing e.g.
+    # "Adobe Publication Adobe Glyph List". Pubid::Adobe itself is purely
+    # structural and renders slug-form citations.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **_opts)
+        id = @id
+
+        return render_tech_note(id) if id.is_a?(Identifiers::TechNote)
+        return render_publication(id) if id.is_a?(Identifiers::Publication)
+
+        raise ArgumentError, "Unknown Adobe identifier class: #{id.class}"
+      end
+
+      private
+
+      def render_tech_note(id)
+        "Adobe TN #{id.number}"
+      end
+
+      def render_publication(id)
+        rendered = "Adobe Publication #{id.slug}"
+        rendered << "-#{id.version}" if id.version
+        rendered
+      end
+    end
+  end
+end

data/lib/pubid/adobe/urn_generator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Adobe
+    # Generates URN strings for Adobe identifiers.
+    #
+    # Format:
+    #   urn:adobe:tech-note:<number>            e.g. urn:adobe:tech-note:5014
+    #   urn:adobe:publication:<slug>[:v<ver>]   e.g. urn:adobe:publication:adobe-glyph-list
+    #                                             urn:adobe:publication:adobe-japan1:v7
+    class UrnGenerator
+      attr_reader :identifier
+
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def generate
+        if identifier.is_a?(Identifiers::TechNote)
+          generate_tech_note
+        elsif identifier.is_a?(Identifiers::Publication)
+          generate_publication
+        else
+          raise ArgumentError,
+                "Unknown Adobe identifier class: #{identifier.class}"
+        end
+      end
+
+      private
+
+      def generate_tech_note
+        "urn:adobe:tech-note:#{identifier.number}"
+      end
+
+      def generate_publication
+        parts = ["urn:adobe:publication", identifier.slug]
+        parts << "v#{identifier.version}" if identifier.version
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/adobe/urn_parser.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Adobe
+    # Parses Adobe URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:adobe:tech-note:<number>
+    #   urn:adobe:publication:<slug>[:v<version>]
+    #
+    # Examples:
+    #   urn:adobe:tech-note:5014                  → Adobe Technical Note #5014
+    #   urn:adobe:publication:adobe-glyph-list    → adobe-glyph-list
+    #   urn:adobe:publication:adobe-japan1:v7     → adobe-japan1-7
+    class UrnParser < Pubid::UrnParser::Base
+      PREFIX = "urn:adobe:".freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        namespace = parts.fetch(0)
+
+        case namespace
+        when "tech-note"
+          parse_tech_note(parts)
+        when "publication"
+          parse_publication(parts)
+        else
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Unknown Adobe URN namespace: #{namespace.inspect} in #{urn.inspect}"
+        end
+      end
+
+      private
+
+      def strip_namespace(urn)
+        unless urn.downcase.start_with?(PREFIX)
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Invalid Adobe URN: #{urn.inspect}"
+        end
+
+        urn[PREFIX.length..]
+      end
+
+      def parse_tech_note(parts)
+        number = parts.fetch(1)
+        flavor_parse("Adobe Technical Note ##{number}")
+      end
+
+      def parse_publication(parts)
+        slug = parts.fetch(1)
+        version_seg = parts[2]
+        if version_seg&.start_with?("v")
+          flavor_parse("#{slug}-#{version_seg.sub(/\Av/, "")}")
+        else
+          flavor_parse(slug)
+        end
+      end
+
+      def split_parts(body)
+        body.split(":")
+      end
+
+      def flavor_parse(text)
+        ::Pubid::Adobe.parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/adobe.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Adobe
+    extend Pubid::PrefixesSupport
+
+    # Leading identifier prefix tokens that an Adobe document id can start
+    # with. Tech notes appear as both `Adobe Technical Note #<n>` and the
+    # short alias `ATN<n>` in citations; both must route to this flavor.
+    # Named publications start with `Adobe` (e.g. `Adobe Glyph List`,
+    # `Adobe-Japan1-7`).
+    PREFIXES = ["Adobe", "ATN"].freeze
+
+    autoload :Builder,      "#{__dir__}/adobe/builder"
+    autoload :Identifier,   "#{__dir__}/adobe/identifier"
+    autoload :Identifiers,  "#{__dir__}/adobe/identifiers"
+    autoload :Parser,       "#{__dir__}/adobe/parser"
+    autoload :Renderer,     "#{__dir__}/adobe/renderer"
+    autoload :UrnGenerator, "#{__dir__}/adobe/urn_generator"
+    autoload :UrnParser,    "#{__dir__}/adobe/urn_parser"
+
+    # Parse an Adobe identifier string into an identifier object.
+    # @param identifier [String]
+    # @return [Pubid::Adobe::Identifier]
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    # with the Adobe-specific renderer.
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Adobe::Renderer)
+
+    # Auto-discover identifier types from the Identifiers namespace.
+    # @return [Array<Class>]
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c < Pubid::Identifier }
+        .reject { |c| c == Identifier }
+    end
+
+    # Lookup: type key → identifier class
+    # @param code [String, Symbol]
+    # @return [Class, nil]
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: type short letter (e.g. "ATN") → identifier class
+    # @param short [String]
+    # @return [Class<Identifier>]
+    def self.identifier_klass_for_short(short)
+      @by_short ||= identifier_types.to_h { |klass| [klass.type[:short].to_s, klass] }
+      @by_short.fetch(short.to_s)
+    end
+  end
+end
+
+Pubid::Registry.register(:adobe, Pubid::Adobe)