relaton-iso 0.5.0

data/bin/rspec

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/bin/safe_yaml

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'safe_yaml' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("safe_yaml", "safe_yaml")

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/relaton/processor.rb

@@ -0,0 +1,22 @@
+require "relaton/processor"
+
+module Relaton
+  module RelatonIso
+    class Processor < Relaton::Processor
+      def initialize
+        @short = :relaton_iso
+        @prefix = "ISO"
+        @defaultprefix = %r{^(ISO)[ /]}
+        @idtype = "ISO"
+      end
+
+      def get(code, date, opts)
+        ::RelatonIso::IsoBibliography.get(code, date, opts)
+      end
+
+      def from_xml(xml)
+        RelatonIsoBib::XMLParser.from_xml xml
+      end
+    end
+  end
+end

data/lib/relaton_iso.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "relaton_iso/version"
+require "relaton_iso/iso_bibliography"
+if defined? Relaton
+  require_relative "relaton/processor"
+  Relaton::Registry.instance.register(Relaton::RelatonIso::Processor)
+end

data/lib/relaton_iso/hit.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RelatonIso
+  # Hit.
+  class Hit
+    # @return [RelatonIso::HitCollection]
+    attr_reader :hit_collection
+
+    # @return [Array<Hash>]
+    attr_reader :hit
+
+    # @param hit [Hash]
+    # @param hit_collection [RelatonIso:HitCollection]
+    def initialize(hit, hit_collection = nil)
+      @hit            = hit
+      @hit_collection = hit_collection
+    end
+
+    # Parse page.
+    # @return [RelatonIso::IsoBibliographicItem]
+    def fetch
+      @fetch ||= Scrapper.parse_page @hit
+    end
+
+    # @return [String]
+    def to_s
+      inspect
+    end
+
+    # @return [String]
+    def inspect
+      matched_words = @hit["_highlightResult"].
+        reduce([]) { |a, (_k, v)| a + v["matchedWords"] }.uniq
+
+      "<#{self.class}:#{format('%#.14x', object_id << 1)} "\
+      "@text=\"#{@hit_collection&.hit_pages&.text}\" "\
+      "@fullIdentifier=\"#{@fetch&.shortref}\" "\
+      "@matchedWords=#{matched_words} "\
+      "@category=\"#{@hit['category']}\" "\
+      "@title=\"#{@hit['title']}\">"
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder = nil, **opts)
+      if builder
+        fetch.to_xml builder, **opts
+      else
+        builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+          fetch.to_xml xml, **opts
+        end
+        builder.doc.root.to_xml
+      end
+    end
+  end
+end

data/lib/relaton_iso/hit_collection.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "relaton_iso/hit"
+
+module RelatonIso
+  # Page of hit collection.
+  class HitCollection < Array
+    # @return [TrueClass, FalseClass]
+    attr_reader :fetched
+
+    # @return [RelatonIso::HitPages]
+    attr_reader :hit_pages
+
+    # @param hits [Array<Hash>]
+    def initialize(hits, hit_pages = nil)
+      concat(hits.map { |h| Hit.new(h, self) })
+      @fetched = false
+      @hit_pages = hit_pages
+    end
+
+    # @return [RelatonIso::HitCollection]
+    def fetch
+      workers = RelatonBib::WorkersPool.new 4
+      workers.worker(&:fetch)
+      each do |hit|
+        workers << hit
+      end
+      workers.end
+      workers.result
+      @fetched = true
+      self
+    end
+
+    def to_s
+      inspect
+    end
+
+    def inspect
+      "<#{self.class}:#{format('%#.14x', object_id << 1)} @fetched=#{@fetched}>"
+    end
+  end
+end

data/lib/relaton_iso/hit_pages.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "algoliasearch"
+require "relaton_iso/hit_collection"
+
+module RelatonIso
+  # Pages of hits.
+  class HitPages < Array
+    Algolia.init application_id: "JCL49WV5AR",
+                 api_key: "dd1b9e1ab383f4d4817d29cd5e96d3f0"
+
+    # @return [String]
+    attr_reader :text
+
+    # @param text [String]
+    def initialize(text)
+      @text = text
+      @index = Algolia::Index.new "all_en"
+      resp = @index.search(text, facetFilters: ["category:standard"])
+      @nb_pages = resp["nbPages"]
+      self << HitCollection.new(resp["hits"], self)
+    end
+
+    # @return [RelatonIso::HitCollection]
+    def last
+      collection(@nb_pages - 1)
+    end
+
+    # @param i [Integer]
+    # @return [RelatonIso::HitCollection]
+    def [](idx)
+      # collection i
+      return if idx + 1 > @nb_pages
+
+      collection idx
+      super
+    end
+
+    # @return [Array]
+    def map(&block)
+      m = []
+      @nb_pages.times do |n|
+        m << yield(self[n]) if block
+      end
+      m
+    end
+
+    def each(&block)
+      @nb_pages.times do |n|
+        yield self[n] if block
+      end
+    end
+
+    def to_s
+      inspect
+    end
+
+    def inspect
+      "<#{self.class}:#{format('%#.14x', object_id << 1)} @text=#{@text} "\
+      "@pages=#{@nb_pages}>"
+    end
+
+    # @return [Integer]
+    def size
+      @nb_pages
+    end
+
+    def to_xml(**opts)
+      builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+        xml.documents do
+          each do |page|
+            page.fetch
+            page.each { |hit| hit.to_xml xml, **opts }
+          end
+        end
+      end
+      builder.to_xml
+    end
+
+    private
+
+    # @param i [Integer]
+    # @return [RelatonIso::HitCollection]
+    def collection(idx)
+      return if idx + 1 > @nb_pages
+
+      while Array.instance_method(:size).bind(self).call < idx + 1
+        resp = @index.search(@text,
+                             facetFilters: ["category:standard"],
+                             page: idx)
+        self << HitCollection.new(resp["hits"], self)
+      end
+      Array.instance_method(:[]).bind(self).call idx
+    end
+  end
+end

data/lib/relaton_iso/iso_bibliography.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+# require 'relaton_iso/iso_bibliographic_item'
+require "relaton_iso/scrapper"
+require "relaton_iso/hit_pages"
+require "relaton_iec"
+
+module RelatonIso
+  # Class methods for search ISO standards.
+  class IsoBibliography
+    class << self
+      # @param text [String]
+      # @return [RelatonIso::HitPages]
+      def search(text)
+        HitPages.new text
+      rescue Algolia::AlgoliaProtocolError
+        warn "Could not access http://www.iso.org"
+        []
+      end
+
+      # @param text [String]
+      # @return [Array<RelatonIso::IsoBibliographicItem>]
+      # def search_and_fetch(text)
+      #   Scrapper.get(text)
+      # end
+
+      # @param code [String] the ISO standard Code to look up (e..g "ISO 9000")
+      # @param year [String] the year the standard was published (optional)
+      # @param opts [Hash] options; restricted to :all_parts if all-parts reference is required,
+      #   :keep_year if undated reference should return actual reference with year
+      # @return [String] Relaton XML serialisation of reference
+      def get(code, year, opts)
+        if year.nil?
+          /^(?<code1>[^:]+):(?<year1>[^:]+)$/ =~ code
+          unless code1.nil?
+            code = code1
+            year = year1
+          end
+        end
+        code += "-1" if opts[:all_parts]
+        return Iecbib::IecBibliography.get(code, year, opts) if %r[^ISO/IEC DIR].match code
+
+        ret = isobib_get1(code, year, opts)
+        if ret.nil? && code =~ %r[^ISO\s]
+          c = code.gsub "ISO", "ISO/IEC"
+          warn "Attempting ISO/IEC retrieval"
+          ret = isobib_get1(c, year, opts)
+        end
+        return nil if ret.nil?
+
+        ret.to_most_recent_reference unless year || opts[:keep_year]
+        ret.to_all_parts if opts[:all_parts]
+        ret
+      end
+
+      private
+
+      def fetch_ref_err(code, year, missed_years)
+        id = year ? "#{code}:#{year}" : code
+        warn "WARNING: no match found online for #{id}. "\
+          "The code must be exactly like it is on the standards website."
+        warn "(There was no match for #{year}, though there were matches "\
+          "found for #{missed_years.join(', ')}.)" unless missed_years.empty?
+        if /\d-\d/ =~ code
+          warn "The provided document part may not exist, or the document "\
+            "may no longer be published in parts."
+        else
+          warn "If you wanted to cite all document parts for the reference, "\
+            "use \"#{code} (all parts)\".\nIf the document is not a standard, "\
+            "use its document type abbreviation (TS, TR, PAS, Guide)."
+        end
+        nil
+      end
+
+      def fetch_pages(s, n)
+        workers = RelatonBib::WorkersPool.new n
+        workers.worker { |w| { i: w[:i], hit: w[:hit].fetch } }
+        s.each_with_index { |hit, i| workers << { i: i, hit: hit } }
+        workers.end
+        workers.result.sort { |x, y| x[:i] <=> y[:i] }.map { |x| x[:hit] }
+      end
+
+      def isobib_search_filter(code)
+        docidrx = %r{^(ISO|IEC)[^0-9]*\s[0-9-]+}
+        corrigrx = %r{^(ISO|IEC)[^0-9]*\s[0-9-]+:[0-9]+/}
+        warn "fetching #{code}..."
+        result = search(code)
+        result.each do |page|
+          ret = page.select do |i|
+            i.hit["title"] &&
+              i.hit["title"].match(docidrx).to_s == code &&
+              corrigrx !~ i.hit["title"]
+          end
+          return ret unless ret.empty?
+        end
+        []
+      end
+
+      # Sort through the results from RelatonIso, fetching them three at a time,
+      # and return the first result that matches the code,
+      # matches the year (if provided), and which # has a title (amendments do not).
+      # Only expects the first page of results to be populated.
+      # Does not match corrigenda etc (e.g. ISO 3166-1:2006/Cor 1:2007)
+      # If no match, returns any years which caused mismatch, for error reporting
+      def isobib_results_filter(result, year)
+        missed_years = []
+        result.each_slice(3) do |s| # ISO website only allows 3 connections
+          fetch_pages(s, 3).each_with_index do |r, _i|
+            next if r.nil?
+            return { ret: r } if !year
+
+            r.dates.select { |d| d.type == "published" }.each do |d|
+              return { ret: r } if year.to_i == d.on.year
+
+              missed_years << d.on.year
+            end
+          end
+        end
+        { years: missed_years }
+      end
+
+      def isobib_get1(code, year, _opts)
+        # return iev(code) if /^IEC 60050-/.match code
+        result = isobib_search_filter(code) || return
+        ret = isobib_results_filter(result, year)
+        return ret[:ret] if ret[:ret]
+
+        fetch_ref_err(code, year, ret[:years])
+      end
+    end
+  end
+end

data/lib/relaton_iso/scrapper.rb

@@ -0,0 +1,421 @@
+# frozen_string_literal: true
+
+require "algoliasearch"
+require "relaton_iso_bib"
+require "relaton_iso/hit"
+require "nokogiri"
+require "net/http"
+
+Algolia.init application_id: "JCL49WV5AR",
+             api_key: "dd1b9e1ab383f4d4817d29cd5e96d3f0"
+
+module RelatonIso
+  # Scrapper.
+  # rubocop:disable Metrics/ModuleLength
+  module Scrapper
+    DOMAIN = "https://www.iso.org"
+
+    TYPES = {
+      "TS" => "technical-specification",
+      "TR" => "technical-report",
+      "PAS" => "publicly-available-specification",
+      # "AWI" => "approvedWorkItem",
+      # "CD" => "committeeDraft",
+      # "FDIS" => "finalDraftInternationalStandard",
+      # "NP" => "newProposal",
+      # "DIS" => "draftInternationalStandard",
+      # "WD" => "workingDraft",
+      # "R" => "recommendation",
+      "Guide" => "guide",
+    }.freeze
+
+    class << self
+      # @param text [String]
+      # @return [Array<Hash>]
+      # def get(text)
+      #   iso_workers = RelatonBib::WorkersPool.new 4
+      #   iso_workers.worker { |hit| iso_worker(hit, iso_workers) }
+      #   algolia_workers = start_algolia_search(text, iso_workers)
+      #   iso_docs = iso_workers.result
+      #   algolia_workers.end
+      #   algolia_workers.result
+      #   iso_docs
+      # rescue
+      #   warn "Could not connect to http://www.iso.org"
+      #   []
+      # end
+
+      # Parse page.
+      # @param hit [Hash]
+      # @return [Hash]
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def parse_page(hit_data)
+        return unless hit_data["path"] =~ /\d+$/
+
+        doc, url = get_page "/standard/#{hit_data['path'].match(/\d+$/)}.html"
+
+        # Fetch edition.
+        edition = doc&.xpath("//strong[contains(text(), 'Edition')]/..")&.
+          children&.last&.text&.match(/\d+/)&.to_s
+
+        titles, abstract = fetch_titles_abstract(doc)
+
+        RelatonIsoBib::IsoBibliographicItem.new(
+          fetched: Date.today.to_s,
+          docid: fetch_docid(doc),
+          edition: edition,
+          language: langs(doc).map { |l| l[:lang] },
+          script: langs(doc).map { |l| script(l[:lang]) }.uniq,
+          titles: titles,
+          type: fetch_type(hit_data["title"]),
+          docstatus: fetch_status(doc, hit_data["status"]),
+          ics: fetch_ics(doc),
+          dates: fetch_dates(doc),
+          contributors: fetch_contributors(hit_data["title"]),
+          editorialgroup: fetch_workgroup(doc),
+          abstract: abstract,
+          copyright: fetch_copyright(hit_data["title"], doc),
+          link: fetch_link(doc, url),
+          relations: fetch_relations(doc),
+          structuredidentifier: fetch_structuredidentifier(doc),
+        )
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      private
+
+      # Start algolia search workers.
+      # @param text[String]
+      # @param iso_workers [RelatonBib::WorkersPool]
+      # @reaturn [RelatonBib::WorkersPool]
+      # def start_algolia_search(text, iso_workers)
+      #   index = Algolia::Index.new "all_en"
+      #   algolia_workers = RelatonBib::WorkersPool.new
+      #   algolia_workers.worker do |page|
+      #     algolia_worker(index, text, page, algolia_workers, iso_workers)
+      #   end
+
+      #   # Add first page so algolia worker will start.
+      #   algolia_workers << 0
+      # end
+
+      # Fetch ISO documents.
+      # @param hit [Hash]
+      # @param isiso_workers [RelatonIso::WorkersPool]
+      # def iso_worker(hit, iso_workers)
+      #   print "Parse #{iso_workers.size} of #{iso_workers.nb_hits}  \r"
+      #   parse_page hit
+      # end
+
+      # Fetch hits from algolia search service.
+      # @param index[Algolia::Index]
+      # @param text [String]
+      # @param page [Integer]
+      # @param algolia_workers [RelatonBib::WorkersPool]
+      # @param isiso_workers [RelatonBib::WorkersPool]
+      # def algolia_worker(index, text, page, algolia_workers, iso_workers)
+      #   res = index.search text, facetFilters: ["category:standard"], page: page
+      #   next_page = res["page"] + 1
+      #   algolia_workers << next_page if next_page < res["nbPages"]
+      #   res["hits"].each do |hit|
+      #     iso_workers.nb_hits = res["nbHits"]
+      #     iso_workers << hit
+      #   end
+      #   iso_workers.end unless next_page < res["nbPages"]
+      # end
+
+      # Fetch titles and abstracts.
+      # @param doc [Nokigiri::HTML::Document]
+      # @return [Array<Array>]
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def fetch_titles_abstract(doc)
+        titles   = []
+        abstract = []
+        langs(doc).each do |lang|
+          # Don't need to get page for en. We already have it.
+          d = lang[:path] ? get_page(lang[:path])[0] : doc
+
+          # Check if unavailable for the lang.
+          next if d.css("h5.help-block").any?
+
+          titles << fetch_title(d, lang[:lang])
+
+          # Fetch abstracts.
+          abstract_content = d.css("div[itemprop='description'] p").text
+          next if abstract_content.empty?
+
+          abstract << {
+            content: abstract_content,
+            language: lang[:lang],
+            script: script(lang[:lang]),
+            format: "text/plain",
+          }
+        end
+        [titles, abstract]
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      # Get langs.
+      # @param doc [Nokogiri::HTML::Document]
+      # @return [Array<Hash>]
+      def langs(doc)
+        lgs = [{ lang: "en" }]
+        doc.css("ul#lang-switcher ul li a").each do |lang_link|
+          lang_path = lang_link.attr("href")
+          lang = lang_path.match(%r{^\/(fr)\/})
+          lgs << { lang: lang[1], path: lang_path } if lang
+        end
+        lgs
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      # Get page.
+      # @param path [String] page's path
+      # @return [Array<Nokogiri::HTML::Document, String>]
+      def get_page(path)
+        url = DOMAIN + path
+        uri = URI url
+        resp = Net::HTTP.get_response(uri) # .encode("UTF-8")
+        if resp.code == "301"
+          path = resp["location"]
+          url = DOMAIN + path
+          uri = URI url
+          resp = Net::HTTP.get_response(uri) # .encode("UTF-8")
+        end
+        n = 0
+        while resp.body !~ /<strong/ && n < 10
+          resp = Net::HTTP.get_response(uri) # .encode("UTF-8")
+          n += 1
+        end
+        [Nokogiri::HTML(resp.body), url]
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      # Fetch docid.
+      # @param doc [Nokogiri::HTML::Document]
+      # @return [Array<RelatonBib::DocumentIdentifier>]
+      def fetch_docid(doc)
+        item_ref = doc.at("//strong[@id='itemReference']")
+        return [] unless item_ref
+
+        [RelatonBib::DocumentIdentifier.new(id: item_ref.text, type: "ISO")]
+      end
+
+      # @param doc [Nokogiri::HTML::Document]
+      def fetch_structuredidentifier(doc)
+        item_ref = doc.at("//strong[@id='itemReference']")
+        unless item_ref
+          return RelatonIsoBib::StructuredIdentifier.new(
+            project_number: "?", part_number: "", prefix: nil, id: "?",
+          )
+        end
+
+        m = item_ref.text.match(/^(.*?\d+)-?((?<=-)\d+|)/)
+        RelatonIsoBib::StructuredIdentifier.new(
+          project_number: m[1], part_number: m[2], prefix: nil,
+          id: item_ref.text, type: "ISO"
+        )
+      end
+
+      # Fetch status.
+      # @param doc [Nokogiri::HTML::Document]
+      # @param status [String]
+      # @return [Hash]
+      def fetch_status(doc, _status)
+        stage, substage = doc.css("li.dropdown.active span.stage-code > strong").text.split "."
+        RelatonBib::DocumentStatus.new(stage: stage, substage: substage)
+      end
+
+      # Fetch workgroup.
+      # @param doc [Nokogiri::HTML::Document]
+      # @return [Hash]
+      def fetch_workgroup(doc)
+        wg_link = doc.css("div.entry-name.entry-block a")[0]
+        # wg_url = DOMAIN + wg_link['href']
+        workgroup = wg_link.text.split "/"
+        {
+          name: "International Organization for Standardization",
+          abbreviation: "ISO",
+          url: "www.iso.org",
+          technical_committee: [{
+            name: wg_link.text + doc.css("div.entry-title")[0].text,
+            type: "TC",
+            number: workgroup[1]&.match(/\d+/)&.to_s&.to_i,
+          }],
+        }
+      end
+
+      # rubocop:disable Metrics/MethodLength
+
+      # Fetch relations.
+      # @param doc [Nokogiri::HTML::Document]
+      # @return [Array<Hash>]
+      def fetch_relations(doc)
+        doc.css("ul.steps li").reduce([]) do |a, r|
+          r_type = r.css("strong").text
+          type = case r_type
+                 when "Previously", "Will be replaced by" then "obsoletes"
+                 when "Corrigenda/Amendments", "Revised by", "Now confirmed"
+                   "updates"
+                 else r_type
+                 end
+          if ["Now", "Now under review"].include? type
+            a
+          else
+            a + r.css("a").map do |id|
+              fref = RelatonBib::FormattedRef.new(
+                content: id.text, format: "text/plain",
+              )
+              bibitem = RelatonIsoBib::IsoBibliographicItem.new(
+                formattedref: fref,
+              )
+              { type: type, bibitem: bibitem }
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # Fetch type.
+      # @param title [String]
+      # @return [String]
+      def fetch_type(title)
+        type_match = title.match(%r{^(ISO|IWA|IEC)(?:(/IEC|/IEEE|/PRF|
+          /NP)*\s|/)(TS|TR|PAS|AWI|CD|FDIS|NP|DIS|WD|R|Guide|(?=\d+))}x)
+        # return "international-standard" if type_match.nil?
+        if TYPES[type_match[3]]
+          TYPES[type_match[3]]
+        elsif type_match[1] == "ISO"
+          "international-standard"
+        elsif type_match[1] == "IWA"
+          "international-workshop-agreement"
+        end
+        # rescue => _e
+        #   puts 'Unknown document type: ' + title
+      end
+
+      # Fetch titles.
+      # @param doc [Nokogiri::HTML::Document]
+      # @param lang [String]
+      # @return [Hash]
+      def fetch_title(doc, lang)
+        titles = doc.at("//h3[@itemprop='description'] | //h2[@itemprop='description']").
+          text.split " -- "
+        case titles.size
+        when 0
+          intro, main, part = nil, "", nil
+        when 1
+          intro, main, part = nil, titles[0], nil
+        when 2
+          if /^(Part|Partie) \d+:/ =~ titles[1]
+            intro, main, part = nil, titles[0], titles[1]
+          else
+            intro, main, part = titles[0], titles[1], nil
+          end
+        when 3
+          intro, main, part = titles[0], titles[1], titles[2]
+        else
+          intro, main, part = titles[0], titles[1], titles[2..-1]&.join(" -- ")
+        end
+        {
+          title_intro: intro,
+          title_main: main,
+          title_part: part,
+          language: lang,
+          script: script(lang),
+        }
+      end
+
+      # Return ISO script code.
+      # @param lang [String]
+      # @return [String]
+      def script(lang)
+        case lang
+        when "en", "fr" then "Latn"
+        end
+      end
+
+      # Fetch dates
+      # @param doc [Nokogiri::HTML::Document]
+      # @return [Array<Hash>]
+      def fetch_dates(doc)
+        dates = []
+        publish_date = doc.xpath("//span[@itemprop='releaseDate']").text
+        unless publish_date.empty?
+          dates << { type: "published", on: publish_date }
+        end
+        dates
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def fetch_contributors(title)
+        title.sub(/\s.*/, "").split("/").map do |abbrev|
+          case abbrev
+          when "IEC"
+            name = "International Electrotechnical Commission"
+            url  = "www.iec.ch"
+          else
+            name = "International Organization for Standardization"
+            url = "www.iso.org"
+          end
+          { entity: { name: name, url: url, abbreviation: abbrev },
+            roles: ["publisher"] }
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # Fetch ICS.
+      # @param doc [Nokogiri::HTML::Document]
+      # @return [Array<Hash>]
+      def fetch_ics(doc)
+        doc.xpath("//strong[contains(text(), "\
+                  "'ICS')]/../following-sibling::dd/div/a").map do |i|
+          code = i.text.match(/[\d\.]+/).to_s.split "."
+          { field: code[0], group: code[1], subgroup: code[2] }
+        end
+      end
+
+      # Fetch links.
+      # @param doc [Nokogiri::HTML::Document]
+      # @param url [String]
+      # @return [Array<Hash>]
+      def fetch_link(doc, url)
+        obp_elms = doc.xpath("//a[contains(@href, '/obp/ui/')]")
+        obp = obp_elms.attr("href").value if obp_elms.any?
+        rss = DOMAIN + doc.xpath("//a[contains(@href, 'rss')]").attr("href").value
+        [
+          { type: "src", content: url },
+          { type: "obp", content: obp },
+          { type: "rss", content: rss },
+        ]
+      end
+
+      # Fetch copyright.
+      # @param title [String]
+      # @return [Hash]
+      def fetch_copyright(title, doc)
+        owner_name = title.match(/.*?(?=\s)/).to_s
+        from = title.match(/(?<=:)\d{4}/).to_s
+        if from.empty?
+          from = doc.xpath("//span[@itemprop='releaseDate']").text.match(/\d{4}/).to_s
+        end
+        { owner: { name: owner_name }, from: from }
+      end
+    end
+
+    # private
+    #
+    # def next_hits_page(next_page)
+    #   page = @index.search @text, facetFilters: ['category:standard'],
+    #                               page:         next_page
+    #   page.each do |key, value|
+    #     if key == 'hits'
+    #       @docs[key] += value
+    #     else
+    #       @docs[key] = value
+    #     end
+    #   end
+    # end
+  end
+  # rubocop:enable Metrics/ModuleLength
+end