relaton 1.8.pre3 → 1.8.pre4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d954779afa85cdbe30b00b6780f4fe2ea261839da0f82855dca6e63fe8be77d
-  data.tar.gz: e7549980e5771e74412291428b8010ad4d6a7720526b98169b97dac82539e909
+  metadata.gz: e0872533d5f93e35d777c6a84a4f38a5698b64cc00d9d103b77f7e10fc34738b
+  data.tar.gz: 3f1cc128d958996cd8ea6eb31bacc530bba464a8d8b5cb855cd4e204214ef7d1
 SHA512:
-  metadata.gz: 466c2e7c24c972df07bf9548b0dac26ec0eb2c03d7c8716abba50cc7a95f83dd58c903b3b99a99fbddcb3afa1d68518c93082acee68034ec3d3230e10d4f0b25
-  data.tar.gz: 3f4fb6fd8750375862ae109d8d50654372fa3d8e1b6b8eb966e827a026cd4c99f1790a68068c6785a93c6a2c459b6c1506a1768aef881025fa12914cffd0708b
+  metadata.gz: 1862b4eb76509da3ae2ac959d1ffd7bf6e785bc45033c5123236f5c3f9dc5cafc42940a7cba78222960a59ad542fb0786f2a0be8e5da926bbb4b3aa886278a5e
+  data.tar.gz: b21c4797a9003696de1e5d79f017d19c417a9db72e549eeaab7edaa935e26ce9f1b009fdea83bf8896100ed30c63d5b7df730fbeaacedfc91243468cbc54a39b

data/lib/relaton/config.rb

@@ -12,14 +12,13 @@ module Relaton
   end
 
   class Configuration
-    attr_accessor :logs, :use_api, :api_host, :api_mode
+    attr_accessor :logs, :use_api, :api_host
 
     def initialize
       @logs = %i(info error) # allowed values: :info, :warning, :error, :debug
 
       # @TODO change to true when we start using api.relaton.org
       @use_api = true
-      @api_mode = false
       @api_host = "https://api.relaton.org/api/v1"
     end
   end

data/lib/relaton/db.rb

@@ -1,18 +1,11 @@
 module Relaton
-  # class RelatonError < StandardError; end
-
   class Db
     # @param global_cache [String] directory of global DB
     # @param local_cache [String] directory of local DB
-    def initialize(global_cache, local_cache) # rubocop:disable Metrics/MethodLength
+    def initialize(global_cache, local_cache)
       @registry = Relaton::Registry.instance
-      if Relaton.configuration.api_mode
-        gpath = global_cache
-        lpath = local_cache
-      else
-        gpath = global_cache && File.expand_path(global_cache)
-        lpath = local_cache && File.expand_path(local_cache)
-      end
+      gpath = global_cache && File.expand_path(global_cache)
+      lpath = local_cache && File.expand_path(local_cache)
       @db = open_cache_biblio(gpath, type: :global)
       @local_db = open_cache_biblio(lpath, type: :local)
       @static_db = open_cache_biblio File.expand_path "../relaton/static_cache", __dir__
@@ -525,12 +518,10 @@ module Relaton
       end
 
       def global_bibliocache_name
-        Relaton.configuration.api_mode ? "cache" : "#{Dir.home}/.relaton/cache"
+        "#{Dir.home}/.relaton/cache"
       end
 
       def local_bibliocache_name(cachename)
-        return nil if Relaton.configuration.api_mode || cachename.nil?
-
         cachename = "relaton" if cachename.empty?
         "#{cachename}/cache"
       end

data/lib/relaton/db_cache.rb

@@ -1,6 +1,5 @@
 require "fileutils"
 require "timeout"
-require "relaton/storage"
 
 module Relaton
   class DbCache
@@ -11,15 +10,14 @@ module Relaton
     def initialize(dir, ext = "xml")
       @dir = dir
       @ext = ext
-      @storage = Storage.instance
-      FileUtils::mkdir_p @dir unless Relaton.configuration.api_mode
+      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" && !Relaton.configuration.api_mode
+      return unless new_dir && @ext == "xml"
 
       if File.exist? new_dir
         warn "[relaton] WARNING: target directory exists \"#{new_dir}\""
@@ -32,9 +30,7 @@ module Relaton
 
     # Clear database
     def clear
-      return if Relaton.configuration.api_mode
-
-      FileUtils.rm_rf Dir.glob "#{dir}/*" if @ext == "xml" # if it's static DB
+      FileUtils.rm_rf Dir.glob "#{dir}/*" if @ext == "xml" # if it isn't a static DB
     end
 
     # Save item
@@ -47,8 +43,9 @@ module Relaton
       end
       /^(?<pref>[^(]+)(?=\()/ =~ key.downcase
       prefix_dir = "#{@dir}/#{pref}"
-      file = "#{filename(key)}.#{ext(value)}"
-      @storage.save prefix_dir, file, value
+      FileUtils::mkdir_p prefix_dir unless Dir.exist? prefix_dir
+      set_version prefix_dir
+      file_safe_write "#{filename(key)}.#{ext(value)}", value
     end
 
     # Read item
@@ -88,20 +85,29 @@ module Relaton
     # Returns all items
     # @return [Array<String>]
     def all(&block)
-      @storage.all(@dir, &block)
+      Dir.glob("#{@dir}/**/*.{xml,yml,yaml}").sort.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)
-      @storage.delete filename(key)
+      file = filename key
+      f = search_ext file
+      File.delete f if 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)
-      @storage.check_version? fdir
+      version_file = "#{fdir}/version"
+      return false unless File.exist? version_file
+
+      v = File.read version_file, encoding: "utf-8"
+      v.strip == self.class.grammar_hash(fdir)
     end
 
     # if cached reference is undated, expire it after 60 days
@@ -120,7 +126,17 @@ module Relaton
     # @param key [String]
     # @return [String, NilClass]
     def get(key)
-      @storage.get filename(key), static: @ext == "yml"
+      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
@@ -135,6 +151,31 @@ module Relaton
       end
     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]
@@ -158,11 +199,13 @@ module Relaton
       code
     end
 
-    # Return item's subdir
-    # @param key [String]
-    # @return [String]
-    # def prefix(key)
-    #   key.downcase.match(/^[^(]+(?=\()/).to_s
-    # 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
+      end
+    end
   end
 end

data/lib/relaton/version.rb

@@ -1,3 +1,3 @@
 module Relaton
-  VERSION = "1.8.pre3".freeze
+  VERSION = "1.8.pre4".freeze
 end

data/relaton.gemspec

@@ -30,7 +30,6 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
 
   # spec.add_dependency "algoliasearch"
-  spec.add_dependency "aws-sdk-s3", "~> 1.96.0"
   spec.add_dependency "relaton-bipm", "~> 1.8.0"
   spec.add_dependency "relaton-bsi", "~> 1.8.0"
   spec.add_dependency "relaton-calconnect", "~> 1.8.0"

data/spec/relaton/db_spec.rb

@@ -1,22 +1,22 @@
 RSpec.describe Relaton::Db do
   before(:each) { FileUtils.rm_rf %w[testcache testcache2] }
 
-  context "initialization in API mode" do
-    before(:each) { Relaton.configure { |c| c.api_mode = true } }
-    after(:each) { Relaton.configure { |c| c.api_mode = false } }
-
-    it do
-      db = Relaton::Db.new "cache", nil
-      cache = db.instance_variable_get :@db
-      expect(cache.dir).to eq "cache"
-    end
-
-    it "with default cache directory" do
-      db = Relaton::Db.init_bib_caches global_cache: true
-      cache = db.instance_variable_get :@db
-      expect(cache.dir).to eq "cache"
-    end
-  end
+  # context "initialization in API mode" do
+  #   before(:each) { Relaton.configure { |c| c.api_mode = true } }
+  #   after(:each) { Relaton.configure { |c| c.api_mode = false } }
+
+  #   it do
+  #     db = Relaton::Db.new "cache", nil
+  #     cache = db.instance_variable_get :@db
+  #     expect(cache.dir).to eq "cache"
+  #   end
+
+  #   it "with default cache directory" do
+  #     db = Relaton::Db.init_bib_caches global_cache: true
+  #     cache = db.instance_variable_get :@db
+  #     expect(cache.dir).to eq "cache"
+  #   end
+  # end
 
   context "modifing database" do
     let(:db) { Relaton::Db.new "testcache", "testcache2" }

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: relaton
 version: !ruby/object:Gem::Version
-  version: 1.8.pre3
+  version: 1.8.pre4
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-11 00:00:00.000000000 Z
+date: 2021-07-16 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: aws-sdk-s3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.96.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.96.0
 - !ruby/object:Gem::Dependency
   name: relaton-bipm
   requirement: !ruby/object:Gem::Requirement
@@ -512,7 +498,6 @@ files:
 - lib/relaton/static_cache/iso/iso_iec_dir_2_iso.yml
 - lib/relaton/static_cache/iso/iso_iec_dir_iec_sup.yml
 - lib/relaton/static_cache/iso/iso_iec_dir_jtc_1_sup.yml
-- lib/relaton/storage.rb
 - lib/relaton/util.rb
 - lib/relaton/version.rb
 - lib/relaton/workers_pool.rb
@@ -522,7 +507,6 @@ files:
 - spec/relaton/db_spec.rb
 - spec/relaton/processor_spec.rb
 - spec/relaton/regirtry_spec.rb
-- spec/relaton/storage_spec.rb
 - spec/relaton_spec.rb
 - spec/spec_helper.rb
 - spec/support/gb_t_20223_2006.xml

data/lib/relaton/storage.rb

@@ -1,186 +0,0 @@
-require "aws-sdk-s3"
-
-module Relaton
-  #
-  # Man
-  #
-  class Storage
-    include Singleton
-
-    def initialize
-      if Relaton.configuration.api_mode
-        @s3 = Aws::S3::Client.new
-      end
-    end
-
-    #
-    # Save file to storage
-    #
-    # @param dir [String]
-    # @param key [String]
-    # @param value [String]
-    #
-    def save(dir, key, value)
-      set_version dir
-      if Relaton.configuration.api_mode then s3_write key, value
-      else file_safe_write key, value
-      end
-    end
-
-    #
-    # Returns all items
-    #
-    # @param dir [String]
-    #
-    # @return [Array<String>]
-    #
-    def all(dir, &block)
-      return all_s3 dir, &block if Relaton.configuration.api_mode
-
-      Dir.glob("#{dir}/**/*.{xml,yml,yaml}").sort.map do |f|
-        content = File.read(f, encoding: "utf-8")
-        block ? yield(f, content) : content
-      end
-    end
-
-    # Delete item
-    # @param key [String] path to file without extension
-    def delete(key)
-      f = search_ext(key)
-      if Relaton.configuration.api_mode && f
-        @s3.delete_object bucket: ENV["AWS_BUCKET"], key: f
-      elsif f then File.delete f
-      end
-    end
-
-    # Check if version of the DB match to the gem grammar hash.
-    # @param fdir [String] dir pathe to flavor cache
-    # @return [Boolean]
-    def check_version?(fdir)
-      file_version = "#{fdir}/version"
-      if Relaton.configuration.api_mode
-        check_version_s3? file_version, fdir
-      else
-        return false unless File.exist? fdir
-
-        v = File.read file_version, encoding: "utf-8"
-        v.strip == grammar_hash(fdir)
-      end
-    end
-
-    # Reads file by a key
-    #
-    # @param key [String]
-    # @return [String, NilClass]
-    def get(key, static: false)
-      return unless (f = search_ext(key, static: static))
-
-      if Relaton.configuration.api_mode && !static
-        s3_read f
-      else
-        File.read(f, encoding: "utf-8")
-      end
-    end
-
-    private
-
-    # Check if version of the DB match to the gem grammar hash.
-    # @param file_version [String] dir pathe to flover cache
-    # @param dir [String] fdir pathe to flavor cache
-    # @return [Boolean]
-    def check_version_s3?(file_version, fdir)
-      s3_read(file_version) == grammar_hash(fdir)
-    rescue Aws::S3::Errors::NoSuchKey
-      false
-    end
-
-    #
-    # Read file form AWS S#
-    #
-    # @param [String] key file name
-    #
-    # @return [String] content
-    #
-    def s3_read(key)
-      obj = @s3.get_object bucket: ENV["AWS_BUCKET"], key: key
-      obj.body.read
-    end
-
-    #
-    # Write file to AWS S3
-    #
-    # @param [String] key
-    # @param [String] value
-    #
-    def s3_write(key, value)
-      @s3.put_object(bucket: ENV["AWS_BUCKET"], key: key, body: value,
-                     content_type: "text/plain; charset=utf-8")
-    end
-
-    #
-    # Returns all items
-    #
-    # @param dir [String]
-    #
-    # @return [Array<String>]
-    #
-    def all_s3(dir)
-      list = @s3.list_objects_v2 bucket: ENV["AWS_BUCKET"], prefix: dir
-      list.contents.select { |i| i.key.match?(/\.xml$/) }.sort_by(&:key).map do |item|
-        content = s3_read item.key
-        block_given? ? yield(item.key, content) : content
-      end
-    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, static: false)
-      if Relaton.configuration.api_mode && !static
-        fs = @s3.list_objects_v2 bucket: ENV["AWS_BUCKET"], prefix: "#{file}."
-        fs.contents.first&.key
-      else
-        Dir["#{file}.*"].first
-      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"
-      return set_version_s3 file_version, fdir if Relaton.configuration.api_mode
-
-      FileUtils::mkdir_p fdir unless Dir.exist?(fdir)
-      unless File.exist? file_version
-        file_safe_write file_version, grammar_hash(fdir)
-      end
-    end
-
-    # Set version of the DB to the gem grammar hash.
-    # @param fdir [String] dir pathe to flover cache
-    def set_version_s3(fver, dir)
-      @s3.head_object bucket: ENV["AWS_BUCKET"], key: fver
-    rescue Aws::S3::Errors::NotFound
-      s3_write fver, grammar_hash(dir)
-    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
-      end
-    end
-
-    # @param fdir [String] dir pathe to flover cache
-    # @return [String]
-    def grammar_hash(fdir)
-      type = fdir.split("/").last
-      Relaton::Registry.instance.by_type(type)&.grammar_hash
-    end
-  end
-end

data/spec/relaton/storage_spec.rb

@@ -1,130 +0,0 @@
-RSpec.describe Relaton::Storage do
-  context "API mode" do
-    before(:each) do
-      Relaton.configure do |config|
-        config.api_mode = true
-      end
-      Singleton.__init__ Relaton::Storage
-    end
-
-    after(:each) do
-      Relaton.configure do |config|
-        config.api_mode = false
-      end
-      Singleton.__init__ Relaton::Storage
-    end
-
-    let(:storage) { Relaton::Storage.instance }
-    let(:bucket) { "test-bucket" }
-
-    it "save document to S3" do
-      dir = "cahche/iso"
-      # file = "doc.xml"
-      body = "<doc>Test doc</doc>"
-      key = File.join dir, "doc.xml"
-      client = double "AwsClient"
-      expect(ENV).to receive(:[]).with("AWS_BUCKET").and_return(bucket).twice
-      expect(client).to receive(:head_object).with(bucket: bucket, key: "cahche/iso/version")
-      expect(client).to receive(:put_object).with(
-        bucket: bucket, key: key, body: body,
-        content_type: "text/plain; charset=utf-8"
-      )
-      expect(Aws::S3::Client).to receive(:new).and_return client
-      storage.save dir, key, body
-    end
-
-    it "read document from S3" do
-      dir = "cahche/iso"
-      # file = "doc.xml"
-      body = "<doc>Test doc</doc>"
-      key = File.join dir, "doc"
-      client = double "AwsClient"
-      item = double "Item", key: "#{key}.xml"
-      list = double "List", contents: [item]
-      obj_body = double "Body", read: body
-      obj = double "Object", body: obj_body
-      expect(ENV).to receive(:[]).with("AWS_BUCKET").and_return(bucket).twice
-      expect(client).to receive(:list_objects_v2).with(bucket: bucket, prefix: "#{key}.").and_return list
-      expect(client).to receive(:get_object).with(bucket: bucket, key: "#{key}.xml").and_return obj
-      expect(Aws::S3::Client).to receive(:new).and_return client
-      expect(storage.get(key)).to eq body
-    end
-
-    it "delete document from S3" do
-      key = "cache/iso/doc"
-      client = double "AwsClient"
-      item = double "Item", key: "#{key}.xml"
-      list = double "List", contents: [item]
-      expect(ENV).to receive(:[]).with("AWS_BUCKET").and_return(bucket).twice
-      expect(client).to receive(:list_objects_v2).with(bucket: bucket, prefix: "#{key}.").and_return list
-      expect(client).to receive(:delete_object).with(bucket: bucket, key: "#{key}.xml")
-      expect(Aws::S3::Client).to receive(:new).and_return client
-      storage.delete key
-    end
-
-    it "return all the documents from S3" do
-      dir = "cahche/iso"
-      # file = "doc.xml"
-      body = "<doc>Test doc</doc>"
-      key = File.join dir, "doc.xml"
-      client = double "AwsClient"
-      expect(ENV).to receive(:[]).with("AWS_BUCKET").and_return(bucket).twice
-      item = double "Item", key: key
-      list = double "List", contents: [item]
-      obj_body = double "Body", read: body
-      obj = double "Object", body: obj_body
-      expect(client).to receive(:list_objects_v2).with(bucket: bucket, prefix: dir).and_return list
-      expect(client).to receive(:get_object).with(bucket: bucket, key: key).and_return obj
-      expect(Aws::S3::Client).to receive(:new).and_return client
-      contents = storage.all dir
-      expect(contents).to eq [body]
-    end
-
-    it "set version" do
-      dir = "cahche/iso"
-      key = File.join dir, "version"
-      hash = Relaton::Registry.instance.by_type("iso").grammar_hash
-      client = double "AwsClient"
-      expect(ENV).to receive(:[]).with("AWS_BUCKET").and_return(bucket).twice
-      # expect(ENV).to receive(:[]).and_call_original
-      error = Aws::S3::Errors::NotFound.new Seahorse::Client::RequestContext.new, ""
-      expect(client).to receive(:head_object).with(bucket: bucket, key: key)
-        .and_raise error
-      expect(client).to receive(:put_object).with(
-        bucket: bucket, key: key, body: hash,
-        content_type: "text/plain; charset=utf-8"
-      )
-      expect(Aws::S3::Client).to receive(:new).and_return client
-      storage.send :set_version, dir
-    end
-
-    context "check version" do
-      it "valid" do
-        dir = "cahche/iso"
-        key = File.join dir, "version"
-        hash = Relaton::Registry.instance.by_type("iso").grammar_hash
-        client = double "AwsClient"
-        obj_body = double "Body", read: hash
-        obj = double "Object", body: obj_body
-        expect(client).to receive(:get_object).with(bucket: bucket, key: key).and_return obj
-        expect(Aws::S3::Client).to receive(:new).and_return client
-        expect(ENV).to receive(:[]).with("AWS_BUCKET").and_return(bucket)
-        expect(storage.check_version?(dir)).to be true
-      end
-
-      it "version file doesn't exist" do
-        dir = "cahche/iso"
-        key = File.join dir, "version"
-        # hash = "invalid"
-        client = double "AwsClient"
-        # obj_body = double "Body", read: hash
-        # obj = double "Object", body: obj_body
-        error = Aws::S3::Errors::NoSuchKey.new Seahorse::Client::RequestContext.new, ""
-        expect(client).to receive(:get_object).with(bucket: bucket, key: key).and_raise error
-        expect(Aws::S3::Client).to receive(:new).and_return client
-        expect(ENV).to receive(:[]).with("AWS_BUCKET").and_return(bucket)
-        expect(storage.check_version?(dir)).to be false
-      end
-    end
-  end
-end