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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc5caa9d5213f1beb15ba9b972f40a3b6acbf7440d58ca1a958d6c5537f172a2
-  data.tar.gz: d3091a1f1228ffa5fd3113c41fc0781c4150a3705586fb070acfdb24057bd9f2
+  metadata.gz: 37fab215eeedb21350f3e195a6a803d47680d35f75767d782600312cef05fa8e
+  data.tar.gz: c4542c9253678a25c5656f213ca39e12689bef778f816b70a383333c0db422d8
 SHA512:
-  metadata.gz: 6274eda8271b12eb7fc122d6125cd9c70c42351b00298b28777731f1b8fbb7d6fad98b837f5b7f686dede0b6aab5c2da36166fb44c83d25dceb394aa5314a1f5
-  data.tar.gz: 3fc1db36905ae3ae93b8de640370b428688d804c8a86c5f5e4510e292fe6cf30ae69a74caf2125a636d9ae7f67dc27859aa79975b647bb911b1373789aa62f36
+  metadata.gz: bd5901f08f8b7c4359598dc38eaa65411679884c4c860350b8b129943fa366a13dcb3f0bf91048a9922d199b364caeaf4f320cdc059898f78a5f8088364b30cd
+  data.tar.gz: ccc9c3ce79b02416dd0a0c31a8dab36fe13da7556e9812ed5d403d66bcdc1c4ecb938d766f2376148315e4c0c3590e243c1ef5c5e97488df8a526df934df3af3

data/README.adoc

@@ -6,7 +6,8 @@ image:https://github.com/relaton/relaton/actions/workflows/rake.yml/badge.svg["B
 Gem for importing and caching bibliographic references to technical standards.
 Every standards-body flavor ships inside this single gem; flavor code loads on
 demand via `autoload`, and the `Relaton::Db` API routes a reference to the right
-flavor by its prefix. The command-line interface, `relaton-cli`, is a separate gem.
+flavor by its prefix. The command-line interface,
+link:gems/relaton-cli/docs/README.adoc[`relaton-cli`], is a separate gem.
 
 == Installation
 
@@ -420,6 +421,56 @@ db.load_entry("ISO(ISO 19011)")
 => nil
 ----
 
+== Organization metadata
+
+Besides bibliographic references, Relaton exposes a lightweight store of
+standards-development-organization (SDO) metadata: an organization's names (with
+translations) and its logos. This is a separate, non-flavor concern -- it does
+not go through `Relaton::Db` -- reached through the top-level
+`Relaton.organization` method.
+
+The data (names, translations and logo variants) is served as an `index.yaml`
+manifest by the https://github.com/relaton/relaton-data-sdo[`relaton-data-sdo`]
+data repository, downloaded on first use and cached under `~/.relaton/sdo`.
+
+[source,ruby]
+----
+org = Relaton.organization("ISO")   # case-insensitive; nil if unknown
+
+# Names (relaton-db#132) -- default, or a translation by language code
+# (passed positionally or as the language: keyword)
+org.name                   # => "International Organization for Standardization"
+org.name("fr")             # => "Organisation internationale de normalisation"
+org.name(language: "fr")   # => "Organisation internationale de normalisation"
+
+# Logos (metanorma#346). A single organization can have several logo variants,
+# distinguished by style (the primary discriminator), format and size.
+# All arguments are optional; omitting one matches any value.
+org.logo_query(format: "eps", size: "700x300", style: "default")
+# => [#<Relaton::Sdo::Logo style="default" format="eps" size="700x300" url=...>, ...]
+
+org.logo_query   # => every logo variant for the organization
+
+# Fetch one logo. Returns nil if nothing matches, the sole match if one does,
+# and raises Relaton::Sdo::Error if the filter is ambiguous.
+logo = org.logo(format: "eps", style: "default")
+logo.content    # raw binary content (fetched lazily, memoized)
+logo.data_uri   # "data:application/postscript;base64,..."  -- ready to embed
+logo.save                 # write to a filename derived from the URL; returns the path
+logo.save("/tmp/iso.eps") # ...or to a custom path
+----
+
+The store is configurable -- the manifest URL, the cache directory, a swappable
+storage backend (e.g. an S3-backed object), and the cache TTL:
+
+[source,ruby]
+----
+Relaton::Sdo.configure do |config|
+  config.url         = "https://example.org/my-index.yaml"
+  config.storage_dir = "/var/cache/relaton-sdo"
+end
+----
+
 == Layout
 
 ----
@@ -430,6 +481,7 @@ lib/
     ├── version.rb       # Relaton::VERSION — the single source of truth
     ├── db.rb, db/       # Relaton::Db: registry, cache, workers pool
     ├── core/ bib/ index/ logger/   # shared infrastructure
+    ├── sdo/             # Relaton.organization: SDO org/logo store (non-flavor)
     └── iso/ iec/ ietf/ … 3gpp/     # ~29 flavor plugins
 spec/<flavor>/           # each flavor's spec suite
 grammar/                 # shared RelaxNG test schemas (test-only, not shipped)
@@ -480,6 +532,10 @@ link:lib/relaton/core/README.adoc[core],
 link:lib/relaton/index/README.adoc[index],
 link:lib/relaton/logger/README.adoc[logger].
 
+Maintaining your own dataset? See
+link:docs/data-repository-format.adoc[Relaton data repository format] for the
+repository layout, index file specification, and GitHub Pages publishing contract.
+
 
 == Development
 

data/bin/console

@@ -6,6 +6,5 @@ require "relaton"
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 
-# (If you use this, don't forget to add pry to your Gemfile!)
 require "pry"
 Pry.start

data/lib/relaton/3gpp/bibliography.rb

@@ -2,15 +2,20 @@
 
 module Relaton
   module ThreeGpp
-    # Methods for search IANA standards.
+    # Methods for search 3GPP standards.
     module Bibliography
       SOURCE = "https://raw.githubusercontent.com/relaton/relaton-data-3gpp/v2/"
 
       # @param text [String]
-      # @return [RelatonBib::BibliographicItem]
-      def search(text) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-        index = Relaton::Index.find_or_create "3GPP", url: "#{SOURCE}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml"
-        row = index.search(text.sub(/^3GPP\s/, "")).min_by { |r| r[:id] }
+      # @return [Relaton::ThreeGpp::ItemData, nil]
+      def search(text)
+        # An unrecognized reference raises; like ISO and ETSI we let it
+        # propagate — relaton-cli rescues Pubid::Errors::Error and renders
+        # "… is not a recognized standards identifier", and API callers rescue
+        # it themselves. The rescue below lists transport errors only, so it
+        # does not swallow the parse error.
+        pubid = ::Pubid::Tgpp::Identifier.parse text.to_s.strip
+        row = best_match pubid
         return unless row
 
         url = "#{SOURCE}#{row[:file]}"
@@ -26,10 +31,10 @@ module Relaton
         raise Relaton::RequestError, e.message
       end
 
-      # @param ref [String] the W3C standard Code to look up
+      # @param ref [String] the 3GPP standard Code to look up
       # @param year [String, NilClass] not used
       # @param opts [Hash] options
-      # @return [RelatonBib::BibliographicItem]
+      # @return [Relaton::ThreeGpp::ItemData, nil]
       def get(ref, _year = nil, _opts = {})
         Util.info "Fetching from Relaton repository ...", key: ref
         result = search(ref)
@@ -42,6 +47,76 @@ module Relaton
         result
       end
 
+      private
+
+      #
+      # Find the index row for a reference, newest version first.
+      #
+      # Passing the pubid to `Index::Type#search` is what enables the binary
+      # search on `id.root.number` — `Type#search_candidates` narrows only when
+      # its argument is NOT a String, so the plain text this used to pass
+      # disabled the narrowing however the index was built. With 88,464 rows in
+      # 3,767 number buckets that is the whole point of the index-v2 migration.
+      #
+      # The rows are selected with pubid's subset match `pubid === row`, the
+      # default of `Index::Type#search`. `release` and `version` are 3GPP's
+      # only optional components: when the reference omits one, it matches
+      # any value, so a bare `3GPP TS 23.207` still finds the `REL-19/19.0.0`
+      # row. pubid declares `suffix` and `parts` strict for 3GPP, because they
+      # are part of the document code (`TS 29.198-04-1`, `TR 00.01U`), not
+      # qualifiers. The document type is the identifier's class, and `===`
+      # requires the same class, so `TS 23.207` and `TR 23.207` never match.
+      #
+      # @param pubid [::Pubid::Tgpp::Identifier]
+      # @return [Hash, nil] the winning index row (`{ id:, file: }`)
+      #
+      def best_match(pubid)
+        index.search(pubid)
+             .max_by { |r| [version_key(r[:id].version), r[:id].to_s, r[:file]] }
+      end
+
+      #
+      # Order key for a 3GPP version — the highest version wins.
+      #
+      # Versions are dotted strings, so they must be compared segment by
+      # segment as integers rather than as text: `19.0.0` is newer than
+      # `4.0.0` but loses as a string. This is a deliberate behaviour change.
+      # The previous key, `min_by { r[:id] }` over raw strings, returned
+      # `REL-10/10.0.0` for `3GPP TS 23.207` — neither the newest nor the
+      # oldest of its 37 rows, just whichever sorted first as text. Scored
+      # against each document's own publication date over 870 documents in 59
+      # multi-row groups, this key picks the newest published document 51/59
+      # (86%) of the time; the old one managed 1/59 (2%).
+      #
+      # No release key is layered on top. Ranking releases numerically is wrong
+      # (the chronological order is Ph1, Ph2, REL-96 … REL-99, Release 2000,
+      # UMTS, REL-4 … REL-21, so REL-99 would outrank REL-19) and a
+      # hand-maintained 27-token table would disagree with this key on only 9
+      # of 3,982 multi-row groups — all draft TRs carried into a later release
+      # at a lower version, where the release answer is not clearly better.
+      #
+      # An absent version sorts below every present one. Ties break on the
+      # rendered id and then the file path, because the index sort is not
+      # stable.
+      #
+      # @param version [String, nil]
+      # @return [Array<Integer>]
+      #
+      def version_key(version)
+        version.to_s.split(".").map(&:to_i)
+      end
+
+      # The index is pubid-backed: `pubid_class:` is what makes Relaton::Index
+      # deserialize the rows into identifiers, sort them by `id.root.number`,
+      # and let `Type#search` bsearch. Without it the rows stay raw hashes,
+      # `FileIO#sorted` stays false, and every lookup scans all 88,464 of them.
+      def index
+        Relaton::Index.find_or_create(
+          "3GPP", url: "#{SOURCE}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml",
+          pubid_class: ::Pubid::Tgpp::Identifier
+        )
+      end
+
       extend Bibliography
     end
   end

data/lib/relaton/3gpp/data_fetcher.rb

@@ -14,8 +14,16 @@ module Relaton
         Util.error msg
       end
 
+      # The index is pubid-backed: `pubid_class:` makes Relaton::Index sort the
+      # rows by `id.root.number` on save and serialize each id to its
+      # `_type: pubid:3gpp:*` hash. Without it a v1-shaped file would be
+      # written under a v2 name, with no error and no narrowing — FileIO#save
+      # only calls `to_hash` when the value is an instance of `pubid_class`.
       def index
-        @index ||= Relaton::Index.find_or_create "3gpp", file: "#{INDEXFILE}.yaml"
+        @index ||= Relaton::Index.find_or_create(
+          "3gpp", file: "#{INDEXFILE}.yaml",
+          pubid_class: ::Pubid::Tgpp::Identifier
+        )
       end
 
       #
@@ -104,17 +112,57 @@ module Relaton
         return unless bib
 
         bib1 = bib
-        file = output_file(bib1.docnumber)
+        # A DISTINCT docnumber that sanitizes to the same filename must not be
+        # merged into the other document — give it a path of its own. Only a
+        # genuine duplicate (same docnumber, same path) still merges.
+        file = unique_output_file(bib1.docnumber)
+        # A reserved path only ever belongs to one docnumber, so a hit here is
+        # the same document again and still merges. Checked FIRST: a
+        # disambiguated path stays != output_file forever, so gating the merge
+        # on that comparison would drop the merge enrichment on every repeat of
+        # a disambiguated docnumber.
         if @files.include? file
           bib1 = merge_duplication bib1, file
           Util.warn "File #{file} already exists. Document: #{bib.docnumber}" if bib1.nil?
         else
+          if file != output_file(bib1.docnumber)
+            Util.warn "File #{output_file bib1.docnumber} already exists. " \
+                      "Document: #{bib.docnumber}. Writing #{file} instead."
+          end
           @files << file
-          index.add_or_update bib1.docnumber, file
+          index_primary bib1.docidentifier&.detect(&:primary), file
         end
         File.write file, serialize(bib1), encoding: "UTF-8" unless bib1.nil?
       end
 
+      #
+      # Add a document's primary id to the index.
+      #
+      # The pubid is already parsed on `Docidentifier`, so index it directly
+      # rather than re-parsing `docnumber`. `pubid.to_s` (no publisher token)
+      # reproduces the `docnumber` string this used to store byte-for-byte, so
+      # the index key does not move; `docnumber` still names the output file.
+      #
+      # An id pubid cannot rebuild is recorded in `@errors` — the inherited
+      # `report_errors` logs a String value as the message — and the row is
+      # skipped rather than indexed unparsed: `Relaton::Index` rejects the
+      # WHOLE index if a single row fails to deserialize, and its sort calls
+      # `.root.number` on every id. The data file is still written, so the
+      # document is unindexed, never lost. (The W3C precedent.)
+      #
+      # @param [Docidentifier, nil] docid the document's primary identifier
+      # @param [String] file path the document was written to
+      #
+      def index_primary(docid, file)
+        if docid&.pubid
+          index.add_or_update docid.pubid, file
+          return
+        end
+
+        id = docid&.content || file
+        @errors[id.to_s] = "Unparseable primary id `#{id}` was not indexed (#{file})"
+      end
+
       #
       # Merge duplication
       #

data/lib/relaton/3gpp/docidentifier.rb

@@ -0,0 +1,114 @@
+module Relaton
+  module ThreeGpp
+    # Structured 3GPP document identifier. `content` stays the canonical string
+    # (e.g. "3GPP TS 29.198-04-1:REL-5/5.0.0") and the parsed
+    # `Pubid::Tgpp::Identifier` is kept alongside it in `@pubid`.
+    #
+    # Without this subclass 3GPP items inherit `Bib::Docidentifier`, whose
+    # `remove_part!` / `remove_date!` / `to_all_parts!` all raise
+    # NotImplementedError — so `ItemData#to_all_parts` and
+    # `#to_most_recent_reference`, which broadcast to every docidentifier,
+    # raised on every 3GPP item.
+    class Docidentifier < Bib::Docidentifier
+      attr_reader :pubid
+
+      # Capture the inherited (LocalizedMarkedUpString) content setter before
+      # overriding #content=, so #refresh_content! can write the re-rendered
+      # string back WITHOUT re-parsing (a re-parse would rebuild @pubid from
+      # the string and discard the in-place mutations just made).
+      alias_method :store_content, :content=
+
+      def initialize(attrs = {}, options = {})
+        pubid = attrs.is_a?(Hash) ? attrs.delete(:pubid) : nil
+        attrs[:content] ||= render(pubid) if pubid
+        super
+        @pubid = pubid if pubid
+      end
+
+      def content=(value)
+        super
+        return unless value
+
+        @pubid = begin
+          # Rescue LoadError so a missing pubid gem degrades to a plain string,
+          # and StandardError so non-3GPP or unparseable content just leaves
+          # @pubid nil rather than raising. Deserialization reaches this setter
+          # without the flavor entry file necessarily having been loaded, hence
+          # the local require.
+          require "pubid"
+          ::Pubid::Tgpp::Identifier.parse(value.to_s)
+        rescue LoadError, StandardError
+          nil
+        end
+      end
+
+      # `Pubid::Tgpp::Identifier` models number/suffix/parts/release/version.
+      # It has no date, and `suffix` is folded into the document code, so:
+      #
+      #   * #remove_part! clears `parts` — a real, separable component here
+      #     (unlike IALA's, which is a no-op): "TS 29.198-04-1" -> "TS 29.198".
+      #   * #remove_date! clears `release` AND `version`. 3GPP carries no date;
+      #     those two are its version discriminators — the same pair
+      #     `Bibliography#ignored` treats as omittable — so clearing both gives
+      #     the version-agnostic ("most recent") reference "TS 23.207".
+      #   * #to_all_parts! does both, then wraps `@pubid` in pubid's `AllParts`.
+      #     `content` stays the plain stripped id — the Tgpp renderer has no
+      #     "(all parts)" marker, and `content` is cached from the pre-wrap
+      #     pubid on purpose. `#pubid` itself, read directly, now answers
+      #     `all_parts? == true` and renders WITH pubid's generic marker
+      #     (`#to_s`), since it's the wrapper.
+      #
+      # All three no-op safely when @pubid is nil (parse failed, or the pubid
+      # gem is unavailable), so ItemData#to_all_parts and
+      # #to_most_recent_reference never raise on 3GPP items.
+
+      def remove_part!
+        clear_attrs! :parts
+      end
+
+      def remove_date!
+        clear_attrs! :release, :version
+      end
+
+      def to_all_parts!
+        return if !@pubid || @pubid.all_parts?
+
+        # `#exclude` (no args) rebuilds a full independent copy — `remove_part!`
+        # / `remove_date!` mutate `@pubid` in place, so a bare reference here
+        # would lose the original part/version to that mutation too.
+        original = @pubid.exclude
+        remove_part!
+        remove_date!
+        @pubid = original.to_all_parts
+      end
+
+      private
+
+      def clear_attrs!(*attrs)
+        return unless @pubid
+
+        cleared = attrs.select { |attr| @pubid.respond_to?("#{attr}=") }
+        return if cleared.empty?
+
+        # `parts` is a collection: empty it rather than nil it, so #code keeps
+        # rendering through `parts.map` instead of tripping over nil.
+        cleared.each do |attr|
+          @pubid.public_send("#{attr}=", attr == :parts ? [] : nil)
+        end
+        refresh_content!
+      end
+
+      def refresh_content!
+        store_content(render(@pubid)) if @pubid
+      end
+
+      # `Pubid::Tgpp::Identifier#to_s` defaults to OMITTING the "3GPP " token —
+      # deliberately, so it reproduces the index id. The stored docidentifier
+      # content carries the prefix ("3GPP TS 23.207:REL-4/4.0.0"), so every
+      # render here must opt back in or a mutation would silently strip it.
+      def render(pubid)
+        pubid.to_s(with_publisher: true)
+      end
+    end
+  end
+end

data/lib/relaton/3gpp/item.rb

@@ -1,5 +1,6 @@
 require_relative "item_data"
 require_relative "ext"
+require_relative "docidentifier"
 
 module Relaton
   module ThreeGpp
@@ -7,6 +8,11 @@ module Relaton
       model ItemData
 
       attribute :ext, Ext
+      # Shadow the Bib::Docidentifier declaration in Bib::ItemShared so items
+      # carry the pubid-backed 3GPP identifier. Bibitem and Bibdata subclass
+      # Item, so this one declaration covers all three.
+      attribute :docidentifier, Docidentifier, collection: true,
+                                               initialize_empty: true
     end
   end
 end

data/lib/relaton/3gpp/parser.rb

@@ -94,7 +94,7 @@ module Relaton
       #
       def parse_docid
         @errors[:docid] &&= @row[0].nil? || @row[0].empty?
-        [Bib::Docidentifier.new(type: "3GPP", content: "3GPP #{number}", primary: true)]
+        [Docidentifier.new(type: "3GPP", content: "3GPP #{number}", primary: true)]
       end
 
       #

data/lib/relaton/3gpp/processor.rb

@@ -10,6 +10,7 @@ module Relaton
         @prefix = "3GPP"
         @defaultprefix = %r{^3GPP\s}
         @idtype = "3GPP"
+        @pubid_flavor = :Tgpp # global prefixes sourced from Pubid::Tgpp.prefixes
         @datasets = %w[status-smg-3GPP status-smg-3GPP-force]
       end
 
@@ -61,7 +62,9 @@ module Relaton
       #
       def remove_index_file
         require_relative "../3gpp"
-        Relaton::Index.find_or_create("3GPP", url: true, file: "#{INDEXFILE}.yaml").remove_file
+        Relaton::Index.find_or_create(
+          "3GPP", url: true, file: "#{INDEXFILE}.yaml"
+        ).remove_file
       end
     end
   end

data/lib/relaton/3gpp.rb

@@ -1,4 +1,8 @@
 require "net/http"
+# pubid loads with the flavor, for the ::Pubid::Tgpp::Identifier that the
+# index code names. Processor#remove_index_file names no pubid class: the
+# delete never reads the index (see lib/relaton/index/CLAUDE.md).
+require "pubid"
 require "relaton/index"
 require "relaton/core"
 require "relaton/bib"
@@ -11,7 +15,7 @@ require_relative "3gpp/bibliography"
 
 module Relaton
   module ThreeGpp
-    INDEXFILE = "index-v1".freeze
+    INDEXFILE = "index-v2".freeze
 
     # Returns hash of XML reammar
     # @return [String]

data/lib/relaton/adobe/bibdata.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Adobe
+    class Bibdata < Item
+      model ItemData
+      include Bib::BibdataShared
+    end
+  end
+end

data/lib/relaton/adobe/bibitem.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Adobe
+    class Bibitem < Item
+      model ItemData
+      include Bib::BibitemShared
+    end
+  end
+end

data/lib/relaton/adobe/bibliography.rb

@@ -0,0 +1,92 @@
+require "net/http"
+
+module Relaton
+  module Adobe
+    # Retrieval front-end for the Adobe flavor. Parses a reference with
+    # Pubid::Adobe, looks it up in the `relaton-data-adobe` index, fetches the
+    # matching YAML record, and deserializes it into a Relaton::Adobe::Item.
+    # Modelled on Relaton::Oiml::Bibliography (pubid-backed, index via
+    # `pubid_class`); adapted because Adobe identifiers carry no edition
+    # year/language, so there is no per-edition selection — each reference maps
+    # to a single record.
+    module Bibliography
+      ENDPOINT = "https://raw.githubusercontent.com/relaton/relaton-data-adobe/main/".freeze
+
+      class << self
+        # Search for an Adobe publication by its identifier.
+        #
+        # @param text [String, Pubid::Adobe::Identifier] the Adobe reference to
+        #   look up (e.g. "Adobe Technical Note #5014", "ATN5014",
+        #   "Adobe Publication adobe-glyph-list")
+        # @param _year [String, nil] unused (Adobe ids carry no edition year)
+        # @param _opts [Hash] options (unused)
+        # @return [Relaton::Adobe::Item, nil]
+        def search(text, _year = nil, _opts = {})
+          pubid = pubid_for(text) or return
+          Util.info "Fetching from Relaton repository ...", key: pubid.to_s
+          # Tech notes narrow by number via binary search; publications have no
+          # number, so pass nil to scan (Relaton::Index::Type#search returns all
+          # rows for a nil id, then applies the block).
+          query = pubid.root.number ? pubid : nil
+          row = index.search(query) { |r| pubid_match?(r[:id], pubid) }.first
+          unless row
+            Util.info "Not found.", key: pubid.to_s
+            return
+          end
+
+          uri = URI("#{ENDPOINT}#{row[:file]}")
+          resp = Net::HTTP.get_response uri
+          unless resp.code == "200"
+            raise Relaton::RequestError, "Could not access #{uri}: HTTP #{resp.code}"
+          end
+
+          item = Relaton::Adobe::Item.from_yaml resp.body
+          Util.info "Found: `#{item.docidentifier.first&.content}`", key: pubid.to_s
+          item.tap { |i| i.fetched = Date.today.to_s }
+        rescue SocketError, Errno::EINVAL, Errno::ECONNRESET, EOFError,
+               Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+               Net::ProtocolError, Net::ReadTimeout, OpenSSL::SSL::SSLError,
+               Errno::ETIMEDOUT => e
+          raise Relaton::RequestError, "Could not access #{uri}: #{e.message}"
+        end
+
+        def get(ref, year = nil, opts = {})
+          search(ref, year, opts)
+        end
+
+        private
+
+        # Coerce a reference to a Pubid::Adobe identifier. A non-canonical or
+        # non-Adobe string (e.g. a title-cased "Adobe Glyph List") is a graceful
+        # miss (logged, returns nil) rather than a raised Parslet error — the
+        # ref reached here only because it matched the flavor's prefix regex.
+        def pubid_for(text)
+          return text unless text.is_a?(String)
+
+          ::Pubid::Adobe.parse(text)
+        rescue StandardError
+          Util.info "Not found.", key: text
+          nil
+        end
+
+        def index
+          Relaton::Index.find_or_create(
+            :adobe,
+            url: "#{ENDPOINT}#{INDEXFILE}.zip",
+            file: "#{INDEXFILE}.yaml",
+            pubid_class: ::Pubid::Adobe::Identifier,
+          )
+        end
+
+        # Identity match on the human render: pubid renders a tech note as
+        # `Adobe TN <n>` (dropping the filename slug, so `ATN5014` and
+        # `Adobe Technical Note #5014` both match a record stored with its slug)
+        # and a publication as `Adobe Publication <slug>` including its version.
+        # Both `row_id` and `query` are Pubid::Adobe identifiers.
+        def pubid_match?(row_id, query)
+          row_id.to_s == query.to_s
+        end
+      end
+    end
+  end
+end

data/lib/relaton/adobe/docidentifier.rb

@@ -0,0 +1,49 @@
+module Relaton
+  module Adobe
+    # Structured Adobe document identifier. The docid string is the canonical
+    # form (e.g. "Adobe TN 5014", "Adobe Publication adobe-glyph-list"); its
+    # `content` is soft-parsed into a Pubid::Adobe identifier kept in `@pubid`
+    # (a TechNote or Publication), mirroring Relaton::Oiml::Docidentifier.
+    #
+    # Parsing is soft: a non-Adobe or non-canonical string (e.g. a title-cased
+    # "Adobe Glyph List") leaves `@pubid` nil rather than raising, so the plain
+    # `content` string still round-trips.
+    class Docidentifier < Bib::Docidentifier
+      attr_reader :pubid
+
+      def initialize(attrs = {}, options = {})
+        pubid = attrs.is_a?(Hash) ? attrs.delete(:pubid) : nil
+        attrs[:content] ||= pubid.to_s if pubid
+        super
+        @pubid = pubid if pubid
+      end
+
+      def content=(value)
+        super
+        @pubid = ::Pubid::Adobe.parse(value) if value
+      rescue StandardError
+        @pubid = nil
+      end
+
+      # Adobe identifiers carry no part/date/all-parts component, so the base
+      # class's abstract mutation hooks (which otherwise raise NotImplementedError)
+      # are implemented as safe no-ops over the wrapped pubid: they keep
+      # `Bib::ItemData#to_most_recent_reference` / `#to_all_parts` from raising on
+      # Adobe items, and never change the rendered `content`.
+      def remove_part!
+        @pubid&.part = nil
+      end
+
+      def remove_date!
+        return unless @pubid
+
+        @pubid.date = nil
+        self.content = @pubid.to_s
+      end
+
+      def to_all_parts!
+        @pubid &&= @pubid.to_all_parts
+      end
+    end
+  end
+end

data/lib/relaton/adobe/doctype.rb

@@ -0,0 +1,14 @@
+module Relaton
+  module Adobe
+    # Adobe publication document types. The value is carried in the
+    # inherited `content` attribute (e.g. `tech-note`, `publication`).
+    # The list mirrors the categories Adobe publishes through this
+    # dataset (font tech notes and named publications).
+    class Doctype < Bib::Doctype
+      TYPES = %w[
+        tech-note
+        publication
+      ].freeze
+    end
+  end
+end