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

data/lib/relaton/ogc/hit_collection.rb

@@ -10,7 +10,7 @@ module Relaton
       def find
         return self if ref.nil? || ref.empty?
 
-        row = index.search(ref).min_by { |r| r[:id] }
+        row = best_match ref
         return self unless row
 
         url = "#{ENDPOINT}#{row[:file]}"
@@ -25,12 +25,87 @@ module Relaton
         self
       end
 
-      # @return [Relaton::Index]
+      # @return [Relaton::Index::Type]
       def index
         @index ||= Relaton::Index.find_or_create(
-          :ogc, url: "#{ENDPOINT}index-v1.zip", file: "#{INDEXFILE}.yaml",
+          :ogc, url: "#{ENDPOINT}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml",
+          pubid_class: ::Pubid::Ogc::Identifier
         )
       end
+
+      private
+
+      #
+      # Find the index row for a reference, latest revision first.
+      #
+      # Passing the pubid to `Index::Type#search` is what enables the binary
+      # search on `id.root.number` — with the plain string this used to pass,
+      # the whole index is scanned however the index was built. Selection is
+      # `Type#search`'s default with no block — pubid's asymmetric subset match
+      # (`Pubid::SubsetMatch`): the reference on the left, the row on the right,
+      # and a component it omits matches any
+      # value. `revision` is OGC's only optional component, so a
+      # bare `OGC 12-128` still finds the `r19` row, while `OGC 12-128r19`
+      # reaches only its own. `year` is always stated — the bsearch key is the
+      # `<nnn>` field alone, so one bucket holds every year that reused the
+      # number (`05-007` and `17-007` share bucket `007`).
+      #
+      # @param text [String]
+      # @return [Hash, nil]
+      #
+      # The substring-scan fallback this used to take when parsing failed is
+      # gone with the rescue. It was the same conflation the convention
+      # rejects: an unparseable string matched a SUBSTRING of the rendered
+      # ids, so an ambiguous reference silently resolved to whichever row
+      # sorted first, instead of telling the caller the reference is not an
+      # identifier. ecma, w3c and xsf never had one.
+      def best_match(text)
+        pubid = parse_ref text
+        rows = index.search(pubid)
+        rows.max_by { |r| [revision_key(r[:id].revision), r[:file]] }
+      end
+
+      #
+      # Order key for an OGC revision suffix.
+      #
+      # Revisions are `r<n>` with optional letter suffixes (`r3a`, `r12a`) plus
+      # the odd `a` and `c1`, so the number must be compared as an integer:
+      # `r2` beats `r14` as text but is the older document. The token itself
+      # breaks the tie, so `r3a` sorts above `r3` and a repeated lookup returns
+      # the same row (the index sort is not stable). An absent revision sorts
+      # below every present one.
+      #
+      # Highest revision is the newest published document in 105 of the 106
+      # multi-revision documents in the index, scored against each document's
+      # own `date[0].at`; the previous `min_by` on the rendered id matched 1.
+      #
+      # @param revision [String, nil]
+      # @return [Array]
+      #
+      def revision_key(revision)
+        [revision.to_s[/\d+/].to_i, revision.to_s]
+      end
+
+      #
+      # Parse a user reference into a `Pubid::Ogc::Identifier`, or nil.
+      #
+      # `Pubid::Ogc` takes the `OGC ` publisher token as optional and
+      # lowercases the revision, so `OGC 19-025r1`, `19-025r1`, `11-038R2` and
+      # the revision-less `16-079` all parse without normalization here.
+      #
+      # @param text [String]
+      # @return [Pubid::Ogc::Identifier, nil]
+      #
+      # An unrecognized reference **raises**; like ISO, ETSI and 3GPP we let it
+      # propagate. relaton-cli rescues `Pubid::Errors::Error` and renders
+      # `"..." is not a recognized standards identifier`
+      # (`gems/relaton-cli/lib/relaton/cli/command.rb:324`), and `Db#fetch`
+      # logs it through the `StandardError` arm at `lib/relaton/db.rb:122`.
+      # Rescuing here would collapse "this identifier is malformed" into "no
+      # such document", leaving a caller unable to tell them apart.
+      def parse_ref(text)
+        ::Pubid::Ogc::Identifier.parse text.to_s.strip
+      end
     end
   end
 end

data/lib/relaton/ogc/processor.rb

@@ -9,6 +9,7 @@ module Relaton
         @defaultprefix = %r{^OGC\s}
         @idtype = "OGC"
         @datasets = %w[ogc-naming-authority]
+        @pubid_flavor = :Ogc
       end
 
       # @param code [String]
@@ -50,7 +51,7 @@ module Relaton
       def remove_index_file
         require_relative "../ogc"
         Relaton::Index.find_or_create(
-          :ogc, url: true, file: "#{INDEXFILE}.yaml",
+          :ogc, url: true, file: "#{INDEXFILE}.yaml"
         ).remove_file
       end
     end

data/lib/relaton/ogc.rb

@@ -1,3 +1,7 @@
+# pubid loads with the flavor, for the ::Pubid::Ogc::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/iso"
 require_relative "version"
@@ -11,7 +15,7 @@ require_relative "ogc/bibliography"
 
 module Relaton
   module Ogc
-    INDEXFILE = "index-v1".freeze
+    INDEXFILE = "index-v2".freeze
     class Error < StandardError; end
 
     # Returns hash of XML reammar

data/lib/relaton/oiml/bibliography.rb

@@ -20,13 +20,7 @@ module Relaton
         def search(text, year = nil, _opts = {}) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
           pubid = text.is_a?(String) ? ::Pubid::Oiml.parse(text) : text
           Util.info "Fetching from Relaton repository ...", key: pubid.to_s
-          # Pass the pubid so Relaton::Index narrows candidates by number via
-          # binary search before applying the block. Every row's `:id` is a
-          # Pubid::Oiml::Identifier (Relaton::Index deserialized it via the
-          # `pubid_class` passed in `#index`), so the block compares pubids and
-          # the result picks the latest edition.
-          row = index.search(pubid) { |r| pubid_match?(r[:id], pubid, year) }
-                     .max_by { |r| r[:id].year.to_i }
+          row = best_row(pubid, year)
           unless row
             Util.info "Not found.", key: pubid.to_s
             return
@@ -48,9 +42,29 @@ module Relaton
           raise Relaton::RequestError, "Could not access #{uri}: #{e.message}"
         end
 
+        # Fetch an OIML publication, suppressing the edition year for an undated
+        # citation so the designation renders undated (`OIML B 18`), the way the
+        # ISO fetcher does. A dated citation (`OIML B 18:2022`, or an explicit
+        # `year`) still pins that edition. Mirrors `Relaton::Iso::Bibliography#get`.
+        #
+        # @param opts [Hash] options
+        # @option opts [Boolean] :keep_year retain the edition year even for an
+        #   undated citation (or, when false, strip it even for a dated one)
+        #
         # @see #search
         def get(ref, year = nil, opts = {})
-          search(ref, year, opts)
+          item = search(ref, year, opts)
+          return item unless item
+
+          pubid = ref.is_a?(String) ? ::Pubid::Oiml.parse(ref) : ref
+          dated = oiml_side(pubid).year || year
+          # Keep the year only when the citation genuinely asks for it: a resolved
+          # year (unless keep_year is explicitly false), or keep_year truthy. (ISO
+          # also keeps for :all_parts; OIML has no all-parts retrieval, so search
+          # ignores opts and there is nothing to mirror here.)
+          return item if (dated && opts[:keep_year].nil?) || opts[:keep_year]
+
+          item.to_most_recent_reference
         end
 
         private
@@ -64,6 +78,60 @@ module Relaton
           )
         end
 
+        # The index row for a reference: the latest edition among the rows it
+        # matches.
+        #
+        # The pubid is passed to `Index::Type#search`, so the index narrows
+        # candidates by number via binary search, and each row's `:id` is a
+        # Pubid::Oiml::Identifier (deserialized via the `pubid_class` in
+        # `#index`).
+        #
+        # A Bulletin matches exactly (`exact: true`). Its year is part of its
+        # locator, not an edition: the issue and the sequence render after the
+        # year, so the stem below reduces every article of one year to
+        # `OIML Bulletin`, and a lookup used to return any one of them.
+        #
+        # This flavor does not use pubid's subset match `===` yet. Measured
+        # over the full `relaton-data-oiml` index, `===` lets a language-less
+        # Amendment, Annex or Errata reference reach its translations
+        # (`language` is not strict), lets `OIML R 137-1 (F)` reach
+        # `OIML R 137-1-2:2012 (F)` (`subpart` is not strict), and rejects
+        # `OIML R 102:1995 Annex B-C` for `OIML R 102 Annex B-C` (the
+        # `year_on_base` render flag is compared).
+        #
+        # @param query [Pubid::Oiml::Identifier]
+        # @param year [String, nil]
+        # @return [Hash, nil] the index row (`{ id:, file: }`)
+        def best_row(query, year)
+          return index.search(query, exact: true).first if bulletin?(query)
+
+          index.search(query) { |r| pubid_match?(r[:id], query, year) }
+               .max_by { |r| oiml_side(r[:id]).year.to_i }
+        end
+
+        # @return [Boolean] true for an identifier of an OIML Bulletin
+        def bulletin?(pubid)
+          pubid.is_a?(::Pubid::Oiml::Identifiers::Bulletin)
+        end
+
+        # A document OIML co-publishes with another SDO (ISO confirmed so far)
+        # is a Pubid::Oiml::Identifiers::DualPublished — a "|"-joined pair
+        # (pubid#437), e.g. `ISO 4064-1:2024|OIML R 49-1:2024`. It delegates
+        # #root/#code/#type/#stage/#iteration/#publisher to whichever side is
+        # OIML, but NOT #year or #language — those read nil on the wrapper
+        # itself regardless of what either side holds. This unwraps to the
+        # OIML side for those reads (a plain, non-dual pubid is returned
+        # unchanged), so a query and a row agree on year/language/stem
+        # whether either one is dual-published or not, and regardless of
+        # which side print order named first.
+        #
+        # @param pubid [Pubid::Oiml::Identifier] a plain or dual-published pubid
+        # @return [Pubid::Oiml::Identifier] the OIML-flavored side (itself, for
+        #   a plain pubid)
+        def oiml_side(pubid)
+          pubid.is_a?(::Pubid::Oiml::Identifiers::DualPublished) ? pubid.oiml_identifier : pubid
+        end
+
         # Both `row_id` and `query` are Pubid::Oiml::Identifier instances.
         # Matching is on the year/language-stripped "stem" (e.g. `OIML R 138`),
         # which keeps the type letter and any amendment suffix — so an amendment
@@ -71,13 +139,15 @@ module Relaton
         # does not expose the suffix as its own attribute. Language must match
         # exactly (a language-less query targets the language-less abstract
         # record); year is nil-tolerant so an unqualified query finds the latest
-        # edition (selected by `max_by` in #search). The `year` argument lets a
-        # caller pin an edition the reference string omitted.
+        # edition (selected by `max_by` in #best_row). The `year` argument lets
+        # a caller pin an edition the reference string omitted.
         def pubid_match?(row_id, query, year)
-          wanted_year = (query.year || year)&.to_s
-          stem(row_id) == stem(query) &&
-            row_id.language.to_s == query.language.to_s &&
-            (wanted_year.nil? || row_id.year.to_s == wanted_year)
+          row = oiml_side(row_id)
+          q = oiml_side(query)
+          wanted_year = (q.year || year)&.to_s
+          stem(row) == stem(q) &&
+            row.language.to_s == q.language.to_s &&
+            (wanted_year.nil? || row.year.to_s == wanted_year)
         end
 
         # The identifier without its edition year or language, e.g.
@@ -85,8 +155,13 @@ module Relaton
         # via #exclude (returns a copy, so the cached index id is untouched)
         # rather than string surgery on #to_s. The amendment suffix is kept, so
         # an amendment (`OIML R 138-Amend`) never reduces to the base record.
+        #
+        # Reduced through #oiml_side first: `#exclude` recurses correctly into
+        # both sides of a DualPublished (unlike a direct #year/#language read),
+        # but a plain query has no external side to reduce to, so comparing
+        # full dual-published stems against a plain one would never match.
         def stem(pubid)
-          pubid.exclude(:year, :language).to_s
+          oiml_side(pubid).exclude(:year, :language).to_s
         end
       end
     end

data/lib/relaton/oiml/docidentifier.rb

@@ -17,16 +17,31 @@ module Relaton
         @pubid = nil
       end
 
+      # Both mutators go through #exclude (an immutable copy) rather than
+      # mutating `@pubid` in place: for a plain identifier the two are
+      # equivalent, but for a Pubid::Oiml::Identifiers::DualPublished
+      # (pubid#437, e.g. `ISO 4064-1:2024|OIML R 49-1:2024`) a direct
+      # `@pubid.part = nil`/`@pubid.date = nil` is a silent no-op — neither
+      # attribute is delegated to either side — while `#exclude` correctly
+      # recurses into both sides. `content=` re-parses the rendered string,
+      # which resyncs `@pubid` too, so there is nothing left to reassign here.
       def remove_part!
-        @pubid&.part = nil
+        return unless @pubid
+
+        self.content = @pubid.exclude(:part).to_s
       end
 
       def remove_date!
-        @pubid&.date = nil
+        return unless @pubid
+
+        # Re-sync `content` from the now-dateless pubid: it is the string that
+        # actually renders (e.g. `OIML R 138`, or `OIML R 138 (E)` keeping the
+        # language). Mutating `@pubid` alone leaves the dated `content` in place.
+        self.content = @pubid.exclude(:date).to_s
       end
 
       def to_all_parts!
-        @pubid&.all_parts = true
+        @pubid &&= @pubid.to_all_parts
       end
     end
   end

data/lib/relaton/omg/docidentifier.rb

@@ -0,0 +1,67 @@
+module Relaton
+  module Omg
+    # An OMG document identifier backed by `Pubid::Omg`.
+    #
+    # `content` stays a plain string, so serialization is unchanged; the parsed
+    # identifier lives beside it in `@pubid` and drives the mutators. Follows
+    # the IALA and CEN shape (`lib/relaton/iala/docidentifier.rb`,
+    # `lib/relaton/cen/model/docidentifier.rb`).
+    class Docidentifier < Bib::Docidentifier
+      # @return [Pubid::Omg::Identifier, nil] nil when the content is not an
+      #   OMG identifier, or the grammar cannot read it
+      attr_reader :pubid
+
+      # Capture the inherited (LocalizedMarkedUpString) content setter before
+      # overriding #content=, so #refresh_content! writes the re-rendered string
+      # back WITHOUT re-parsing it and discarding the mutation.
+      alias_method :store_content, :content=
+
+      def content=(value)
+        super
+        return unless value
+
+        @pubid = begin
+          # `pubid` is required lazily because deserialization reaches this
+          # class without the flavor entry file having been loaded. LoadError
+          # degrades to a plain string; StandardError covers a non-OMG value
+          # and a title the grammar rejects, both of which are DATA and must
+          # not raise. A malformed *query* raises — see Scraper.scrape_page.
+          require "pubid"
+          ::Pubid::Omg::Identifier.parse(value)
+        rescue LoadError, StandardError
+          nil
+        end
+      end
+
+      # OMG identifiers carry no date. The version is OMG's discriminator
+      # (`OMG AMI4CCM 1.0` and `OMG AMI4CCM 1.1` are two editions of one
+      # specification), so the version-agnostic ("most recent") reference drops
+      # the version — as IALA maps `remove_date!` onto its edition.
+      def remove_date!
+        return unless @pubid
+
+        replace_pubid @pubid.exclude(:version)
+      end
+
+      # The part is the volume or format segment after the version, e.g.
+      # `Superstructure` in `OMG UML 2.1.1 Superstructure`.
+      def remove_part!
+        return unless @pubid
+
+        replace_pubid @pubid.exclude(:part)
+      end
+
+      # `to_all_parts!` stays the inherited no-op. An OMG part is a volume or a
+      # format name, not a numbered part, so there is no "all parts" form.
+
+      private
+
+      # `Pubid#exclude` returns a COPY, so the new identifier replaces the old
+      # one.
+      def replace_pubid(new_pubid)
+        @pubid = new_pubid
+        store_content @pubid.to_s
+      end
+    end
+  end
+end

data/lib/relaton/omg/item.rb

@@ -2,6 +2,7 @@ module Relaton
   module Omg
     class Item < Bib::Item
       model ItemData
+      attribute :docidentifier, Docidentifier, collection: true, initialize_empty: true
       attribute :ext, Ext
     end
   end

data/lib/relaton/omg/processor.rb

@@ -6,6 +6,7 @@ module Relaton
       def initialize # rubocop:disable Lint/MissingSuper
         @short = :relaton_omg
         @prefix = "OMG"
+        @pubid_flavor = :Omg # Pubid::Omg.prefixes is ["OMG"], the same as @prefix
         @defaultprefix = /^OMG /
         @idtype = "OMG"
       end

data/lib/relaton/omg/scraper.rb

@@ -1,23 +1,31 @@
 # frozen_string_literal: true
 
+require "json"
 require "mechanize"
+require "pubid"
 
 module Relaton
   module Omg
     class Scraper
       URL_PATTERN = "https://www.omg.org/spec/"
+      LD_DATE = "https://www.omg.org/techprocess/ab/SpecificationMetadata/publicationDate"
 
-      def initialize(acronym, version = nil, spec = nil)
+      # @param acronym [String] the specification acronym, e.g. "UML"
+      # @param version [String, nil] the version, e.g. "2.1.1" or "2.5 beta 1"
+      # @param part [String, nil] the document part, e.g. "Superstructure"
+      def initialize(acronym, version = nil, part = nil)
         @acronym = acronym
         @version = version
-        @spec = spec
+        @part = part
       end
 
+      # @param ref [String] the OMG reference, e.g. "OMG UML 2.1.1 Superstructure"
+      # @return [Relaton::Omg::ItemData, nil] nil when the page is not found
+      # @raise [Pubid::Errors::ParseError] when the reference is not an OMG
+      #   identifier
       def self.scrape_page(ref)
-        %r{^OMG (?<acronym>[^\s]+)(?:[\s/](?<version>[\d.]+(?:\sbeta(?:\s\d)?)?))?(?:[\s/](?<spec>\w+))?$} =~ ref
-        return unless acronym
-
-        scraper = new(acronym, version, spec)
+        pubid = ::Pubid::Omg::Identifier.parse(ref)
+        scraper = new(pubid.acronym, pubid.version, pubid.part)
         doc = scraper.get_doc
         return if doc.nil? || scraper.fetch_link.empty?
 
@@ -56,15 +64,15 @@ module Relaton
 
       def fetch_title
         content = @doc.at('//dt[.="Title:"]/following-sibling::dd').text
-        content += ": #{@spec}" if @spec
+        content += ": #{@part}" if @part
         [Bib::Title.new(type: "main", content: content, language: "en", script: "Latn")]
       end
 
+      # The version comes from the page, not from the query, so a versionless
+      # query (`OMG AMI4CCM`) answers with the version that the page shows.
       def fetch_docid
-        id = ["OMG", @acronym]
-        id << doc_version if doc_version
-        id << @spec if @spec
-        [Bib::Docidentifier.new(content: id.join(" "), type: "OMG", primary: true)]
+        id = render_id(@acronym, doc_version, @part)
+        [Docidentifier.new(content: id, type: "OMG", primary: true)]
       end
 
       def fetch_abstract
@@ -81,11 +89,39 @@ module Relaton
       end
 
       def fetch_date
+        return [] unless pub_date
+
         [Bib::Date.new(type: "published", at: pub_date.to_s)]
       end
 
       def pub_date
-        ::Date.parse @doc.at('//dt[.="Publication Date:"]/following-sibling::dd').text.strip
+        return @pub_date if defined? @pub_date
+
+        @pub_date = jsonld_date || dd_date
+      end
+
+      # The visible date renders the month name in the locale of the server, and
+      # the CDN caches that variant. Parse the machine-readable value first.
+      #
+      # @return [Date, nil]
+      def jsonld_date
+        script = @doc.at('//script[@type="application/ld+json"]')
+        return unless script
+
+        node = JSON.parse(script.text).find { |e| e.is_a?(Hash) && e[LD_DATE] }
+        value = node && node[LD_DATE].first["@value"]
+        value && ::Date.parse(value)
+      rescue JSON::ParserError, ::Date::Error
+        nil
+      end
+
+      # @return [Date, nil]
+      def dd_date
+        text = @doc.at('//dt[.="Publication Date:"]/following-sibling::dd').text.strip
+        ::Date.parse text
+      rescue ::Date::Error
+        Util.warn "Cannot parse the publication date `#{text}`."
+        nil
       end
 
       def fetch_status
@@ -98,8 +134,8 @@ module Relaton
         return @links if @links
 
         @links = []
-        if @spec
-          a = @doc.at("//a[@href='#{@url}/#{@spec}/PDF']")
+        if @part
+          a = @doc.at("//a[@href='#{@url}/#{@part}/PDF']")
           @links << Bib::Uri.new(type: "src", content: a[:href]) if a
         else
           a = @doc.at('//dt[.="This Document:"]/following-sibling::dd/a')
@@ -116,8 +152,8 @@ module Relaton
           ver = row.at("td").text
           unless ver == doc_version
             acronym = row.at("td[3]/a")[:href].split("/")[4]
-            id = ["OMG", acronym, ver].join(" ")
-            docid = Bib::Docidentifier.new(content: id, type: "OMG")
+            id = render_id(acronym, ver)
+            docid = Docidentifier.new(content: id, type: "OMG")
             bibitem = Bib::ItemBase.new(formattedref: Bib::Formattedref.new(content: id), docidentifier: [docid])
             mem << Bib::Relation.new(type: "obsoletes", bibitem: bibitem)
           end
@@ -136,6 +172,15 @@ module Relaton
           '//dt/span/a[contains(., "IPR Mode")]/../../following-sibling::dd/span',
         ).map { |l| l.text.match(/[\w\s-]+/).to_s.strip }
       end
+
+      private
+
+      # @return [String] the identifier, rendered by pubid
+      def render_id(acronym, version, part = nil)
+        ::Pubid::Omg::Identifiers::Specification.new(
+          acronym: acronym, version: version, part: part,
+        ).to_s
+      end
     end
   end
 end

data/lib/relaton/omg.rb

@@ -3,6 +3,7 @@ require "relaton/bib"
 require_relative "version"
 require_relative "omg/util"
 require_relative "omg/ext"
+require_relative "omg/docidentifier"
 require_relative "omg/item_data"
 require_relative "omg/item"
 require_relative "omg/bibitem"

data/lib/relaton/plateau/bibliography.rb

@@ -7,7 +7,11 @@ module Relaton
         HitCollection.new(code).find
       end
 
-      def get(code, _year = nil, _opts = {})
+      # Only a transport failure is rescued, and it becomes the
+      # Relaton::RequestError that Relaton::Db retries. Anything else keeps
+      # its own class: an unrecognized reference raises Pubid::Errors::ParseError
+      # (relaton-cli reports it), and a bug keeps its backtrace.
+      def get(code, _year = nil, _opts = {}) # rubocop:disable Metrics/MethodLength
         Util.info "Fetching ...", key: code
         result = search(code).fetch_doc
         if result
@@ -16,8 +20,11 @@ module Relaton
         else
           Util.warn "Not found.", key: code
         end
-      rescue StandardError => e
-        raise Error, e.message
+      rescue SocketError, Errno::EINVAL, Errno::ECONNRESET, EOFError,
+             Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+             Net::ProtocolError, Net::ReadTimeout, OpenSSL::SSL::SSLError,
+             Errno::ETIMEDOUT => e
+        raise Relaton::RequestError, e.message
       end
     end
   end

data/lib/relaton/plateau/data_fetcher.rb

@@ -13,7 +13,9 @@ module Relaton
       TECHNICAL_REPORTS_URL = "https://www.mlit.go.jp/plateau/_next/data/1.3.0/libraries/technical-reports.json".freeze
 
       def index
-        @index ||= Relaton::Index.find_or_create :plateau, file: "#{INDEXFILE}.yaml"
+        @index ||= Relaton::Index.find_or_create(
+          :plateau, file: "#{INDEXFILE}.yaml", pubid_class: ::Pubid::Plateau::Identifier
+        )
       end
 
       def log_error(msg)
@@ -123,10 +125,31 @@ module Relaton
         else
           File.write(file, serialize(item))
           @files << file
-          index.add_or_update id, file
+          pid = pubid id
+          if pid
+            index.add_or_update pid, file
+          else
+            Util.warn "Unparseable id `#{id}` was not indexed (#{file})", key: id
+          end
         end
       end
 
+      # Parse a canonical PLATEAU docidentifier into a Pubid::Plateau::Identifier,
+      # or nil if pubid can't parse it or it doesn't round-trip through
+      # `from_hash(to_hash)` — so a single bad id never aborts the crawl or
+      # corrupts index-v2 (the read side rejects an index whose rows don't
+      # deserialize). The parser emits canonical ids, so this should not skip
+      # anything; the guard is defensive.
+      def pubid(id)
+        pid = ::Pubid::Plateau.parse id
+        hash = pid.to_hash
+        return nil unless ::Pubid::Plateau::Identifier.from_hash(hash).to_hash == hash
+
+        pid
+      rescue StandardError
+        nil
+      end
+
       def file_name(id)
         name = id.gsub(/\s+/, "-").gsub(/[^\w-]+/, "").downcase
         if id.match?(/民間活用編/)

data/lib/relaton/plateau/handbook_parser.rb

@@ -16,13 +16,20 @@ module Relaton
         @edition ||= @version["title"].split.first.match(/[\d.]+/).to_s
       end
 
+      # Canonical PLATEAU handbook edition label, e.g. "第3.0版" — the form
+      # Pubid::Plateau parses. The Latinized #edition is kept for the structured
+      # Bib::Edition/number and the ext structuredidentifier.
+      def edition_label
+        @edition_label ||= @version["title"].to_s[/第[\d.]+版/].to_s
+      end
+
       def slug_number
         @slug_number ||= @entry["slug"]&.to_s&.split("_")&.first
       end
 
       def parse_docnumber
         @errors[:hb_docnumber] &&= @entry["slug"].nil? || @entry["slug"].to_s.empty?
-        ["Handbook ##{slug_number}", edition].compact.join(" ")
+        ["Handbook ##{slug_number}", edition_label].reject { |s| s.to_s.empty? }.join(" ")
       end
 
       def parse_abstract

data/lib/relaton/plateau/hit.rb

@@ -1,10 +1,18 @@
 module Relaton
   module Plateau
     class Hit < Relaton::Core::Hit
+      # The index names the file, so a non-200 is an access failure, not a
+      # miss. Without the check the error page body reached Item.from_yaml,
+      # which returned an item with no docidentifier.
       def item
         @item ||= begin
-          url = "#{HitCollection::ENDPOINT}#{hit[:file]}"
-          resp = Net::HTTP.get_response(URI(url))
+          uri = URI("#{HitCollection::ENDPOINT}#{hit[:file]}")
+          resp = Net::HTTP.get_response(uri)
+          unless resp.code == "200"
+            raise Relaton::RequestError,
+                  "Could not access #{uri}: HTTP #{resp.code}"
+          end
+
           Item.from_yaml(resp.body)
         end
       end