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



11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/relaton/db.rb', line 11

def initialize(global_cache, local_cache)
  @registry = Relaton::Registry.instance
  gpath = global_cache && File.expand_path(global_cache)
  @db = open_cache_biblio(gpath, type: :global)
  lpath = local_cache && File.expand_path(local_cache)
  @local_db = open_cache_biblio(lpath, type: :local)
  @static_db = open_cache_biblio File.expand_path("../relaton/static_cache",
                                                  __dir__)
  @queues = {}
  @semaphore = Mutex.new
end

Class Method Details

.init_bib_caches(**opts) ⇒ Object

Initialse and return relaton instance, with local and global cache names local_cache: local cache name; none created if nil; “relaton” created if empty global_cache: boolean to create global_cache flush_caches: flush caches



490
491
492
493
494
495
 
# File 'lib/relaton/db.rb', line 490

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

Instance Method Details

#clear ⇒ Object

Clear global and local databases



37
38
39
40
 
# File 'lib/relaton/db.rb', line 37

def clear
  @db&.clear
  @local_db&.clear
end

#docid_type(code) ⇒ Array

The document identifier class corresponding to the given code

Parameters:

  • code (String)

Returns:

  • (Array) 


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

def docid_type(code)
  stdclass = standard_class(code) or return [nil, code]
  _prefix, code = strip_id_wrapper(code, stdclass)
  [@registry.processors[stdclass].idtype, code]
end

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

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,

Parameters:

  • code (String) —

    the ISO standard Code 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

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(code, year = nil, opts = {})
  stdclass = standard_class(code) || return
  processor = @registry.processors[stdclass]
  ref = if processor.respond_to?(:urn_to_code)
          processor.urn_to_code(code)&.first
        else code
        end
  ref ||= code
  result = combine_doc ref, year, opts, stdclass
  result ||= check_bibliocache(ref, year, opts, stdclass)
  result
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
99
100
 
# File 'lib/relaton/db.rb', line 89

def fetch_all(text = nil, edition: nil, year: nil)
  result = @static_db.all do |file, yml|
    search_yml file, yml, text, edition, year
  end.compact
  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(code, year = nil, opts = {}, &block) ⇒ Object

Fetch asynchronously



103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/relaton/db.rb', line 103

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]
      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
      end
      @queues[stdclass] = { queue: Queue.new, workers_pool: wp }
      Thread.new { process_queue @queues[stdclass] }
    end
    @queues[stdclass][:queue] << [code, 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) 


140
141
142
143
144
145
146
147
148
 
# File 'lib/relaton/db.rb', line 140

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 = standard_class(code) or return nil unless std

  check_bibliocache(code, year, opts, std)
end

#load_entry(key) ⇒ Hash

Parameters:

  • key (String)

Returns:

  • (Hash) 


161
162
163
164
165
166
167
 
# File 'lib/relaton/db.rb', line 161

def load_entry(key)
  unless @local_db.nil?
    entry = @local_db[key]
    return entry if entry
  end
  @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) 


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

def mv(new_dir, type: :global)
  case type
  when :global
    @db&.mv new_dir
  when :local
    @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.



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

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) 


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

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