relaton 2.1.0 → 2.2.0.pre.alpha.1

data/lib/relaton/db_cache.rb

@@ -1,230 +0,0 @@
-require "fileutils"
-require "timeout"
-
-module Relaton
-  class DbCache
-    # @return [String]
-    attr_reader :dir
-
-    # @param dir [String] DB directory
-    def initialize(dir, ext = "xml")
-      @dir = dir
-      @ext = ext
-      FileUtils::mkdir_p dir
-    end
-
-    # Move caches to anothe dir
-    # @param new_dir [String, nil]
-    # @return [String, nil]
-    def mv(new_dir)
-      return unless new_dir && @ext == "xml"
-
-      if File.exist? new_dir
-        Util.info "target directory exists `#{new_dir}`"
-        return
-      end
-
-      FileUtils.mv dir, new_dir
-      @dir = new_dir
-    end
-
-    # Clear database
-    def clear
-      FileUtils.rm_rf Dir.glob "#{dir}/*"
-    end
-
-    # Save item
-    # @param key [String]
-    # @param value [String] Bibitem xml serialization
-    def []=(key, value)
-      if value.nil?
-        delete key
-        return
-      end
-
-      prefix_dir = "#{@dir}/#{prefix(key)}"
-      FileUtils::mkdir_p prefix_dir
-      set_version prefix_dir
-      file_safe_write "#{filename(key)}.#{ext(value)}", value
-    end
-
-    # @param value [String]
-    # @return [String]
-    def ext(value)
-      case value
-      when /^not_found/ then "notfound"
-      when /^redirection/ then "redirect"
-      else @ext
-      end
-    end
-
-    # Read item
-    # @param key [String]
-    # @return [String]
-    def [](key)
-      value = get(key)
-      if (code = redirect_code value)
-        self[code]
-      else
-        value
-      end
-    end
-
-    #
-    # Save entry from cache of `db` to this cache.
-    #
-    # @param [String] key key of the entry
-    # @param [Relaton::Db] db database
-    #
-    def clone_entry(key, db)
-      self[key] ||= db.get(key)
-      if (code = redirect_code get(key))
-        clone_entry code, db
-      end
-    end
-
-    # Return fetched date
-    # @param key [String]
-    # @return [String]
-    def fetched(key)
-      value = self[key]
-      return unless value
-
-      if value.match?(/^not_found/)
-        value.match(/\d{4}-\d{2}-\d{2}/).to_s
-      else
-        doc = Nokogiri::XML value
-        doc.at("/bibitem/fetched|bibdata/fetched")&.text
-      end
-    end
-
-    # Returns all items
-    # @return [Array<String>]
-    def all(&block)
-      Dir.glob("#{@dir}/**/*.{xml,yml,yaml}").map do |f|
-        content = File.read(f, encoding: "utf-8")
-        block ? yield(f, content) : content
-      end
-    end
-
-    # Delete item
-    # @param key [String]
-    def delete(key)
-      file = filename key
-      f = search_ext file
-      return unless f
-
-      if File.extname(f) == ".redirect"
-        code = redirect_code get(key)
-        delete code if code
-      end
-      File.delete f
-    end
-
-    # Check if version of the DB match to the gem grammar hash.
-    # @param fdir [String] dir pathe to flover cache
-    # @return [Boolean]
-    def check_version?(fdir)
-      version_dir = "#{fdir}/version"
-      return false unless File.exist? version_dir
-
-      v = File.read version_dir, encoding: "utf-8"
-      v.strip == self.class.grammar_hash(fdir)
-    end
-
-    # if cached reference is undated, expire it after 60 days
-    # @param key [String]
-    # @param year [String]
-    def valid_entry?(key, year)
-      datestr = fetched key
-      return false unless datestr
-
-      date = Date.parse datestr
-      year || Date.today - date < 60
-    end
-
-    # Reads file by a key
-    #
-    # @param key [String]
-    # @return [String, NilClass]
-    def get(key)
-      file = filename key
-      return unless (f = search_ext(file))
-
-      File.read(f, encoding: "utf-8")
-    end
-
-    # @param fdir [String] dir pathe to flover cache
-    # @return [String]
-    def self.grammar_hash(fdir)
-      type = fdir.split("/").last
-      Relaton::Registry.instance.by_type(type)&.grammar_hash
-    end
-
-    private
-
-    # @param value [String]
-    # @return [String]
-    def filename(key)
-      prefcode = key.downcase.match(/^(?<prefix>[^(]+)\((?<code>[^)]+)/)
-      fn = if prefcode
-             "#{prefcode[:prefix]}/#{prefcode[:code].gsub(/[:\s\/()]/,
-                                                          '_').squeeze('_')}"
-           else
-             key.gsub(/[-:\s]/, "_")
-           end
-      "#{@dir}/#{fn.sub(/(,|_$)/, '')}"
-    end
-
-    #
-    # Checks if there is file with xml or txt extension and return filename with
-    # the extension.
-    #
-    # @param file [String]
-    # @return [String, NilClass]
-    def search_ext(file)
-      if File.exist?("#{file}.#{@ext}")
-        "#{file}.#{@ext}"
-      elsif File.exist? "#{file}.notfound"
-        "#{file}.notfound"
-      elsif File.exist? "#{file}.redirect"
-        "#{file}.redirect"
-      end
-    end
-
-    # Set version of the DB to the gem grammar hash.
-    # @param fdir [String] dir pathe to flover cache
-    def set_version(fdir)
-      file_version = "#{fdir}/version"
-      unless File.exist? file_version
-        file_safe_write file_version, self.class.grammar_hash(fdir)
-      end
-    end
-
-    # Return item's file name
-    # @param key [String]
-    # @return [String]
-    def prefix(key)
-      key.downcase.match(/^[^(]+(?=\()/).to_s
-    end
-
-    # Check if a file content is redirection
-    #
-    # @prarm value [String] file content
-    # @return [String, NilClass] redirection code or nil
-    def redirect_code(value)
-      %r{redirection\s(?<code>.*)} =~ value
-      code
-    end
-
-    # @param file [String]
-    # @content [String]
-    def file_safe_write(file, content)
-      File.open file, File::RDWR | File::CREAT, encoding: "UTF-8" do |f|
-        Timeout.timeout(10) { f.flock File::LOCK_EX }
-        f.write content
-        f.flock File::LOCK_UN
-      end
-    end
-  end
-end

data/lib/relaton/registry.rb

@@ -1,118 +0,0 @@
-require "singleton"
-
-# class Error < StandardError
-# end
-
-module Relaton
-  class Registry
-    SUPPORTED_GEMS = %w[
-      relaton/gb relaton/iec relaton/ietf relaton/iso
-      relaton/itu relaton/nist relaton/ogc relaton/calconnect
-      relaton/omg relaton/un relaton/w3c relaton/ieee
-      relaton/iho relaton/bipm relaton/ecma relaton/cie
-      relaton/bsi relaton/cen relaton/iana relaton/3gpp
-      relaton/oasis relaton/doi relaton/jis relaton/xsf
-      relaton/ccsds relaton/etsi relaton/isbn relaton/plateau
-    ].freeze
-
-    include Singleton
-
-    attr_reader :processors
-
-    def initialize
-      @processors = {}
-      register_gems
-    end
-
-    def register_gems
-      # Util.info("Info: detecting backends:")
-
-      SUPPORTED_GEMS.each do |b|
-        require "#{b}/processor"
-        register Kernel.const_get "#{gem_to_module_path(b)}::Processor"
-      rescue LoadError => e
-        Util.error "backend #{b} not present\n" \
-                   "#{e.message}\n#{e.backtrace.join "\n"}"
-      end
-    end
-
-    def register(processor)
-      raise Error unless processor < Core::Processor
-
-      p = processor.new
-      return if processors[p.short]
-
-      Util.debug("processor \"#{p.short}\" registered")
-      processors[p.short] = p
-    end
-
-    def find_processor(short)
-      processors[short.to_sym]
-    end
-
-    # @return [Array<Symbol>]
-    def supported_processors
-      processors.keys
-    end
-
-    #
-    # Search a rpocessos by dataset name
-    #
-    # @param [String] dataset
-    #
-    # @return [Relaton::Core::Processor, nil]
-    #
-    def find_processor_by_dataset(dataset)
-      processors.values.detect { |p| p.datasets&.include? dataset }
-    end
-
-    #
-    # Find processor by type
-    #
-    # @param type [String]
-    # @return [Relaton::Core::Processor]
-    def by_type(type)
-      processors.values.detect { |v| v.prefix == type&.upcase }
-    end
-
-    def [](stdclass)
-      processors[stdclass]
-    end
-
-    #
-    # Find processor by reference or prefix
-    #
-    # @param [String] ref reference or prefix
-    #
-    # @return [Relaton::Core::Processor] processor
-    #
-    def processor_by_ref(ref)
-      processors[class_by_ref(ref)]
-    end
-
-    #
-    # Find processor by refernce or prefix
-    #
-    # @param ref [String] reference or prefix
-    #
-    # @return [Symbol, nil] standard class name
-    #
-    def class_by_ref(ref)
-      ref = Regexp.last_match(1) if ref =~ /^\w+\((.*)\)$/
-      @processors.each do |class_name, processor|
-        return class_name if /^(urn:)?#{processor.prefix}\b/i.match?(ref) ||
-          processor.defaultprefix.match(ref)
-      end
-      Util.info "`#{ref}` does not have a recognised prefix", key: ref
-      nil
-    end
-
-    private
-
-    def gem_to_module_path(gem_name)
-      gem_name.split("/").map do |part|
-        part.capitalize.sub("3gpp", "ThreeGpp")
-      end.join("::")
-    end
-  end
-end

data/lib/relaton/util.rb

@@ -1,7 +0,0 @@
-module Relaton
-  module Util
-    extend Relaton::Bib::Util
-
-    PROGNAME = "relaton".freeze
-  end
-end

data/lib/relaton/workers_pool.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Relaton
-  # Workers poll.
-  class WorkersPool
-    def initialize(workers = 2, &)
-      # num_workers = workers < 2 ? 2 : workers
-      @queue = SizedQueue.new(workers * 2)
-      @threads = Array.new workers do
-        Thread.new do
-          while item = @queue.pop; yield(item) end
-        end
-      end
-    end
-
-    def <<(item)
-      @queue << item
-      self
-    end
-  end
-end