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

data/lib/relaton/itu/hit_collection.rb

@@ -24,21 +24,21 @@ module Relaton
       RECEDITIONS_URL = "#{DOMAIN}/mws/api/recommendations/getRecEditions?idrec=%<idrec>s&lang=en".freeze
       HANDLE_URL = "http://handle.itu.int/11.1002/1000/%<idrec>s-en".freeze
 
+      # `ref` is a Pubid::Itu identifier; its class and sector pick the route.
       def search
-        case ref.to_ref
-        # `ref` is a parsed Pubid, so only the abbreviated `OB.N` form survives
-        # here — the local grammar reduces "Operational Bulletin 1096" to the
-        # code "Operational" and drops the year, which no route can resolve.
-        when %r{^ITU-R\sRR}, %r{\bOB\.} then request_publication
-        when /^ITU-T/ then request_recommendation
-        # A Report reference renders "Report ITU-R …" (the discriminator leads,
-        # as ITU cites it), so it no longer starts with the sector — but it is
-        # still served from the index like any other ITU-R document.
-        when /^ITU-R\s/, /^Report\sITU-R\s/ then request_document
+        if publication?(ref) then request_publication
+        # an annex to a bulletin has no landing page, and it is not a
+        # recommendation either
+        elsif publication?(ref.root) then @array = []
+        else
+          case sector
+          when "T" then request_recommendation
+          when "R" then request_document
+          end
         end
       rescue Mechanize::ResponseCodeError, SocketError, Timeout::Error, Errno::ECONNRESET,
               EOFError, Net::ProtocolError, OpenSSL::SSL::SSLError => e
-        raise Relaton::RequestError, "Could not access #{ref.to_ref}: #{e.message}"
+        raise Relaton::RequestError, "Could not access #{ref}: #{e.message}"
       end
 
       def agent
@@ -70,6 +70,21 @@ module Relaton
 
       private
 
+      # Radio Regulations and Operational Bulletins live on www.itu.int/pub,
+      # not in the dataset.
+      def publication?(id)
+        id.is_a?(::Pubid::Itu::Identifiers::RadioRegulations) ||
+          id.is_a?(::Pubid::Itu::Identifiers::SpecialPublication)
+      end
+
+      # An annex or an appendix carries its sector on the recommendation it
+      # belongs to.
+      #
+      # @return [String, nil] "T" or "R"
+      def sector
+        (ref.sector || ref.root.sector)&.to_s
+      end
+
       # ITU-T Recommendations and supplements. The index is preferred (offline,
       # every edition, no scraping); the live path covers what the dataset does
       # not have — Implementers' Guides, the `(V##)`/`Annex` forms the data
@@ -86,9 +101,8 @@ module Relaton
 
       # @return [Array<Relaton::Itu::Hit>] newest edition first
       def index_hits
-        pubid = index_pubid_ref
-        return [] unless pubid
-
+        # Every edition is a candidate; Bibliography selects the year.
+        pubid = ref.exclude(:year, :month, :day)
         Util.info "Fetching from Relaton repository ...", key: ref.to_s
         index.search(pubid) { |i| index_match?(pubid, i[:id]) }
           .map { |r| index_hit r }.sort_by { |h| edition_key h.hit[:code] }.reverse
@@ -112,7 +126,10 @@ module Relaton
       def year_satisfied?(hits)
         return false if hits.empty?
 
-        ref.year.nil? || hits.any? { |h| edition_key(h.hit[:code]).first == ref.year.to_i }
+        year = Bibliography.edition_year(ref)
+        return true if year.nil?
+
+        hits.any? { |h| edition_key(h.hit[:code]).first == year.to_i }
       end
 
       # The edition date of a rendered docidentifier, as `[year, month]`. Uses
@@ -135,14 +152,13 @@ module Relaton
 
       def request_document # rubocop:todo Metrics/MethodLength, Metrics/AbcSize
         Util.info "Fetching from Relaton repository ...", key: ref.to_s
-        # Pass the reference's parsed pubid (not a String) so Relaton::Index can
+        # Pass the reference as a pubid (not a String) so Relaton::Index can
         # narrow candidates by document number before the block; `index_match?`
         # then matches every edition when the reference omits the part and the
         # exact edition when it names one. Rows are Pubid::Itu objects (not
         # Comparable), so rank by the numeric edition in `code.parts` (`["3"]` → 3)
         # to return the latest — index order isn't by edition.
-        pubid = pubid_ref
-        row = index.search(pubid) { |i| index_match?(pubid, i[:id]) }
+        row = index.search(ref) { |i| index_match?(ref, i[:id]) }
           .max_by { |i| i[:id].code&.parts&.last.to_i }
         return unless row
 
@@ -155,30 +171,6 @@ module Relaton
         @array = [hit]
       end
 
-      # Parse the reference into a Pubid::Itu identifier for the index lookup. A
-      # ref pubid can't parse raises (a `Pubid`/`Parslet` error) and propagates to
-      # the caller (relaton-cli / API callers rescue it), mirroring the ETSI
-      # flavor — the consumer no longer degrades to a raw-string substring search.
-      #
-      # @return [::Pubid::Itu::Identifier]
-      def pubid_ref
-        ::Pubid::Itu.parse ref.to_ref
-      end
-
-      # The reference as a pubid for an ITU-T index lookup, stripped of its
-      # edition date (every edition is a candidate; Bibliography selects the
-      # year). Unlike `#pubid_ref` this **rescues** an unparseable reference: the
-      # ITU-T path has a live fallback to degrade to, and a malformed reference
-      # (e.g. `ITU-T G.Suppl.47`) should warn and report "Not found", not raise.
-      #
-      # @return [::Pubid::Itu::Identifier, nil]
-      def index_pubid_ref
-        undated = ref.dup.tap { |r| r.year = r.month = r.day = nil }
-        ::Pubid::Itu.parse undated.to_ref
-      rescue StandardError
-        nil
-      end
-
       # Does an index row's id match the reference? When the reference omits the
       # part/edition (a bare `ITU-R P.838`), every edition of that exact document
       # matches — "search all parts"; when it names a part (`ITU-R P.838-2`), only
@@ -227,9 +219,15 @@ module Relaton
         nil
       end
 
-      # @return [String] the `rec=` value for the rec.aspx lookup
+      # The `rec=` value for the rec.aspx lookup: the document without its
+      # sector, edition date or version — "H.264", "A Suppl. 2",
+      # "G.989 Suppl. 1". An amendment or an annex is looked up by the
+      # recommendation it belongs to.
+      #
+      # @return [String]
       def rec_query
-        ref.suppl ? "#{ref.code} Suppl. #{ref.suppl}" : ref.code
+        Bibliography.document(ref).exclude(:year, :month, :day, :version)
+          .to_s.delete_prefix("ITU-T ")
       end
 
       # @param idrec [String]
@@ -244,10 +242,14 @@ module Relaton
       # @param edition [Hash] a getRecEditions entry
       # @return [Relaton::Itu::Hit]
       def recommendation_hit(edition)
+        # The crawler's rec_name canonicalisation ("G 231" -> "G.231"): the
+        # code is parsed with Pubid::Itu, which rejects the space spelling.
+        require_relative "data_parser_t"
+        name = DataParserT.normalize_rec_name edition["rec_name"]
         # No `:ref` key: it drives Hit#gi_imp, which would route an Implementers'
         # Guide reference onto the getImplGuides endpoints.
         Hit.new({
-          code: "ITU-T #{edition['rec_name']}",
+          code: "ITU-T #{name}",
           title: edition["title"],
           url: format(HANDLE_URL, idrec: edition["idrec"]),
           type: "recommendation",
@@ -279,21 +281,31 @@ module Relaton
       end
 
       # The /pub identifier for a Radio Regulation or an Operational Bulletin
-      # (`OB.1096` → `T-SP-OB.1096-2016`). nil — no hit — rather than a bogus URL
-      # when the bulletin reference carries no number.
+      # (`OB.1096` → `T-SP-OB.1096-2016`). nil — no hit — for any other special
+      # publication, which has no derivable landing page.
       #
       # @return [String, nil]
       def publication_id
-        return "R-REG-RR-#{ref.year}" if ref.code == "RR"
+        return "R-REG-RR-#{ref.year}" if radio_regulations?
 
-        num = ref.code[/\d+/]
-        "T-SP-OB.#{num}-#{ref.year}" if num
+        "T-SP-OB.#{ref.number}-#{ref.year}" if bulletin?
       end
 
-      # @return [String] the docidentifier-friendly code (year only, no month)
+      # The docidentifier (year only, no month or day). A bulletin keeps its
+      # sector even when the reference is the sector-less `ITU OB No. 1096`.
+      #
+      # @return [String]
       def publication_code
-        "#{ref.prefix}-#{ref.sector} #{ref.code} (#{ref.year})"
+        return "ITU-R RR (#{ref.year})" if radio_regulations?
+
+        "ITU-T OB.#{ref.number} (#{ref.year})"
       end
+
+      def radio_regulations?
+        ref.is_a? ::Pubid::Itu::Identifiers::RadioRegulations
+      end
+
+      def bulletin? = ref.series.to_s == "OB"
     end
   end
 end

data/lib/relaton/itu/processor.rb

@@ -6,6 +6,7 @@ module Relaton
       def initialize
         @short = :relaton_itu
         @prefix = "ITU"
+        @pubid_identifier = :Itu # Db cache key
         @defaultprefix = %r{^ITU\s}
         @idtype = "ITU"
         @datasets = %w[itu-r itu-t]

data/lib/relaton/itu/scraper.rb

@@ -112,13 +112,23 @@ module Relaton
           type = "ISO"
           text.match(/[^(]+/).to_s.strip.squeeze(" ")
         else
-          pubid = Pubid.parse(text)
-          type = pubid.prefix
-          pubid.to_s
+          type = "ITU"
+          canonical_id text
         end => id
         Docidentifier.new(type: type, content: id, primary: true)
       end
 
+      # The pubid spelling of an ITU code. The code is data from ITU, so a
+      # form pubid cannot identify is kept as ITU wrote it.
+      #
+      # @param text [String]
+      # @return [String]
+      def canonical_id(text)
+        ::Pubid::Itu.parse(text).to_s
+      rescue ::Pubid::Errors::ParseError
+        text
+      end
+
       # @return [Array<Relaton::Bib::Contributor>]
       def fetch_contributors
         contribs = fetch_publisher_contributors

data/lib/relaton/itu.rb

@@ -1,5 +1,4 @@
 require "mechanize"
-require "parslet"
 require "pubid"
 require "digest/md5"
 require "relaton/index"
@@ -11,7 +10,6 @@ require_relative "itu/item_data"
 require_relative "itu/model/item"
 require_relative "itu/model/bibitem"
 require_relative "itu/model/bibdata"
-require_relative "itu/pubid"
 require_relative "itu/scraper"
 require_relative "itu/hit_collection"
 require_relative "itu/bibliography"

data/lib/relaton/jis/bibliography.rb

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

data/lib/relaton/jis/data_fetcher.rb

@@ -114,12 +114,12 @@ module Relaton
       end
 
       def parse_offset(resp) # rubocop:disable Metrics/AbcSize
-        if resp.at('//*[@id="btnPaging"]') # first page
+        if resp.at_xpath('//*[@id="btnPaging"]') # first page
           xpath = '//script[contains(.,"var count =")]'
-          @count = resp.at(xpath).text.match(/var count = (\d+);/)[1]
-          resp.at("//*[@id='offset']")[:value].to_i
+          @count = resp.at_xpath(xpath).text.match(/var count = (\d+);/)[1]
+          resp.at_xpath("//*[@id='offset']")[:value].to_i
         else
-          script = resp.at("//script").text
+          script = resp.at_xpath("//script").text
           script.match(/\("offset"\)\.value = '(\d+)'/)[1].to_i
         end
       end

data/lib/relaton/jis/processor.rb

@@ -10,6 +10,7 @@ module Relaton
       def initialize # rubocop:disable Lint/MissingSuper
         @short = :relaton_jis
         @prefix = "JIS"
+        @pubid_identifier = :Jis # Db cache key
         @defaultprefix = %r{^(JIS|TR)\s}
         @idtype = "JIS"
         @datasets = %w[jis-webdesk]

data/lib/relaton/jis/scraper.rb

@@ -22,7 +22,7 @@ module Relaton
       end
 
       def fetch # rubocop:disable Metrics/MethodLength
-        @doc = @agent.get(@url).at "//div[@id='main']/section"
+        @doc = @agent.get(@url).at_xpath "//div[@id='main']/section"
         contributors = fetch_contributor
         eg_contributor = fetch_editorialgroup_contributor
         contributors << eg_contributor if eg_contributor
@@ -33,7 +33,7 @@ module Relaton
 
       def fetch_title
         result = { "ja" => "Jpan", "en" => "Latn" }.map.with_index do |(lang, script), i|
-          content = @doc.at("./h2/text()[#{i + 2}]").text.strip
+          content = @doc.at_xpath("./h2/text()[#{i + 2}]").text.strip
           Bib::Title.new content: content, language: lang, script: script
         end
         @errors[:title] &&= result.empty?
@@ -84,12 +84,12 @@ module Relaton
       end
 
       def document_id
-        @document_id ||= @doc.at("./h2/text()[1]")&.text&.strip
+        @document_id ||= @doc.at_xpath("./h2/text()[1]")&.text&.strip
       end
 
       def fetch_date
         result = DATETYPES.each_with_object([]) do |(key, type), a|
-          node = @doc.at("./div/div/div/p/text()[contains(.,'#{key}')]")
+          node = @doc.at_xpath("./div/div/div/p/text()[contains(.,'#{key}')]")
           next unless node
 
           at = node.text.match(/\d{4}-\d{2}-\d{2}/).to_s
@@ -116,7 +116,7 @@ module Relaton
       def langs_scripts # rubocop:disable Metrics/MethodLength
         @langs_scripts ||= begin
           result = LANGS.each_with_object([]) do |(key, lang), a|
-            l = @doc.at(
+            l = @doc.at_xpath(
               "./div/div/div[@class='blockContentFile']/div/div/p[1]" \
               "/span[contains(.,'#{key}')]/following-sibling::span",
             )
@@ -132,7 +132,7 @@ module Relaton
       def fetch_status
         xpath = "./div/div/div/p/text()[contains(.,'状態')]" \
                 "/following-sibling::span"
-        st = @doc.at(xpath)
+        st = @doc.at_xpath(xpath)
         status_val = STATUSES[st&.text&.strip]
         @errors[:status] &&= status_val.nil?
         return unless status_val
@@ -155,7 +155,7 @@ module Relaton
       end
 
       def fetch_ics
-        td = @doc.at("./table/tr[th[.='ICS']]/td")
+        td = @doc.at_xpath("./table/tr[th[.='ICS']]/td")
         @errors[:ics] &&= td.nil?
         return [] unless td
 
@@ -194,7 +194,7 @@ module Relaton
       end
 
       def fetch_editorialgroup_contributor # rubocop:disable Metrics/MethodLength
-        node = @doc.at("./table/tr[th[.='原案作成団体']]/td")
+        node = @doc.at_xpath("./table/tr[th[.='原案作成団体']]/td")
         @errors[:editorialgroup] &&= node.nil?
         return unless node
 

data/lib/relaton/nist/bibliography.rb

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

data/lib/relaton/oasis/bibliography.rb

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

data/lib/relaton/oasis/browser_agent.rb

@@ -1,5 +1,5 @@
 require "ferrum"
-require "nokogiri"
+require "moxml"
 
 module Relaton
   module Oasis
@@ -42,7 +42,7 @@ module Relaton
       def get(url)
         @browser.go_to(url)
         wait_for_challenge
-        Nokogiri::HTML(@browser.body)
+        Moxml.new.parse_html(@browser.body)
       end
 
       # HTTP status code of the most recent navigation's main resource,

data/lib/relaton/oasis/data_parser.rb

@@ -7,7 +7,7 @@ module Relaton
       #
       # Initialize parser.
       #
-      # @param [Nokogiri::HTML::Element] node document node
+      # @param [Moxml::Element] node document node
       #
       def initialize(node, errors = {}, agent: nil)
         @node = node
@@ -16,14 +16,14 @@ module Relaton
       end
 
       def title
-        @title ||= @node.at("./summary/div/h2").text
+        @title ||= @node.at_xpath("./summary/div/h2").text
       end
 
       def text
         xpath = "./div/div/div[contains(@class, " \
                 "'standard__grid--cite-as')]" \
                 "/p[em or i or a or span]"
-        @text ||= @node.at(xpath)&.text&.strip
+        @text ||= @node.at_xpath(xpath)&.text&.strip
       end
 
       #
@@ -144,7 +144,7 @@ module Relaton
         xpath = "./div/div/div[contains(@class, " \
                 "'standard__grid--cite-as')]" \
                 "/p[strong or span/strong]/a"
-        @link_node ||= @node.at(xpath)
+        @link_node ||= @node.at_xpath(xpath)
       end
 
       #
@@ -220,7 +220,7 @@ module Relaton
         parts = document_part_refs
         result = case parts.size
                  when 0
-                   txt = @node.at("./summary/div/h2").text
+                   txt = @node.at_xpath("./summary/div/h2").text
                    parse_spec title_to_docid(txt)
                  when 1 then parse_part parse_spec(parts[0])
                  else parts_to_docid parts