relaton 1.6.0 → 1.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed7e272fcfcf43938fe37532ceebde987f4f096e55d5dcd06a99a09302fd66f4
-  data.tar.gz: 3a01eeed34f2f1817c05675d54287f68f312048ff40f450f1783dbac6beddba6
+  metadata.gz: e745abe47353b4f9a1d6e0621121590fa64ba8083898683d735a4e3f2ee965d2
+  data.tar.gz: 100fde35c4b874028be98f497eb1f0ad77b400b1fdc13200e0ccc4b1d971217b
 SHA512:
-  metadata.gz: f35b5b2e317af3ff9a7f0a77dbe54e54796e314513518c9d538298a12ab21fda6fa0aff7020e5b1ea6d87ab7e6608e4b792f7ed5229e3b45f2aba409c04a2c5d
-  data.tar.gz: cc97d7bfda217e408afc66ca06d31c9c1b2a9a165976116efd841dce8f59d696e29cb92a2a0940db594f2792fa563c5d13372102938d4e2151386021d909fe3f
+  metadata.gz: 5f50ab12ccc315db33c26a5040d9062fb2be2028f66371bd31cdb19724ed26827bae2453e3509536171f5a2ebd0aa4fd745164593d38bdfa2749007a4d56036f
+  data.tar.gz: 10c6d44de29e572ca8683d314da6259e5209ad339e131105bb56d79024df5225de5e7895cefab39be2c4863688e68da42f29ab606b9750e53171152f5148f678

data/docs/README.adoc

@@ -62,6 +62,13 @@ e.g. `get("ISO 19115-1", "2014", all_parts: true)` is transformed into a referen
 
 == Usage
 
+=== Create DB
+
+`Relaton::Db#new(globalcache, localcache)` creates new DB. Returns Relaton::Db instance.
+
+* `globalcache` - (String or nil) path to globalcache directory
+* `localcache` - (String or nil) path to localcache directory
+
 [source,ruby]
 ----
 require "relaton"
@@ -93,7 +100,47 @@ db = Relaton::Db.new("globalcache", "localcache")
  @local_db=#<Relaton::DbCache:0x007faabc8fa5c0 @dir="localcache", @ext="xml">,
  @local_db_name="localcache",
 ...
+----
+
+=== Modify DB
+
+==== Move DB
+
+`Relaton::Db#mv(new_globalcache_dir, new_localcahe_dir)` moves DB directories to new location.
+
+* `new_globalcahe_dir` - (String or nil) new globalcache location
+* `new_localcahe_dir` - (String or nil) new localcache location
+
+[source,ruby]
+----
+db.mv("new_globalcache_dir", "new_localcahe_dir")
+----
+
+==== Clear DB
 
+`Relaton::Db#clear` removes all entries form DB
+
+=== Fetch documens
+
+==== Fetch document by references
+
+There are 3 fetching methods:
+
+* `Relaton::Db#fetch(reference, year, options)` - fetches document from local cache or remote source.
+* `Relaton::Db#fetch_db(reference, year, options)` - fetches document from local cache
+* `Relaton::Db#fetch_async(reference, year, options, &block)` - fetches document asynchronously
+
+Arguments:
+
+* `reference` - (String) reference to fethc document
+* `year` - (String or nil) year to filter relult (optional)
+* `options` - (Hash) hash of options. Alloved options:
+- `:all_parts` - (Boolean) should be `true` if all-parts reference is required
+- `:keep_yer` - (Boolean) should be `true` if undated reference should return actual reference with year
+- `:retries` - (Number) number of network retries. Default 1
+
+[source,ruby]
+----
 x = db.fetch("IEEE 19011")
 [relaton-ieee] ("IEEE 19011") fetching...
 [relaton-ieee] WARNING: no match found online for IEEE 19011. The code must be exactly like it is on the standards website.
@@ -105,7 +152,7 @@ x = db.fetch("ISO 19011")
 => #<RelatonIsoBib::IsoBibliographicItem:0x007fb1d0ab2f00
 ...
 
-x = db.fetch("ISO 19011", "2011")
+x = db.fetch("ISO 19011", "2011", retries: 3)
 [relaton-iso] ("ISO 19011") fetching...
 [relaton-iso] ("ISO 19011") found ISO 19011:2011
 => #<RelatonIsoBib::IsoBibliographicItem:0x007fb1d2593068
@@ -117,9 +164,185 @@ x = db.fetch("ISO 19115", nil, all_parts: true)
 => #<RelatonIsoBib::IsoBibliographicItem:0x007fb1d0ae8bf0
 ...
 
+# Fetchig from local cache
+
+x = db.fetch("ISO 19011")
+=> #<RelatonIsoBib::IsoBibliographicItem:0x007fde5f48a9f0
+...
+
+x = db.fetch_db("ISO 5749")
+=> nil
+
+# Fetching asynchronously
+
+# prepare queue for results
+results = Queue.new
+
+# fetch document
+db.fetch_async("ISO 19115") do |result|
+  results << { "ISO 19115" => result }
+end
+# fetch other documets the same way
+
+# wait until documets fetching
+while x = results.pop
+  # do thatever you need with result x
+end
+----
+
+==== Fetch by URN
+
+This functionality works only for IEC documents.
+
+[source,ruby]
+----
+x = db.fetch "urn:iec:std:iec:60050-102:2007:::"
+[relaton-iec] ("IEC 60050-102") fetching...
+[relaton-iec] ("IEC 60050-102") found IEC 60050-102:2007
+=> #<RelatonIec::IecBibliographicItem:0x007fbd6c3790e8
+...
+----
+
+=== Fetch combined documents
+
+This functionality works only for ISO, IEC, ITU, and NIST documents.
+
+==== Fetch included documents
+[source,ruby]
+----
+bib = db.fetch "ISO 19115-1 + Amd 1"
+[relaton-iso] ("ISO 19115-1") fetching...
+[relaton-iso] ("ISO 19115-1") found ISO 19115-1:2014
+[relaton-iso] ("ISO 19115-1/Amd 1") fetching...
+[relaton-iso] ("ISO 19115-1/Amd 1") found ISO 19115-1:2014/Amd 1:2018
+=> #<RelatonIsoBib::IsoBibliographicItem:0x007f95a929a748
+
+bib.docidentifier[0].id
+=> "ISO 19115-1 + Amd 1"
+
+bib.relation[0].type
+=> "updates"
+
+bib.relation[0].bibitem.docidentifier[0].id
+=> "ISO 19115-1"
+
+bib.relation[1].type
+=> "derivedFrom"
+
+bib.relation[1].bibitem.docidentifier[0].id
+=> "ISO 19115-1/Amd 1:2018"
+
+bib.docidentifier[0].id
+=> "ISO 19115-1, Amd 1"
+
+bib.relation[0].type
+=> "updates"
+
+bib.relation[0].bibitem.docidentifier[0].id
+=> "ISO 19115-1"
+
+bib.relation[1].type
+=> "complements"
+
+bib.relation[1].description
+=> "amendment"
+
+bib.relation[1].bibitem.docidentifier[0].id
+=> "ISO 19115-1/Amd 1:2018"
+----
+
+==== Fetch applied documents
+[source,ruby]
+----
+bib = db.fetch "ISO 19115-1, Amd 1"
+=> ["Chinese Standard", "GB/T 1.1"]
+[relaton-iso] ("ISO 19115-1") fetching...
+[relaton-iso] ("ISO 19115-1") found ISO 19115-1:2014
+[relaton-iso] ("ISO 19115-1/Amd 1") fetching...
+[relaton-iso] ("ISO 19115-1/Amd 1") found ISO 19115-1:2014/Amd 1:2018
+=> #<RelatonIsoBib::IsoBibliographicItem:0x007fb09b36d1b8
+...
+----
+
+==== Fetch all documents from cache
+
+`Relaton::Db#fetch_all(text = nil, edition: nil, year: nil)` - fetches all document from local cache
+
+* `text` - (String) filter entries by a text (optional)
+* `edition` - (String) filter entries by an edition (optional)
+* `year` - (Integer) filter entries by a year (optional)
+
+[source,ruby]
+----
+# query for all entries in a cahche
+
+items = db.fetch_all
+=> [#<RelatonIec::IecBibliographicItem:0x007facda8fdc28
+...
+
+items.size
+=> 6
+
+# query for all entries in a cahche for a certain string
+
+items = db.fetch_all("mathematical terminology")
+=> [#<RelatonIec::IecBibliographicItem:0x007ffeae5bd240
+...
+
+items.size
+=> 1
+
+items[0].docidentifier[0].id
+=> "IEC 60050-102:2007"
+
+# query for all entries in a cahche for a certain string and edition
+
+items = db.fetch_all("system", edition: "2")
+=> [#<RelatonIsoBib::IsoBibliographicItem:0x007ffebe2d1be8
+...
+
+items.size
+=> 1
+
+items[0].docidentifier[0].id
+=> "ISO 19011:2011"
+
+# query for all entries in a cahche for a certain string and year
+
+items = db.fetch_all("system", year: 2018)
+=> [#<RelatonIsoBib::IsoBibliographicItem:0x007ffeae645fa0
+...
+
+items.size
+=> 1
+
+items[0].docidentifier[0].id
+=> "ISO 19011 (all parts)"
+----
+
+=== Static DB
+
+This gem has a static DB which is distributed with it. Now the static contains documents:
+----
+ISO/IEC DIR 1 IEC SUP
+ISO/IEC DIR 1 ISO SUP
+ISO/IEC DIR 1
+ISO/IEC DIR 2 IEC
+ISO/IEC DIR 2 ISO
+ISO/IEC DIR IEC SUP
+ISO/IEC DIR 1 ISO SUP
+----
+
+=== Get document type
+[source,ruby]
+----
 db.docid_type("CN(GB/T 1.1)")
 => ["Chinese Standard", "GB/T 1.1"]
+----
 
+=== Serializing
+[source,ruby]
+----
 x.to_xml
 => "<bibitem id="ISO19115(allparts)" type="standard">
       ...
@@ -146,11 +369,14 @@ db.load_entry("ISO(ISO 19011)")
 => "<bibdata type="standard">
       ...
     <?bibdata>"
+----
 
+=== Entry manipulation
+[source,ruby]
+----
 db.save_entry("ISO(ISO 19011)", nil)
 => nil
 
 db.load_entry("ISO(ISO 19011)")
 => nil
-
 ----

data/globalcache/iec/iec_60050_102_2007.xml

@@ -0,0 +1,58 @@
+<bibdata type="standard">
+  <fetched>2021-02-03</fetched>
+  <title type="title-main" format="text/plain" language="en" script="Latn">International Electrotechnical Vocabulary (IEV)</title>
+  <title type="title-part" format="text/plain" language="en" script="Latn">Part 102: Mathematics -- General concepts and linear algebra</title>
+  <title type="main" format="text/plain" language="en" script="Latn">International Electrotechnical Vocabulary (IEV) - Part 102: Mathematics -- General concepts and linear algebra</title>
+  <uri type="src">https://webstore.iec.ch/publication/160</uri>
+  <uri type="obp">/preview/info_iec60050-102%7Bed1.0%7Db.pdf</uri>
+  <docidentifier type="IEC">IEC 60050-102:2007</docidentifier>
+  <docidentifier type="URN">urn:iec:std:iec:60050-102:2007:::en</docidentifier>
+  <date type="published">
+    <on>2007-08-27</on>
+  </date>
+  <contributor>
+    <role type="publisher"/>
+    <organization>
+      <name>International Electrotechnical Commission</name>
+      <abbreviation>IEC</abbreviation>
+      <uri>www.iec.ch</uri>
+    </organization>
+  </contributor>
+  <edition>1.0</edition>
+  <language>en</language>
+  <script>Latn</script>
+  <abstract format="text/plain" language="en" script="Latn">This part of IEC 60050 gives the general mathematical terminology used in the fields of electricity, electronics and telecommunications, together with basic concepts in linear algebra. It maintains a clear distinction between mathematical concepts and physical concepts, even if some terms are used in both cases. Another part will deal with functions.&#13;
+It has the status of a horizontal standard in accordance with IEC Guide 108.</abstract>
+  <status>
+    <stage>60</stage>
+    <substage>60</substage>
+  </status>
+  <copyright>
+    <from>2007</from>
+    <owner>
+      <organization>
+        <name>International Electrotechnical Commission</name>
+        <abbreviation>IEC</abbreviation>
+        <uri>www.iec.ch</uri>
+      </organization>
+    </owner>
+  </copyright>
+  <place>Geneva</place>
+  <ext>
+    <doctype>international-standard</doctype>
+    <editorialgroup>
+      <technical-committee number="1" type="technicalCommittee">TC 1 - Terminology</technical-committee>
+    </editorialgroup>
+    <ics>
+      <code>01.040.07</code>
+      <text>Natural and applied sciences (Vocabularies)</text>
+    </ics>
+    <ics>
+      <code>07.020</code>
+      <text>Mathematics</text>
+    </ics>
+    <structuredidentifier type="IEC">
+      <project-number>60050</project-number>
+    </structuredidentifier>
+  </ext>
+</bibdata>

data/globalcache/iec/version

@@ -0,0 +1 @@
+407d6f5afdc9ae9ea7abe6e84d27f40b

data/lib/relaton.rb

@@ -1,8 +1,9 @@
-require_relative "relaton/util"
-require_relative "relaton/config"
+require "relaton/util"
+require "relaton/config"
 
-require_relative "relaton/db"
-require_relative "relaton/db_cache"
-require_relative "relaton/version"
-require_relative "relaton/registry"
-require_relative "relaton/processor"
+require "relaton/workers_pool"
+require "relaton/db"
+require "relaton/db_cache"
+require "relaton/version"
+require "relaton/registry"
+require "relaton/processor"

data/lib/relaton/config.rb

@@ -12,10 +12,11 @@ module Relaton
   end
 
   class Configuration
-    attr_accessor :logs
+    attr_accessor :logs, :use_api
 
     def initialize
-      @logs ||= %i(warning error)
+      @logs = %i(warning error)
+      @use_api = false # @TODO change to true when we start using api.relaton.org
     end
   end
 

data/lib/relaton/db.rb

@@ -12,37 +12,112 @@ module Relaton
       @registry = Relaton::Registry.instance
       @db = open_cache_biblio(global_cache, type: :global)
       @local_db = open_cache_biblio(local_cache, type: :local)
-      @db_name = global_cache
-      @local_db_name = local_cache
-      static_db_name = File.expand_path "../relaton/static_cache", __dir__
-      @static_db = open_cache_biblio static_db_name
+      @static_db = open_cache_biblio File.expand_path("../relaton/static_cache", __dir__)
+      @queues = {}
     end
 
+    # Move global and/or local caches to anothe dirs
+    # @param new_global_dir [String, nil]
+    # @param new_local_dir [String, nil]
+    def mv(new_global_dir, new_local_dir)
+      @db.mv new_global_dir
+      @local_db.mv new_local_dir
+    end
+
+    # Clear global and local databases
+    def clear
+      @db.clear
+      @local_db.clear
+    end
+
+    ##
     # The class of reference requested is determined by the prefix of the code:
     # GB Standard for gbbib, IETF for ietfbib, ISO for isobib, IEC or IEV for iecbib,
+    #
     # @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
-    # @return [NilClass, RelatonIsoBib::IsoBibliographicItem,
+    #
+    # @param opts [Hash] options
+    # @option opts [Boolean] :all_parts If all-parts reference is required
+    # @option opts [Boolean] :keep_year If undated reference should return actual reference with year
+    # @option opts [Integer] :retries (1) Number of network retries
+    #
+    # @return [nil, RelatonBib::BibliographicItem, RelatonIsoBib::IsoBibliographicItem,
     #   RelatonItu::ItuBibliographicItem, RelatonIetf::IetfBibliographicItem,
-    #   RelatonNist::NistBibliongraphicItem, RelatonGb::GbbibliographicItem]
+    #   RelatonIec::IecBibliographicItem, RelatonIeee::IeeeBibliographicItem,
+    #   RelatonNist::NistBibliongraphicItem, RelatonGb::GbbibliographicItem,
+    #   RelatonOgc::OgcBibliographicItem, RelatonCalconnect::CcBibliographicItem]
+    #   RelatonBipm::BipmBibliographicItem, RelatonIho::IhoBibliographicItem,
+    #   RelatonOmg::OmgBibliographicItem RelatinUn::UnBibliographicItem,
+    #   RelatonW3c::W3cBibliographicItem
+    ##
     def fetch(code, year = nil, opts = {})
       stdclass = standard_class(code) || return
-      check_bibliocache(code, year, opts, stdclass)
+      processor = @registry.processors[stdclass]
+      ref = processor.respond_to?(:urn_to_code) ? processor.urn_to_code(code)&.first : code
+      ref ||= code
+      result = combine_doc ref, year, opts, stdclass
+      result ||= check_bibliocache(ref, year, opts, stdclass)
+      result
+    end
+
+    # @see Relaton::Db#fetch
+    def fetch_db(code, year = nil, opts = {})
+      opts[:fetch_db] = true
+      fetch code, year, opts
+    end
+
+    # fetch all standards from DB
+    # @param test [String, nil]
+    # @param edition [String], nil
+    # @param year [Integer, nil]
+    # @return [Array]
+    def fetch_all(text = nil, edition: nil, year: nil)
+      result = @static_db.all { |file, yml| search_yml file, yml, text, edition, year }.compact
+      db = @db || @local_db
+      result += db.all { |file, xml| search_xml file, xml, text, edition, year }.compact if db
+      result
+    end
+
+    # Fetch asynchronously
+    def fetch_async(code, year = nil, opts = {}, &_block) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      stdclass = standard_class code
+      if stdclass
+        unless @queues[stdclass]
+          processor = @registry.processors[stdclass]
+          wp = WorkersPool.new(processor.threads) { |args| yield fetch *args }
+          @queues[stdclass] = { queue: Queue.new, workers_pool: wp }
+          Thread.new { process_queue @queues[stdclass] }
+        end
+        @queues[stdclass][:queue] << [code, year, opts]
+      else yield nil
+      end
     end
 
     # @param code [String]
     # @param year [String, NilClass]
     # @param stdclass [Symbol, NilClass]
+    #
     # @param opts [Hash]
+    # @option opts [Boolean] :all_parts If all-parts reference is required
+    # @option opts [Boolean] :keep_year If undated reference should return actual reference with year
+    # @option opts [Integer] :retries (1) Number of network retries
+    #
+    # @return [nil, RelatonBib::BibliographicItem, RelatonIsoBib::IsoBibliographicItem,
+    #   RelatonItu::ItuBibliographicItem, RelatonIetf::IetfBibliographicItem,
+    #   RelatonIec::IecBibliographicItem, RelatonIeee::IeeeBibliographicItem,
+    #   RelatonNist::NistBibliongraphicItem, RelatonGb::GbbibliographicItem,
+    #   RelatonOgc::OgcBibliographicItem, RelatonCalconnect::CcBibliographicItem]
+    #   RelatonBipm::BipmBibliographicItem, RelatonIho::IhoBibliographicItem,
+    #   RelatonOmg::OmgBibliographicItem RelatinUn::UnBibliographicItem,
+    #   RelatonW3c::W3cBibliographicItem
     def fetch_std(code, year = nil, stdclass = nil, opts = {})
       std = nil
       @registry.processors.each do |name, processor|
         std = name if processor.prefix == stdclass
       end
-      unless std
-        std = standard_class(code) or return nil
-      end
+      std = standard_class(code) or return nil unless std
+
       check_bibliocache(code, year, opts, std)
     end
 
@@ -86,27 +161,115 @@ module Relaton
 
     private
 
+    # @param file [String] file path
+    # @param yml [String] content in YAML format
+    # @param text [String, nil] text to serach
+    # @param edition [String, nil] edition to filter
+    # @param year [Integer, nil] year to filter
+    # @return [BibliographicItem, nil]
+    def search_yml(file, yml, text, edition, year)
+      item = search_edition_year(file, yml, edition, year)
+      return unless item
+
+      item if match_xml_text(item.to_xml(bibdata: true), text)
+    end
+
+    # @param file [String] file path
+    # @param xml [String] content in XML format
+    # @param text [String, nil] text to serach
+    # @param edition [String, nil] edition to filter
+    # @param year [Integer, nil] year to filter
+    # @return [BibliographicItem, nil]
+    def search_xml(file, xml, text, edition, year)
+      return unless text.nil? || match_xml_text(xml, text)
+
+      search_edition_year(file, xml, edition, year)
+    end
+
+    # @param file [String] file path
+    # @param content [String] content in XML or YAmL format
+    # @param edition [String, nil] edition to filter
+    # @param year [Integer, nil] year to filter
+    # @return [BibliographicItem, nil]
+    def search_edition_year(file, content, edition, year) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      processor = @registry.processors[standard_class(file.split("/")[-2])]
+      item = file.match?(/xml$/) ? processor.from_xml(content) : processor.hash_to_bib(YAML.safe_load(content))
+      item if (edition.nil? || item.edition == edition) &&
+        (year.nil? || item.date.detect { |d| d.type == "published" && d.on(:year) == year })
+    end
+
+    # @param xml [String] content in XML format
+    # @param text [String, nil] text to serach
+    # @return [Boolean]
+    def match_xml_text(xml, text)
+      %r{((?<attr>=((?<apstr>')|"))|>).*?#{text}.*?(?(<attr>)(?(<apstr>)'|")|<)}mi.match?(xml)
+    end
+
+    # @param code [String]
+    # @param year [String, nil]
+    # @param stdslass [String]
+    #
+    # @param opts [Hash] options
+    # @option opts [Boolean] :all_parts If all-parts reference is required
+    # @option opts [Boolean] :keep_year If undated reference should return actual reference with year
+    # @option opts [Integer] :retries (1) Number of network retries
+    #
+    # @return [nil, RelatonBib::BibliographicItem, RelatonIsoBib::IsoBibliographicItem,
+    #   RelatonItu::ItuBibliographicItem, RelatonIetf::IetfBibliographicItem,
+    #   RelatonIec::IecBibliographicItem, RelatonIeee::IeeeBibliographicItem,
+    #   RelatonNist::NistBibliongraphicItem, RelatonGb::GbbibliographicItem,
+    #   RelatonOgc::OgcBibliographicItem, RelatonCalconnect::CcBibliographicItem]
+    #   RelatonBipm::BipmBibliographicItem, RelatonIho::IhoBibliographicItem,
+    #   RelatonOmg::OmgBibliographicItem RelatinUn::UnBibliographicItem,
+    #   RelatonW3c::W3cBibliographicItem
+    def combine_doc(code, year, opts, stdclass) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      if (refs = code.split " + ").size > 1
+        reltype = "derivedFrom"
+        reldesc = nil
+      elsif (refs = code.split ", ").size > 1
+        reltype = "complements"
+        reldesc = RelatonBib::FormattedString.new content: "amendment"
+      else return
+      end
+
+      doc = @registry.processors[stdclass].hash_to_bib docid: { id: code }
+      ref = refs[0]
+      updates = check_bibliocache(ref, year, opts, stdclass)
+      doc.relation << RelatonBib::DocumentRelation.new(bibitem: updates, type: "updates") if updates
+      refs[1..-1].each_with_object(doc) do |c, d|
+        bib = check_bibliocache("#{ref}/#{c}", year, opts, stdclass)
+        if bib
+          d.relation << RelatonBib::DocumentRelation.new(type: reltype, description: reldesc, bibitem: bib)
+        end
+      end
+    end
+
     # @param code [String] code of standard
     # @return [Symbol] standard class name
     def standard_class(code)
       @registry.processors.each do |name, processor|
-        return name if /^#{processor.prefix}/.match(code) ||
+        return name if /^(urn:)?#{processor.prefix}/i.match?(code) ||
           processor.defaultprefix.match(code)
       end
       allowed = @registry.processors.reduce([]) do |m, (_k, v)|
         m << v.prefix
       end
       warn <<~WARN
-       #{code} does not have a recognised prefix: #{allowed.join(', ')}.
-       See https://github.com/relaton/relaton/ for instructions on prefixing and wrapping document identifiers to disambiguate them.
-       WARN
+        #{code} does not have a recognised prefix: #{allowed.join(', ')}.
+        See https://github.com/relaton/relaton/ for instructions on prefixing and wrapping document identifiers to disambiguate them.
+      WARN
     end
 
     # TODO: i18n
     # Fofmat ID
     # @param code [String]
     # @param year [String]
+    #
     # @param opts [Hash]
+    # @option opts [Boolean] :all_parts If all-parts reference is required
+    # @option opts [Boolean] :keep_year If undated reference should return actual reference with year
+    # @option opts [Integer] :retries (1) Number of network retries
+    #
     # @param stdClass [Symbol]
     # @return [Array<String>] docid and code
     def std_id(code, year, opts, stdclass)
@@ -129,23 +292,36 @@ module Relaton
 
     # @param entry [String] XML string
     # @param stdclass [Symbol]
-    # @param id [String] docid
-    # @return [NilClass, RelatonIsoBib::IsoBibliographicItem,
+    # @return [nil, RelatonBib::BibliographicItem, RelatonIsoBib::IsoBibliographicItem,
     #   RelatonItu::ItuBibliographicItem, RelatonIetf::IetfBibliographicItem,
-    #   RelatonNist::NistBibliongraphicItem, RelatonGb::GbbibliographicItem]
-    def bib_retval(entry, stdclass, id)
-      entry =~ /^not_found/ ? nil : @registry.processors[stdclass].from_xml(entry)
+    #   RelatonIec::IecBibliographicItem, RelatonIeee::IeeeBibliographicItem,
+    #   RelatonNist::NistBibliongraphicItem, RelatonGb::GbbibliographicItem,
+    #   RelatonOgc::OgcBibliographicItem, RelatonCalconnect::CcBibliographicItem]
+    #   RelatonBipm::BipmBibliographicItem, RelatonIho::IhoBibliographicItem,
+    #   RelatonOmg::OmgBibliographicItem RelatinUn::UnBibliographicItem,
+    #   RelatonW3c::W3cBibliographicItem
+    def bib_retval(entry, stdclass)
+      entry.nil? || entry.match?(/^not_found/) ? nil : @registry.processors[stdclass].from_xml(entry)
     end
 
     # @param code [String]
     # @param year [String]
+    #
     # @param opts [Hash]
+    # @option opts [Boolean] :all_parts If all-parts reference is required
+    # @option opts [Boolean] :keep_year If undated reference should return actual reference with year
+    # @option opts [Integer] :retries (1) Number of network retries
+    #
     # @param stdclass [Symbol]
-    # @return [NilClass, RelatonIsoBib::IsoBibliographicItem,
+    # @return [nil, RelatonBib::BibliographicItem, RelatonIsoBib::IsoBibliographicItem,
     #   RelatonItu::ItuBibliographicItem, RelatonIetf::IetfBibliographicItem,
+    #   RelatonIec::IecBibliographicItem, RelatonIeee::IeeeBibliographicItem,
     #   RelatonNist::NistBibliongraphicItem, RelatonGb::GbbibliographicItem,
     #   RelatonOgc::OgcBibliographicItem, RelatonCalconnect::CcBibliographicItem]
-    def check_bibliocache(code, year, opts, stdclass)
+    #   RelatonBipm::BipmBibliographicItem, RelatonIho::IhoBibliographicItem,
+    #   RelatonOmg::OmgBibliographicItem RelatinUn::UnBibliographicItem,
+    #   RelatonW3c::W3cBibliographicItem
+    def check_bibliocache(code, year, opts, stdclass) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
       id, searchcode = std_id(code, year, opts, stdclass)
       yaml = @static_db[id]
       return @registry.processors[stdclass].hash_to_bib YAML.safe_load(yaml) if yaml
@@ -153,31 +329,41 @@ module Relaton
       db = @local_db || @db
       altdb = @local_db && @db ? @db : nil
       if db.nil?
+        return if opts[:fetch_db]
+
         bibentry = new_bib_entry(searchcode, year, opts, stdclass, db: db, id: id)
-        return bib_retval(bibentry, stdclass, id)
+        return bib_retval(bibentry, stdclass)
       end
 
       db.delete(id) unless db.valid_entry?(id, year)
       if altdb
-        # db[id] ||= altdb[id]
-        db.clone_entry id, altdb
+        return bib_retval(altdb[id], stdclass) if opts[:fetch_db]
+
+        db.clone_entry id, altdb if altdb.valid_entry? id, year
         db[id] ||= new_bib_entry(searchcode, year, opts, stdclass, db: db, id: id)
         altdb.clone_entry(id, db) if !altdb.valid_entry?(id, year)
       else
+        return bib_retval(db[id], stdclass) if opts[:fetch_db]
+
         db[id] ||= new_bib_entry(searchcode, year, opts, stdclass, db: db, id: id)
       end
-      bib_retval(db[id], stdclass, id)
+      bib_retval(db[id], stdclass)
     end
 
     # @param code [String]
     # @param year [String]
+    #
     # @param opts [Hash]
+    # @option opts [Boolean] :all_parts If all-parts reference is required
+    # @option opts [Boolean] :keep_year If undated reference should return actual reference with year
+    # @option opts [Integer] :retries (1) Number of network retries
+    #
     # @param stdclass [Symbol]
     # @param db [Relaton::DbCache,`NilClass]
     # @param id [String] docid
     # @return [String]
-    def new_bib_entry(code, year, opts, stdclass, **args)
-      bib = @registry.processors[stdclass].get(code, year, opts)
+    def new_bib_entry(code, year, opts, stdclass, **args) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      bib = net_retry(code, year, opts, stdclass, opts.fetch(:retries, 1))
       bib_id = bib&.docidentifier&.first&.id
 
       # when docid doesn't match bib's id then return a reference to bib's id
@@ -185,11 +371,19 @@ module Relaton
         bid = std_id(bib.docidentifier.first.id, nil, {}, stdclass).first
         args[:db][bid] ||= bib_entry bib
         "redirection #{bid}"
-      else
-        bib_entry bib
+      else bib_entry bib
       end
     end
 
+    # @raise [RelatonBib::RequestError]
+    def net_retry(code, year, opts, stdclass, retries)
+      @registry.processors[stdclass].get(code, year, opts)
+    rescue RelatonBib::RequestError => e
+      raise e unless retries > 1
+
+      net_retry(code, year, opts, stdclass, retries - 1)
+    end
+
     # @param bib [RelatonGb::GbBibliongraphicItem, RelatonIsoBib::IsoBibliographicItem,
     #   RelatonIetf::IetfBibliographicItem, RelatonItu::ItuBibliographicItem,
     #   RelatonNist::NistBibliongraphicItem, RelatonOgc::OgcBibliographicItem]
@@ -202,21 +396,32 @@ module Relaton
       end
     end
 
-    # @param dir [String] DB directory
+    # @param dir [String, nil] DB directory
     # @param type [Symbol]
     # @return [Relaton::DbCache, NilClass]
     def open_cache_biblio(dir, type: :static)
       return nil if dir.nil?
 
       db = DbCache.new dir, type == :static ? "yml" : "xml"
+      return db if type == :static
 
       Dir["#{dir}/*/"].each do |fdir|
-        next if type == :static || db.check_version?(fdir)
+        next if db.check_version?(fdir)
 
         FileUtils.rm_rf(Dir.glob(fdir + "/*"), secure: true)
+        db.set_version fdir
         warn "[relaton] cache #{fdir}: version is obsolete and cache is cleared."
       end
       db
     end
+
+    # @param qwp [Hash]
+    # @option qwp [Queue] :queue The queue of references to fetch
+    # @option qwp [Relaton::WorkersPool] :workers_pool The pool of workers
+    def process_queue(qwp)
+      while args = qwp[:queue].pop
+        qwp[:workers_pool] << args
+      end
+    end
   end
 end