relaton 3.0.0.pre.alpha.5 → 3.0.0.pre.alpha.7

data/lib/relaton/gb/bibliography.rb

@@ -9,15 +9,15 @@ module Relaton
     class Bibliography
       class << self
         # rubocop:disable Metrics/MethodLength
-        # @param text [Strin] code of standard for search
+        # @param ref [Strin] code of standard for search
         # @return [RelatonGb::HitCollection]
-        def search(text)
-          case text
+        def search(ref)
+          case ref
           when /^(GB|GJ|GS)/
             # Scrape national standards.
-            Util.info "Fetching from openstd.samr.gov.cn ...", key: text
+            Util.info "Fetching from openstd.samr.gov.cn ...", key: ref
             require_relative "gb_scraper"
-            GbScraper.scrape_page text
+            GbScraper.scrape_page ref
           # when /^ZB/
             # Scrape proffesional.
           # when /^DB/
@@ -26,26 +26,34 @@ module Relaton
             # Enterprise standard
           when %r{^T/[^\s]{2,6}\s}
             # Scrape social standard.
-            Util.info "Fetching from www.ttbz.org.cn ...", key: text
+            Util.info "Fetching from www.ttbz.org.cn ...", key: ref
             require_relative "t_scraper"
-            TScraper.scrape_page text
+            TScraper.scrape_page ref
           else
             # Scrape sector standard.
             require "relaton/gb/sec_scraper"
-            SecScraper.scrape_page text
+            SecScraper.scrape_page ref
           end
         end
         # rubocop:enable Metrics/MethodLength
 
-        # @param code [String] the GB standard Code to look up (e..g "GB/T 20223")
+        # @param ref [String, Pubid::Gb::Identifier] the GB standard Code to
+        #   look up (e.g. "GB/T 20223"), 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 [Relaton::Gb::ItemData, nil]
-        # @raise [Pubid::Errors::ParseError] when the code is not a GB
+        # @raise [Pubid::Errors::ParseError] when the reference is not a GB
         #   identifier
-        def get(code, year = nil, opts = {})
+        def get(ref, year = nil, opts = {}) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
           require "pubid"
-          pubid = ::Pubid::Gb::Identifier.parse(code)
+          # A parsed pubid comes from Relaton::Db (relaton#205); it is never
+          # mutated (`exclude` below copies).
+          pubid = ref.is_a?(String) ? ::Pubid::Gb::Identifier.parse(ref) : ref
+          if pubid.all_parts?
+            opts = opts.merge(all_parts: true)
+            pubid = pubid.identifiers.first
+          end
           year = (year || pubid.year)&.to_s
           pubid = pubid.exclude(:year)
           pubid.part = "1" if opts[:all_parts]

data/lib/relaton/iala/bibliography.rb

@@ -8,15 +8,15 @@ module Relaton
       class << self
         # Search for an IALA publication by its identifier.
         #
-        # @param text [String] the IALA reference to look up (e.g. "IALA S1070")
+        # @param ref [String] the IALA reference to look up (e.g. "IALA S1070")
         # @param _year [String, nil] optional edition/year filter
         # @param _opts [Hash] options (unused)
         # @return [Relaton::Iala::Item, nil]
-        def search(text, _year = nil, _opts = {})
-          Util.info "Fetching from Relaton repository ...", key: text
-          row = best_match text
+        def search(ref, _year = nil, _opts = {})
+          Util.info "Fetching from Relaton repository ...", key: ref.to_s
+          row = best_match ref
           unless row
-            Util.info "Not found.", key: text
+            Util.info "Not found.", key: ref.to_s
             return
           end
 
@@ -27,7 +27,7 @@ module Relaton
           end
 
           item = Relaton::Iala::Item.from_yaml resp.body
-          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 }
         rescue SocketError, Errno::EINVAL, Errno::ECONNRESET, EOFError,
                Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
@@ -59,7 +59,7 @@ module Relaton
         # must never match each other. An `Annex` row carries its base
         # identifier, which `===` compares with its own subset match.
         #
-        # @param text [String]
+        # @param ref [String]
         # @return [Hash, nil]
         #
         # The substring-scan fallback this used to take when parsing failed is
@@ -68,8 +68,8 @@ module Relaton
         # ids, so an ambiguous reference silently resolved to whichever row
         # sorted first, instead of telling the caller the reference is not an
         # identifier. ecma, w3c and xsf never had one.
-        def best_match(text)
-          pubid = parse_ref text
+        def best_match(ref)
+          pubid = parse_ref ref
           rows = index.search(pubid)
           rows.max_by { |r| [edition_key(r[:id].edition), language_key(r[:id]), r[:file]] }
         end
@@ -114,7 +114,7 @@ module Relaton
         # zero-pads the number to its type's canonical width, so `IALA M1`,
         # `M0001` and `R1016:ed2.0(F)` all parse without normalization here.
         #
-        # @param text [String]
+        # @param ref [String, Pubid::Iala::Identifier]
         # @return [Pubid::Iala::Identifier, nil]
         #
         # An unrecognized reference **raises**; like ISO, ETSI and 3GPP we let it
@@ -124,8 +124,11 @@ module Relaton
         # logs it through the `StandardError` arm at `lib/relaton/db.rb:122`.
         # Rescuing here would collapse "this identifier is malformed" into "no
         # such document", leaving a caller unable to tell them apart.
-        def parse_ref(text)
-          ::Pubid::Iala::Identifier.parse text.to_s.strip
+        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::Iala::Identifier.parse ref.to_s.strip
         end
 
         # The index is pubid-backed: `pubid_class:` is what makes

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

@@ -7,7 +7,7 @@ module Relaton
         @short = :relaton_iec
         @prefix = "IEC"
         @pubid_flavor = :Iec # global prefixes sourced from Pubid::Iec.prefixes
-        @defaultprefix = %r{^(IEC\s|CISPR\s|IEV($|\s))}
+        @defaultprefix = %r{^(IEC\s|CISPR\s|IEV($|\s)|CEI\s)} # CEI: IEC's French spelling (relaton#243)
         @idtype = "IEC"
         @datasets = %w[iec-harmonized-all iec-harmonized-latest]
       end
@@ -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/index/config.rb

@@ -4,7 +4,7 @@ module Relaton
     # Configuration class for Relaton::Index
     #
     class Config
-      attr_reader :storage, :storage_dir, :filename
+      attr_reader :storage, :storage_dir, :filename, :build_sidecar_in_child
 
       #
       # Set default values
@@ -13,6 +13,14 @@ module Relaton
         @storage = FileStorage
         @storage_dir = Dir.home
         @filename = "index.yaml"
+        @build_sidecar_in_child = true
+      end
+
+      # Build the sidecar in a forked child when available, so the one-time
+      # full materialization's memory dies with the child (relaton#242).
+      # Set to false to force an in-process build.
+      def build_sidecar_in_child=(flag)
+        @build_sidecar_in_child = flag
       end
 
       #