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

data/lib/relaton/jis/hit_collection.rb

@@ -36,23 +36,15 @@ module Relaton
       #   the list of available edition years when none match the requested year
       #
       def find
-        if pubid.year
-          find_by_year pubid.year
-        else
-          find_all_years
-        end
+        pubid.year ? find_by_year : find_all_years
       end
 
-      def find_by_year(ref_year)
-        missed_years = []
-        @array.each do |hit|
-          next unless hit.matches?
-
-          return hit.item if hit.pubid.year.to_s == ref_year.to_s
-
-          missed_years << hit.pubid.year
-        end
-        missed_years
+      # The item of the requested edition. When no edition has the requested
+      # year, the years of the matching editions are returned.
+      def find_by_year
+        editions = @array.select(&:matches?)
+        hit = edition_hit editions
+        hit ? hit.item : editions.map { |h| h.pubid.year }
       end
 
       # The main item is the latest edition of the requested type; every other
@@ -69,9 +61,11 @@ module Relaton
 
       # The lowest-numbered part becomes the all-parts umbrella; every candidate
       # sharing the series and number is attached as an `instanceOf` relation.
+      # A part-less document counts as part 0. Its index row deserializes with
+      # `parts` nil, not [].
       def find_all_parts
         parts = @array.select { |hit| hit.matches? all_parts: true }
-        lowest = parts.min_by { |hit| hit.pubid.parts.first.to_i }
+        lowest = parts.min_by { |hit| Array(hit.pubid.parts).first.to_i }
         item = lowest.item.to_all_parts
         attach_relations item, item.docidentifier.first.content
       end
@@ -101,14 +95,21 @@ module Relaton
       def index
         @index ||= Relaton::Index.find_or_create(
           :jis,
-          url: "#{GH_URL}#{INDEXFILE_V2}.zip",
-          file: "#{INDEXFILE_V2}.yaml",
+          url: "#{GH_URL}#{INDEXFILE}.zip",
+          file: "#{INDEXFILE}.yaml",
           pubid_class: ::Pubid::Jis::Identifier,
         )
       end
 
       private
 
+      # The exact printed id comes first, then the same identifier without the
+      # reaffirmation mark (`JIS L 4107:2000` finds `JIS L 4107:2000R`).
+      def edition_hit(editions)
+        editions.find { |h| h.pubid.to_s == pubid.to_s } ||
+          editions.find { |h| h.pubid.matches? pubid, ignore: [:reaffirmed] }
+      end
+
       # Broad candidate filter: same series and number as the reference. For a
       # supplement (amendment/corrigendum/explanation) the document series and
       # number live on `base`, so compare against that.

data/lib/relaton/jis/processor.rb

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

data/lib/relaton/jis.rb

@@ -15,9 +15,8 @@ require_relative "jis/bibliography"
 
 module Relaton
   module Jis
-    INDEXFILE = "index-v1"
-    # Pubid-based index produced alongside index-v1 during the pubid migration.
-    INDEXFILE_V2 = "index-v2"
+    # The pubid index. relaton-data-jis rebuilds the legacy index-v1 from data/.
+    INDEXFILE = "index-v2"
 
     class Error < StandardError; end
 

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

@@ -1,14 +1,15 @@
 require "net/http"
+require "json"
 
 module Relaton
   module Logger
     module Channels
       #
-      # This class is used to create a GitHub issue with the log content.
-      # The issue will be created in the repository specified in the
-      # initializer.
+      # This class is used to report the log content as a GitHub issue in the
+      # repository specified in the initializer.
       # The log content is stored in the issue body. Only unique log messages
-      # are stored.
+      # are stored. When an open issue with the same title already exists, the
+      # log is added to it as a comment rather than opening a duplicate.
       # Token is required to create an issue. It should be stored in the
       # environment variable GITHUB_TOKEN.
       # To create an issue, call the create_issue method after all log messages
@@ -35,33 +36,97 @@ module Relaton
         def close
         end
 
+        # Report the collected log. A crawler runs on a schedule, so creating a
+        # fresh issue every time would pile up duplicates of the same standing
+        # report; when an open issue with this title already exists, add the run's
+        # log as a comment on it instead.
         def create_issue
           return if @log.empty? || ENV["GITHUB_TOKEN"].nil?
 
-          responce = post_issue
-
-          if responce.code.to_i == 201
-            puts "Issue created!"
+          if (number = open_issue_number)
+            report_response post_comment(number), "Issue #{number} commented!", 201
           else
-            puts "Failed to create issue: #{responce.code} #{responce.message}\n#{responce.body}"
+            report_response post_issue, "Issue created!", 201
           end
         end
 
         private
 
-        def post_issue
-          uri = URI("https://api.github.com/repos/#{@repo}/issues")
+        def report_response(responce, success_message, success_code)
+          if responce.code.to_i == success_code
+            puts success_message
+          else
+            puts "Failed to report issue: #{responce.code} #{responce.message}\n#{responce.body}"
+          end
+        end
+
+        # Number of the open issue with exactly this title, or nil. Any failure
+        # (network, rate limit, missing search scope) degrades to nil, so the
+        # worst case is the previous behaviour — a new issue.
+        def open_issue_number
+          query = "repo:#{@repo} is:issue is:open in:title \"#{@title}\""
+          uri = URI("https://api.github.com/search/issues")
+          uri.query = URI.encode_www_form(q: query, per_page: 100)
+          responce = get(uri)
+          return nil unless responce.code.to_i == 200
+
+          items = JSON.parse(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}"
+          nil
+        end
+
+        def get(uri)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.request(Net::HTTP::Get.new(uri.request_uri, headers))
+        end
+
+        def post(uri, body)
           http = Net::HTTP.new(uri.host, uri.port)
           http.use_ssl = true
 
           request = Net::HTTP::Post.new(uri.request_uri, headers)
-          request.body = issue_body.to_json
+          request.body = body.to_json
 
           http.request(request)
         end
 
+        def post_issue
+          post URI("https://api.github.com/repos/#{@repo}/issues"), issue_body
+        end
+
+        def post_comment(number)
+          post URI("https://api.github.com/repos/#{@repo}/issues/#{number}/comments"),
+               { body: body }
+        end
+
         def issue_body
-          { title: @title, body: @log.join("\n") }
+          { title: @title, body: body }
+        end
+
+        # GitHub rejects an issue or comment body longer than this with a 422,
+        # which loses the whole report — and these reports get long (a crawl can
+        # log hundreds of ids it could not index). Keep as many whole lines as
+        # fit and say how many were left out.
+        MAX_BODY = 65_536
+        TRUNCATION_ROOM = 200
+
+        def body
+          lines = @log.to_a
+          text = lines.join("\n")
+          return text if text.length <= MAX_BODY
+
+          kept = []
+          size = 0
+          lines.each do |line|
+            break if size + line.length + 1 > MAX_BODY - TRUNCATION_ROOM
+
+            kept << line
+            size += line.length + 1
+          end
+          "#{kept.join("\n")}\n\n…and #{lines.size - kept.size} more (see the run log)"
         end
 
         def headers

data/lib/relaton/nist/data_fetcher.rb

@@ -9,44 +9,94 @@ require_relative "mods_parser"
 module Relaton
   module Nist
     class DataFetcher < Core::DataFetcher
-      URL = "https://github.com/usnistgov/NIST-Tech-Pubs/releases/download/Nov2024/allrecords-MODS.xml"
+      RELEASES_URL = "https://github.com/usnistgov/NIST-Tech-Pubs/releases"
+      MODS_ASSET = "allrecords-MODS.xml"
 
-      def fetch(_source = nil)
+      def fetch(source = nil)
         FileUtils.rm Dir[File.join(@output, "*.#{@ext}")]
-        fetch_tech_pubs
+        fetch_tech_pubs source
         # add_static_files
         index.save
         report_errors
       end
 
-      def fetch_tech_pubs
-        xml_data = Mechanize.new.get(URL).body
+      def fetch_tech_pubs(source = nil)
+        xml_data = Mechanize.new.get(source_url(source)).body
         docs = LocMods::Collection.from_xml xml_data
         docs.mods.each { |doc| write_file ModsParser.new(doc, series, @errors).parse }
       end
 
+      # Build the MODS download URL for a NIST-Tech-Pubs release. With no tag
+      # (nil, blank, or "latest") use GitHub's `latest/download` redirect so new
+      # releases are picked up automatically by the crawler; a concrete tag
+      # (e.g. "June2026") pins that specific release.
+      def source_url(source = nil)
+        tag = source.to_s.strip
+        path = tag.empty? || tag.casecmp?("latest") ? "latest/download" : "download/#{tag}"
+        "#{RELEASES_URL}/#{path}/#{MODS_ASSET}"
+      end
+
       def write_file(bib)
         id = bib.docidentifier.find(&:primary) || bib.docidentifier.first
-        file = output_file id.content.sub(/^NIST IR/, "NISTIR")
+        unless id
+          failures << "Document skipped: no identifier (#{document_label(bib)})"
+          return
+        end
+        # Distinct docids can sanitize to one filename; take a path of our own
+        # rather than overwriting the other document (Core#unique_output_file).
+        docid = id.content.sub(/^NIST IR/, "NISTIR")
+        file = unique_output_file docid
         if @files.include? file
+          # Same reserved path == same docid: a genuine duplicate. Checked FIRST,
+          # because a disambiguated path stays != output_file forever.
           Util.warn "File #{file} exists. Docid: #{id.content}"
-        else @files << file
+        elsif file != output_file(docid)
+          Util.warn "File #{output_file docid} exists. Docid: #{id.content}. Writing #{file} instead."
         end
+        @files << file
         pid = pubid id.content
-        index.add_or_update pid, file if pid
+        if pid
+          index.add_or_update pid, file
+        else
+          failures << "Unparseable id `#{id.content}` was not indexed (#{file})"
+        end
         File.write file, serialize(bib), encoding: "UTF-8"
       end
 
-      # Parse a docidentifier string into a Pubid::Nist::Identifier; nil (with a
-      # warning) if pubid can't parse it, so a single bad id never aborts the
-      # crawl or corrupts index-v2.
+      # A human-readable label for a bib with no usable docidentifier, so the
+      # skipped record is identifiable in the reported error.
+      def document_label(bib)
+        Array(bib.title).map(&:content).compact.reject(&:empty?).first || "unknown title"
+      end
+
+      # Parse a docidentifier string into a Pubid::Nist::Identifier, or nil if
+      # pubid can't parse it — so a single bad id never aborts the crawl or
+      # corrupts index-v2. The caller records the failure (see #write_file) so
+      # #report_errors can surface it as a tracked GitHub issue.
       def pubid(id)
         ::Pubid::Nist::Identifier.parse id
-      rescue StandardError => e
-        Util.warn "Failed to parse `#{id}` with pubid: #{e.message}"
+      rescue StandardError
         nil
       end
 
+      # Per-document failures (unparseable ids, identifier-less records)
+      # collected during the crawl and surfaced by #report_errors.
+      def failures
+        @failures ||= []
+      end
+
+      # Surface accumulated per-document failures through the shared error
+      # machinery (the "Error fetching documents" GitHub issue in CI) so they
+      # are visible and tracked, not a hard crash or a silent stderr warning.
+      # The gh_issue channel is registered inside #report_errors, so emit these
+      # at :error (via #log_error) after it is set up and before super creates
+      # the issue.
+      def report_errors
+        gh_issue
+        failures.each { |msg| log_error msg }
+        super
+      end
+
       # def add_static_files
       #   Dir["./static/*.yaml"].each do |file|
       #     bib = Item.from_yaml(File.read(file, encoding: "UTF-8"))

data/lib/relaton/nist/docidentifier.rb

@@ -0,0 +1,165 @@
+module Relaton
+  module Nist
+    # NIST document identifier backed by a parsed Pubid::Nist::Identifier.
+    #
+    # Mirrors the CCSDS/IEC flavors (lib/relaton/ccsds/model/docidentifier.rb,
+    # lib/relaton/iec/model/docidentifier.rb): the lutaml `content` stays a plain
+    # string for serialization, while the parsed pubid is kept in `@pubid` so the
+    # base class's abstract structural mutators (`remove_part!`, `remove_date!`,
+    # `to_all_parts!`) can edit the identifier graph and re-render.
+    #
+    # NIST-specific caveats:
+    # - **A pubid is only adopted when it round-trips.** A NIST DOI such as
+    #   `NIST.SP.800-162` is itself a valid NIST pubid in dotted MR form, but it
+    #   must serialize verbatim (its `:human` render is `NIST SP 800-162`). So
+    #   `content=` keeps the parsed pubid only when `pubid.to_s(:human)` equals
+    #   the input; otherwise the raw string is preserved. This test is
+    #   type-independent, so it holds no matter what order lutaml assigns
+    #   `content`/`type` on `from_xml`/`from_yaml` (unlike a `type == "NIST"`
+    #   gate, which sees a nil `type` on the YAML setter-ordering path).
+    # - **The date lives in the `edition` component, not a `:date` attribute.**
+    #   NIST has no single date field (`year`/`month` scalars are nil on the
+    #   common parse paths); a publication year is carried as the edition id
+    #   (`FIPS 46e1977`) or its trailing `additional_text` (`NBS CIRC 11e2.1915`).
+    #   So `remove_date!` clears the scalar date fields *and* the edition's
+    #   year component, while preserving non-year editions/revisions (`r5`, `e2`).
+    #   Dates carried in the `update` component (some NBS supplements) are left
+    #   intact — `update` also encodes non-date update codes (`/Upd2`).
+    # - **No `(all parts)` marker in `content`.** `content` is live-derived
+    #   from `@pubid` (see below), so `to_all_parts!` freezes the already
+    #   part+date+stage-stripped rendering into `@raw_content` before
+    #   wrapping `@pubid` — matching IEC/CCSDS. `#pubid` itself, read
+    #   directly, now answers `all_parts? == true` and renders WITH pubid's
+    #   generic "(all parts)" marker, since it's the wrapper.
+    class Docidentifier < Bib::Docidentifier
+      attribute :content, :string
+
+      attr_reader :pubid
+
+      YEAR = /\A\d{4}\z/
+
+      def initialize(arg = nil, **kwargs)
+        arg.is_a?(Hash) ? super(arg) : super(**kwargs)
+        # `super` normally runs `content=` via lutaml's attribute application; the
+        # re-run is a fallback for construction paths that skip it (so the value
+        # is parsed exactly once in the common case).
+        raw = arg.is_a?(Hash) ? (arg["content"] || arg[:content]) : kwargs[:content]
+        self.content = raw if raw && @pubid.nil? && @raw_content.nil?
+      end
+
+      alias_method :original_content=, :content=
+      alias_method :original_content, :content
+
+      def content=(value)
+        @pubid = nil
+        @raw_content = nil
+
+        parsed = value.is_a?(::Pubid::Nist::Identifier) ? value : parse_pubid(value)
+
+        # Adopt the pubid only when it renders back to the exact input, so
+        # non-canonical forms (DOIs) are preserved as the raw string.
+        if parsed && (!value.is_a?(::String) || parsed.to_s(format: :human) == value)
+          @pubid = parsed
+        elsif value.is_a?(::String)
+          @raw_content = value
+        end
+
+        send(:original_content=, to_s)
+      end
+
+      def content
+        return @raw_content if @raw_content
+        return @pubid.to_s(format: :human) if @pubid
+
+        original_content
+      end
+
+      def to_s
+        content.to_s
+      end
+
+      # `#exclude` (no args) clones the whole graph (incl. a supplement's
+      # base), since `walk_chain` mutates it in place. `@raw_content` freezes
+      # the stripped rendering — `content` is live from `@pubid`, and the
+      # wrapper would otherwise add pubid's generic "(all parts)" marker,
+      # which pubid-nist itself never has. `identifiers` then keeps the
+      # ORIGINAL part/date/stage, not the stripped working copy.
+      def to_all_parts!
+        return if !@pubid || @pubid.all_parts?
+
+        original = @pubid.exclude
+        remove_part!
+        remove_date!
+        remove_stage!
+        @raw_content = to_s
+        @pubid = original.to_all_parts
+      end
+
+      def remove_part!
+        walk_chain { |node| clear_part_on(node) }
+      end
+
+      def remove_stage!
+        walk_chain { |node| node.stage = nil if node.respond_to?(:stage=) }
+      end
+
+      def remove_date!
+        walk_chain { |node| clear_date_on(node) }
+      end
+
+      private
+
+      def parse_pubid(value)
+        return nil unless value.is_a?(::String) && !value.empty?
+
+        ::Pubid::Nist::Identifier.parse(value)
+      rescue StandardError
+        Util.warn "Failed to parse Pubid: #{value}"
+        nil
+      end
+
+      # Apply a mutation to the top pubid and every identifier down the
+      # `base` chain (only SupplementIdentifier exposes the chain; a
+      # plain identifier returns nil and the walk terminates after one pass).
+      def walk_chain
+        return unless @pubid
+
+        node = @pubid
+        while node
+          yield node
+          node = node.respond_to?(:base) ? node.base : nil
+        end
+        refresh_content!
+      end
+
+      def clear_part_on(pubid)
+        pubid.part = nil if pubid.respond_to?(:part=)
+        pubid.parts = nil if pubid.respond_to?(:parts=)
+      end
+
+      # NIST spreads the date across scalar fields (mostly nil in practice) and
+      # the edition component. Clear the scalars, then strip a year that rides on
+      # the edition: a trailing year suffix (`e2.1915` -> `e2`) or a whole
+      # bare-year edition (`e1977`/`r2001` -> gone), while leaving numbered
+      # editions and revisions (`e2`, `r5`) intact.
+      def clear_date_on(pubid)
+        %i[year month revision_year revision_month edition_year update_year]
+          .each { |f| pubid.send("#{f}=", nil) if pubid.respond_to?("#{f}=") }
+
+        return unless pubid.respond_to?(:edition) && (ed = pubid.edition)
+
+        if ed.respond_to?(:additional_text) && ed.additional_text.to_s.match?(YEAR)
+          ed.additional_text = nil
+        end
+        return unless ed.respond_to?(:id) && ed.id.to_s.match?(YEAR) &&
+          (!ed.respond_to?(:additional_text) || ed.additional_text.nil?)
+
+        pubid.edition = nil if pubid.respond_to?(:edition=)
+      end
+
+      def refresh_content!
+        send(:original_content=, to_s)
+      end
+    end
+  end
+end

data/lib/relaton/nist/item.rb

@@ -1,4 +1,5 @@
 require_relative "date"
+require_relative "docidentifier"
 require_relative "ext"
 
 module Relaton
@@ -9,6 +10,7 @@ module Relaton
     class Item < Bib::Item
       model ItemData
 
+      attribute :docidentifier, Docidentifier, collection: true, initialize_empty: true
       attribute :date, Date, collection: true
       attribute :relation, Relation, collection: true, initialize_empty: true
       attribute :ext, Ext

data/lib/relaton/nist/item_base.rb

@@ -0,0 +1,16 @@
+require_relative "docidentifier"
+
+module Relaton
+  module Nist
+    # Nested bibitem used inside Relation. Mirrors Iso::ItemBase / Iec::ItemBase:
+    # overrides the shared docidentifier/relation with the NIST-flavored types so
+    # a relation's cross-reference ids are Nist::Docidentifier too (keeping the
+    # whole tree's docidentifier collections a single, YAML-serializable type).
+    class ItemBase < Bib::ItemBase
+      model ItemData
+
+      attribute :docidentifier, Docidentifier, collection: true, initialize_empty: true
+      attribute :relation, Relation, collection: true, initialize_empty: true
+    end
+  end
+end

data/lib/relaton/nist/mods_parser.rb

@@ -26,7 +26,7 @@ module Relaton
         args = ATTRS.each_with_object({}) do |attr, hash|
           hash[attr] = send("parse_#{attr}")
         end
-        args[:ext] = Ext.new(doctype: parse_doctype, flavor: "nilst")
+        args[:ext] = Ext.new(doctype: parse_doctype, flavor: "nist")
         ItemData.new(**args)
       end
 
@@ -39,7 +39,10 @@ module Relaton
           { type: "DOI", content: parse_doi },
         ].reject { |id| id[:content].nil? || id[:content].empty? }
         @errors[:docidentifier] &&= ids.empty?
-        ids.map { |id| Bib::Docidentifier.new(**id) }
+        # All ids share the Nist::Docidentifier collection type (Item#docidentifier)
+        # so YAML serialization stays valid; the DOI is not canonical NIST pubid
+        # form, so the class keeps it as the raw string (see Docidentifier#content=).
+        ids.map { |id| Docidentifier.new(**id) }
       end
 
       # @return [String]
@@ -55,7 +58,7 @@ module Relaton
         # not any inside the number). Then force :human rendering.
         spaced = str.sub(/\A(NIST|NBS)\.([A-Z][A-Za-z]*)\./, '\1 \2 ')
         ::Pubid::Nist::Identifier.parse(spaced).to_s(format: :human)
-      rescue Parslet::ParseFailed
+      rescue ::Pubid::Errors::ParseError
         str.gsub(".", " ").sub(/^[\D]+/, &:upcase)
       end
 
@@ -154,21 +157,36 @@ module Relaton
       def parse_doctype = Doctype.new(content: "standard")
 
       def parse_contributor
-        # exclude primary contributors to avoid duplication
-        contributor = @doc.name.reject { |n| n.usage == "primary" }.map do |name|
+        seen = []
+        contributor = @doc.name.filter_map do |name|
           entity, default_role = create_entity(name)
           next unless entity
 
+          # A name may appear twice — as the `usage="primary"` main entry and
+          # again as a plain added entry. Keep the first (primary) occurrence
+          # and drop the duplicate, so the lead author is retained, not doubled.
+          key = contributor_key(name)
+          next if seen.include?(key)
+
+          seen << key
           role = (name.role || []).reduce([]) do |a, r|
             a + r.role_term.map { |rt| Bib::Contributor::Role.new(type: rt.content) }
           end
           role << Bib::Contributor::Role.new(type: default_role) if role.empty?
           create_contributor(entity, role)
-        end.compact
+        end
         @errors[:contributor] &&= contributor.empty?
         contributor
       end
 
+      # De-duplication signature for a contributor: its type, its non-date name
+      # parts, and its authority id — so identically-named people with distinct
+      # authority ids are still kept separate.
+      def contributor_key(name)
+        parts = name.name_part.reject(&:type).map { |p| p.content&.strip }
+        [name.type, parts, name.name_identifier&.first&.content]
+      end
+
       def create_contributor(entity, role)
         case entity
         when Bib::Person
@@ -228,17 +246,25 @@ module Relaton
         item_id = get_id_from_str related_item_id(item)
         return if item_id.nil? || item_id.empty?
 
-        docid = Bib::Docidentifier.new(type: "NIST", content: item_id)
+        docid = Docidentifier.new(type: "NIST", content: item_id)
         fref = Bib::Formattedref.new(content: item_id)
         ItemData.new(docidentifier: [docid], formattedref: fref)
       end
 
+      # Derive the related document's DOI id. Prefer an `otherType` that carries
+      # a `10.6028` DOI — it may be embedded in prose (e.g. "Translation of |a
+      # 10.6028/NIST.SP.1299" or "Supersedes … https://doi.org/10.6028/…"), not
+      # only a bare DOI — otherwise fall back to the `<name><namePart>`. Returns
+      # nil (relation skipped by #create_related_item) when neither yields a DOI,
+      # so a related item with no name and no DOI never aborts the crawl.
       def related_item_id(item)
-        if item.other_type && item.other_type[0..6] == "10.6028"
-          item.other_type
-        else
-          item.name[0].name_part[0].content
-        end => id
+        id = if item.other_type&.include?("10.6028")
+               item.other_type
+             else
+               item.name&.first&.name_part&.first&.content
+             end
+        return if id.nil?
+
         doi = remove_doi_prefix(id)
         return if doi.nil?
 

data/lib/relaton/nist/processor.rb

@@ -6,6 +6,7 @@ module Relaton
       def initialize # rubocop:disable Lint/MissingSuper
         @short = :relaton_nist
         @prefix = "NIST"
+        @pubid_flavor = :Nist # global prefixes sourced from Pubid::Nist.prefixes
         @defaultprefix = %r{^(NIST|NBS|NISTGCR|ITL Bulletin|JPCRD|NISTIR|CSRC|FIPS)(/[^\s])?\s}
         @idtype = "NIST"
         @datasets = %w[nist-tech-pubs]
@@ -60,7 +61,7 @@ module Relaton
       def remove_index_file
         require_relative "../nist"
         Relaton::Index.find_or_create(
-          :nist, url: true, file: "#{INDEXFILE}.yaml", pubid_class: ::Pubid::Nist::Identifier
+          :nist, url: true, file: "#{INDEXFILE}.yaml"
         ).remove_file
       end
     end

data/lib/relaton/nist/relation.rb

@@ -1,7 +1,10 @@
+require_relative "item_base"
+
 module Relaton
   module Nist
     class Relation
       attribute :type, :string, values: %w[obsoletedBy supersedes supersededBy]
+      attribute :bibitem, ItemBase
     end
   end
 end