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

data/lib/relaton/index/file_io.rb

@@ -6,8 +6,6 @@ module Relaton
     # In index mode url should be nil.
     #
     class FileIO
-      include IdNumber
-
       # Raised internally when a deserialized id cannot be parsed or is not
       # understood by the pubid class; `#load_index` rescues it to trigger the
       # wrong-structure handling (re-download, or stop and log).
@@ -152,11 +150,13 @@ module Relaton
         load_index(yaml) || []
       end
 
-      # Deserialize and sort by the same narrowing key Type#search bsearches
-      # on, so binary search always has a consistent total order. The published
-      # index is only approximately sorted (generated under pubid 1.x base
-      # semantics); merely detecting sortedness left bsearch disabled and every
-      # search a full O(n) scan. Sorting here is one-time per load.
+      # Deserialize and sort by the same narrowing key Type#search bsearches on
+      # — the base document's number, `id.root.number.to_s` (see
+      # Type#candidates_by_number) — so binary search always has a consistent
+      # total order. The published index is only approximately sorted (generated
+      # under pubid 1.x base semantics); merely detecting sortedness left bsearch
+      # disabled and every search a full O(n) scan. Sorting here is one-time per
+      # load.
       def deserialize_pubid(index)
         return index unless @pubid_class
 
@@ -164,7 +164,7 @@ module Relaton
           { id: deserialize_id(r[:id]), file: r[:file] }
         end
         warn_unless_sorted(deserialized)
-        deserialized.sort_by! { |r| get_id_number(r[:id]) }
+        deserialized.sort_by! { |r| r[:id].root.number.to_s }
         @sorted = true
         deserialized
       end
@@ -184,13 +184,13 @@ module Relaton
         raise InvalidIndexError, "unsupported id #{raw.inspect}"
       end
 
-      # Log when the loaded index is not already in get_id_number order, so the
+      # Log when the loaded index is not already in narrowing-key order, so the
       # in-memory sort above (and the underlying not-sorted index file) is
       # visible. Stops at the first out-of-order pair.
       def warn_unless_sorted(index)
         prev = nil
         index.each do |r|
-          num = get_id_number(r[:id])
+          num = r[:id].root.number.to_s
           if prev && prev > num
             Util.warn "Index file `#{file}` is not sorted by id number; " \
                       "sorting #{index.size} entries in memory.", progname
@@ -275,7 +275,7 @@ module Relaton
 
       def sort_structured_index(index)
         if @pubid_class && index.first&.dig(:id).is_a?(@pubid_class)
-          index.sort_by { |item| get_id_number item[:id] }
+          index.sort_by { |item| item[:id].root.number.to_s }
         else
           index
         end

data/lib/relaton/index/file_storage.rb

@@ -39,7 +39,12 @@ module Relaton
       def write(file, data)
         dir = File.dirname file
         FileUtils.mkdir_p dir
-        File.write file, data, encoding: "UTF-8"
+        # Write the bytes verbatim. `data` is often a raw Net::HTTP body, an
+        # ASCII-8BIT string; passing `encoding: "UTF-8"` would *transcode* it and
+        # raise Encoding::UndefinedConversionError on any non-ASCII byte (e.g. a
+        # UTF-8 `\xC3` in "électrotechnique"). The bytes are already valid UTF-8
+        # and `read` decodes them as UTF-8, so a binary write round-trips.
+        File.binwrite file, data
       end
 
       #

data/lib/relaton/index/pool.rb

@@ -15,6 +15,8 @@ module Relaton
       # @param [String, nil] url external URL to index, used to fetch index for searching files
       # @param [String, nil] file output file name
       # @param [Array<Symbol>, nil] id_keys keys to check if index is correct
+      # @param [String, nil] pages_url base URL of the Pages site that serves
+      #   the machine index (manifest + shards), see Relaton::Index::ShardSource
       #
       # @return [Relaton::Index::Type] typed index
       #
@@ -22,7 +24,10 @@ module Relaton
         if @pool[type.upcase.to_sym]&.actual?(**args)
           @pool[type.upcase.to_sym]
         else
-          @pool[type.upcase.to_sym] = Type.new(type, args[:url], args[:file], args[:id_keys], args[:pubid_class])
+          @pool[type.upcase.to_sym] = Type.new(
+            type, args[:url], args[:file], args[:id_keys], args[:pubid_class],
+            pages_url: args[:pages_url]
+          )
         end
       end
 

data/lib/relaton/index/shard_source.rb

@@ -0,0 +1,201 @@
+require "json"
+require "net/http"
+require "openssl"
+require "zlib"
+
+module Relaton
+  module Index
+    #
+    # Reads a flavor's machine index from its GitHub Pages site (relaton#189).
+    #
+    # `index/manifest.json` gives the lookup rule, and a query reads only the
+    # one `index/shard-NNNNN.json` its document family lives in, in place of the
+    # whole `index-vN.zip`. The shard key is `crc32(id.root.number.to_s) %
+    # shards`, the expression the relaton-cli producer (`MachineIndex`) writes
+    # and `Type#candidates_by_number` narrows on. See
+    # `docs/data-repository-format.adoc`, "The machine index on the Pages site".
+    #
+    # Everything is held in memory for TTL seconds and never written to the
+    # storage. A shard 404 is a definitive "not found" (empty buckets are not
+    # published). A transport failure raises `Relaton::RequestError`, which
+    # `Relaton::Db#net_retry` retries; a machine index this client cannot read
+    # raises `Relaton::Index::Error`. Neither falls back to the monolith: the
+    # whole index is read only when the manifest publishes no shards, or when
+    # the query has no root number to key on.
+    #
+    class ShardSource
+      TTL = 24 * 60 * 60
+      VERSION = 2
+      KEY = "root-number".freeze
+      ALGORITHM = "crc32".freeze
+
+      NET_ERRORS = [
+        SocketError, Timeout::Error, IOError, SystemCallError, OpenSSL::SSL::SSLError,
+        Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError,
+        Zlib::Error # a truncated gzip body, which Net::HTTP inflates
+
+      ].freeze
+
+      attr_reader :pages_url
+
+      #
+      # @param [String] dir flavor directory name, used in log messages
+      # @param [String] pages_url base URL of the Pages site, with a trailing `/`
+      # @param [Class] pubid_class the flavor's pubid identifier class
+      #
+      def initialize(dir, pages_url, pubid_class)
+        @pages_url = pages_url.end_with?("/") ? pages_url : "#{pages_url}/"
+        # Only the deserialization helpers are used: this FileIO reads and
+        # writes no file.
+        @file_io = FileIO.new(dir, nil, nil, nil, pubid_class)
+        @mutex = Mutex.new
+        @state = nil
+      end
+
+      #
+      # Rows of the shard that holds the document family of `id`.
+      #
+      # @param [Pubid::Identifier] id parsed query
+      #
+      # @return [Array<Hash>] `{ id:, file: }` rows, empty when not found
+      #
+      def rows(id)
+        number = id.root.number.to_s
+        state = current_state
+        shards = manifest(state)["shards"]
+        return load_whole_index(state) if shards.zero? || number.empty?
+
+        n = Zlib.crc32(number) % shards
+        once(state, n) { fetch_shard(n) }
+      end
+
+      #
+      # Every row, from the monolith the manifest names (`<index>.zip` on the
+      # Pages site). Needed by a String query and a block-only search.
+      #
+      # @return [Array<Hash>] `{ id:, file: }` rows, sorted by root number
+      #
+      def whole_index
+        load_whole_index current_state
+      end
+
+      private
+
+      # One generation of cached data. It is replaced as a whole when it
+      # expires, so a fetch that finishes late stores into its own generation
+      # and never mixes an old shard with a new manifest.
+      def new_state
+        { created: Time.now, data: {}, locks: {} }
+      end
+
+      def current_state
+        @mutex.synchronize do
+          @state = new_state if @state.nil? || Time.now - @state[:created] > TTL
+          @state
+        end
+      end
+
+      # Runs the block once for each key in a generation. The network call is
+      # made under a lock for that key only, so lookups of other shards (from
+      # the `Relaton::Db` workers pool) do not wait for it. A raise stores
+      # nothing, so the next call tries again.
+      def once(state, key)
+        lock = @mutex.synchronize { state[:locks][key] ||= Mutex.new }
+        lock.synchronize do
+          data = state[:data]
+          return @mutex.synchronize { data[key] } if @mutex.synchronize { data.key?(key) }
+
+          value = yield
+          @mutex.synchronize { data[key] = value }
+        end
+      end
+
+      def manifest(state)
+        once(state, :manifest) do
+          body = get("index/manifest.json")
+          raise Error, "no machine index manifest at `#{url('index/manifest.json')}`" unless body
+
+          check_manifest parse_json(body, "index/manifest.json")
+        end
+      end
+
+      def check_manifest(data)
+        unless data.is_a?(Hash) && data["version"] == VERSION &&
+            data["key"] == KEY && data["algorithm"] == ALGORITHM &&
+            data["shards"].is_a?(Integer) && !data["shards"].negative? &&
+            data["index"].is_a?(String) && !data["index"].empty?
+          raise Error, "unsupported machine index manifest at " \
+                       "`#{url('index/manifest.json')}`: #{data.inspect}"
+        end
+
+        data
+      end
+
+      def fetch_shard(num)
+        path = format("index/shard-%05d.json", num)
+        body = get(path)
+        return [] unless body
+
+        data = parse_json(body, path)
+        raise Error, "shard `#{url(path)}` is not an array" unless data.is_a?(Array)
+
+        data.map { |r| { id: deserialize(r["id"], path), file: r["file"] } }
+      end
+
+      def load_whole_index(state)
+        path = "#{manifest(state)['index']}.zip"
+        once(state, :whole_index) do
+          body = get(path)
+          raise Error, "no whole index at `#{url(path)}`" unless body
+
+          yaml = unzip(body)
+          raise Error, "empty archive at `#{url(path)}`" unless yaml
+
+          index = YAML.safe_load(yaml, permitted_classes: [Symbol])
+          raise Error, "wrong structure of `#{url(path)}`" unless @file_io.check_basic_format(index)
+
+          @file_io.deserialize_pubid(index)
+        rescue FileIO::InvalidIndexError, Psych::SyntaxError, Zip::Error, Zlib::Error => e
+          raise Error, "cannot read `#{url(path)}`: #{e.message}"
+        end
+      end
+
+      def unzip(body)
+        yaml = nil
+        # `open_buffer` does not return the block's value.
+        Zip::File.open_buffer(body) { |zip| yaml = zip.entries.first&.get_input_stream&.read }
+        yaml
+      end
+
+      def deserialize(raw, path)
+        @file_io.deserialize_id(raw)
+      rescue FileIO::InvalidIndexError => e
+        raise Error, "cannot read shard `#{url(path)}`: #{e.message}"
+      end
+
+      def parse_json(body, path)
+        JSON.parse(body)
+      rescue JSON::ParserError => e
+        raise Error, "cannot parse `#{url(path)}`: #{e.message}"
+      end
+
+      def url(path)
+        "#{@pages_url}#{path}"
+      end
+
+      #
+      # @return [String, nil] the body, or nil for a 404
+      #
+      def get(path)
+        resp = Net::HTTP.get_response(URI.parse(url(path)))
+        case resp.code
+        when "200" then resp.body
+        when "404" then nil
+        else raise Relaton::RequestError, "Could not access #{url(path)}: HTTP #{resp.code}"
+        end
+      rescue *NET_ERRORS => e
+        raise Relaton::RequestError, "Could not access #{url(path)}: #{e.message}"
+      end
+    end
+  end
+end

data/lib/relaton/index/type.rb

@@ -4,8 +4,6 @@ module Relaton
     # Relaton::Index::Type is a class for indexing Relaton files.
     #
     class Type
-      include IdNumber
-
       #
       # Initialize a new Relaton::Index::Type object
       #
@@ -15,14 +13,26 @@ module Relaton
       # @param [Array<Symbol>] id_keys keys of identifier to be used for sorting index
       #   format of index file is checked if id_keys all is provided at least in one of the IDs
       # @param [Pubid::Identifier, nil] pubid class for deserialization
+      # @param [String, nil] pages_url base URL of the Pages site that serves
+      #   the machine index. With it the type reads the index from there, in
+      #   memory (see ShardSource), and a parsed query fetches one shard only.
       #
-      def initialize(type, url = nil, file = nil, id_keys = nil, pubid_class = nil) # rubocop:disable Metrics/ParameterLists
+      def initialize(type, url = nil, file = nil, id_keys = nil, pubid_class = nil, # rubocop:disable Metrics/ParameterLists
+                     pages_url: nil)
         @file = file
+        @dir = type.to_s.downcase
+        @pubid_class = pubid_class
+        @pages_url = pages_url
         filename = file || Index.config.filename
-        @file_io = FileIO.new type.to_s.downcase, url, filename, id_keys, pubid_class
+        @file_io = FileIO.new @dir, url, filename, id_keys, pubid_class
+        @source = new_source
       end
 
+      # With a Pages source the whole index is not kept here: the source holds
+      # it, and drops it when its 24 h expire.
       def index
+        return @source.whole_index if @source
+
         @index ||= @file_io.read
       end
 
@@ -33,11 +43,14 @@ module Relaton
       # @param [Hash] **args arguments
       # @option args [String, nil] :url external URL to index, used to fetch index for searching files
       # @option args [String, nil] :file output file name
+      # @option args [String, nil] :pages_url base URL of the Pages site
       #
       # @return [Boolean] true if index is actual, false otherwise
       #
       def actual?(**args)
-        (!args.key?(:url) || args[:url] == @file_io.url) && (!args.key?(:file) || args[:file] == @file)
+        (!args.key?(:url) || args[:url] == @file_io.url) &&
+          (!args.key?(:file) || args[:file] == @file) &&
+          (!args.key?(:pages_url) || args[:pages_url] == @pages_url)
       end
 
       #
@@ -62,15 +75,34 @@ module Relaton
       end
 
       #
-      # Search index for a given ID
+      # Search index for a given ID.
+      #
+      # Without a block, two identifiers are matched with pubid's asymmetric
+      # subset match `id === item[:id]` (`Pubid::SubsetMatch`): the query is the
+      # reference, and a component it leaves nil or empty matches any value, so
+      # `OGC 12-128` answers with `12-128r19`. That is what a search by
+      # reference means. A caller that needs **exact** equality passes
+      # `exact: true`, which selects the rows with `item[:id] == id`. A nil
+      # component is a wildcard for `===`, not "the document has none": over
+      # the fixture indexes the subset match accepts 260 CCSDS pairs (the `-S`
+      # suffix) and 20,513 IETF pairs (a draft slug matches each of its
+      # versions) that `==` rejects. `Relaton::Ccsds` and `Relaton::Ietf` are
+      # the two callers that pass it.
+      #
+      # A String query keeps the substring match it always had, unless it is
+      # `exact:`.
       #
       # @param [String, Pubid::Identifier] id ID to search for
+      # @param [Boolean] exact match with `==` instead of the subset match
       #
       # @return [Array<Hash>] search results
       #
-      def search(id = nil, &block)
+      def search(id = nil, exact: false, &block)
+        raise ArgumentError, "search takes exact: or a block, not both" if exact && block
+
         items = search_candidates(id)
         return items.select(&block) if block
+        return items.select { |i| i[:id] == id } if exact
 
         items.select { |i| match_item(i, id) }
       end
@@ -90,7 +122,10 @@ module Relaton
       # @return [void]
       #
       def remove_file
-        @file_io.remove
+        # A Pages source has no file: its FileIO would resolve the default
+        # filename against the working directory.
+        @file_io.remove unless @source
+        @source = new_source
         @index = nil
         @id_lookup = nil
       end
@@ -114,7 +149,15 @@ module Relaton
         end
       end
 
+      def new_source
+        ShardSource.new(@dir, @pages_url, @pubid_class) if @pages_url
+      end
+
       def search_candidates(id)
+        # A parsed query reads only its own shard. `@index`, once loaded, is
+        # never refreshed, so the shards stay the fresher answer.
+        return @source.rows(id) if @source && id && !id.is_a?(String)
+
         # index needs to be created to check if sorted
         idx = index
         if @file_io.sorted && id && !id.is_a?(String)
@@ -124,8 +167,14 @@ module Relaton
         end
       end
 
+      # Narrowing key: the base *document's* number as a string. `#root` walks a
+      # supplement/amendment/corrigendum's `.base` chain to the origin (and
+      # returns self for a base document), so a document and all its wrappers
+      # share one key and cluster together. `.to_s` because the key is compared
+      # as a string (a pubid number Component is not `<`/`>`-comparable), and
+      # FileIO sorts the index by this exact same key so bsearch stays valid.
       def candidates_by_number(id)
-        target = get_id_number(id)
+        target = id.root.number.to_s
         left = bsearch_left(target)
         return [] unless left
 
@@ -135,23 +184,25 @@ module Relaton
 
       def bsearch_left(target)
         index.bsearch_index do |item|
-          get_id_number(item[:id]) >= target
+          item[:id].root.number.to_s >= target
         end
       end
 
       def bsearch_right(target)
         index.bsearch_index do |item|
-          get_id_number(item[:id]) > target
+          item[:id].root.number.to_s > target
         end || index.size
       end
 
+      # The query is the reference, so two identifiers take the subset match.
+      # See #search for the exact-equality escape hatch.
       def match_item(item, id)
         if item[:id].is_a?(String)
           item[:id].include?(id.is_a?(String) ? id : id.to_s)
         elsif id.is_a?(String)
           item[:id].to_s.include?(id)
         else
-          item[:id] == id
+          id === item[:id]
         end
       end
     end

data/lib/relaton/index.rb

@@ -5,13 +5,14 @@ require "zip"
 require "relaton/logger"
 
 require_relative "version"
+require_relative "core/request_error"
 require_relative "index/file_storage"
 require_relative "index/config"
 require_relative "index/util"
-require_relative "index/id_number"
 require_relative "index/pool"
 require_relative "index/type"
 require_relative "index/file_io"
+require_relative "index/shard_source"
 
 module Relaton
   module Index

data/lib/relaton/iso/bibliography.rb

@@ -43,14 +43,14 @@ module Relaton
         if year&.respond_to?(:to_i)
           query_pubid.root.date = ::Pubid::Components::Date.new(year: year.to_s)
         end
-        query_pubid.root.all_parts = opts[:all_parts] if opts[:all_parts]
+        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)
 
         date_filter = opts[:publication_date_before] || opts[:publication_date_after]
-        if date_filter && !query_pubid.root.all_parts
+        if date_filter && !query_pubid.all_parts
           ret = find_match_by_date(hits, query_pubid, opts)
         else
           ret = hits.fetch_doc(date_filter ? opts : {})
@@ -69,9 +69,6 @@ module Relaton
         return ret if get_all
 
         ret.to_most_recent_reference
-      rescue Parslet::ParseFailed
-        Util.warn "Is not recognized as a standards identifier.", key: code
-        nil
       end
 
       # @param query_pubid [Pubid::Iso::Identifier]
@@ -285,8 +282,8 @@ module Relaton
       def check_year(year, hit) # rubocop:disable Metrics/AbcSize
         pub = hit.pubid
         own_year = pub.date&.year.to_s
-        base_year = pub.base_identifier&.date&.year.to_s
-        if pub.base_identifier.nil?
+        base_year = pub.base&.date&.year.to_s
+        if pub.base.nil?
           own_year == year.to_s
         else
           base_year == year.to_s || own_year == year.to_s
@@ -307,7 +304,11 @@ module Relaton
           Util.info "TIP: Matches exist for #{ids}.", key: pubid.to_s
         end
 
-        if pubid.part
+        # `pubid` may itself be the all-parts wrapper (an all-parts query that
+        # still found nothing): its own `part` is always nil (never delegated),
+        # so read the underlying document via `#root`, and skip suggesting
+        # "(all parts)" to a caller who already asked for it.
+        if pubid.all_parts || pubid.root.part
           Util.info "TIP: If it cannot be found, the document may no longer be published in parts.", key: pubid.to_s
         else
           Util.info "TIP: If you wish to cite all document parts for the reference, " \
@@ -324,6 +325,12 @@ module Relaton
         pubid = ::Pubid::Iso::Identifier.parse(ref_no_type_stage)
         resp, = isobib_search_filter(pubid, opts, any_types_stages: true)
         resp.map &:pubid
+      rescue ::Pubid::Errors::ParseError
+        # The type/stage-stripped variant is a machine-derived probe, not the
+        # user's identifier; if it doesn't parse there are simply no
+        # alternative-type/stage candidates. The original reference already
+        # parsed in #get, so a failure here must not abort the lookup.
+        []
       end
 
       #
@@ -354,11 +361,11 @@ module Relaton
       #
       def filter_hits(hit_collection, query_pubid, any_types_stages) # rubocop:disable Metrics/AbcSize
         # filter out
-        excludings = build_excludings(query_pubid.root.all_parts, any_types_stages)
+        excludings = build_excludings(query_pubid.all_parts, any_types_stages)
         no_year_ref = hit_collection.ref_pubid_no_year.exclude(*excludings)
         hit_collection.select! do |i|
           pubid_match?(i.pubid, query_pubid, excludings, no_year_ref) &&
-            !(query_pubid.root.all_parts && i.pubid.part.nil?)
+            !(query_pubid.all_parts && i.pubid.part.nil?)
         end
 
         filter_hits_by_year(hit_collection, query_pubid.root.date&.year)
@@ -380,7 +387,7 @@ module Relaton
         if pubid.is_a? String then pubid == query_pubid.to_s
         else
           pubid = pubid.dup
-          pubid.base_identifier = pubid.base_identifier.exclude(:date, :edition) if pubid.base_identifier
+          pubid.base = pubid.base.exclude(:date, :edition) if pubid.base
           normalize_compound_part(pubid.exclude(*excludings)) == no_year_ref
         end
       end
@@ -394,12 +401,10 @@ module Relaton
       # before comparing. `exclude` returns a fresh instance, so mutating this
       # copy is safe. Remove once pubid create() splits compound parts itself.
       def normalize_compound_part(pubid)
-        num = pubid.part&.value.to_s
+        num = pubid.part.to_s
         return pubid unless pubid.subpart.nil? && num.include?("-")
 
-        head, tail = num.split("-", 2)
-        pubid.part = ::Pubid::Iso::Components::Code.new(value: head)
-        pubid.subpart = ::Pubid::Iso::Components::Code.new(value: tail)
+        pubid.part, pubid.subpart = num.split("-", 2)
         pubid
       end
     end

data/lib/relaton/iso/data_fetcher.rb

@@ -190,9 +190,9 @@ module Relaton
 
       def amend_base(ref)
         pubid = ::Pubid::Iso::Identifier.parse(ref)
-        return nil unless pubid.base_identifier
+        return nil unless pubid.base
 
-        pubid.base_identifier.to_s
+        pubid.base.to_s
       rescue StandardError
         nil
       end
@@ -284,7 +284,7 @@ module Relaton
       # is expected to parse; if one does not (`docid.pubid` is nil) record it
       # so `report_errors` raises a tracked GitHub issue at the end, and skip
       # the index entry rather than indexing a raw string (which would crash
-      # the index sort: `get_id_number` calls `.number` on the id). The data
+      # the index sort: it calls `.root.number` on the id). The data
       # file is still written, so the document is not lost — only unindexed
       # until its id parses.
       def index_primary(docid, file)

data/lib/relaton/iso/data_parser.rb

@@ -100,7 +100,11 @@ module Relaton
       def docidentifier
         ids = []
         if pubid
-          ids << Docidentifier.new(content: pubid, type: "ISO", primary: true)
+          primary = Docidentifier.new(content: pubid, type: "ISO", primary: true)
+          ids << primary
+          if (undated = undated_docid(primary))
+            ids << undated
+          end
           if (ref = iso_reference_pubid)
             ids << Docidentifier.new(content: ref, type: "iso-reference")
           end
@@ -114,6 +118,16 @@ module Relaton
         ids
       end
 
+      # Build the undated reference docid (e.g. `ISO 10303-52` from
+      # `ISO 10303-52:2011`). Returns nil when the reference carries no year
+      # (the undated form would just duplicate the primary).
+      def undated_docid(primary)
+        undated = Docidentifier.new(content: pubid, type: "iso-undated")
+        undated unless undated.to_s == primary.to_s
+      rescue StandardError
+        nil
+      end
+
       def safe_urn_docid
         return nil unless urn_pubid
 
@@ -385,9 +399,9 @@ module Relaton
       end
 
       def base_relation
-        return [] unless pubid&.base_identifier
+        return [] unless pubid&.base
 
-        [relation_for(pubid.base_identifier.to_s, "updates")]
+        [relation_for(pubid.base.to_s, "updates")]
       end
 
       def relation_for(ref, type)