Class: Relaton::Db

Inherits:
Object
  • Object
show all
Defined in:
lib/relaton/db.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(global_cache, local_cache) ⇒ Db

Returns a new instance of Db.

Parameters:

  • global_cache (String) —

    directory of global DB

  • local_cache (String) —

    directory of local DB



5
6
7
8
9
10
11
12
13
 
# File 'lib/relaton/db.rb', line 5

def initialize(global_cache, local_cache)
  @registry = Relaton::Registry.instance
  gpath = global_cache && File.expand_path(global_cache)
  @db = open_cache_biblio(gpath)
  lpath = local_cache && File.expand_path(local_cache)
  @local_db = open_cache_biblio(lpath)
  @queues = {}
  @semaphore = Mutex.new
end

Class Method Details

.flush_caches(gcache, lcache) ⇒ Object 



638
639
640
641
 
# File 'lib/relaton/db.rb', line 638

def flush_caches(gcache, lcache)
  FileUtils.rm_rf gcache unless gcache.nil?
  FileUtils.rm_rf lcache unless lcache.nil?
end

.global_bibliocache_name ⇒ Object 



643
644
645
 
# File 'lib/relaton/db.rb', line 643

def global_bibliocache_name
  "#{Dir.home}/.relaton/cache"
end

.init_bib_caches(**opts) ⇒ Relaton::Db

Initialse and return relaton instance, with local and global cache names

Parameters:

  • local_cache (String, nil) —

    local cache name; “relaton” created if empty or nil

  • global_cache (Boolean, nil) —

    create global_cache if true

  • flush_caches (Boolean, nil) —

    flush caches if true

Returns:



631
632
633
634
635
636
 
# File 'lib/relaton/db.rb', line 631

def init_bib_caches(**opts) # rubocop:disable Metrics/CyclomaticComplexity
  globalname = global_bibliocache_name if opts[:global_cache]
  localname = local_bibliocache_name(opts[:local_cache])
  flush_caches globalname, localname if opts[:flush_caches]
  Relaton::Db.new(globalname, localname)
end

.local_bibliocache_name(cachename) ⇒ Object 



647
648
649
650
651
652
 
# File 'lib/relaton/db.rb', line 647

def local_bibliocache_name(cachename)
  return nil if cachename.nil?

  cachename = "relaton" if cachename.empty?
  "#{cachename}/cache"
end

Instance Method Details

#clear ⇒ Object

Clear global and local databases



27
28
29
30
31
32
33
 
# File 'lib/relaton/db.rb', line 27

def clear
  @db&.clear
  @local_db&.clear
  @registry.processors.each_value do |p|
    p.remove_index_file if p.respond_to? :remove_index_file
  end
end

#docid_type(code) ⇒ Array

The document identifier class corresponding to the given code

Parameters:

  • code (String)

Returns:

  • (Array) 


166
167
168
169
170
 
# File 'lib/relaton/db.rb', line 166

def docid_type(code)
  stdclass = @registry.class_by_ref(code) or return [nil, code]
  _, code = strip_id_wrapper(code, stdclass)
  [@registry[stdclass].idtype, code]
end

#fetch(text, year = nil, opts = {}) ⇒ nil, ...

The class of reference requested is determined by the prefix of the reference: GB Standard for gbbib, IETF for ietfbib, ISO for isobib, IEC or IEV for

iecbib,

Parameters:

  • text (String) —

    the standard reference to look up (e.g. “ISO 9000”)

  • year (String) (defaults to: nil) —

    the year the standard was published (optional)

  • opts (Hash) (defaults to: {}) —

    options

Options Hash (opts):

  • :all_parts (Boolean) —

    If all-parts reference is required

  • :keep_year (Boolean) —

    If undated reference should return actual reference with year

  • :retries (Integer) — default: 1 —

    Number of network retries

  • :no_cache (Boolean) —

    If true then don’t use cache

  • :publication_date_before (String) —

    published before this date (exclusive, formats: “YYYY”, “YYYY-MM”, or “YYYY-MM-DD”)

  • :publication_date_after (String) —

    published on or after this date (inclusive, formats: “YYYY”, “YYYY-MM”, or “YYYY-MM-DD”)

Returns:

  • (nil, RelatonBib::BibliographicItem, RelatonIsoBib::IsoBibliographicItem, RelatonItu::ItuBibliographicItem, RelatonIetf::IetfBibliographicItem, RelatonIec::IecBibliographicItem, RelatonIeee::IeeeBibliographicItem, RelatonNist::NistBibliongraphicItem, RelatonGb::GbbibliographicItem, RelatonOgc::OgcBibliographicItem, RelatonCalconnect::CcBibliographicItem, RelatinUn::UnBibliographicItem, RelatonBipm::BipmBibliographicItem, RelatonIho::IhoBibliographicItem, RelatonOmg::OmgBibliographicItem, RelatonW3c::W3cBibliographicItem) 


65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/relaton/db.rb', line 65

def fetch(text, year = nil, opts = {})
  reference = text.strip
  stdclass = @registry.class_by_ref(reference) || return
  processor = @registry[stdclass]
  ref = if processor.respond_to?(:urn_to_code)
          processor.urn_to_code(reference)&.first
        else reference
        end
  ref ||= reference
  result = combine_doc ref, year, opts, stdclass
  result || check_bibliocache(ref, year, opts, stdclass)
end

#fetch_all(text = nil, edition: nil, year: nil) ⇒ Array

fetch all standards from DB

Parameters:

  • test (String, nil)
  • edition (String) (defaults to: nil) —

    , nil

  • year (Integer, nil) (defaults to: nil)

Returns:

  • (Array) 


89
90
91
92
93
94
95
96
97
98
 
# File 'lib/relaton/db.rb', line 89

def fetch_all(text = nil, edition: nil, year: nil)
  result = []
  db = @db || @local_db
  if db
    result += db.all do |file, xml|
      search_xml file, xml, text, edition, year
    end.compact
  end
  result
end

#fetch_async(ref, year = nil, opts = {}, &block) ⇒ RelatonBib::BibliographicItem, ...

Fetch asynchronously

Parameters:

  • ref (String) —

    reference

  • year (String) (defaults to: nil) —

    document yer

  • opts (Hash) (defaults to: {}) —

    options

Returns:

  • (RelatonBib::BibliographicItem, RelatonBib::RequestError, nil) —

    bibitem if document is found, request error if server doesn’t answer, nil if document not found



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/relaton/db.rb', line 112

def fetch_async(ref, year = nil, opts = {}, &block) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
  stdclass = @registry.class_by_ref ref
  if stdclass
    unless @queues[stdclass]
      processor = @registry[stdclass]
      threads = ENV["RELATON_FETCH_PARALLEL"]&.to_i || processor.threads
      wp = WorkersPool.new(threads) do |args|
        args[3].call fetch(*args[0..2])
      rescue Relaton::RequestError => e
        args[3].call e
      rescue StandardError => e
        Util.error "`#{args[0]}` -- #{e.message}"
        args[3].call nil
      end
      @queues[stdclass] =
        { queue: SizedQueue.new(threads * 2), workers_pool: wp }
      Thread.new { process_queue @queues[stdclass] }
    end
    @queues[stdclass][:queue] << [ref, year, opts, block]
  else yield nil
  end
end

#fetch_db(code, year = nil, opts = {}) ⇒ Object

See Also:



79
80
81
82
 
# File 'lib/relaton/db.rb', line 79

def fetch_db(code, year = nil, opts = {})
  opts[:fetch_db] = true
  fetch code, year, opts
end

#fetch_std(code, year = nil, stdclass = nil, opts = {}) ⇒ nil, ...

Parameters:

  • code (String)
  • year (String, NilClass) (defaults to: nil)
  • stdclass (Symbol, NilClass) (defaults to: nil)
  • opts (Hash) (defaults to: {})

Options Hash (opts):

  • :all_parts (Boolean) —

    If all-parts reference is required

  • :keep_year (Boolean) —

    If undated reference should return actual reference with year

  • :retries (Integer) — default: 1 —

    Number of network retries

Returns:

  • (nil, RelatonBib::BibliographicItem, RelatonIsoBib::IsoBibliographicItem, RelatonItu::ItuBibliographicItem, RelatonIetf::IetfBibliographicItem, RelatonIec::IecBibliographicItem, RelatonIeee::IeeeBibliographicItem, RelatonNist::NistBibliongraphicItem, RelatonGb::GbbibliographicItem, RelatonOgc::OgcBibliographicItem, RelatonCalconnect::CcBibliographicItem, RelatinUn::UnBibliographicItem, RelatonBipm::BipmBibliographicItem, RelatonIho::IhoBibliographicItem, RelatonOmg::OmgBibliographicItem, RelatonW3c::W3cBibliographicItem) 


153
154
155
156
157
158
159
160
161
 
# File 'lib/relaton/db.rb', line 153

def fetch_std(code, year = nil, stdclass = nil, opts = {})
  std = nil
  @registry.processors.each do |name, processor|
    std = name if processor.prefix == stdclass
  end
  std = @registry.class_by_ref(code) or return nil unless std

  check_bibliocache(code, year, opts, std)
end

#load_entry(key) ⇒ Hash

Parameters:

  • key (String)

Returns:

  • (Hash) 


174
175
176
 
# File 'lib/relaton/db.rb', line 174

def load_entry(key)
  (@local_db && @local_db[key]) || @db[key]
end

#mv(new_dir, type: :global) ⇒ String?

Move global or local caches to anothe dirs

Parameters:

  • new_dir (String, nil)
  • type: (Symbol) (defaults to: :global)

Returns:

  • (String, nil) 


19
20
21
22
23
24
 
# File 'lib/relaton/db.rb', line 19

def mv(new_dir, type: :global)
  case type
  when :global then @db&.mv new_dir
  when :local then @local_db&.mv new_dir
  end
end

#save_entry(key, value) ⇒ Object

Parameters:

  • key (String)
  • value (String) —

    Bibitem xml serialisation.

Options Hash (value):

  • Bibitem (String) —

    xml serialisation.



181
182
183
184
 
# File 'lib/relaton/db.rb', line 181

def save_entry(key, value)
  @db.nil? || (@db[key] = value)
  @local_db.nil? || (@local_db[key] = value)
end

#to_xml ⇒ String

list all entries as a serialization

Returns:

  • (String) 


188
189
190
191
192
193
 
# File 'lib/relaton/db.rb', line 188

def to_xml
  db = @local_db || @db || return
  Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
    xml.documents { xml.parent.add_child db.all.join(" ") }
  end.to_xml
end