relaton-nist 1.12.2 → 1.12.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81b3111f5bb486625e9b8028bd607a00de151487d9b7114d88ba54f219b7cd07
-  data.tar.gz: df54cc75c2228c28ce4e04e1faddbb672446560c99aad3f804308fd1a7eb57eb
+  metadata.gz: 4c73a4a75166a362d34e2d1a4bec088d74863cf1ac9a4eee0798cfa84cbceca6
+  data.tar.gz: 398bd9b074c7c10da66c86047e617e7b643ea6cc3e45f1daa6fdd6f43d38bb4c
 SHA512:
-  metadata.gz: 2776eebb515b1ddbdb72f3ce4f31df912e2b2eb92eb7d6200462686d48676f17473e1668050fc4397cab720b1ff4e24b10b45df3cc8623413dfe0e75212f480c
-  data.tar.gz: 14c30c1e0f58c26075e55a0f7c3ded41cac1a4122844fb11efe3cf1052b13048ceada426bfa0983bd28ef6b9f29b3e508ffbe7a405ea222b7885c8273b9db794
+  metadata.gz: 7695197e53d2d8b8b2048f034c6d47db2ce293f7f8dedafacefae8efb4ad85ed96169f5b317957a228b32bfa1e9a8899b80238aa8be594edd94e89619c9fbb51
+  data.tar.gz: 1b2eb51d32d0b0eb9456242e5727b891468509a55cdc2ce2251fa84857b83d6d29966bb3799557672da7cabc126949f0cc18d6581cb9464caa38293a317a7265

data/README.adoc

@@ -1,4 +1,4 @@
-= RelatonNist: retrieve NIST Standards for bibliographic use using the BibliographicItem model
+= Relaton for NIST: bibliographic retrieval of NIST publications
 
 image:https://img.shields.io/gem/v/relaton-nist.svg["Gem Version", link="https://rubygems.org/gems/relaton-nist"]
 image:https://github.com/relaton/relaton-nist/workflows/macos/badge.svg["Build Status (macOS)", link="https://github.com/relaton/relaton-nist/actions?workflow=macos"]
@@ -8,10 +8,41 @@ image:https://codeclimate.com/github/relaton/relaton-nist/badges/gpa.svg["Code C
 image:https://img.shields.io/github/issues-pr-raw/relaton/relaton-nist.svg["Pull Requests", link="https://github.com/relaton/relaton-nist/pulls"]
 image:https://img.shields.io/github/commits-since/relaton/relaton-nist/latest.svg["Commits since latest",link="https://github.com/relaton/relaton-nist/releases"]
 
+== Purpose
 
-RelatonNist is a Ruby gem that implements the https://github.com/metanorma/metanorma-model-iso#iso-bibliographic-item[IsoBibliographicItem model].
+`relaton-nist` provides bibliographic information of NIST publications using the
+https://github.com/metanorma/metanorma-model-nist#nist-bibliographic-item-model[NistBibliographicItem model].
+
+Relaton for NIST has been developed in cooperation with the NIST Cybersecurity
+Resource Center (CSRC) and the Computer Security Division (ITL/CSD).
+
+== Data sources
+
+Relaton for NIST retrieves bibliographic information from two sources:
+
+* bibliographic feed from the NIST Cybersecurity Resource Center (CSRC) of
+all CSRC publications (in Relaton JSON)
+* bibliographic dataset from the NIST Library through the Information Services
+Office (ISO) that contains information about all NIST Technical Publications
+(https://github.com/usnistgov/NIST-Tech-Pubs[GitHub])
+
+Bibliographic information offered through CSRC are provided with enhanced
+metadata that is not available at the NIST Library dataset, including:
+
+* public drafts (the NIST Library dataset only contains final publications)
+* revision information: revision number, iteration
+* document stage information: retired, withdrawn, etc.
+* bibliographic dates, including issued date, updated date, published date,
+  obsolete date, commenting period
+* document relationships: supersession and replacements
+* contacts: enhanced name parts and affiliation information
+
+Relaton for NIST therefore uses the following order of priority for the data
+sources:
+
+. bibliographic feed from NIST CSRC
+. NIST Library dataset
 
-You can use it to retrieve metadata of NIST Standards from https://csrc.nist.gov, and access such metadata through the `IsoBibliographicItem` object.
 
 == Installation
 

data/lib/relaton_nist/data_fetcher.rb

@@ -137,26 +137,10 @@ module RelatonNist
 
     # @param doc [Nokogiri::XML::Element]
     # @return [Array<Hash>]
-    def fetch_contributor(doc) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+    def fetch_contributor(doc)
       contribs = doc.xpath("contributors/person_name").map do |p|
-        forename = []
-        initial = []
-        p.at("given_name")&.text&.split&.each do |fn|
-          if /^(?<init>\w)\.?$/ =~ fn
-            initial << RelatonBib::LocalizedString.new(init, doc["language"], "Latn")
-          else
-            forename << RelatonBib::LocalizedString.new(fn, doc["language"], "Latn")
-          end
-        end
-        sname = p.at("surname").text
-        surname = RelatonBib::LocalizedString.new sname, doc["language"], "Latn"
-        ident = p.xpath("ORCID").map do |id|
-          RelatonBib::PersonIdentifier.new "orcid", id.text
-        end
-        fullname = RelatonBib::FullName.new(
-          surname: surname, forename: forename, initial: initial, identifier: ident,
-        )
-        person = RelatonBib::Person.new name: fullname, affiliation: affiliation(doc)
+        person = RelatonBib::Person.new(name: fullname(p, doc),
+                                        affiliation: affiliation(doc))
         { entity: person, role: [{ type: p["contributor_role"] }] }
       end
       contribs + doc.xpath("publisher").map do |p|
@@ -164,6 +148,57 @@ module RelatonNist
       end
     end
 
+    #
+    # Create full name object from person name element.
+    #
+    # @param [Nokogiri::XML::Element] person name element
+    # @param [Nokogiri::XML::Element] doc document element
+    #
+    # @return [RelatonBib::FullName] full name object
+    #
+    def fullname(person, doc)
+      forename, initial = forename_initial(person, doc)
+      surname = localized_string person.at("surname").text, doc
+      ident = person.xpath("ORCID").map do |id|
+        RelatonBib::PersonIdentifier.new "orcid", id.text
+      end
+      RelatonBib::FullName.new(surname: surname, forename: forename,
+                               initial: initial, identifier: ident)
+    end
+
+    #
+    # Create forename and initials objects from person name element.
+    #
+    # @param [Nokogiri::XML::Element] person person name element
+    # @param [Nokogiri::XML::Element] doc document element
+    #
+    # @return [Array<Array<RelatonBib::LocalizedString>>] forename and initials
+    #
+    def forename_initial(person, doc)
+      forename = []
+      initial = []
+      fname = person.at("given_name")&.text
+      if fname
+        if /^(?<inits>(?:\w[.\s]+|[A-Z]{1,2}$)+)$/ =~ fname
+          inits.split(/[.\s]*/).each { |i| initial << localized_string(i, doc) }
+        else forename << localized_string(fname, doc)
+        end
+      end
+      [forename, initial]
+    end
+
+    #
+    # Create localized string
+    #
+    # @param [String] content content of string
+    # @param [Nokogiri::XML::Elemrnt] doc XML element
+    #
+    # @return [RelatonBib::LocalizedString] localized string
+    #
+    def localized_string(content, doc)
+      RelatonBib::LocalizedString.new content, doc["language"], "Latn"
+    end
+
     #
     # Create publisher organization
     #

data/lib/relaton_nist/hit.rb

@@ -14,7 +14,7 @@ module RelatonNist
     # @return [Iteger]
     def sort_value # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
       @sort_value ||= begin
-        sort_phrase = [hit[:serie], hit[:code], hit[:title]].join " "
+        sort_phrase = [hit[:series], hit[:code], hit[:title]].join " "
         corr = hit_collection&.text&.split&.map do |w|
           if w =~ /\w+/ &&
               sort_phrase =~ Regexp.new(Regexp.escape(w), Regexp::IGNORECASE)

data/lib/relaton_nist/hit_collection.rb

@@ -25,8 +25,75 @@ module RelatonNist
       sort_hits!
     end
 
+    # @return [Array<RelatonNist::Hit>]
+    def search_filter # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      @array.select do |item|
+        %r{
+          ^(?:(?:NIST|NBS)\s?)?
+          (?:(?<series>(?:SP|FIPS|IR|ITL\sBulletin|White\sPaper))\s)?
+          (?<code>[0-9-]{3,}[A-Z]?)
+          (?<prt1>pt\d+)?
+          (?<vol1>v\d+)?
+          (?<ver1>ver[\d.]+)?
+          (?<rev1>r\d+)?
+          (?:\s(?<prt2>Part\s\d+))?
+          (?:\s(?<vol2>Vol\.\s\d+))?
+          (?:\s(?<ver2>(?:Ver\.|Version)\s[\d.]+))?
+          (?:\s(?<rev2>Rev\.\s\d+))?
+          (?:\s(?<add>Add)endum)?
+        }x =~ item.hit[:code]
+        (refparts[:code] && [series, item.hit[:series]].include?(refparts[:series]) && refparts[:code] == code &&
+          long_to_short(refparts[:prt1], refparts[:prt2]) == long_to_short(prt1, prt2) &&
+          long_to_short(refparts[:vol1], refparts[:vol2]) == long_to_short(vol1, vol2) &&
+          long_to_short(refparts[:ver1], refparts[:ver2]) == long_to_short(ver1, ver2) &&
+          long_to_short(refparts[:rev1], refparts[:rev2]) == long_to_short(rev1, rev2) &&
+          long_to_short(refparts[:add1], refparts[:add2]) == add) || item.hit[:title]&.include?(text.sub(/^NIST\s/, ""))
+      end
+    end
+
     private
 
+    def refparts # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      @refparts ||= {
+        perfix: match(/^(NIST|NBS)\s?/, text),
+        series: match(/(SP|FIPS|IR|ITL\sBulletin|White\sPaper)(?=\.|\s)/, text),
+        code: match(/(?<=\.|\s)[0-9-]{3,}[A-Z]?/, text),
+        prt1: match(/(?<=(\.))?pt(?(1)-)[A-Z\d]+/, text),
+        vol1: match(/(?<=(\.))?v(?(1)-)\d+/, text),
+        ver1: match(/(?<=(\.))?ver(?(1)[-\d]|[.\d])+/, text)&.gsub(/-/, "."),
+        rev1: match(/(?<=[^a-z])(?<=(\.))?r(?(1)-)\d+/, text),
+        add1: match(/(?<=(\.))?add(?(1)-)\d+/, text),
+        prt2: match(/(?<=\s)Part\s[A-Z\d]+/, text),
+        vol2: match(/(?<=\s)Vol\.\s\d+/, text),
+        ver2: match(/(?<=\s)Ver\.\s\d+/, text),
+        rev2: match(/(?<=\s)Rev\.\s\d+/, text),
+        add2: match(/(?<=\/)Add/, text),
+      }
+    end
+
+    def match(regex, code)
+      regex.match(code)&.to_s
+    end
+
+    def full_ref # rubocop:disable Metrics/AbcSize
+      @full_ref ||= begin
+        ref = "#{refparts[:perfix]}#{refparts[:series]} #{refparts[:code]}"
+        ref += long_to_short(refparts[:prt1], refparts[:prt2]).to_s
+        ref += long_to_short(refparts[:vol1], refparts[:vol2]).to_s
+        ref
+      end
+    end
+
+    # @param short [String]
+    # @param long [String]
+    # @return [String, nil]
+    def long_to_short(short, long)
+      return short.sub(/-/, "") if short
+      return unless long
+
+      long.sub(/Part\s/, "pt").sub(/Vol\.\s/, "v").sub(/Rev\.\s/, "r").sub(/(Ver\.|Version)\s/, "ver")
+    end
+
     def sort_hits!
       @array.sort! do |a, b|
         if a.sort_value == b.sort_value
@@ -39,7 +106,8 @@ module RelatonNist
     end
 
     def from_ga # rubocop:disable Metrics/AbcSize
-      fn = text.gsub(%r{[/\s:.]}, "_").upcase
+      ref = full_ref
+      fn = ref.gsub(%r{[/\s:.]}, "_").upcase
       yaml = OpenURI.open_uri "#{GHNISTDATA}#{fn}.yaml"
       hash = YAML.safe_load yaml
       bib = RelatonNist::NistBibliographicItem.from_hash hash
@@ -52,55 +120,15 @@ module RelatonNist
       raise e
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-
-    # @param stage [String]
-    # @return [Array<RelatonNist::Hit>]
-    # def from_csrc(**opts)
-    #   from, to = nil
-    #   if year
-    #     d    = Date.strptime year, "%Y"
-    #     from = d.strftime "%m/%d/%Y"
-    #     to   = d.next_year.prev_day.strftime "%m/%d/%Y"
-    #   end
-    #   url = "#{DOMAIN}/publications/search?keywords-lg=#{text}"\
-    #         "&sortBy-lg=relevence"
-    #   url += "&dateFrom-lg=#{from}" if from
-    #   url += "&dateTo-lg=#{to}" if to
-    #   url += if /PD/.match? opts[:stage]
-    #            "&status-lg=Draft,Retired Draft,Withdrawn"
-    #          else
-    #            "&status-lg=Final,Withdrawn"
-    #          end
-
-    #   doc = Nokogiri::HTML OpenURI.open_uri(::Addressable::URI.parse(url).normalize)
-    #   doc.css("table.publications-table > tbody > tr").map do |h|
-    #     link  = h.at("td/div/strong/a")
-    #     serie = h.at("td[1]").text.strip
-    #     code  = h.at("td[2]").text.strip
-    #     title = link.text
-    #     doc_url = DOMAIN + link[:href]
-    #     status = h.at("td[4]").text.strip.downcase
-    #     release_date = Date.strptime h.at("td[5]").text.strip, "%m/%d/%Y"
-    #     Hit.new(
-    #       {
-    #         code: code, serie: serie, title: title, url: doc_url,
-    #         status: status, release_date: release_date
-    #       }, self
-    #     )
-    #   end
-    # end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
-
     # Fetches data form json
     # @param stage [String]
     # @return [Array<RelatonNist::Hit>]
     def from_json(**opts)
       select_data(**opts).map do |h|
-        /(?<serie>(?<=-)\w+$)/ =~ h["series"]
+        /(?<series>(?<=-)\w+$)/ =~ h["series"]
         title = [h["title-main"], h["title-sub"]].compact.join " - "
         release_date = RelatonBib.parse_date h["published-date"], false
-        Hit.new({ code: h["docidentifier"], serie: serie.upcase, title: title,
+        Hit.new({ code: h["docidentifier"], series: series.upcase, title: title,
                   url: h["uri"], status: h["status"],
                   release_date: release_date, json: h }, self)
       end
@@ -109,6 +137,7 @@ module RelatonNist
     # @param stage [String]
     # @return [Array<Hach>]
     def select_data(**opts) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength,Metrics/PerceivedComplexity
+      ref = "#{refparts[:series]} #{refparts[:code]}"
       d = Date.strptime year, "%Y" if year
       statuses = %w[draft-public draft-prelim]
       data.select do |doc|
@@ -119,7 +148,7 @@ module RelatonNist
         else
           next unless doc["status"] == "final"
         end
-        doc["docidentifier"].include? text
+        doc["docidentifier"].include?(ref) || doc["docidentifier"].include?(full_ref)
       end
     end
 
@@ -147,7 +176,6 @@ module RelatonNist
     #
     # @prarm ctime [Time, NilClass]
     def fetch_data(ctime)
-      # resp = OpenURI.open_uri("#{PUBS_EXPORT}.meta")
       if !ctime || ctime < OpenURI.open_uri("#{PUBS_EXPORT}.meta").last_modified
         @data = nil
         uri_open = URI.method(:open) || Kernel.method(:open)

data/lib/relaton_nist/nist_bibliography.rb

@@ -14,7 +14,8 @@ module RelatonNist
       # @param text [String]
       # @return [RelatonNist::HitCollection]
       def search(text, year = nil, opts = {})
-        HitCollection.search text, year, opts
+        ref = text.sub(/^NIST\sIR/, "NISTIR")
+        HitCollection.search ref, year, opts
       rescue OpenURI::HTTPError, SocketError, OpenSSL::SSL::SSLError => e
         raise RelatonBib::RequestError, e.message
       end
@@ -55,12 +56,12 @@ module RelatonNist
         end
 
         code += "-1" if opts[:all_parts]
-        nistbib_get1(code, year, opts)
+        nistbib_get(code, year, opts)
       end
 
       private
 
-      def nistbib_get1(code, year, opts)
+      def nistbib_get(code, year, opts)
         result = nistbib_search_filter(code, year, opts) || (return nil)
         ret = nistbib_results_filter(result, year, opts)
         if ret[:ret]
@@ -84,7 +85,7 @@ module RelatonNist
       # @option opts [String] :stage
       #
       # @return [Hash]
-      def nistbib_results_filter(result, year, opts)
+      def nistbib_results_filter(result, year, opts) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         missed_years = []
         iter = /\w+(?=PD)|(?<=PD-)\w+/.match(opts[:stage])&.to_s
         iteration = case iter
@@ -133,111 +134,23 @@ module RelatonNist
       # @param year [String, nil]
       # @param opts [Hash]
       # @return [RelatonNist::HitCollection]
-      def nistbib_search_filter(code, year, opts) # rubocop:disable Metrics/MethodLength
+      def nistbib_search_filter(code, year, opts)
         warn "[relaton-nist] (\"#{code}\") fetching..."
-        # match = %r{
-        #   ^((?:NIST)\s)?
-        #   (?<serie>(SP|FIPS|NISTIR|ITL\sBulletin|White\sPaper))\s
-        #   (?<code>[0-9-]{3,}[A-Z]?)
-        #   (?<prt1>pt\d+)?
-        #   (?<vol1>v\d+)?
-        #   (?<ver1>ver[\d\.]+)?
-        #   (?<rev1>r\d+)?
-        #   (\s(?<prt2>Part\s\d+))?
-        #   (\s(?<vol2>Vol\.\s\d+))?
-        #   (\s(?<ver2>(Ver\.|Version)\s[\d\.]+))?
-        #   (\s(?<rev2>Rev\.\s\d+))?
-        #   (\/(?<upd>Add))?
-        # }x.match(code)
-        # match ||= %r{
-        #   ^NIST\.
-        #   (?<serie>(SP|FIPS|IR|ITL\sBulletin|White\sPaper))\.
-        #   ((PD-\d+|PUB)\.)?
-        #   (?<code>[0-9-]{3,}[A-Z]?)
-        #   (\.(?<prt1>pt-\d+))?
-        #   (\.(?<vol1>v-\d+))?
-        #   (\.(?<ver1>ver-[\d\.]+))?
-        #   (\.(?<rev1>r-\d+))?
-        # }x.match(code)
-        matches = {
-          serie: match(/(SP|FIPS|(NIST)?IR|ITL\sBulletin|White\sPaper)(?=\.|\s)/, code),
-          code: match(/(?<=\.|\s)[0-9-]{3,}[A-Z]?/, code),
-          prt1: match(/(?<=(\.))?pt(?(1)-)[A-Z\d]+/, code),
-          vol1: match(/(?<=(\.))?v(?(1)-)\d+/, code),
-          ver1: match(/(?<=(\.))?ver(?(1)[-\d]|[\.\d])+/, code)&.gsub(/-/, "."),
-          rev1: match(/(?<=[^a-z])(?<=(\.))?r(?(1)-)\d+/, code),
-          add1: match(/(?<=(\.))?add(?(1)-)\d+/, code),
-          prt2: match(/(?<=\s)Part\s[A-Z\d]+/, code),
-          vol2: match(/(?<=\s)Vol\.\s\d+/, code),
-          ver2: match(/(?<=\s)Ver\.\s\d+/, code),
-          rev2: match(/(?<=\s)Rev\.\s\d+/, code),
-          add2: match(/(?<=\/)Add/, code),
-        }
-        ref = matches[:code] ? "#{matches[:serie]} #{matches[:code]}" : code
-        result = search(ref, year, opts)
-        selected_result = result.select { |i| search_filter i, matches, code }
-        return selected_result if selected_result.any? || !matches[:code]
-
-        search full_ref(matches)
-      end
-
-      def full_ref(matches)
-        ref = "#{matches[:serie]} #{matches[:code]}"
-        ref += long_to_short(matches[:prt1], matches[:prt2]).to_s
-        ref += long_to_short(matches[:vol1], matches[:vol2]).to_s
-        ref
-      end
-
-      def match(regex, code)
-        regex.match(code)&.to_s
-      end
-
-      # @param item [RelatonNist::Hit]
-      # @param matches [Hash]
-      # @param text [String]
-      # @return [Boolean]
-      def search_filter(item, matches, text) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        %r{
-          ^((?:NIST)\s)?
-          ((?<serie>(SP|FIPS|NISTIR|ITL\sBulletin|White\sPaper))\s)?
-          (?<code>[0-9-]{3,}[A-Z]?)
-          (?<prt1>pt\d+)?
-          (?<vol1>v\d+)?
-          (?<ver1>ver[\d.]+)?
-          (?<rev1>r\d+)?
-          (\s(?<prt2>Part\s\d+))?
-          (\s(?<vol2>Vol\.\s\d+))?
-          (\s(?<ver2>(Ver\.|Version)\s[\d.]+))?
-          (\s(?<rev2>Rev\.\s\d+))?
-          (\s(?<add>Add)endum)?
-        }x =~ item.hit[:code]
-        matches[:code] && [serie, item.hit[:serie]].include?(matches[:serie]) && matches[:code] == code &&
-          long_to_short(matches[:prt1], matches[:prt2]) == long_to_short(prt1, prt2) &&
-          long_to_short(matches[:vol1], matches[:vol2]) == long_to_short(vol1, vol2) &&
-          long_to_short(matches[:ver1], matches[:ver2]) == long_to_short(ver1, ver2) &&
-          long_to_short(matches[:rev1], matches[:rev2]) == long_to_short(rev1, rev2) &&
-          long_to_short(matches[:add1], matches[:add2]) == add || item.hit[:title].include?(text.sub(/^NIST\s/, ""))
-      end
-
-      # @param short [String]
-      # @param long [String]
-      # @return [String, nil]
-      def long_to_short(short, long)
-        return short.sub(/-/, "") if short
-        return unless long
-
-        long.sub(/Part\s/, "pt").sub(/Vol\.\s/, "v").sub(/Rev\.\s/, "r").sub(/(Ver\.|Version)\s/, "ver")
+        result = search(code, year, opts)
+        result.search_filter
       end
 
-      def fetch_ref_err(code, year, missed_years)
+      def fetch_ref_err(code, year, missed_years) # rubocop:disable Metrics/MethodLength
         id = year ? "#{code}:#{year}" : code
-        warn "[relaton-nist] WARNING: no match found online for #{id}. "\
-          "The code must be exactly like it is on the standards website."
-        warn "[relaton-nist] (There was no match for #{year}, though there were matches "\
-          "found for #{missed_years.join(', ')}.)" unless missed_years.empty?
-        if /\d-\d/ =~ code
-          warn "[relaton-nist] The provided document part may not exist, "\
-            "or the document may no longer be published in parts."
+        warn "[relaton-nist] WARNING: no match found online for #{id}. " \
+             "The code must be exactly like it is on the standards website."
+        unless missed_years.empty?
+          warn "[relaton-nist] (There was no match for #{year}, though there " \
+               "were matches found for #{missed_years.join(', ')}.)"
+        end
+        if /\d-\d/.match? code
+          warn "[relaton-nist] The provided document part may not exist, " \
+               "or the document may no longer be published in parts."
         end
         nil
       end

data/lib/relaton_nist/processor.rb

@@ -5,7 +5,7 @@ module RelatonNist
     def initialize # rubocop:disable Lint/MissingSuper
       @short = :relaton_nist
       @prefix = "NIST"
-      @defaultprefix = %r{^(NIST|NISTGCR|ITL Bulletin|JPCRD|NISTIR|CSRC|FIPS)(/[^\s])?\s}
+      @defaultprefix = %r{^(NIST|NBS|NISTGCR|ITL Bulletin|JPCRD|NISTIR|CSRC|FIPS)(/[^\s])?\s}
       @idtype = "NIST"
       @datasets = %w[nist-tech-pubs]
     end

data/lib/relaton_nist/version.rb

@@ -1,3 +1,3 @@
 module RelatonNist
-  VERSION = "1.12.2".freeze
+  VERSION = "1.12.5".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: relaton-nist
 version: !ruby/object:Gem::Version
-  version: 1.12.2
+  version: 1.12.5
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-02 00:00:00.000000000 Z
+date: 2022-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: equivalent-xml