relaton 3.0.1 → 3.0.3

data/lib/relaton/ietf/scraper.rb

@@ -2,6 +2,7 @@
 
 require "pubid"
 require "pubid/ietf"
+require_relative "bibxml_parser"
 
 module Relaton
   module Ietf
@@ -15,6 +16,13 @@ module Relaton
       # publishing their `index-v1` for released relatons, untouched.
       IETF = "https://raw.githubusercontent.com/relaton/relaton-data-ietf/main/"
 
+      # The IETF bibxml service, read when the index has no row for a versioned
+      # Internet-Draft (relaton-ietf#125). The data repo crawls the rsync
+      # `bibxml-ids` snapshot, which keeps only some versions of each draft
+      # (`draft-ietf-vcarddav-vcardrev`: only -22); this service resolves any
+      # version the datatracker knows, and answers 404 for one it does not.
+      BIBXML_IDS = "https://bib.ietf.org/public/rfc/bibxml-ids/"
+
       # @param ref [String, Pubid::Ietf::Identifier] a reference, or its parse
       #   from Relaton::Db (relaton#205), which is used as it is
       # @return [Relaton::Ietf::ItemData, nil]
@@ -24,8 +32,9 @@ module Relaton
 
         fetch_doc id
       rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
-             Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
-             Net::ProtocolError, SocketError
+             Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH,
+             OpenSSL::SSL::SSLError, Net::HTTPBadResponse,
+             Net::HTTPHeaderSyntaxError, Net::ProtocolError, SocketError
         raise Relaton::RequestError, "No document found for #{ref} reference"
       end
 
@@ -44,7 +53,55 @@ module Relaton
       # such pairs in the first 40k rows of the index fixture).
       def fetch_doc(id)
         row = index.search(id, exact: true).first
-        get_page "#{IETF}#{row[:file]}" if row
+        return get_page "#{IETF}#{row[:file]}" if row
+
+        fetch_bibxml id if versioned_draft? id
+      end
+
+      # Only a versioned draft falls back. The index holds every RFC, sub-series
+      # and unversioned draft aggregator the data repo has, so a miss on one of
+      # those is a real "not found", and bib.ietf.org has no aggregator to offer.
+      def versioned_draft?(id)
+        id.is_a?(::Pubid::Ietf::Identifiers::InternetDraft) && !id.version.to_s.empty?
+      end
+
+      #
+      # Read one draft version from bib.ietf.org and parse it the way
+      # `DataFetcher#process_singleton` parses a crawled file: the same
+      # CP1252 repair, the same parser, and the version from the identifier.
+      #
+      # A 404 is the service's "no such version". Any other non-200 (a 429, a
+      # 5xx) is push-back or an outage, so it raises `Relaton::RequestError`:
+      # `Db#net_retry` then retries it, and the Db cache does not store it as a
+      # not-found.
+      #
+      # @param id [Pubid::Ietf::Identifiers::InternetDraft]
+      # @return [Relaton::Ietf::ItemData, nil] nil on a 404 or an unreadable body
+      #
+      def fetch_bibxml(id)
+        res = Net::HTTP.get_response URI("#{BIBXML_IDS}reference.I-D.#{id}.xml")
+        return if res.code == "404"
+        raise Relaton::RequestError, "#{BIBXML_IDS} answered #{res.code} for #{id}" unless res.code == "200"
+
+        bib = parse_bibxml(res.body, id)
+        return unless bib
+
+        bib.version = [Bib::Version.new(draft: id.version.to_s)]
+        bib.fetched = Date.today.to_s
+        bib
+      end
+
+      # A 200 that is not bibxml (an HTML error page, a truncated body) costs
+      # this one document, not the caller's compile. These are the errors the
+      # parse raises on such a body: lutaml's `InvalidFormatError`, and the
+      # converter's `NoMethodError` on a document with no `<front>` and
+      # `ArgumentError` from its regexes. They are named, not `StandardError`,
+      # so a transport error still reaches `scrape_page`'s rescue.
+      def parse_bibxml(body, id)
+        BibXMLParser.parse BibXMLParser.to_utf8(body)
+      rescue Lutaml::Model::InvalidFormatError, NoMethodError, ArgumentError => e
+        Util.warn "Unreadable bibxml for `#{id}`: #{e.message.to_s.lines.first.to_s.strip}"
+        nil
       end
 
       #

data/lib/relaton/ietf/wg_name_resolver.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "json"
+
 require "net/http"
 
 module Relaton
@@ -20,7 +20,7 @@ module Relaton
           response = Net::HTTP.get_response(uri)
           break unless response.is_a?(Net::HTTPSuccess)
 
-          data = JSON.parse(response.body)
+          data = Relaton::Json.parse_external(response.body)
           objects = data["objects"] || []
           break if objects.empty?
 

data/lib/relaton/iho/CLAUDE.md

@@ -55,6 +55,10 @@ In `item.rb`, `require_relative "relation"` is placed **after** the `Item` class
 
 `Bibliography.search`/`.get` fetches YAML from the relaton-data-iho GitHub repo via `Relaton::Index`, then deserializes into model objects.
 
+**Editions.** The pubid `version` is the edition (`IHO B-12 3.0.0`; the grammar takes `a.b.c` only). A reference with no version answers with the **latest** edition: `version_key` compares the segments as integers (`2.10.0` after `2.9.0`). It used to be `min_by` on the string, which returned the oldest.
+
+**The edition reaches the index only through the committed row.** A record prints `B-12` and keeps its edition in `edition:`, so `relaton index` cannot read a version from the docid. `MachineIndex#refine` (relaton-cli) takes the committed `index-v3.yaml` row when it adds only a `version` to the parse. Before that, the Pages index (generated 2026-10-29) had no `version` in any of its 325 rows, so every versioned reference answered not-found (relaton-data-iho#20). The suite did not see it: `spec/fixtures/index-v3.zip` is the committed index, which has versions.
+
 ### Test Infrastructure
 
 - **VCR cassettes** (`spec/vcr_cassettes/`): recorded HTTP responses for offline testing

data/lib/relaton/iho/bibliography.rb

@@ -21,7 +21,7 @@ module Relaton
           # Pubid::Iho::Identifiers::* (Relaton::Index deserialized it via the
           # `pubid_class` passed in `#index`), so `pubid_match?` compares pubids.
           row = index.search(pubid) { |r| pubid_match?(r[:id], pubid) }
-                     .min_by { |r| r[:id].version.to_s }
+                     .max_by { |r| version_key(r[:id]) }
           unless row
             Util.info "Not found.", key: pubid.to_s
             return
@@ -96,6 +96,12 @@ module Relaton
           )
         end
 
+        # The sort key for the latest edition: segments compare as integers,
+        # so 2.10.0 is later than 2.9.0. A row with no version is the oldest.
+        def version_key(id)
+          id.version.to_s.split(".").map(&:to_i)
+        end
+
         # Both `row_id` and `query` are Pubid::Iho::Identifiers::* instances.
         # Class identity pins the series (S/P/M/B/C). Subdivision keys
         # (part/appendix/annex/supplement) use strict equality — a nil query

data/lib/relaton/index/dataset_lock.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
+require "yeptris"
+
 require "digest"
-require "json"
 require "net/http"
 require "time"
 require "uri"
@@ -91,8 +92,8 @@ module Relaton
         end
         raise Error, "cannot fetch #{uri}: HTTP #{res.code}" unless res.code == "200"
 
-        JSON.parse(res.body)
-      rescue JSON::ParserError => e
+        Yeptris::JSON.load(res.body)
+      rescue Yeptris::JSON::ParseError => e
         raise Error, "malformed manifest at #{uri}: #{e.message}"
       end
 

data/lib/relaton/index/shard_source.rb

@@ -1,3 +1,4 @@
+require "yeptris"
 require "json"
 require "net/http"
 require "openssl"
@@ -174,8 +175,8 @@ module Relaton
       end
 
       def parse_json(body, path)
-        JSON.parse(body)
-      rescue JSON::ParserError => e
+        Yeptris::JSON.load(body)
+      rescue Yeptris::JSON::ParseError => e
         raise Error, "cannot parse `#{url(path)}`: #{e.message}"
       end
 

data/lib/relaton/index/sqlite_backend.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "yeptris"
+
 require "sqlite3"
 
 module Relaton
@@ -34,7 +36,7 @@ module Relaton
         @db.transaction do
           @db.execute("DELETE FROM index_rows")
           @db.prepare("INSERT INTO index_rows (number, sort_key, id_json, file) VALUES (?, ?, ?, ?)") do |stmt|
-            rows_enum.each { |(number, sort_key, id_hash, file)| stmt.execute(number, sort_key, JSON.generate(id_hash), file) }
+            rows_enum.each { |(number, sort_key, id_hash, file)| stmt.execute(number, sort_key, Yeptris::JSON.dump(id_hash), file) }
           end
           meta_set("schema_version", SCHEMA_VERSION)
         end
@@ -44,14 +46,14 @@ module Relaton
       def bucket(number)
         rows = []
         @db.execute("SELECT id_json, file FROM index_rows WHERE number = ? ORDER BY rowid", [number]) do |row|
-          rows << { id: JSON.parse(row[0]), file: row[1] }
+          rows << { id: Yeptris::JSON.load(row[0]), file: row[1] }
         end
         rows
       end
 
       def each_row
         @db.execute("SELECT id_json, file FROM index_rows ORDER BY rowid") do |row|
-          yield({ id: JSON.parse(row[0]), file: row[1] })
+          yield({ id: Yeptris::JSON.load(row[0]), file: row[1] })
         end
       end
 

data/lib/relaton/isbn/open_library.rb

@@ -1,3 +1,4 @@
+require "yeptris"
 module Relaton
   module Isbn
     #
@@ -37,7 +38,7 @@ module Relaton
         response = Net::HTTP.get_response uri
         return unless response.is_a? Net::HTTPSuccess
 
-        data = JSON.parse response.body
+        data = Relaton::Json.parse_external response.body
         return unless data["records"]&.any?
 
         data["records"].first.last

data/lib/relaton/iso/data_fetcher.rb

@@ -1,5 +1,5 @@
+require "yeptris"
 require "fileutils"
-require "json"
 require "net/http"
 require "tmpdir"
 require_relative "../iso"
@@ -168,7 +168,7 @@ module Relaton
         amend_map = Hash.new { |h, k| h[k] = [] }
         date_map = {}
         File.foreach(path, encoding: "UTF-8") do |line|
-          rec = JSON.parse(line)
+          rec = Relaton::Json.parse_external(line)
           id = rec["id"]
           ref = normalize_reference(rec["reference"])
           next unless ref
@@ -179,7 +179,7 @@ module Relaton
           if rec["supplementType"] && (base = amend_base(ref))
             amend_map[base] << ref
           end
-        rescue JSON::ParserError
+        rescue ::JSON::ParserError
           next
         end
         Util.info "Indexed #{ref_map.size} references; " \
@@ -216,11 +216,11 @@ module Relaton
         path = download_tc_dataset
         map = {}
         File.foreach(path, encoding: "UTF-8") do |line|
-          rec = JSON.parse(line)
+          rec = Relaton::Json.parse_external(line)
           ref = rec["reference"]
           title = rec["title"]
           map[ref] = title if ref && title.is_a?(Hash)
-        rescue JSON::ParserError
+        rescue ::JSON::ParserError
           next
         end
         Util.info "Indexed #{map.size} committees."
@@ -231,7 +231,7 @@ module Relaton
         Util.info "Parsing records..."
         count = 0
         File.foreach(path, encoding: "UTF-8") do |line|
-          rec = JSON.parse(line)
+          rec = Relaton::Json.parse_external(line)
           next unless ingestable?(rec["reference"])
 
           fetch_pub(rec, ref_index, tc_index, amend_index, date_index)

data/lib/relaton/iso/model/docidentifier.rb

@@ -64,10 +64,6 @@ module Relaton
         original_content
       end
 
-      def to_s
-        content.to_s
-      end
-
       # `remove_part!`/`remove_date!` are unnecessary here: `to_all_parts`'s
       # own identity computation already excludes part/date (down the whole
       # base chain, so a supplement's own year is dropped too — a disclosed

data/lib/relaton/itu/data_fetcher.rb

@@ -1,5 +1,5 @@
+require "yeptris"
 require "net/http"
-require "json"
 require "uri"
 require "mechanize"
 require_relative "../itu"
@@ -542,7 +542,7 @@ module Relaton
         request["User-Agent"] = USER_AGENT
 
         response = http.request(request)
-        json = JSON.parse(response.body)
+        json = Relaton::Json.parse_external(response.body)
         json["Data"] || []
       end
     end

data/lib/relaton/itu/hit_collection.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
+
 require "cgi"
-require "json"
 require_relative "hit"
 
 module Relaton
@@ -239,8 +239,8 @@ module Relaton
       # @return [Array<Hash>] editions of the recommendation
       def editions(idrec)
         # a `null` body parses to nil, so `|| []` is not redundant
-        JSON.parse(agent.get(format(RECEDITIONS_URL, idrec: idrec)).body) || []
-      rescue JSON::ParserError
+        Relaton::Json.parse_external(agent.get(format(RECEDITIONS_URL, idrec: idrec)).body) || []
+      rescue ::JSON::ParserError
         []
       end
 

data/lib/relaton/itu/recommendation_fields.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "json"
+
 require_relative "family_cache"
 
 module Relaton
@@ -251,7 +251,7 @@ module Relaton
       end
 
       def get_data(url)
-        JSON.parse request_document(url).body
+        Relaton::Json.parse_external request_document(url).body
       end
 
       def request_document(url)

data/lib/relaton/jis/data_fetcher.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+
 require_relative "../jis"
 require_relative "scraper"
 
@@ -92,7 +93,7 @@ module Relaton
         body = { record: 0, dantai: "JIS", searchtype2: 1,
                  status_1: 1, status_2: 2 } # rubocop:disable Naming/VariableNumber
         resp = agent.post "#{URL}W11M0270/index", body
-        disp = JSON.parse resp.body
+        disp = Relaton::Json.parse_external resp.body
         @initial_time = Time.now
         disp["status"] || Util.warn("No results found for JIS")
       end

data/lib/relaton/json.rb

@@ -0,0 +1,21 @@
+require "yeptris"
+
+module Relaton
+  # JSON at the system boundary — data we do not control. Everything we
+  # generate or own (index manifests, shards, the db cache, request bodies,
+  # the schema-version table) parses with Yeptris::JSON's default strict
+  # surface.
+  module Json
+    module_function
+
+    # Third-party feeds carry duplicate keys in the wild (Crossref book
+    # records keyed by ISBN, NIST's scraped pubs export keyed by "&nbsp",
+    # the UN search API's blank keys, CCSDS's embedded config); parsing them
+    # the historical way is last-wins. yeptris 0.6.51 carries the boundary
+    # opt-out (yeptris-ruby#335/#339), so the whole stack stays on yeptris —
+    # no stdlib fallback anywhere.
+    def parse_external(source)
+      ::Yeptris::JSON.load(source, allow_duplicate_key: true)
+    end
+  end
+end

data/lib/relaton/logger/channels/gh_issue.rb

@@ -1,5 +1,5 @@
+require "yeptris"
 require "net/http"
-require "json"
 
 module Relaton
   module Logger
@@ -70,7 +70,7 @@ module Relaton
           responce = get(uri)
           return nil unless responce.code.to_i == 200
 
-          items = JSON.parse(responce.body)["items"] || []
+          items = Yeptris::JSON.load(responce.body)["items"] || []
           items.find { |i| i["title"] == @title }&.fetch("number", nil)
         rescue StandardError => e
           puts "Failed to search for an open `#{@title}` issue: #{e.message}"
@@ -88,7 +88,7 @@ module Relaton
           http.use_ssl = true
 
           request = Net::HTTP::Post.new(uri.request_uri, headers)
-          request.body = body.to_json
+          request.body = Yeptris::JSON.dump(body)
 
           http.request(request)
         end

data/lib/relaton/logger/formatter_json.rb

@@ -1,8 +1,9 @@
+require "yeptris"
 module Relaton::Logger
   class FormatterJSON < ::Logger::Formatter
     def call(severity, _datetime, progname, msg, **args)
       hash = { prog: progname, message: msg, severity: severity }.merge(args)
-      "#{hash.to_json}\n"
+      Yeptris::JSON.dump(hash) + "\n"
     end
   end
 end

data/lib/relaton/nist/CLAUDE.md

@@ -64,6 +64,8 @@ All data models inherit from `Lutaml::Model::Serializable` and use declarative a
   - **Per-record resilience (mirrors the ISO flavor).** A single bad record must never abort the crawl. `#write_file` skips (never `id.content`-crashes on) a record whose MODS entry yields **no docidentifier** (e.g. a DOI stored only in `<identifier type="doi">`, which `ModsParser#parse_doi` doesn't read), and records ids that `#pubid` can't parse (new series like `NIST RB`/`NIST CHIPS`) as "not indexed" — the YAML is still written, only the index-v2 entry is skipped. Both classes accumulate in `#failures`; the `#report_errors` override emits each at `:error` (via `#log_error` → `Util.error`), which the shared `Core::DataFetcher` gh_issue machinery turns into one "Error fetching documents" GitHub issue in CI (`GITHUB_REPOSITORY` + `GITHUB_TOKEN`). `#pubid` no longer warns per-failure; reporting is centralized in `#report_errors`.
   - **Draft-stage rows come from CSRC (relaton#313).** The MODS collection has no draft records, so `#fetch_csrc` adds the CSRC pubs-export feed (`PubsExport.instance.data`) after the MODS pass. It builds each row **exactly as the runtime builds a CSRC hit** — `HitCollection#hit_data` (which calls `#pubs_export_id`) → `Scraper.parse_page` — so the crawled id and the live id are one string, with the stage, revision and update from the row's uri and DOI (`NIST FIPS 197/Upd1 ipd`, `NIST SP 800-108r1 ipd`, `NIST SP 1800-12 2pd`). Only a row whose id carries a **stage** is written; finals come from MODS, so a CSRC row never shadows a base document. On the 914-row fixture feed this writes 302 staged records. Don't go back to a hand-built `"NIST #{series} #{docnumber} #{stage}"` id: it dropped the numbered drafts (`2pd`…), the `/UpdN`, and spelled revisions `Rev. 1`. A stage that CSRC does not list (e.g. `NIST FIPS 197 fpd`) still answers through the consumer's #303 family fallback. Three more rules: `#csrc_bib` clears the `fetched` date the runtime stamps, or every draft changes each day and `Core#force_write` rewrites ~300 files per incremental crawl; CSRC lists a republished draft twice (`…/ipd` and `…/ipd-(1)`, one DOI, so one id), so each id is written once and the plain uri wins; and only the build step is rescued (to a `#failures` entry) — a write error stops the crawl, as in the MODS pass. `#pubs_export_id` must not mutate its row (`sub`, not `sub!`): the crawler and the runtime share the `PubsExport` data.
   - **A CSRC relation names the related document (relaton#314).** `Scraper#related_id` finds the related feed row by its uri and derives its id with `HitCollection.pubs_export_id` (the class method the instance method delegates to). The entry's own `docidentifier` drops the update and the part, and the hit's code is the record's own id, so neither is the related id. `HitCollection#search_filter` ends in an `ensure` that returns `arr`: every branch must set `arr`, because an earlier `return` is overridden there.
+  - **CSWP comes from CSRC, not the NIST Library (relaton-nist#104).** The NIST Library announced CSWP data, but its MODS release (`allrecords-MODS.xml`, and the MARC `allrecords.xml`) holds **no** CSWP record — 0 on the Sept2026 release. It publishes CSWPs only as RIS/BibTeX files under `bib/` on its `nist-pages` branch. So the index has only the CSRC draft CSWP rows (`#fetch_csrc`), and a final CSWP answers from CSRC at runtime: `HitCollection#search` asks the CSRC feed (`from_json`) and asks the index (`from_ga`) only when CSRC gives no hit. That is the chosen rule — CSRC wins, no merge — because CSRC lists every numbered CSWP with more metadata (affiliations, status, supersedes, comment period). `hit_collection_spec.rb` pins the CSRC answer.
+  - **Legacy dated CSWP ids and CSWP translations come from a static table (relaton#406).** CSRC lists neither the ~30 **legacy dated ids** (`NIST CSWP 01142020`, the same paper as `CSWP 9`, from before NIST numbered the series) nor the translations (`NIST.CSWP.6.spa`). `cswp.yaml` holds both, built once from the 84 RIS files (header of the file says how), and `Cswp` reads it. `Bibliography.get` asks `Cswp.lookup` **first** — the parenthetical-date regex after it would strip `(spa)`. A legacy id fetches the numbered id through the normal CSRC path and adds the dated id as a non-primary docidentifier (`06222021-draft` → the CSRC `CSWP 19 ipd`); a translation, dated or numbered, answers an offline record from the table (`NIST CSWP 6(spa)`, the RIS title/authors/year/DOI, `language`/`script` from `Cswp::LANGUAGES`, a `translatedFrom` relation to the original). `normalize` reads `NIST CSWP 6 spa`, `NIST CSWP 6(spa)` and `NIST.CSWP.6.spa` as one key. `Processor#cache_pubid` returns nil (so `Db` hands `get` the String and does not cache) for **every legacy id** and for a translation that pubid does not render back. A legacy answer is the numbered record plus the dated id, and `Db` would store it under the numbered id's row, so a later `NIST CSWP 9` would carry `NIST CSWP 01142020`. pubid reads `04162018ar` as `04162018a`, `6 spa` as `6(spa)`, and fails on `04162018bg`/`02122014pl`. A translation answers only for its own RIS year. Not mapped, on purpose: `02042022-1`…`-5` have no SN and share the title "Cybersecurity White Paper: EO Response", so they still answer not-found. The CSRC `ipd` rows of `27`/`29`/`32` already answer, so the table leaves out their RIS files. A new translation means a new table row.
   - **`#write_file` serializes before it indexes**, so a record that fails to serialize leaves no index row naming a file that was never written. That is how a `Bib::Date` in `Scraper.fetch_dates` hid: `Nist::ItemData` takes `Nist::Date`, and YAML serialization rejects the parent class (the same strictness as the docidentifier note below).
 - `ModsParser` — maps MODS XML (via `loc_mods`) to `ItemData`
 - `Scraper` — fetches items from GitHub YAML or CSRC JSON
@@ -118,6 +120,11 @@ NIST-specific gotchas (why this isn't a straight copy of IEC/CCSDS):
   `@raw_content` before wrapping `@pubid` in pubid's `AllParts` — matching
   IEC/CCSDS. `#pubid` itself, read directly, now answers `all_parts? ==
   true` and renders WITH pubid's generic "(all parts)" marker.
+- **The internal form drops `NIST `/`NBS `** (relaton#49), so
+  `docid.to_s(form: :internal)` is `SP 800-113` for `NIST SP 800-113`. The rule
+  is the `"NIST"` row of `Bib::Docidentifier::FORM_PUBID`: `@pubid`
+  renders with `to_s(with_publisher: false)`. A DOI docid has type `DOI` and is
+  unchanged. `to_s` itself is inherited from `Bib::Docidentifier`.
 
 ### Serialization Round-Trip Pattern
 

data/lib/relaton/nist/bibliography.rb

@@ -39,6 +39,9 @@ module Relaton
           # read back as its printed form; the pubid itself is not changed.
           ref = ref.to_s unless ref.is_a?(String)
           return fetch_ref_err(ref, year, []) if ref.match?(/\sEP$/)
+          # Before the parsing below, which reads "(spa)" as a date.
+          cswp = Cswp.lookup(ref)
+          return cswp_get(ref, cswp, year, opts) if cswp
 
           /^(?<code2>[^(]+)(?:\((?<date2>\w+\s(?:\d{2},\s)?\d{4})\))?\s?\(?(?:(?<=\()(?<stage>(?:I|F|\d)PD))?/ =~ ref
           stage ||= /(?<=\.)PD-\w+(?=\.)/.match(ref)&.to_s
@@ -62,6 +65,34 @@ module Relaton
 
         private
 
+        #
+        # Get a CSWP that CSRC does not list (relaton#406). A legacy dated id
+        # answers the numbered CSRC record, with the dated id as an extra
+        # docidentifier; a translation answers its record from the RIS table.
+        #
+        # @param ref [String] reference
+        # @param cswp [Array] the Cswp.lookup result
+        # @param year [String, nil] year
+        # @param opts [Hash] options
+        #
+        # @return [Relaton::Nist::ItemData, nil] bibliographic item
+        #
+        def cswp_get(ref, cswp, year, opts)
+          type, id, dated = cswp
+          if type == :translation
+            return fetch_ref_err(ref, year, [id[:year]]) if year && year.to_s != id[:year]
+
+            item = Cswp.translation_item(id)
+            Util.info "Found: `#{item.docidentifier.first.content}`", key: ref
+            return item
+          end
+
+          Util.info "Legacy dated CSWP id, fetching `#{id}`", key: ref
+          item = nistbib_get(id, year, opts)
+          item&.docidentifier&.<< Docidentifier.new(content: dated, type: "NIST")
+          item
+        end
+
         #
         # Get NIST document by reference
         #

data/lib/relaton/nist/cswp.rb

@@ -0,0 +1,137 @@
+require "yaml"
+
+module Relaton
+  module Nist
+    #
+    # CSWP ids the CSRC pubs-export feed does not list (relaton#406): the
+    # legacy dated ids from before the series was numbered, and the
+    # translations. The table (`cswp.yaml`) is built from the NIST Library RIS
+    # files; see the header of that file.
+    #
+    # This file loads no flavor model at require time, so the processor can
+    # ask #lookup on the cold path. #translation_item needs the models.
+    #
+    module Cswp
+      # ISO 639-2 code of a translation => [ISO 639-1 code, ISO 15924 script]
+      LANGUAGES = {
+        "ara" => %w[ar Arab], "bul" => %w[bg Cyrl], "fre" => %w[fr Latn],
+        "gre" => %w[el Grek], "ind" => %w[id Latn], "jpn" => %w[ja Jpan],
+        "kor" => %w[ko Kore], "may" => %w[ms Latn], "nor" => %w[no Latn],
+        "pol" => %w[pl Latn], "por" => %w[pt Latn], "spa" => %w[es Latn],
+        "ukr" => %w[uk Cyrl]
+      }.freeze
+
+      class << self
+        # @return [Hash] the table as written in cswp.yaml
+        def table
+          @table ||= YAML.load_file File.expand_path("cswp.yaml", __dir__)
+        end
+
+        #
+        # The comparable form of a CSWP reference: no publisher, the
+        # separators (".", "(...)") read as spaces, upper case.
+        # "NIST CSWP 6(spa)", "NIST.CSWP.6.spa" and "NIST CSWP 6 spa" all
+        # give "CSWP 6 SPA".
+        #
+        # @param ref [String]
+        # @return [String]
+        def normalize(ref)
+          ref.to_s.sub(/\ANIST[.\s]+/i, "").gsub(/[().]/, " ").squeeze(" ").strip.upcase
+        end
+
+        #
+        # Find a reference in the table.
+        #
+        # @param ref [String]
+        # @return [Array, nil] `[:legacy, numbered id, dated id]` for a
+        #   legacy id of an English CSWP, `[:translation, entry]` for a
+        #   translation (dated or numbered), nil otherwise
+        def lookup(ref)
+          key = normalize ref
+          return unless key.start_with? "CSWP "
+
+          key = key.delete_prefix "CSWP "
+          dated, target = legacy[key]
+          entry = translations[(target || key).upcase]
+          return [:translation, entry] if entry
+
+          [:legacy, "NIST CSWP #{target}", "NIST CSWP #{dated}"] if target
+        end
+
+        #
+        # Build the record of a translation from its RIS fields.
+        #
+        # @param entry [Hash] a translation entry from #lookup
+        # @return [Relaton::Nist::ItemData]
+        def translation_item(entry) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          number, lang_code = entry[:id].split
+          language, script = LANGUAGES.fetch lang_code
+          id = "NIST CSWP #{number}(#{lang_code})"
+          ItemData.new(
+            type: "standard",
+            docidentifier: [
+              Docidentifier.new(content: id, type: "NIST", primary: true),
+              Docidentifier.new(content: entry[:doi].split("/").last, type: "DOI"),
+            ],
+            title: [Bib::Title.new(content: entry[:title], language: "en", script: "Latn")],
+            source: [Bib::Uri.new(type: "doi", content: "https://doi.org/#{entry[:doi]}")],
+            date: [Date.new(type: "published", at: entry[:year])],
+            contributor: entry[:authors].map { |name| author name } << publisher,
+            language: [language],
+            script: [script],
+            relation: [original_relation("NIST CSWP #{number}")],
+            place: [Bib::Place.new(city: "Gaithersburg", region: [Bib::Place::RegionType.new(iso: "MD")])],
+            ext: Ext.new(doctype: Doctype.new(content: "standard"), flavor: "nist"),
+          )
+        end
+
+        private
+
+        # dated id (upper case) => [dated id, numbered id]
+        def legacy
+          @legacy ||= table["legacy"].to_h { |dated, numbered| [dated.upcase, [dated, numbered]] }
+        end
+
+        # translation id (upper case) => entry
+        def translations
+          @translations ||= table["translations"].to_h do |id, fields|
+            [id.upcase, fields.transform_keys(&:to_sym).merge(id: id, authors: fields["authors"] || [])]
+          end
+        end
+
+        # @param name [String] RIS author, "Surname, Forename"
+        # @return [Bib::Contributor]
+        def author(name)
+          surname, forename = name.split(/,\s*/, 2)
+          fullname = Bib::FullName.new(
+            surname: Bib::LocalizedString.new(content: surname, language: "en", script: "Latn"),
+            forename: [Bib::FullNameType::Forename.new(content: forename, language: "en", script: "Latn")],
+          )
+          Bib::Contributor.new(
+            person: Bib::Person.new(name: fullname),
+            role: [Bib::Contributor::Role.new(type: "author")],
+          )
+        end
+
+        # @return [Bib::Contributor]
+        def publisher
+          org = Bib::Organization.new(
+            name: [Bib::TypedLocalizedString.new(content: "National Institute of Standards and Technology")],
+            abbreviation: Bib::LocalizedString.new(content: "NIST"),
+          )
+          Bib::Contributor.new(organization: org, role: [Bib::Contributor::Role.new(type: "publisher")])
+        end
+
+        # @param id [String] the original's id
+        # @return [Relaton::Nist::Relation]
+        def original_relation(id)
+          bib = ItemData.new(
+            formattedref: Bib::Formattedref.new(content: id),
+            docidentifier: [Docidentifier.new(content: id, type: "NIST", primary: true)],
+          )
+          Relation.new(type: "translatedFrom", bibitem: bib)
+        end
+      end
+    end
+  end
+end