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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b34a85f74b2b8b07d61b51a20d976f1204240dbc353f9e7d73eeeb7262912337
-  data.tar.gz: 6e51891af83e32391abb096a788685f42d7cc648fc6a3e3483683868daa8e4b3
+  metadata.gz: 5029468b22fa9cc5e65bf7d76f8bb6db597fb331bc1f0a89a21186063ea49963
+  data.tar.gz: 6e572768f9ae838d04e682eb6e5cbc2a48dcb9e999fd2f4dce588952072475a6
 SHA512:
-  metadata.gz: 6530a4f026cf099bcd3a1c1b359d307089b57bbe14f94a77362adabafa329abbcb4f64349feaa9061e9a6eda9ff413645af6b14812bdcb3ac9bcb4e22e6ad0a1
-  data.tar.gz: 7c555c9ddb34285255f22766b7b9c56be98b657018bfb4503bb66bc316eea7a1c2fd796f21e1910ad41615a0079d8db32f76d2b46bc051a2a4e7c6ed4c0316cc
+  metadata.gz: 9ef70c48d70df0a8d7105b7195e0124f51a501eab815bca1ce6825a9113d338f3a1203c237d896443ae0f5ed1893efef97719bfd9a2938c53b58155171bf6c46
+  data.tar.gz: bb362dea5df12c9021b0725132e4f365aa8f97d6a81e9b41c2190c66121b6948aa4f6aee9a52f0c51e218ea38b5655b6ad014ea97d8100f00a83d07098ebfa0c

data/lib/relaton/3gpp/bibliography.rb

@@ -6,15 +6,17 @@ module Relaton
     module Bibliography
       SOURCE = "https://raw.githubusercontent.com/relaton/relaton-data-3gpp/v2/"
 
-      # @param text [String]
+      # @param ref [String, ::Pubid::Tgpp::Identifier] the reference, or the
+      #   parse that Relaton::Db routed with (relaton#205)
       # @return [Relaton::ThreeGpp::ItemData, nil]
-      def search(text)
+      def search(ref)
         # An unrecognized reference raises; like ISO and ETSI we let it
         # propagate — relaton-cli rescues Pubid::Errors::Error and renders
         # "… is not a recognized standards identifier", and API callers rescue
         # it themselves. The rescue below lists transport errors only, so it
         # does not swallow the parse error.
-        pubid = ::Pubid::Tgpp::Identifier.parse text.to_s.strip
+        pubid = ref
+        pubid = ::Pubid::Tgpp::Identifier.parse ref.strip if ref.is_a?(String)
         row = best_match pubid
         return unless row
 
@@ -36,19 +38,30 @@ module Relaton
       # @param opts [Hash] options
       # @return [Relaton::ThreeGpp::ItemData, nil]
       def get(ref, _year = nil, _opts = {})
-        Util.info "Fetching from Relaton repository ...", key: ref
+        Util.info "Fetching from Relaton repository ...", key: log_key(ref)
         result = search(ref)
         unless result
-          Util.info "Not found.", key: ref
+          Util.info "Not found.", key: log_key(ref)
           return
         end
 
-        Util.info "Found: `#{result.docidentifier[0].content}`", key: ref
+        Util.info "Found: `#{result.docidentifier[0].content}`",
+                  key: log_key(ref)
         result
       end
 
       private
 
+      # `Pubid::Tgpp#to_s` omits the `3GPP ` publisher token by default (it
+      # renders the index id), so a pubid from Relaton::Db (relaton#205) is
+      # logged with it, as the caller wrote the reference.
+      #
+      # @param ref [String, ::Pubid::Tgpp::Identifier]
+      # @return [String]
+      def log_key(ref)
+        ref.is_a?(String) ? ref : ref.to_s(with_publisher: true)
+      end
+
       #
       # Find the index row for a reference, newest version first.
       #

data/lib/relaton/3gpp/processor.rb

@@ -23,6 +23,12 @@ module Relaton
         Bibliography.get(code, date, opts)
       end
 
+      # 3GPP index ids print without the `3GPP ` token
+      # (`TS 23.207:REL-18/18.0.0`).
+      def bare_identifiers?
+        true
+      end
+
       #
       # Fetch all the documents from http://xml2rfc.tools.ietf.org/public/rfc/bibxml-3gpp-new/
       #

data/lib/relaton/bib/item_data.rb

@@ -160,6 +160,20 @@ module Relaton
         Converter::Csl.from_item(self)
       end
 
+      # ISO 690 rendered reference (the style instance lives in the
+      # relaton-models citation module; the engine in relaton-render).
+      def to_iso690(lang: "en", script: "Latn")
+        require "relaton/render/iso690"
+        Render::Iso690::Renderer.render(self, lang: lang, script: script)
+      end
+
+      # ISO 690 name-and-date in-text citation.
+      def to_iso690_citation(lang: "en", script: "Latn", disambiguator: nil)
+        require "relaton/render/iso690"
+        Render::Iso690::Renderer.citation(
+          self, disambiguator: disambiguator, lang: lang, script: script
+        )
+      end
 
       def to_asciibib
         Converter::Asciibib.from_item(self)

data/lib/relaton/bipm/bibliography.rb

@@ -5,18 +5,20 @@ module Relaton::Bipm
     GH_ENDPOINT = "https://raw.githubusercontent.com/relaton/relaton-data-bipm/refs/heads/v2/".freeze
 
     class << self
-      # @param text [String]
+      # @param ref [String, Pubid::Bipm::Identifier] the reference, or its
+      #   parse from Relaton::Db (relaton#205)
       # @return [RelatonBipm::BipmBibliographicItem]
-      def search(text, _year = nil, _opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        Util.info "Fetching from Relaton repository ...", key: text
-        ref = text.sub(/^BIPM\s/, "")
-        item = get_bipm ref
+      def search(ref, _year = nil, _opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        key = ref.to_s
+        Util.info "Fetching from Relaton repository ...", key: key
+        query = ref.is_a?(String) ? ref.sub(/^BIPM\s/, "") : ref
+        item = get_bipm query
         unless item
-          Util.info "Not found.", key: text
+          Util.info "Not found.", key: key
           return
         end
 
-        Util.info "Found: `#{item.docidentifier[0].content}`", key: text
+        Util.info "Found: `#{item.docidentifier[0].content}`", key: key
         item
       rescue Mechanize::ResponseCodeError => e
         raise Relaton::RequestError, e.message unless e.response_code == "404"
@@ -40,13 +42,13 @@ module Relaton::Bipm
       # end
 
       #
-      # @param reference [String]
+      # @param ref [String, Pubid::Bipm::Identifier]
       #
       # @return [RelatonBipm::BipmBibliographicItem]
       #
-      def get_bipm(reference) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        pubid = parse_ref reference
-        rows = search_index pubid, reference
+      def get_bipm(ref) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        pubid = ref.is_a?(String) ? parse_ref(ref) : ref
+        rows = search_index pubid, ref.to_s
         return if rows.empty?
 
         # Latest edition wins. Metrologia and SI Brochure rows carry no year,
@@ -78,9 +80,9 @@ module Relaton::Bipm
       #    a rescan cannot help — only re-reading the tail as number-plus-year.
       #
       # @param pubid [Pubid::Bipm::Identifier] the parsed reference
-      # @param reference [String, nil] the raw reference, for the retry
+      # @param ref [String, nil] the raw reference, for the retry
       # @return [Array<Hash>] the matching index rows
-      def search_index(pubid, reference)
+      def search_index(pubid, ref)
         # Reduce the query once, not once per row. `#exclude` copies the
         # identifier, so rebuilding it per candidate dominated the lookup.
         query_stem = stem pubid, pubid
@@ -88,7 +90,7 @@ module Relaton::Bipm
         rows = index.search { |r| pubid_match? r[:id], pubid, query_stem } if rows.empty?
         return rows unless rows.empty?
 
-        retry_pubid = year_number_retry reference
+        retry_pubid = year_number_retry ref
         retry_pubid ? search_index(retry_pubid, nil) : rows
       end
 
@@ -101,10 +103,10 @@ module Relaton::Bipm
       # reference, so a probe that does not parse is a miss (nil), never a
       # malformed-reference error -- the same rule as ISO's type/stage probe.
       #
-      # @param reference [String, nil]
+      # @param ref [String, nil]
       # @return [Pubid::Bipm::Identifier, nil]
-      def year_number_retry(reference)
-        match = reference&.match(/\A(?<stem>.+)\s(?<year>\d{4})-(?<number>\d+)\z/)
+      def year_number_retry(ref)
+        match = ref&.match(/\A(?<stem>.+)\s(?<year>\d{4})-(?<number>\d+)\z/)
         return unless match
 
         parse_ref "#{match[:stem]} #{match[:number].sub(/\A0+(?=\d)/, '')} (#{match[:year]})"
@@ -205,11 +207,11 @@ module Relaton::Bipm
       # Pubid::Errors::Error and renders "... is not a recognized standards
       # identifier".
       #
-      # @param reference [String]
+      # @param ref [String]
       # @return [Pubid::Bipm::Identifier]
       # @raise [Pubid::Errors::ParseError]
-      def parse_ref(reference)
-        ::Pubid::Bipm.parse reference
+      def parse_ref(ref)
+        ::Pubid::Bipm.parse ref
       end
 
       def index
@@ -219,7 +221,8 @@ module Relaton::Bipm
         )
       end
 
-      # @param ref [String] the BIPM standard Code to look up (e..g "BIPM B-11")
+      # @param ref [String, Pubid::Bipm::Identifier] the BIPM standard Code to
+      #   look up (e..g "BIPM B-11"), or its parse from Relaton::Db
       # @param year [String] not used
       # @param opts [Hash] not used
       # @return [RelatonBipm::BipmBibliographicItem]

data/lib/relaton/bsi/bibliography.rb

@@ -7,10 +7,11 @@ module Relaton::Bsi
     Ids = ::Pubid::Bsi::Identifiers
 
     class << self
-      # @param text [String]
+      # @param ref [String] the printed reference
       # @return [Relaton::Bsi::HitCollection]
-      def search(text, year = nil)
-        code = text.sub(/^BSI\s/, "").sub(/ExComm|Expert commentary/, "Ex")
+      def search(ref, year = nil)
+        # A pubid from Relaton::Db (relaton#205) prints "Expert Commentary".
+        code = ref.sub(/^BSI\s/, "").sub(/ExComm|Expert commentary/i, "Ex")
         HitCollection.search(code, year)
       rescue SocketError, Timeout::Error, Errno::EINVAL, Errno::ECONNRESET,
              EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
@@ -19,16 +20,18 @@ module Relaton::Bsi
       end
 
       #
-      # @param code [String] the BSI standard Code to look up
+      # @param ref [String, Pubid::Bsi::Identifier] the BSI standard reference
+      #   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 if all-parts reference is required
       # @option opts [Boolean] :no_year if last published document is required
       #
       # @return [String] Relaton XML serialisation of reference
-      def get(code, year = nil, opts = {})
-        year ||= publication_year(code)
-        ret = bib_get(code, year, opts)
+      def get(ref, year = nil, opts = {})
+        query = ref.is_a?(String) ? parse(ref) : ref
+        year ||= year_of(query)
+        ret = bib_get(ref.to_s, year, opts, query)
         return nil if ret.nil?
 
         ret = ret.to_most_recent_reference unless year || opts[:keep_year]
@@ -40,18 +43,18 @@ module Relaton::Bsi
       # Pubid::Errors::Error and renders "... is not a recognized standards
       # identifier". A catalogue hit code is a different case: `Hit#pubid`
       # rescues, because one odd Algolia row must not abort the search.
-      # @param [String] code document identifier
+      # @param [String] ref the reference
       # @return [Pubid::Bsi::Identifier]
       # @raise [Pubid::Errors::ParseError]
-      def parse(code)
-        ::Pubid::Bsi::Identifier.parse(code)
+      def parse(ref)
+        ::Pubid::Bsi::Identifier.parse(ref)
       end
 
       # Publication year of a reference's base document.
-      # @param [String] code document identifier
+      # @param [String] ref the reference
       # @return [String, nil]
-      def publication_year(code)
-        year_of parse(code)
+      def publication_year(ref)
+        year_of parse(ref)
       end
 
       # Whether a query and a candidate hit denote the same BSI document, at the
@@ -154,14 +157,14 @@ module Relaton::Bsi
       #
       # Search for a BSI standard.
       #
-      # @param [String] code the BSI standard Code to look up
+      # @param [String] ref the BSI standard reference to look up
+      # @param [Pubid::Bsi::Identifier] query the parsed reference
       #
       # @return [Relaton::Bsi::HitCollection] a collection of hits
       #
-      def search_filter(code)
-        query = parse(code)
-        Util.info "Fetching from shop.bsigroup.com ...", key: code
-        search(code).filter_hits!(query)
+      def search_filter(ref, query)
+        Util.info "Fetching from shop.bsigroup.com ...", key: ref
+        search(ref).filter_hits!(query)
       end
 
       # Sort through the results, and return the first result that matches the
@@ -180,15 +183,15 @@ module Relaton::Bsi
         { years: missed_years }
       end
 
-      def bib_get(code, year, _opts)
-        result = search_filter(code) || return
+      def bib_get(ref, year, _opts, query)
+        result = search_filter(ref, query) || return
         ret = results_filter(result, year)
         if ret[:ret]
-          Util.info "Found: `#{ret[:ret].docidentifier.first&.content}`", key: code
+          Util.info "Found: `#{ret[:ret].docidentifier.first&.content}`", key: ref
           ret[:ret]
         else
-          Util.info "Not found", key: code
-          fetch_ref_err(code, year, ret[:years])
+          Util.info "Not found", key: ref
+          fetch_ref_err(ref, year, ret[:years])
         end
       end
     end

data/lib/relaton/calconnect/bibliography.rb

@@ -3,10 +3,10 @@ require "mechanize"
 module Relaton::Calconnect
   class Bibliography
     class << self
-      # @param text [String]
+      # @param ref [String]
       # @return [RelatonCalconnect::HitCollection]
-      def search(text, year = nil, _opts = {})
-        HitCollection.new text, year
+      def search(ref, year = nil, _opts = {})
+        HitCollection.new ref, year
       rescue Mechanize::ResponseCodeError, SocketError, Errno::ECONNREFUSED
         raise Relaton::RequestError, "Could not access https://standards.calconnect.org"
       end
@@ -26,14 +26,14 @@ module Relaton::Calconnect
       # afterwards, because an undated reference reaches every year of the
       # document. That split is why `bib_results_filter` stays.
       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, year, opts) || (return nil)
         ret = bib_results_filter(result, year)
         if ret[:ret]
-          Util.info "Found: `#{ret[:ret].docidentifier.first.content}`", key: ref
+          Util.info "Found: `#{ret[:ret].docidentifier.first.content}`", key: ref.to_s
           ret[:ret]
         else
-          Util.info "Not found.", key: ref
+          Util.info "Not found.", key: ref.to_s
           fetch_ref_err(ref, year, ret[:years])
         end
       end

data/lib/relaton/calconnect/hit_collection.rb

@@ -55,7 +55,7 @@ module Relaton::Calconnect
     # outside the transport rescue in `Bibliography.search`, so it never becomes
     # a `Relaton::RequestError`.
     #
-    # @param ref [String]
+    # @param ref [String, Pubid::Calconnect::Identifier]
     # @return [Pubid::Calconnect::Identifier, nil]
     #
     # An unrecognized reference **raises**; like ISO, ETSI and 3GPP we let it
@@ -66,6 +66,9 @@ module Relaton::Calconnect
     # Rescuing here would collapse "this identifier is malformed" into "no
     # such document", leaving a caller unable to tell them apart.
     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)
+
       ::Pubid::Calconnect::Identifier.parse ref.to_s.strip
     end
 

data/lib/relaton/ccsds/bibliography.rb

@@ -20,31 +20,36 @@ module Relaton
       # Get CCSDS standard by document reference.
       # If format is not specified, then all format will be returned.
       #
-      # @param reference [String]
+      # @param ref [String, Pubid::Ccsds::Identifier] the reference, or
+      #   the parse that Relaton::Db routed with (relaton#205)
       # @param year [String, nil]
       # @param opts [Hash]
       # @option opts [String] :format format of fetched document (DOC, PDF)
       #
       # @return [RelatonCcsds::BibliographicItem]
       #
-      def get(reference, _year = nil, opts = {})
-        ref, opts = parse_format(reference, opts)
-        Util.info "Fetching from Relaton repository ...", key: reference
-        item, hit = fetch_item(ref)
+      def get(ref, _year = nil, opts = {})
+        query, opts = parse_format(ref, opts)
+        Util.info "Fetching from Relaton repository ...", key: ref.to_s
+        item, hit = fetch_item(query)
         if item.nil? || filter_sources(item, opts[:format])
-          Util.info "Not found.", key: reference
+          Util.info "Not found.", key: ref.to_s
           return nil
         end
-        Util.info "Found: `#{hit[:code]}`.", key: reference
+        Util.info "Found: `#{hit[:code]}`.", key: ref.to_s
         item
       end
 
       private
 
-      def parse_format(reference, opts)
-        ref = reference.sub(/\s\((DOC|PDF)\)$/, "")
+      def parse_format(ref, opts)
+        # A pubid carries no format suffix: Processor#query_pubid hands `get`
+        # the String whenever the reference has one.
+        return [ref, opts] unless ref.is_a?(String)
+
+        query = ref.sub(/\s\((DOC|PDF)\)$/, "")
         opts[:format] ||= Regexp.last_match(1)
-        [ref, opts]
+        [query, opts]
       end
       public :parse_format
 

data/lib/relaton/ccsds/hit_collection.rb

@@ -26,7 +26,7 @@ module Relaton
       end
 
       def pubid
-        @pubid ||= Pubid::Ccsds::Identifier.parse(ref)
+        @pubid ||= ref.is_a?(String) ? Pubid::Ccsds::Identifier.parse(ref) : ref
       end
 
       def rows

data/lib/relaton/ccsds/processor.rb

@@ -25,8 +25,9 @@ module Relaton
 
       # A format (` (DOC)` or `opts[:format]`) keeps only the item's sources
       # of that format, a filter the Db cache cannot apply to a cached item:
-      # such a query gets no key, so it is not cached.
-      def cache_key(ref, year, opts)
+      # such a query gets no pubid, so it is not cached, and `get` receives
+      # the String with its format.
+      def query_pubid(ref, opts = {}, parsed = nil)
         require_relative "../ccsds"
         _, format_opts = Bibliography.parse_format(ref, opts.dup)
         return if format_opts[:format]

data/lib/relaton/cen/bibliography.rb

@@ -5,10 +5,10 @@ module Relaton
     # Class methods for search Cenelec standards.
     class Bibliography
       class << self
-        # @param text [String]
+        # @param ref [String] the printed reference
         # @return [Relaton::Cen::HitCollection]
-        def search(text, year = nil)
-          HitCollection.new(text, year).search
+        def search(ref, year = nil)
+          HitCollection.new(ref, year).search
         rescue Mechanize::ResponseCodeError, Net::ReadTimeout => e
           raise Relaton::RequestError, e.message
         end
@@ -32,23 +32,24 @@ module Relaton
         end
 
         #
-        # @param code [String] the CEN standard Code to look up
+        # @param ref [String, Pubid::CenCenelec::Identifier] the CEN standard
+        #   reference 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] :keep_year don't upate reference
         #
         # @return [Relaton::Cen::ItemData, nil]
         #
-        def get(code, year = nil, opts = {})
+        def get(ref, year = nil, opts = {})
           # An empty string is no reference, not a malformed one, so it stays a
           # plain nil rather than a parse failure. Mirrors the guard
           # HitCollection#search already carries.
-          return if code.nil? || code.strip.empty?
+          return if ref.nil? || (ref.is_a?(String) && ref.strip.empty?)
 
-          query = parse code
+          query = ref.is_a?(String) ? parse(ref) : ref
           year ||= publication_year query
 
-          bib_get code, year, opts, query
+          bib_get ref.to_s, year, opts, query
         end
 
         private
@@ -77,10 +78,11 @@ module Relaton
           id.exclude(*keys) == id
         end
 
-        def fetch_ref_err(_code, year, missed_years)
+        def fetch_ref_err(ref, year, missed_years)
           unless missed_years.empty?
             Util.info "There was no match for `#{year}`, though there " \
-                      "were matches found for `#{missed_years.join('`, `')}`."
+                      "were matches found for `#{missed_years.join('`, `')}`.",
+                      key: ref
           end
           nil
         end
@@ -88,10 +90,11 @@ module Relaton
         #
         # Selects the portal hits that denote the same document as the query.
         #
-        # The search text stays the caller's raw reference — that is
-        # search-engine input, not identifier parsing — while the SELECTION is
-        # pubid's. A hit whose code the grammar cannot read is dropped rather
-        # than aborting the search.
+        # The search text is the reference as printed (the caller's String, or
+        # the print of a pubid from Relaton::Db) — that is search-engine input,
+        # not identifier parsing — while the SELECTION is pubid's. A hit whose
+        # code the grammar cannot read is dropped rather than aborting the
+        # search.
         #
         # The selection is pubid's subset match `query === hit.pubid`. A part,
         # a year or a supplement year that the query omits matches any value.
@@ -101,13 +104,13 @@ module Relaton
         # amendment's record, and a supplement reference never answers with
         # its base document.
         #
-        # @param code [String] the raw reference, as the portal form wants it
+        # @param ref [String] the printed reference, as the portal form wants it
         # @param query [Pubid::CenCenelec::Identifier]
         #
         # @return [Relaton::Cen::HitCollection]
         #
-        def search_filter(code, query)
-          search(code).select! { |hit| hit.pubid && query === hit.pubid }
+        def search_filter(ref, query)
+          search(ref).select! { |hit| hit.pubid && query === hit.pubid }
         end
 
         # Sort through the results from Isobib, fetching them three at a time,
@@ -129,18 +132,18 @@ module Relaton
           { years: missed_years }
         end
 
-        def bib_get(code, year, opts, query) # rubocop:disable Metrics/MethodLength
-          ref = year && absent?(query, :year) ? "#{code}:#{year}" : code
-          Util.info "Fetching from standards.cencenelec.eu ...", key: ref
-          result = search_filter(code, query)
+        def bib_get(ref, year, opts, query) # rubocop:disable Metrics/MethodLength
+          key = year && absent?(query, :year) ? "#{ref}:#{year}" : ref
+          Util.info "Fetching from standards.cencenelec.eu ...", key: key
+          result = search_filter(ref, query)
           ret = isobib_results_filter(result, year)
           if ret[:ret]
             bib = year || opts[:keep_year] ? ret[:ret] : ret[:ret].to_most_recent_reference
-            Util.info "Found: `#{bib.docidentifier.first&.content}`", key: ref
+            Util.info "Found: `#{bib.docidentifier.first&.content}`", key: key
             bib
           else
-            Util.info "Not found.", key: ref
-            fetch_ref_err(code, year, ret[:years])
+            Util.info "Not found.", key: key
+            fetch_ref_err(ref, year, ret[:years])
           end
         end
       end

data/lib/relaton/cie/bibliography.rb

@@ -5,23 +5,25 @@ module Relaton
   # IETF bibliography module
     module Bibliography
       class << self
-        # @param code [String] the ECMA standard Code to look up (e..g "ECMA-6")
+        # @param ref [String, Pubid::Cie::Identifier] the CIE reference (e.g.
+        #   "CIE 001-1980"), or its parse from Relaton::Db (relaton#205)
         # @return [Relaton::Cie::ItemData]
-        def search(code)
-          Scrapper.scrape_page code
+        def search(ref)
+          Scrapper.scrape_page ref
         end
 
-        # @param code [String] the ECMA standard Code to look up (e..g "ECMA-6")
+        # @param ref [String, Pubid::Cie::Identifier] the CIE reference (e.g.
+        #   "CIE 001-1980"), or its parse from Relaton::Db (relaton#205)
         # @param year [String] not used
         # @param opts [Hash] not used
         # @return [Relaton::Cie::ItemData] 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
-            Util.info "Found: `#{result.docidentifier.first.content}`", key: code
+            Util.info "Found: `#{result.docidentifier.first.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/cie/scrapper.rb

@@ -6,14 +6,15 @@ module Relaton
       ENDPOINT = "https://raw.githubusercontent.com/relaton/relaton-data-cie/refs/heads/v2/".freeze
 
       class << self
-        # @param code [String]
+        # @param ref [String, Pubid::Cie::Identifier] the reference, or the
+        #   parse that Relaton::Db routed with (relaton#205)
         # @return [Relaton::Cie::ItemData]
-        def scrape_page(code)
+        def scrape_page(ref)
           # An unrecognized reference raises; like ISO and 3GPP we let it
           # propagate -- relaton-cli rescues Pubid::Errors::Error and renders
           # "... is not a recognized standards identifier". Partial refs
           # (`CIE 001`, `CIE 15`) parse, so nothing valid is lost.
-          pubid = ::Pubid::Cie.parse code
+          pubid = to_pubid ref
           index = Index.find_or_create :cie, url: "#{ENDPOINT}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml",
                                               pubid_class: ::Pubid::Cie::Identifier
           # Pass the parsed pubid (not the raw String) so index-v2 narrows
@@ -26,25 +27,31 @@ module Relaton
                      .min_by { |r| r[:id].to_s }
           return unless row
 
-          parse_page "#{ENDPOINT}#{row[:file]}", code
+          parse_page "#{ENDPOINT}#{row[:file]}", ref.to_s
         end
 
         private
 
+        # @param ref [String, Pubid::Cie::Identifier]
+        # @return [Pubid::Cie::Identifier] parses only a String
+        def to_pubid(ref)
+          ref.is_a?(String) ? ::Pubid::Cie.parse(ref) : ref
+        end
+
         # @param url [String]
-        # @param code [String]
+        # @param ref [String]
         # @retrurn [Relato::Cie::ItemData]
-        def parse_page(url, code)
+        def parse_page(url, ref)
           resp = Mechanize.new.get url
           Item.from_yaml(resp.body).tap { |item| item.fetched = Date.today.to_s }
         rescue Mechanize::ResponseCodeError => e
           return if e.response_code == "404"
 
-          raise Relaton::RequestError, "No document found for #{code} reference. #{e.message}"
+          raise Relaton::RequestError, "No document found for #{ref} reference. #{e.message}"
         rescue Mechanize::RedirectLimitReachedError, Timeout::Error,
             Mechanize::UnauthorizedError, Mechanize::UnsupportedSchemeError,
             Mechanize::ResponseReadError, Mechanize::ChunkedTerminationError => e
-          raise Relaton::RequestError, "No document found for #{code} reference. #{e.message}"
+          raise Relaton::RequestError, "No document found for #{ref} reference. #{e.message}"
         end
       end
     end