relaton 3.0.0.pre.alpha.5 → 3.0.0.pre.alpha.6

data/lib/relaton/iana/bibliography.rb

@@ -15,10 +15,10 @@ module Relaton
     module Bibliography
       SOURCE = "https://raw.githubusercontent.com/relaton/relaton-data-iana/refs/heads/v2/"
 
-      # @param text [String, Pubid::Iana::Identifier]
+      # @param ref [String, Pubid::Iana::Identifier]
       # @return [Relaton::Iana::Item, nil]
-      def search(text)
-        pubid = parse_ref text
+      def search(ref)
+        pubid = parse_ref ref
         return unless pubid
 
         # Pass the pubid so Relaton::Index narrows candidates by number via
@@ -34,19 +34,19 @@ module Relaton
         raise Relaton::RequestError, e.message
       end
 
-      # @param ref [String] the IANA registry slug to look up
+      # @param ref [String, Pubid::Iana::Identifier] the IANA registry slug to look up
       # @param year [String, NilClass] not used
       # @param opts [Hash] options
       # @return [Relaton::Iana::Item, nil]
       def get(ref, _year = nil, _opts = {})
-        Util.info "Fetching from Relaton repository ...", key: ref
+        Util.info "Fetching from Relaton repository ...", key: ref.to_s
         result = search(ref)
         unless result
-          Util.info "Not found.", key: ref
+          Util.info "Not found.", key: ref.to_s
           return
         end
 
-        Util.info "Found: `#{result.docidentifier[0].content}`", key: ref
+        Util.info "Found: `#{result.docidentifier[0].content}`", key: ref.to_s
         result
       end
 
@@ -63,14 +63,14 @@ module Relaton
       # 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]
+      # @param ref [String, Pubid::Iana::Identifier]
       # @return [Pubid::Iana::Identifier, nil]
-      def parse_ref(text)
-        return text unless text.is_a? String
+      def parse_ref(ref)
+        return ref unless ref.is_a? String
 
-        ::Pubid::Iana::Identifier.parse text
+        ::Pubid::Iana::Identifier.parse ref
       rescue StandardError => e
-        Util.warn "Failed to parse pubid `#{text}`: #{e.message}"
+        Util.warn "Failed to parse pubid `#{ref}`: #{e.message}"
         nil
       end
 

data/lib/relaton/iana/parser.rb

@@ -125,8 +125,11 @@ module Relaton
       # @return [Array<Relaton::Bib::Date>] date
       #
       def parse_date
-        d = @xml.xpath("./xmlns:created|./xmlns:published|./xmlns:updated", NS).map do |dt|
-          Bib::Date.new(type: dt.name, at: dt.text)
+        # moxml 0.5.98 drops every branch after the second in an N>=3 union
+        # under the reserved `xmlns` prefix (lutaml/moxml#315), which silently
+        # stripped `updated` dates from every crawled registry.
+        d = %w[created published updated].flat_map do |type|
+          @xml.xpath("./xmlns:#{type}", NS).map { |dt| Bib::Date.new(type: dt.name, at: dt.text) }
         end
         result = d.none? && @rootdoc ? @rootdoc.date : d
         @errors[:date] &&= result.empty?

data/lib/relaton/iec/bibliography.rb

@@ -24,18 +24,29 @@ module Relaton
           raise Relaton::RequestError, e.message
         end
 
-        # @param code [String] the IEC standard code to look up (e.g. "IEC 8000")
+        # @param ref [String, Pubid::Iec::Identifier] the IEC standard code to
+        #   look up (e.g. "IEC 8000"), or the parse that Relaton::Db routed
+        #   with (relaton#205); a pubid is never mutated
         # @param year [String] the year the standard was published (optional)
         # @param opts [Hash] options; restricted to :all_parts if all-parts
         #   reference is required
         # @return [Relaton::Iec::ItemData, nil]
-        def get(code, year = nil, opts = {}) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
-          opts[:all_parts] ||= code.match?(/\s\(all parts\)/)
-          ref = code.sub(/\s\(all parts\)/, "")
-          return iev if ref.casecmp("IEV").zero?
-
-          pubid = ::Pubid::Iec::Identifier.parse ref.upcase
+        def get(ref, year = nil, opts = {}) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/MethodLength
+          if ref.is_a?(String)
+            opts[:all_parts] ||= ref.match?(/\s\(all parts\)/)
+            text = ref.sub(/\s\(all parts\)/, "")
+            return iev if text.casecmp("IEV").zero?
+
+            pubid = ::Pubid::Iec::Identifier.parse text.upcase
+          elsif ref.all_parts?
+            opts[:all_parts] = true
+            pubid = ref.identifiers.first
+          else
+            pubid = ref
+          end
           if year
+            # Copy first: a caller's pubid is also its Db cache key.
+            pubid = pubid.class.from_hash(pubid.to_hash)
             pubid.date = ::Pubid::Components::Date.new(year: year.to_s)
           end
 

data/lib/relaton/iec/processor.rb

@@ -63,7 +63,12 @@ module Relaton
 
       # @param code [String]
       # @return [String, nil]
+      # Only a URN: `Relaton::Iec.urn_to_code` splits on `:`, so it would
+      # rewrite any reference with enough colons
+      # (`IEC 60034-1:1969+AMD1:1977+AMD2:1979+AMD3:1980 CSV`).
       def urn_to_code(code)
+        return unless code.match?(/\Aurn:/i)
+
         require_relative "../iec"
         Relaton::Iec.urn_to_code code
       end

data/lib/relaton/ieee/bibliography.rb

@@ -7,11 +7,12 @@ module Relaton
         #
         # Search IEEE bibliography item by reference.
         #
-        # @param code [String]
+        # @param ref [String, Pubid::Ieee::Identifier] the reference, or its
+        #   parse from Relaton::Db (relaton#205)
         #
         # @return [Relaton::Ieee::ItemData, nil]
         #
-        def search(code) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def search(ref) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
           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
@@ -20,7 +21,7 @@ module Relaton
           # 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
+          pubid = parse_pubid ref
           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
@@ -36,20 +37,22 @@ module Relaton
         #
         # Get IEEE bibliography item by reference.
         #
-        # @param code [String] the IEEE standard Code to look up (e..g "528-2019")
+        # @param ref [String, Pubid::Ieee::Identifier] the IEEE standard
+        #   reference to look up (e.g. "IEEE 528-2019"), or its parse from
+        #   Relaton::Db (relaton#205)
         # @param year [String] the year the standard was published (optional)
         # @param opts [Hash] options
         #
         # @return [Relaton::Ieee::ItemData, nil]
         #
-        def get(code, _year = nil, _opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-          Util.info "Fetching from Relaton repository ...", key: code
-          item = search(code)
+        def get(ref, _year = nil, _opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          Util.info "Fetching from Relaton repository ...", key: ref.to_s
+          item = search(ref)
           if item
-            Util.info "Found: `#{item.docidentifier.first.content}`", key: code
+            Util.info "Found: `#{item.docidentifier.first.content}`", key: ref.to_s
             item
           else
-            Util.info "Not found.", key: code
+            Util.info "Not found.", key: ref.to_s
             nil
           end
         end
@@ -60,12 +63,15 @@ module Relaton
         # 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]
+        # @param ref [String, ::Pubid::Ieee::Identifier]
         # @return [::Pubid::Ieee::Identifier, String]
-        def parse_pubid(code)
-          ::Pubid::Ieee::Identifier.parse code
+        def parse_pubid(ref)
+          # A pubid from Relaton::Db (relaton#205) is used as it is.
+          return ref unless ref.is_a?(String)
+
+          ::Pubid::Ieee::Identifier.parse ref
         rescue StandardError
-          code
+          ref
         end
       end
     end

data/lib/relaton/ieee/processor.rb

@@ -44,6 +44,22 @@ module Relaton
         nil
       end
 
+      # An IEEE pubid keeps the other publishers in `publishers` (a joint
+      # development) or `copublisher` (a standard), not in the shared
+      # `copublishers`.
+      #
+      # @param pubid [Pubid::Ieee::Identifier]
+      # @return [Array<String>]
+      def copublishers(pubid)
+        pubid = pubid.identifiers.first if pubid.all_parts?
+        others = if pubid.respond_to?(:publishers) && pubid.publishers
+                   pubid.publishers
+                 elsif pubid.respond_to?(:copublisher)
+                   pubid.copublisher
+                 end
+        Array(others).map(&:to_s) - %w[IEEE AIEE]
+      end
+
       # @param xml [String]
       # @return [Relaton::Ieee::ItemData]
       def from_xml(xml)

data/lib/relaton/ieee/rawbib_id_parser.rb

@@ -138,8 +138,8 @@ module Relaton
           Renderer.new(publisher: "IEEE", number: "P802", part: "11aj", draft: "8.0", year: "2017")
         when "IEEE P802.11ajD9.0, November 2017" # "IEEE P802-11aj/D9.0.2017"
           Renderer.new(publisher: "IEEE", number: "P802", part: "11aj", draft: "9.0", year: "2017")
-        when "ISO/IEC/IEEE P29119-4-DISMay2013" # "ISO/IEC/IEEE DIS P29119-4.2013"
-          Renderer.new(publisher: "ISO/IEC/IEEE", stage: "DIS", number: "P29119", part: "4", year: "2013")
+        when "ISO/IEC/IEEE P29119-4-DISMay2013" # "ISO/IEC/IEEE DIS P29119-4.2013-05"
+          Renderer.new(publisher: "ISO/IEC/IEEE", stage: "DIS", number: "P29119", part: "4", year: "2013", month: "05")
         when "IEEE-P15026-3-DIS-January 2015" # "IEEE DIS P15026-3.2015"
           Renderer.new(publisher: "IEEE", stage: "DIS", number: "P15026", year: "2015")
         when "ANSI/IEEE PC63.7/D rev17, December 2014" # "ANSI/IEEE PC63-7/D/REV-17.2014"

data/lib/relaton/ietf/bibliography.rb

@@ -7,25 +7,27 @@ module Relaton
   # IETF bibliography module
     module Bibliography
       class << self
-        # @param code [String] the ISO standard Code to look up (e..g "ISO 9000")
+        # @param ref [String, Pubid::Ietf::Identifier] the IETF reference
+        #   (e.g. "RFC 8341"), or its parse from Relaton::Db (relaton#205)
         # @return [RelatonIetf::IetfBibliographicItem]
-        def search(text)
-          Scraper.scrape_page text
+        def search(ref)
+          Scraper.scrape_page ref
         end
 
-        # @param code [String] the ISO standard Code to look up (e..g "ISO 9000")
+        # @param ref [String, Pubid::Ietf::Identifier] the IETF reference
+        #   (e.g. "RFC 8341"), or its parse from Relaton::Db (relaton#205)
         # @param year [String] the year the standard was published (optional)
         # @param opts [Hash] options; restricted to :all_parts if all-parts
         #   reference is required
         # @return [RelatonIetf::IetfBibliographicItem] Relaton of reference
-        def get(code, _year = nil, _opts = {})
-          Util.info "Fetching from Relaton repository ...", key: code
-          result = search code
+        def get(ref, _year = nil, _opts = {})
+          Util.info "Fetching from Relaton repository ...", key: ref.to_s
+          result = search ref
           if result
             docid = result.docidentifier.detect(&:primary) || result.docidentifier.first
-            Util.info "Found: `#{docid.content}`", key: code
+            Util.info "Found: `#{docid.content}`", key: ref.to_s
           else
-            Util.info "Not found.", key: code
+            Util.info "Not found.", key: ref.to_s
           end
           result
         end

data/lib/relaton/ietf/scraper.rb

@@ -15,17 +15,18 @@ module Relaton
       # publishing their `index-v1` for released relatons, untouched.
       IETF = "https://raw.githubusercontent.com/relaton/relaton-data-ietf/main/"
 
-      # @param text [String]
+      # @param ref [String, Pubid::Ietf::Identifier] a reference, or its parse
+      #   from Relaton::Db (relaton#205), which is used as it is
       # @return [Relaton::Ietf::ItemData, nil]
-      def scrape_page(text)
-        id = parse_id text.sub(/\AIETF\s+/, "")
+      def scrape_page(ref)
+        id = ref.is_a?(String) ? parse_id(ref.sub(/\AIETF\s+/, "")) : ref
         return unless id
 
         fetch_doc id
       rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
              Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
              Net::ProtocolError, SocketError
-        raise Relaton::RequestError, "No document found for #{text} reference"
+        raise Relaton::RequestError, "No document found for #{ref} reference"
       end
 
       private

data/lib/relaton/iso/bibliography.rb

@@ -24,7 +24,9 @@ module Relaton
         raise Relaton::RequestError, e.message
       end
 
-      # @param ref [String] the ISO standard Code to look up (e..g "ISO 9000")
+      # @param ref [String, Pubid::Iso::Identifier] the ISO standard Code to
+      #   look up (e..g "ISO 9000"), or the parse that Relaton::Db routed with
+      #   (relaton#205); a pubid is never mutated
       # @param year [String, NilClass] the year the standard was published
       # @param opts [Hash] options; restricted to :all_parts if all-parts
       # @option opts [Boolean] :all_parts if all-parts reference is required
@@ -33,21 +35,21 @@ module Relaton
       #
       # @return [RelatonIsoBib::IsoBibliographicItem] Bibliographic item
       def get(ref, year = nil, opts = {}) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity,Metrics/AbcSize
-        code = ref.gsub("\u2013", "-")
-
-        # parse "all parts" request
-        # code.sub! " (all parts)", ""
-        # opts[:all_parts] ||= $~ && opts[:all_parts].nil?
-
-        query_pubid = ::Pubid::Iso::Identifier.parse(code)
+        query_pubid = if ref.is_a?(String)
+                        ::Pubid::Iso::Identifier.parse(ref.gsub("\u2013", "-"))
+                      else
+                        ref
+                      end
         if year&.respond_to?(:to_i)
+          # Copy first: a caller's pubid is also its Db cache key.
+          query_pubid = query_pubid.class.from_hash(query_pubid.to_hash)
           query_pubid.root.date = ::Pubid::Components::Date.new(year: year.to_s)
         end
         query_pubid = query_pubid.to_all_parts if opts[:all_parts]
         Util.info "Fetching from Relaton repository ...", key: query_pubid.to_s
 
         hits, missed_year_ids = isobib_search_filter(query_pubid, opts)
-        tip_ids = look_up_with_any_types_stages(hits, ref, opts)
+        tip_ids = look_up_with_any_types_stages(hits, ref.to_s, opts)
 
         date_filter = opts[:publication_date_before] || opts[:publication_date_after]
         if date_filter && !query_pubid.all_parts

data/lib/relaton/itu/bibliography.rb

@@ -31,13 +31,18 @@ module Relaton
         HitCollection.new(refid).tap(&:search)
       end
 
-      # @param code [String] the ITU standard Code to look up
+      # @param ref [String, Pubid::Itu::Identifier] the ITU standard Code to
+      #   look up, or its parse from Relaton::Db (relaton#205); #with_year
+      #   copies, so the pubid is not changed
       # @param year [String] the year the standard was published (optional)
       # @param opts [Hash] options
       # @return [Relaton::Bib::ItemData, nil]
-      def get(code, year = nil, opts = {})
-        warn_incorrect_ref(code)
-        refid = with_year ::Pubid::Itu.parse(code), year
+      def get(ref, year = nil, opts = {})
+        if ref.is_a? String
+          warn_incorrect_ref(ref)
+          ref = ::Pubid::Itu.parse(ref)
+        end
+        refid = with_year ref, year
 
         ret = itubib_get1(refid)
         return nil if ret.nil?

data/lib/relaton/jis/bibliography.rb

@@ -13,7 +13,8 @@ module Relaton
       # the reference's series and number (a supplement is filed under its base
       # number), so an edition and its amendments are returned together.
       #
-      # @param [String] code JIS document code
+      # @param [String, Pubid::Jis::Identifier] ref JIS document reference; a
+      #   pubid is never mutated
       # @param [String, nil] year JIS document year
       #
       # @return [Relaton::Jis::HitCollection] search result
@@ -21,16 +22,21 @@ module Relaton
       # @raise [Pubid::Errors::ParseError] when the reference is not a JIS
       #   identifier, so a malformed reference is not reported as "not found"
       #
-      def search(code, year = nil)
-        pubid = ::Pubid::Jis::Identifier.parse code
-        pubid.year ||= year.to_i if year
+      def search(ref, year = nil)
+        pubid = ref.is_a?(String) ? ::Pubid::Jis::Identifier.parse(ref) : ref
+        if year && pubid.year.nil?
+          # Copy first: a caller's pubid is also its Db cache key.
+          pubid = pubid.class.from_hash(pubid.to_hash)
+          pubid.year = year.to_i
+        end
         HitCollection.new pubid
       end
 
       #
       # Get JIS document by reference
       #
-      # @param [String] ref JIS document reference
+      # @param [String, Pubid::Jis::Identifier] ref JIS document reference, or
+      #   the parse that Relaton::Db routed with (relaton#205)
       # @param [String, nil] year JIS document year
       # @param [Hash] opts options
       # @option opts [Boolean] :all_parts return all parts of document
@@ -41,16 +47,21 @@ module Relaton
       #   identifier
       #
       def get(ref, year = nil, opts = {}) # rubocop:disable Metrics/AbcSize
-        code = ref.sub(/\s\((all parts|規格群)\)/, "")
-        opts[:all_parts] ||= !$1.nil?
-        Util.info "Fetching from webdesk.jsa.or.jp ...", key: ref
-        hits = search(code, year)
+        if ref.is_a?(String)
+          query = ref.sub(/\s\((all parts|規格群)\)/, "")
+          opts[:all_parts] ||= !$1.nil?
+        else
+          opts[:all_parts] ||= ref.all_parts?
+          query = ref.all_parts? ? ref.identifiers.first : ref
+        end
+        Util.info "Fetching from webdesk.jsa.or.jp ...", key: ref.to_s
+        hits = search(query, year)
         result = opts[:all_parts] ? hits.find_all_parts : hits.find
         if result.is_a? Bib::ItemData
-          Util.info "Found: `#{result.docidentifier[0].content}`", key: ref
+          Util.info "Found: `#{result.docidentifier[0].content}`", key: ref.to_s
           return result
         end
-        hint result, ref, year
+        hint result, ref.to_s, year
       end
 
       #

data/lib/relaton/nist/bibliography.rb

@@ -7,18 +7,18 @@ module Relaton
         #
         # Search NIST documents by reference
         #
-        # @param text [String] reference
+        # @param ref [String] reference
         #
         # @return [Relaton::Nist::HitCollection] search result
         #
-        def search(text, year = nil, opts = {})
-          ref = text.sub(/^NISTIR/, "NIST IR").sub(/\/Add/, " Add")
+        def search(ref, year = nil, opts = {})
+          query = ref.sub(/^NISTIR/, "NIST IR").sub(/\/Add/, " Add")
           # pubid 2.x only recognizes the addendum marker with a trailing
           # period, and only splits an uppercase part letter — canonicalize
           # both ("800-38a Add" -> "800-38A Add.") so @reference parses to the
           # same pubid the index/CSRC carry.
-          ref = ref.sub(/\bAdd\b\.?/i, "Add.").sub(/([0-9])([a-z])(?=\s+Add\.)/) { "#{$1}#{$2.upcase}" }
-          HitCollection.search ref, year, opts
+          query = query.sub(/\bAdd\b\.?/i, "Add.").sub(/([0-9])([a-z])(?=\s+Add\.)/) { "#{$1}#{$2.upcase}" }
+          HitCollection.search query, year, opts
         rescue OpenURI::HTTPError, SocketError, OpenSSL::SSL::SSLError => e
           raise Relaton::RequestError, e.message
         end
@@ -26,34 +26,38 @@ module Relaton
         #
         # Get NIST document by reference
         #
-        # @param code [String] the NIST standard Code to look up
+        # @param ref [String, Pubid::Nist::Identifier] the NIST standard Code
+        #   to look up, or its parse from Relaton::Db (relaton#205)
         # @param year [String] the year the standard was published (optional)
         # @param opts [Hash] options
         # @option opts [Boolean] :all_parts restricted to all parts
         #
         # @return [Relaton::Nist::ItemData, nil] bibliographic item
         #
-        def get(code, year = nil, opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-          return fetch_ref_err(code, year, []) if code.match?(/\sEP$/)
+        def get(ref, year = nil, opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          # The lookup below works on text, so a pubid from Relaton::Db is
+          # read back as its printed form; the pubid itself is not changed.
+          ref = ref.to_s unless ref.is_a?(String)
+          return fetch_ref_err(ref, year, []) if ref.match?(/\sEP$/)
 
-          /^(?<code2>[^(]+)(?:\((?<date2>\w+\s(?:\d{2},\s)?\d{4})\))?\s?\(?(?:(?<=\()(?<stage>(?:I|F|\d)PD))?/ =~ code
-          stage ||= /(?<=\.)PD-\w+(?=\.)/.match(code)&.to_s
+          /^(?<code2>[^(]+)(?:\((?<date2>\w+\s(?:\d{2},\s)?\d{4})\))?\s?\(?(?:(?<=\()(?<stage>(?:I|F|\d)PD))?/ =~ ref
+          stage ||= /(?<=\.)PD-\w+(?=\.)/.match(ref)&.to_s
           if code2
-            code = code2.strip
+            ref = code2.strip
             opts[:date] = parse_date(date2, str: false) if date2
             opts[:stage] = stage if stage
           end
 
           if year.nil?
-            /^(?<code1>[^:]+):(?<year1>[^:]+)$/ =~ code
+            /^(?<code1>[^:]+):(?<year1>[^:]+)$/ =~ ref
             unless code1.nil?
-              code = code1
+              ref = code1
               year = year1
             end
           end
 
-          code += "-1" if opts[:all_parts]
-          nistbib_get(code, year, opts)
+          ref += "-1" if opts[:all_parts]
+          nistbib_get(ref, year, opts)
         end
 
         private
@@ -61,14 +65,14 @@ module Relaton
         #
         # Get NIST document by reference
         #
-        # @param [String] code reference
+        # @param [String] ref reference
         # @param [String] year year
         # @param [Hash] opts options
         #
         # @return [Relaton::Nist::ItemData, nil] bibliographic item
         #
-        def nistbib_get(code, year, opts)
-          result = nistbib_search_filter(code, year, opts) || (return nil)
+        def nistbib_get(ref, year, opts)
+          result = nistbib_search_filter(ref, year, opts) || (return nil)
           ret = nistbib_results_filter(result, year, opts)
           if ret[:ret]
             Util.info "Found: `#{ret[:ret].docidentifier.first.content}`", key: result.reference
@@ -153,14 +157,14 @@ module Relaton
         #
         # Get search results and filter them by code and year
         #
-        # @param code [String] reference
+        # @param ref [String] reference
         # @param year [String, nil] year
         # @param opts [Hash] options
         #
         # @return [Relaton::Nist::HitCollection] hits collection
         #
-        def nistbib_search_filter(code, year, opts)
-          result = search(code, year, opts)
+        def nistbib_search_filter(ref, year, opts)
+          result = search(ref, year, opts)
           result.search_filter
         end
 

data/lib/relaton/oasis/bibliography.rb

@@ -16,16 +16,16 @@ module Relaton
       OPTIONAL = %i[version stage part label].freeze
 
       class << self
-        def search(text, _year = nil, _opts = {}) # rubocop:disable Metrics/MethodLength
-          Util.info "Fetching from Relaton repository ...", key: text
-          row = find_index_entry(text)
+        def search(ref, _year = nil, _opts = {}) # rubocop:disable Metrics/MethodLength
+          Util.info "Fetching from Relaton repository ...", key: ref.to_s
+          row = find_index_entry(ref)
           unless row
-            Util.info "Not found.", key: text
+            Util.info "Not found.", key: ref.to_s
             return
           end
 
           uri = URI("#{ENDPOINT}#{row[:file]}")
-          parse_item(fetch_yaml(uri), text)
+          parse_item(fetch_yaml(uri), ref)
         rescue SocketError, Errno::EINVAL, Errno::ECONNRESET, EOFError,
                Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
                Net::ProtocolError, Net::ReadTimeout,
@@ -78,11 +78,11 @@ module Relaton
         # by substring, so `OASIS amqp` resolved to some `amqp-core` record;
         # v2 matches identifiers, so a partial name no longer resolves.
         #
-        # @param text [String] the reference as the caller wrote it
+        # @param ref [String] the reference as the caller wrote it
         # @return [Hash, nil] the index row, or nil
         #
-        def find_index_entry(text)
-          pubid = parse_ref text
+        def find_index_entry(ref)
+          pubid = parse_ref ref
           return unless pubid
 
           rows = index.search(pubid)
@@ -111,12 +111,15 @@ module Relaton
         # Rescuing here would collapse "this identifier is malformed" into "no
         # such document", leaving a caller unable to tell them apart.
         #
-        # @param text [String]
+        # @param ref [String, Pubid::Oasis::Identifier]
         # @return [Pubid::Oasis::Identifier]
         # @raise [Pubid::Errors::ParseError]
         #
-        def parse_ref(text)
-          slug = text.to_s.strip.sub(/\A#{Regexp.escape PREFIX}/i, "")
+        def parse_ref(ref)
+          # A parsed pubid comes from Relaton::Db (relaton#205); it is used as it is.
+          return ref unless ref.is_a?(String)
+
+          slug = ref.to_s.strip.sub(/\A#{Regexp.escape PREFIX}/i, "")
           ::Pubid::Oasis::Identifier.parse "#{PREFIX}#{slug}"
         end
 
@@ -190,9 +193,9 @@ module Relaton
           resp.body
         end
 
-        def parse_item(yaml, text)
+        def parse_item(yaml, ref)
           item = Item.from_yaml yaml
-          Util.info "Found: `#{item.docidentifier.first.content}`", key: text
+          Util.info "Found: `#{item.docidentifier.first.content}`", key: ref.to_s
           item.tap { |i| i.fetched = Date.today.to_s }
         end
       end