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

data/lib/relaton/iana/bibliography.rb

@@ -2,33 +2,42 @@
 
 module Relaton
   module Iana
-    # Methods for search IANA standards.
+    # Retrieval front-end for the IANA flavor. Parses the citation with
+    # Pubid::Iana, looks it up in the pubid-structured `relaton-data-iana`
+    # index-v2, and fetches the matching per-document YAML over HTTP.
+    #
+    # An IANA entry is a protocol registry, not a numbered standard: the
+    # identifier is a registry slug with at most one "/"
+    # (`IANA _6lowpan-parameters`, `IANA _6lowpan-parameters/lowpan_nhc`). The
+    # index rows key on the TOP-LEVEL slug (`Identifiers::Registry#number`), so
+    # a registry and all of its sub-registries share one bsearch bucket and the
+    # block below distinguishes them.
     module Bibliography
       SOURCE = "https://raw.githubusercontent.com/relaton/relaton-data-iana/refs/heads/v2/"
 
-      # @param text [String]
-      # @return [Relaton::Iana::ItemData, nil]
-      def search(text) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
-        index = Relaton::Index.find_or_create :iana, url: "#{SOURCE}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml"
-        id = text.sub(/^IANA\s/, "")
-        row = index.search(id).min_by { |i| i[:id] }
-        return unless row
+      # @param text [String, Pubid::Iana::Identifier]
+      # @return [Relaton::Iana::Item, nil]
+      def search(text)
+        pubid = parse_ref text
+        return unless pubid
 
-        url = "#{SOURCE}#{row[:file]}"
-        resp = Net::HTTP.get_response URI(url)
-        return unless resp.code == "200"
+        # Pass the pubid so Relaton::Index narrows candidates by number via
+        # binary search before applying the block. The match is exact, so there
+        # is at most one row.
+        row = index.search(pubid) { |r| pubid_match? r[:id], pubid }.first
+        return unless row
 
-        Item.from_yaml(resp.body).tap { |item| item.fetched = Date.today.to_s }
+        fetch_row row
       rescue SocketError, Timeout::Error, Errno::EINVAL, Errno::ECONNRESET,
              EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
              Net::ProtocolError, Errno::ETIMEDOUT => e
         raise Relaton::RequestError, e.message
       end
 
-      # @param ref [String] the W3C standard Code to look up
+      # @param ref [String] the IANA registry slug to look up
       # @param year [String, NilClass] not used
       # @param opts [Hash] options
-      # @return [Relaton::Iana::ItemData, nil]
+      # @return [Relaton::Iana::Item, nil]
       def get(ref, _year = nil, _opts = {})
         Util.info "Fetching from Relaton repository ...", key: ref
         result = search(ref)
@@ -41,6 +50,50 @@ module Relaton
         result
       end
 
+      private
+
+      def index
+        Relaton::Index.find_or_create :iana, url: "#{SOURCE}#{INDEXFILE}.zip",
+                                             file: "#{INDEXFILE}.yaml",
+                                             pubid_class: ::Pubid::Iana::Identifier
+      end
+
+      # `Pubid::Iana::Identifier.parse` accepts both the printed `IANA <slug>`
+      # form and the bare slug the index rows render back to. It raises a plain
+      # RuntimeError on anything else, and a citation relaton cannot parse is a
+      # miss, not an error — `#get` reports it as "Not found.".
+      #
+      # @param text [String, Pubid::Iana::Identifier]
+      # @return [Pubid::Iana::Identifier, nil]
+      def parse_ref(text)
+        return text unless text.is_a? String
+
+        ::Pubid::Iana::Identifier.parse text
+      rescue StandardError => e
+        Util.warn "Failed to parse pubid `#{text}`: #{e.message}"
+        nil
+      end
+
+      # Both arguments are Pubid::Iana identifiers. Compared field by field
+      # rather than with `==` so the two identity fields are explicit: a bare
+      # registry must NOT match its own sub-registries, which share its bsearch
+      # bucket. (index-v1 matched by substring, so `IANA rpki` also hit
+      # `rpki/signed-objects` and `min_by` picked the shortest id.)
+      def pubid_match?(row_id, query)
+        row_id.class == query.class &&
+          row_id.number == query.number &&
+          row_id.sub_registry.to_s == query.sub_registry.to_s
+      end
+
+      # @param row [Hash] an index row
+      # @return [Relaton::Iana::Item, nil]
+      def fetch_row(row)
+        resp = Net::HTTP.get_response URI("#{SOURCE}#{row[:file]}")
+        return unless resp.code == "200"
+
+        Item.from_yaml(resp.body).tap { |item| item.fetched = Date.today.to_s }
+      end
+
       extend self
     end
   end

data/lib/relaton/iana/data_fetcher.rb

@@ -26,7 +26,28 @@ module Relaton
       private
 
       def index
-        @index ||= Relaton::Index.find_or_create :iana, file: "#{INDEXFILE}.yaml"
+        @index ||= Relaton::Index.find_or_create :iana, file: "#{INDEXFILE}.yaml",
+                                                        pubid_class: ::Pubid::Iana::Identifier
+      end
+
+      #
+      # Add a document to the pubid-keyed index-v2.
+      #
+      # Stores the Pubid::Iana identifier object (not its hash): with
+      # pubid_class set, Relaton::Index sorts the index by the id's number on
+      # save and serializes each id to its `_type: pubid:iana:registry` hash.
+      #
+      # The rescue is load-bearing. Relaton::Index rejects the WHOLE index if a
+      # single row fails to deserialize, so a slug pubid cannot parse has to be
+      # skipped here rather than raise and abort the crawl.
+      #
+      # @param [String] docnumber bare registry slug, `registry[/sub-registry]`
+      # @param [String] file path of the document file
+      #
+      def add_to_index(docnumber, file)
+        index.add_or_update ::Pubid::Iana::Identifier.parse(docnumber), file
+      rescue StandardError => e
+        Util.warn "Skipping index entry for `#{docnumber}` (#{file}): #{e.message}"
       end
 
       def parse(content)
@@ -45,13 +66,22 @@ module Relaton
       def save_doc(bib) # rubocop:disable Metrics/MethodLength
         return unless bib
 
-        file = output_file(bib.docnumber)
+        # Two distinct registries can sanitize to one filename (`/` and `-` both
+        # collapse to `-`), e.g. `rpki/signed-objects` and `rpki-signed-objects`.
+        # Take a path of our own rather than overwriting the other document, but
+        # keep the clash visible in the crawl log.
+        file = unique_output_file bib.docnumber
         if @files.include? file
+          # A reserved path only ever belongs to one docnumber, so this is the
+          # same document again: a genuine duplicate, not a collision. Checked
+          # FIRST, because a disambiguated path stays != output_file forever.
           Util.warn "File #{file} already exists. Document: #{bib.docnumber}"
-        else
-          @files << file
+        elsif file != output_file(bib.docnumber)
+          Util.warn "File #{output_file bib.docnumber} already exists. " \
+                    "Document: #{bib.docnumber}. Writing #{file} instead."
         end
-        index.add_or_update bib.docnumber, file
+        @files << file
+        add_to_index bib.docnumber, file
         File.write file, serialize(bib), encoding: "UTF-8"
       end
 

data/lib/relaton/iana/processor.rb

@@ -61,7 +61,9 @@ module Relaton
       #
       def remove_index_file
         require_relative "../iana"
-        Relaton::Index.find_or_create(:iana, url: true, file: "#{INDEXFILE}.yaml").remove_file
+        Relaton::Index.find_or_create(
+          :iana, url: true, file: "#{INDEXFILE}.yaml"
+        ).remove_file
       end
     end
   end

data/lib/relaton/iana.rb

@@ -2,6 +2,7 @@
 
 require "faraday"
 require "relaton/index"
+require "pubid"
 require "relaton/bib"
 require_relative "version"
 require_relative "iana/util"
@@ -15,7 +16,17 @@ require_relative "iana/bibliography"
 
 module Relaton
   module Iana
-    INDEXFILE = "index-v1"
+    # The runtime index is the pubid-backed `index-v2`, whose rows are
+    # `Pubid::Iana::Identifiers::Registry` identifiers serialized as
+    # `_type: pubid:iana:registry` with `number` (the TOP-LEVEL registry slug)
+    # and an optional `sub_registry` — built and read via
+    # `pubid_class: ::Pubid::Iana::Identifier`.
+    #
+    # The legacy string-keyed `index-v1` (whose `:id` was the bare
+    # `registry[/sub-registry]` slug) is no longer produced or read here; it is
+    # emitted by `relaton-data-iana`'s own `crawler.rb`, derived from `index-v2`,
+    # so released gem lines keep resolving. See lib/relaton/iana/CLAUDE.md.
+    INDEXFILE = "index-v2".freeze
 
     # Returns hash of XML reammar
     # @return [String]

data/lib/relaton/iec/data_fetcher.rb

@@ -187,9 +187,15 @@ module Relaton
       def fetch_pub(pub) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         bib = DataParser.new(pub, @errors).parse
         did = bib.docidentifier.detect(&:primary)
-        file = output_file(did.to_s)
+        # Distinct docids can sanitize to one filename; take a path of our own
+        # rather than overwriting the other document. A reserved path only ever
+        # belongs to one docid, so an @files hit is the same document again.
+        file = unique_output_file(did.to_s)
         if @files.include? file then Util.warn "File #{file} exists."
         else
+          if file != output_file(did.to_s)
+            Util.warn "File #{output_file did.to_s} exists. Docid: #{did}. Writing #{file} instead."
+          end
           @files << file
           pubid = parse_pubid(did.to_s)
           index.add_or_update pubid, file if pubid

data/lib/relaton/iec/hit_collection.rb

@@ -91,7 +91,7 @@ module Relaton
       # removed at every nesting level. More robust than comparing attribute
       # objects, whose derived `type`/`stage` differ between a parsed identifier
       # (component object) and a deserialized one (nil/symbol) — at the top level
-      # and inside `base_identifier`.
+      # and inside `base`.
       def canonical_id(pubid, exclude)
         drop = exclude.filter_map { |e| EXCLUDE_KEYS[e] }
         prune(stringify(pubid.to_hash), drop)

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

@@ -50,13 +50,17 @@ module Relaton
         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
+      # pubid behavior change, not a bug; see spec/iec/…/docidentifier_spec.rb
+      # "#to_all_parts!"). `remove_stage!` stays: stage isn't one of the
+      # attributes pubid's `all_parts_edition_keys` strips.
       def to_all_parts!
         return unless @pubid
 
-        remove_part!
-        remove_date!
         remove_stage!
-        @pubid.all_parts = true if @pubid.respond_to?(:all_parts=)
+        @pubid = @pubid.to_all_parts
         refresh_content!
       end
 
@@ -97,7 +101,7 @@ module Relaton
           clear_attr_on(@pubid, attr)
         end
 
-        node = @pubid.base_identifier
+        node = @pubid.base
         while node
           clear_attr_on(node, attr)
           # ConsolidatedIdentifier carries a sibling collection of bundled
@@ -109,7 +113,7 @@ module Relaton
               clear_attr_on(id, attr)
             end
           end
-          node = node.base_identifier
+          node = node.base
         end
         refresh_content!
       end

data/lib/relaton/iec/model/ext.rb

@@ -17,7 +17,7 @@ module Relaton
       attribute :cen_processing, :boolean
       attribute :secretary, :string
       attribute :interest_to_committees, :string
-      attribute :tc_sc_officers_note, :string, raw: true
+      attribute :tc_sc_officers_note, :string
 
       xml do
         map_element "horizontal", to: :horizontal
@@ -30,7 +30,7 @@ module Relaton
         map_element "cen-processing", to: :cen_processing
         map_element "secretary", to: :secretary
         map_element "interest-to-committees", to: :interest_to_committees
-        map_element "tc-sc-officers-note", to: :tc_sc_officers_note
+        map_element "tc-sc-officers-note", to: :tc_sc_officers_note, raw: :content
       end
 
       key_value do

data/lib/relaton/iec/processor.rb

@@ -6,6 +6,7 @@ module Relaton
       def initialize
         @short = :relaton_iec
         @prefix = "IEC"
+        @pubid_flavor = :Iec # global prefixes sourced from Pubid::Iec.prefixes
         @defaultprefix = %r{^(IEC\s|CISPR\s|IEV($|\s))}
         @idtype = "IEC"
         @datasets = %w[iec-harmonized-all iec-harmonized-latest]

data/lib/relaton/ieee/bibliography.rb

@@ -12,9 +12,17 @@ module Relaton
         # @return [Relaton::Ieee::ItemData, nil]
         #
         def search(code) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-          # ref = code.sub(/Std\s/i, "") # .gsub(/[\s,:\/]/, "_").squeeze("_").upcase
-          index = Relaton::Index.find_or_create :ieee, url: "#{GH_URL}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml"
-          row = index.search(code).min_by { |r| r[:id] }
+          index = Relaton::Index.find_or_create :ieee, url: "#{GH_URL}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml",
+                                                       pubid_class: ::Pubid::Ieee::Identifier
+          # Pass the parsed pubid (not the raw String) so index-v2 narrows
+          # candidates by number via binary search before the block runs; the
+          # block keeps the broad substring match the string index gave, and an
+          # unparseable/partial ref falls back to the full-scan String search.
+          # Rows are Pubid::Ieee::Identifier objects (not Comparable), so pick by
+          # the string form.
+          pubid = parse_pubid code
+          needle = pubid.to_s
+          row = index.search(pubid) { |r| r[:id].to_s.include?(needle) }.min_by { |r| r[:id].to_s }
           return unless row
 
           resp = Faraday.get "#{GH_URL}#{row[:file]}"
@@ -45,6 +53,20 @@ module Relaton
             nil
           end
         end
+
+        private
+
+        # Parse a reference into a Pubid::Ieee::Identifier for index narrowing, or
+        # return the raw String when pubid can't parse it (e.g. a partial ref) so
+        # the search falls back to the substring scan.
+        #
+        # @param code [String]
+        # @return [::Pubid::Ieee::Identifier, String]
+        def parse_pubid(code)
+          ::Pubid::Ieee::Identifier.parse code
+        rescue StandardError
+          code
+        end
       end
     end
   end

data/lib/relaton/ieee/data_fetcher.rb

@@ -20,6 +20,90 @@ module Relaton
         "E" => false, "B" => false, "W" => false
       }.freeze
 
+      # Publication subtypes that IEEE does not give a designation to. Such a
+      # record carries a category in `stdnumber` ("White Paper", "Smart Grid
+      # Research: …") and a title in `normtitle`, and IEEE itself cites it by
+      # title. See {#no_standard_number?}.
+      NON_STANDARD_SUBTYPES = ["Whitepapers", "Research Documents"].freeze
+
+      class << self
+        #
+        # Build the pubid-structured `index-v2` from a directory of already
+        # generated per-document BibYAML files (the output of {.fetch}). This is
+        # a **separate step** from doc fetching: `relaton-data-ieee`'s crawler
+        # runs it after obtaining `data/` (a fresh crawl, or a clone of the
+        # published data repo). It parses each document's primary IEEE
+        # docidentifier into a `Pubid::Ieee::Identifier` and writes the index
+        # keyed by `pubid_class: ::Pubid::Ieee::Identifier`, so rows serialize to
+        # the `_type: pubid:ieee:*` structured form.
+        #
+        # Ids that pubid can't parse/round-trip are skipped (they'd otherwise
+        # break the all-pubid index that FileIO deserializes and number-sorts);
+        # the per-file skip and the final coverage summary are logged so the loss
+        # is never silent.
+        #
+        # @param dir [String] directory holding the per-document `*.yaml` files
+        # @param index_file [String] output index filename
+        # @return [Hash] `{ total:, indexed:, skipped: }` counts
+        #
+        def build_index(dir: "data", index_file: "#{INDEXFILE}.yaml")
+          index = Relaton::Index.find_or_create(
+            :ieee, file: index_file, pubid_class: ::Pubid::Ieee::Identifier
+          )
+          total = indexed = 0
+          Dir["#{dir}/*.yaml"].sort.each do |file|
+            total += 1
+            docid = primary_docid(file)
+            pid = docid && pubid(docid)
+            if pid
+              index.add_or_update pid, file
+              indexed += 1
+            else
+              Util.warn "Skipped (unparseable id): `#{docid || '<none>'}` (#{file})"
+            end
+          end
+          index.save
+          Util.info "IEEE #{index_file}: #{indexed}/#{total} indexed, " \
+                    "#{total - indexed} skipped " \
+                    "(#{total.zero? ? 0 : (100.0 * indexed / total).round(1)}% coverage)"
+          { total: total, indexed: indexed, skipped: total - indexed }
+        end
+
+        private
+
+        # Extract the primary, non-trademark IEEE docidentifier string from a
+        # BibYAML file, or nil when absent/unreadable.
+        #
+        # @param file [String]
+        # @return [String, nil]
+        def primary_docid(file)
+          yaml = YAML.safe_load(File.read(file, encoding: "UTF-8"),
+                                permitted_classes: [Symbol, Date, Time])
+          id = yaml && yaml["docidentifier"]&.find do |i|
+            i["type"] == "IEEE" && i["primary"] == true && i["trademark"].nil?
+          end
+          id && id["content"]
+        rescue StandardError
+          nil
+        end
+
+        # Parse a docid string into a Pubid::Ieee::Identifier, or nil if pubid
+        # can't parse it or the structured id won't round-trip through the index
+        # (matching FileIO's `id_supported?` acceptance test).
+        #
+        # @param id [String]
+        # @return [::Pubid::Ieee::Identifier, nil]
+        def pubid(id)
+          pid = ::Pubid::Ieee::Identifier.parse id
+          hash = pid.to_hash
+          return nil unless ::Pubid::Ieee::Identifier.from_hash(hash).to_hash == hash
+
+          pid
+        rescue StandardError
+          nil
+        end
+      end
+
       #
       # Convert documents from `ieee-rawbib` dir (IEEE dataset) to BibYAML/BibXML
       #
@@ -229,10 +313,22 @@ module Relaton
 
         normtitle = cheap_extract_field(xml, "normtitle")
         stdnumber = cheap_extract_field(xml, "stdnumber")
+        # Drop it here as well as in #parse_entry: the winner selection groups
+        # files by docnumber, so a white paper that reads as `IEEE Std 802`
+        # would join the group of the real standard and push its file out.
+        subtype = cheap_extract_field(xml, "publicationsubtype")
+        return nil if no_standard_number?(subtype, stdnumber)
+
         docnumber = nil
         if normtitle && stdnumber
           pubid = RawbibIdParser.parse(normtitle, stdnumber)
-          docnumber = pubid&.to_id
+          # The article title (what `IdamsParser#pubid` compares against) is
+          # the *last* `<title>` in the file: the top-level one (first) is the
+          # designation, present even for a real standard.
+          title = cheap_extract_field(xml, "title", last: true)
+          isbn = xml.include?("<isbn")
+          fabricated = RawbibIdParser.fabricated_title_id?(pubid, title, isbn)
+          docnumber = pubid&.to_s unless fabricated
         end
         [idx, file, docnumber, file.include?("/updates.")]
       rescue StandardError
@@ -241,9 +337,28 @@ module Relaton
         [idx, file, nil, file.include?("/updates.")]
       end
 
-      def cheap_extract_field(xml, tag)
-        m = xml.match(%r{<#{tag}[^>]*?>(?:<!\[CDATA\[)?(.*?)(?:\]\]>)?</#{tag}>}m)
-        m && m[1].strip
+      #
+      # True when the record has no standard number. IEEE gives a white paper
+      # or a research document no designation, so `stdnumber` holds a category
+      # and `normtitle` holds a title. An id built from either is a title
+      # fragment, and records that share a fragment overwrite each other's
+      # output file. Both conditions are required: a record of such a subtype
+      # that does carry a number keeps it.
+      #
+      # @param [String, nil] subtype document element "publicationsubtype"
+      # @param [String, nil] stdnumber document element "stdnumber"
+      #
+      # @return [Boolean]
+      #
+      def no_standard_number?(subtype, stdnumber)
+        NON_STANDARD_SUBTYPES.include?(subtype) && !stdnumber.to_s.match?(/\d/)
+      end
+
+      def cheap_extract_field(xml, tag, last: false)
+        re = %r{<#{tag}[^>]*?>(?:<!\[CDATA\[)?(.*?)(?:\]\]>)?</#{tag}>}m
+        matches = xml.scan(re)
+        m = last ? matches.last : matches.first
+        m && m[0].strip
       end
 
       def select_prefilter_winners(index, total)
@@ -326,12 +441,16 @@ module Relaton
 
         # Stragglers: any remaining staged files (losing duplicates,
         # or bib filenames that didn't end up in saved_writes due to a
-        # crash) get cleaned up so they don't pollute `data/`.
-        Dir.glob(File.join(@output, "*.#{@ext}.*")).each do |f|
+        # crash) get cleaned up so they don't pollute `data/`. Log the
+        # count so an unexpectedly large sweep (e.g. a worker that lost
+        # its state) is visible instead of silent.
+        stragglers = Dir.glob(File.join(@output, "*.#{@ext}.*"))
+        stragglers.each do |f|
           File.unlink(f)
         rescue StandardError
           # ignore — best-effort cleanup
         end
+        Util.info "Reconcile: cleaned #{stragglers.size} staged straggler(s)" unless stragglers.empty?
       end
 
       #
@@ -407,12 +526,7 @@ module Relaton
         pid = Process.fork do
           batch_files.each_with_index do |file, i|
             glob_idx = base_idx + i
-            result = parse_entry(glob_idx, file)
-            next unless result
-
-            _, _, doc, bib, local_errors = result
-            merge_errors(local_errors)
-            commit_doc(doc, bib, file, glob_idx)
+            commit_entry(glob_idx, file, glob_idx)
           end
           File.binwrite(state_path, Marshal.dump(
             backrefs:     backrefs,
@@ -469,12 +583,32 @@ module Relaton
       def run_shard(shard, _shard_idx)
         shard.each_with_index do |entry, i|
           idx, file = entry.is_a?(Array) ? entry : [i, entry]
-          result = parse_entry(idx, file)
-          next unless result
+          commit_entry(idx, file)
+        end
+      end
 
-          _, _, doc, bib, local_errors = result
-          merge_errors(local_errors)
-          commit_doc(doc, bib, file)
+      #
+      # Parse one file and commit it, guarding the commit so a single bad
+      # document (e.g. a pathological docnumber that would raise
+      # Errno::ENAMETOOLONG) logs and is skipped rather than aborting the
+      # serial crawl or killing a parallel worker before it persists its
+      # state. Shared by the serial (`run_shard`) and parallel
+      # (`spawn_batch`) paths.
+      #
+      # @param [Integer] idx original glob index (preserves dedup order)
+      # @param [String] file path to rawbib file
+      # @param [Integer, nil] glob_idx staging index for parallel mode
+      #
+      def commit_entry(idx, file, glob_idx = nil)
+        result = parse_entry(idx, file)
+        return unless result
+
+        _, _, doc, bib, local_errors = result
+        merge_errors(local_errors)
+        begin
+          commit_doc(doc, bib, file, glob_idx)
+        rescue StandardError => e
+          Util.error "commit failed for `#{file}`: #{e.class}: #{e.message}"
         end
       end
 
@@ -501,6 +635,13 @@ module Relaton
         end
         return nil if doc.publicationinfo&.standard_id == "0"
 
+        info = doc.publicationinfo
+        if no_standard_number?(info&.publicationsubtype, info&.stdnumber)
+          Util.warn "No standard number. Normtitle: `#{doc.normtitle}`, " \
+                    "file: `#{file}`"
+          return nil
+        end
+
         local_errors = Hash.new(true)
         bib = IdamsParser.new(doc, self, local_errors).parse
         if bib.docnumber.nil?

data/lib/relaton/ieee/idams_parser.rb

@@ -43,23 +43,28 @@ module Relaton
       #
       # Parse docnumber
       #
-      # @return [String] PubID
+      # @return [String, nil] canonical pubid string, or nil when unparseable
       #
       def docnumber
-        @docnumber ||= pubid&.to_id
+        @docnumber ||= pubid&.to_s
       end
 
       #
-      # Create PubID
+      # Resolve the document's IEEE identifier (pubid-first, RawbibIdParser
+      # fallback).
       #
-      # @return [Relaton::Ieee::RawbibIdParser] PubID
+      # @return [::Pubid::Ieee::Identifier, nil]
       #
       def pubid
-        @pubid ||= begin
-          normtitle = @doc.normtitle
-          stdnumber = @doc.publicationinfo.stdnumber
-          RawbibIdParser.parse(normtitle, stdnumber)
-        end
+        return @pubid if defined?(@pubid)
+
+        normtitle = @doc.normtitle
+        stdnumber = @doc.publicationinfo.stdnumber
+        pid = RawbibIdParser.parse(normtitle, stdnumber)
+        title = @doc.btitle.find { |t| t[:type] == "main" }&.dig(:content)
+        isbn = @doc.isbn_doi.any? { |id| id[:type] == "ISBN" }
+        fabricated = RawbibIdParser.fabricated_title_id?(pid, title, isbn)
+        @pubid = fabricated ? nil : pid
       end
 
       #
@@ -92,8 +97,10 @@ module Relaton
       def parse_docidentifier # rubocop:disable Metrics/MethodLength
         ids = @doc.isbn_doi.map { |id| id[:content] = id.delete(:id); id }
 
-        ids.unshift(content: pubid.to_s(trademark: true), scope: "trademark", type: "IEEE", primary: true)
-        ids.unshift(content: pubid.to_s, type: "IEEE", primary: true)
+        if pubid
+          ids.unshift(content: pubid.to_s(trademark: true), scope: "trademark", type: "IEEE", primary: true)
+          ids.unshift(content: pubid.to_s, type: "IEEE", primary: true)
+        end
 
         result = ids.map { |dcid| Bib::Docidentifier.new(**dcid) }
         @errors[:docidentifier] &&= result.empty?

data/lib/relaton/ieee/processor.rb

@@ -8,6 +8,7 @@ module Relaton
       def initialize # rubocop:disable Lint/MissingSuper
         @short = :relaton_ieee
         @prefix = "IEEE"
+        @pubid_flavor = :Ieee # global prefixes sourced from Pubid::Ieee.prefixes
         @defaultprefix = %r{^(?:(?:(?:ANSI|NACE)/)?IEEE|ANSI|AIEE|ASA|NACE|IRE)\s}
         @idtype = "IEEE"
         @datasets = %w[ieee-rawbib]
@@ -61,7 +62,9 @@ module Relaton
       #
       def remove_index_file
         require_relative "../ieee"
-        Relaton::Index.find_or_create(:ieee, url: true, file: "#{INDEXFILE}.yaml").remove_file
+        Relaton::Index.find_or_create(
+          :ieee, url: true, file: "#{INDEXFILE}.yaml"
+        ).remove_file
       end
     end
   end