relaton 3.0.0.pre.alpha.4 → 3.0.0.pre.alpha.6

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/bipm/processor.rb

@@ -8,6 +8,7 @@ module Relaton
       def initialize
         @short = :relaton_bipm
         @prefix = "BIPM"
+        @pubid_identifier = :Bipm # Db cache key
         @defaultprefix = %r{^(?:BIPM|CCTF|CCDS|CGPM|CIPM|JCRB)(?!\w)}
         @idtype = "BIPM"
         @datasets = %w[bipm-data-outcomes bipm-si-brochure rawdata-bipm-metrologia]

data/lib/relaton/bipm/rawdata_bipm_metrologia/affiliations.rb

@@ -19,9 +19,9 @@ module Relaton::Bipm
       #
       def self.parse(dir)
         affiliations = Dir["#{dir}/*.xml"].each_with_object([]) do |path, m|
-          doc = Nokogiri::XML(File.read(path, encoding: "UTF-8"))
+          doc = Moxml.parse(File.read(path, encoding: "UTF-8"))
           doc.xpath("//aff").each do |aff|
-            m << parse_affiliation(aff) if aff.at("institution")
+            m << parse_affiliation(aff) if aff.at_xpath("institution")
           end
         end.uniq { |a| a.organization.name.first.content }
         new affiliations
@@ -31,18 +31,18 @@ module Relaton::Bipm
       # Parse affiliation organization
       # https://github.com/relaton/relaton-data-bipm/issues/17#issuecomment-1367035444
       #
-      # @param [Nokogiri::XML::Element] aff
+      # @param [Moxml::Element] aff
       #
       # @return [Relaton::Bib::Affiliation] Organization name, country, division, street address
       #
       def self.parse_affiliation(aff)
-        text = aff.at("text()").text
+        text = aff.at_xpath("text()").text
         return if text.include? "Permanent address:" || text.include?("1005 Southover Lane") ||
           text == "Germany" || text.starts_with?("Guest") || text.starts_with?("Deceased") ||
           text.include?("Author to whom any correspondence should be addressed")
 
         args = {}
-        institution = aff.at('institution')
+        institution = aff.at_xpath('institution')
         if institution
           name = institution.text
           return if name == "1005 Southover Lane"
@@ -72,7 +72,7 @@ module Relaton::Bipm
         address = []
         addr = aff.xpath("text()[preceding-sibling::institution]").text.gsub(/^\W*|\W*$/, "")
         address << addr unless addr.empty?
-        country = aff.at('country')
+        country = aff.at_xpath('country')
         address << country.text if country && !country.text.empty?
         address = address.join(", ")
         return [] if address.empty?

data/lib/relaton/bipm/si_brochure_parser.rb

@@ -1,4 +1,4 @@
-require "nokogiri"
+require "moxml"
 
 module Relaton::Bipm
   class SiBrochureParser
@@ -129,7 +129,7 @@ module Relaton::Bipm
     end
 
     def extract_editorialgroup(xml)
-      doc = Nokogiri::XML(xml)
+      doc = Moxml.parse(xml)
       doc.xpath("//editorialgroup/committee").map do |committee|
         acronym = committee["acronym"]
         names = committee.xpath("variant").map do |v|

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/bsi/processor.rb

@@ -19,6 +19,11 @@ module Relaton::Bsi
       ::Relaton::Bsi::Bibliography.get(code, date, opts)
     end
 
+    # `Bibliography.get` applies a year to the document the reference names.
+    def fold_year(pubid, year)
+      fold_year_on_root pubid, year
+    end
+
     # @param xml [String]
     # @return [Relaton::Bsi::ItemData]
     def from_xml(xml)

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,32 +20,38 @@ 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
 
       def fetch_item(ref)
         hit = search(ref).first

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

@@ -8,6 +8,7 @@ module Relaton
       def initialize # rubocop:disable Lint/MissingSuper
         @short = :relaton_ccsds
         @prefix = "CCSDS"
+        @pubid_identifier = :Ccsds # Db cache key
         @defaultprefix = %r{^CCSDS(?!\w)}
         @idtype = "CCSDS"
         @datasets = %w[ccsds]
@@ -22,6 +23,18 @@ module Relaton
         Bibliography.get(code, date, opts)
       end
 
+      # 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 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]
+
+        super
+      end
+
       #
       # Fetch all the documents from a source
       #

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/cen/hit_collection.rb

@@ -105,7 +105,7 @@ module Relaton
       # @return [Array<RelatonCen::Hit>]
       def hits(resp)
         resp.xpath("//table[@class='dashlist']/tbody/tr/td[2]").map do |h|
-          ref = h.at("strong/a")
+          ref = h.at_xpath("strong/a")
           code = ref.text.strip
           url = ref[:href]
           Hit.new({ code: code, url: url }, self)

data/lib/relaton/cen/processor.rb

@@ -20,6 +20,11 @@ module Relaton
         ::Relaton::Cen::Bibliography.get(code, date, opts)
       end
 
+      # `Bibliography.get` applies a year to the document the reference names.
+      def fold_year(pubid, year)
+        fold_year_on_root pubid, year
+      end
+
       # @param xml [String]
       # @return [Relaton::Cen::ItemData]
       def from_xml(xml)

data/lib/relaton/cen/scraper.rb

@@ -53,7 +53,7 @@ module Relaton
         # @param doc [Mechanize::Page]
         # @return [Array<Relaton::Bib::LocalizedMarkedUpString>]
         def fetch_abstract(doc)
-          content = doc.at("//tr[th[.='Abstract/Scope']]/td")
+          content = doc.at_xpath("//tr[th[.='Abstract/Scope']]/td")
           [Bib::Abstract.new(content: content.text, language: "en", script: "Latn")]
         end
 
@@ -68,7 +68,7 @@ module Relaton
         # @param doc [Mechanize::Page]
         # @return [Relaton::Bib::DocumentStatus, nil]
         def fetch_status(doc)
-          s = doc.at("//tr[th[.='Status']]/td")
+          s = doc.at_xpath("//tr[th[.='Status']]/td")
           return unless s
 
           stage = Bib::Status::Stage.new(content: s.text.strip)
@@ -98,7 +98,7 @@ module Relaton
           doc.xpath(
             "//div[@id='DASHBOARD_LISTRELATIONS']/table/tr[th[.!='Sales Points']]",
           ).each_with_object([]) do |rt, acc|
-            type = relation_type rt.at("th").text.downcase
+            type = relation_type rt.at_xpath("th").text.downcase
             rt.xpath("td/a").each do |r|
               acc << Bib::Relation.new(type: type, bibitem: create_relation(r))
             end
@@ -124,7 +124,7 @@ module Relaton
         # @param doc [Mechanize::Page]
         # @return [Array<Relaton::Bib::Title>]
         def fetch_titles(doc)
-          te = doc.at("//tr[th[.='Title']]/td").text.strip
+          te = doc.at_xpath("//tr[th[.='Title']]/td").text.strip
           Bib::Title.from_string te, "en", "Latn"
         end
 
@@ -134,10 +134,10 @@ module Relaton
         def fetch_dates(doc) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
           doc.xpath("//div[@id='DASHBOARD_LISTIMPLEMENTATIONDATES']/table/tr")
             .each_with_object([]) do |d, acc|
-            at = d.at("td").text
+            at = d.at_xpath("td").text
             next if at.empty?
 
-            t = d.at("th").text
+            t = d.at_xpath("th").text
             type = case t
                   when /DOR/ then "adapted"
                   when /DAV/ then "issued"
@@ -154,8 +154,8 @@ module Relaton
         # @param doc [Mechanize::Page]
         # @return [Array<Relaton::Bib::Contributor>]
         def fetch_contributors(doc)
-          code = doc.at("//tr/td/h1/text()").text
-          title = doc.at("//tr/td[3]/h1").text
+          code = doc.at_xpath("//tr/td/h1/text()").text
+          title = doc.at_xpath("//tr/td[3]/h1").text
           %r{/(?<type>\w+)(?:\s(?<num>[^/]+))?$} =~ code
           org = owner_entity
 
@@ -190,7 +190,7 @@ module Relaton
         # @param doc [Mechanize::Page]
         # @return [Array<Bib::Copyright>]
         def fetch_copyright(doc)
-          date = doc.at("//tr[th[.='date of Availability (DAV)']]/td").text
+          date = doc.at_xpath("//tr[th[.='date of Availability (DAV)']]/td").text
           owner = Bib::ContributionInfo.new(organization: owner_entity)
           from = date.match(/^\d{4}/).to_s
           [Bib::Copyright.new(owner: [owner], from: from)]