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 



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 



556
557
558
559
 
# File 'lib/relaton/db.rb', line 556

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

.global_bibliocache_name ⇒ Object 



561
562
563
 
# File 'lib/relaton/db.rb', line 561

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



549
550
551
552
553
554
 
# File 'lib/relaton/db.rb', line 549

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 



565
566
567
568
569
570
 
# File 'lib/relaton/db.rb', line 565

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
34
 
# File 'lib/relaton/db.rb', line 27

def clear
  @db&.clear
  @local_db&.clear
  @registry.processors.each_value do |p|
    require p.short.to_s
    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



158
159
160
161
162
 
# File 'lib/relaton/db.rb', line 158

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,

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



60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/relaton/db.rb', line 60

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



84
85
86
87
88
89
90
91
92
93
 
# File 'lib/relaton/db.rb', line 84

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



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/relaton/db.rb', line 105

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 RelatonBib::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:



74
75
76
77
 
# File 'lib/relaton/db.rb', line 74

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, ...

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



145
146
147
148
149
150
151
152
153
 
# File 'lib/relaton/db.rb', line 145

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 



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

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



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

Options Hash (value):

  • Bibitem (String) —

    xml serialisation.



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

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



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

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