relaton 1.12.0 → 1.12.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb0eb1b1516d3d9891e873ecad6e439da21cb0cf0ef1b13d9f0a53568b04ad6d
-  data.tar.gz: af692237538c88b588db7537366d0fbc476e92e60f48163f892f0cb254c1fa2d
+  metadata.gz: 6e6ac176313825ccd3328f85d357e92a0316dc40af8174f2af9d021ddf00b4e6
+  data.tar.gz: 031ab61832bdca69327a65aabd6563c80798488e3292fb272420470bd44e1bb1
 SHA512:
-  metadata.gz: 771e6695638f73ee4c6bb4c00d376889ecd5b7120cd9f31e055ab06f3060b24b55e3276f90d74909806b5977f54593cabc201a17729922e2589e5ac1c0fe6ea4
-  data.tar.gz: 2e9611d5f1b99206a2c99f42720638321781563109e9b0e01345c9576dd6bbd9836c185b55233ea6d7c7ddeaf7c86d90a00605a52ba12d6f9527b7c9a6df5cc0
+  metadata.gz: db39780d4edf4de3d7d31b150b5a08161c68f9aa62660e0e55d01bde131e997ca3431204e1f4e6db3826c7183a0df032cb09cda57ae998e681535c10d53c0c5b
+  data.tar.gz: bfdb82eb750071772b200ac44d50a5d95019033d4c748483e7bb378b1355c32f8facb0184790da68133dc36018f4386766e6b2739ca9df3d0242e884ba1405ed

data/.github/workflows/rake.yml

@@ -10,23 +10,5 @@ on:
 
 jobs:
   rake:
-    name: Test on Ruby ${{ matrix.ruby }} ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.experimental }}
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby: [ '3.0', '2.7', '2.6' ]
-        os: [ ubuntu-latest, windows-latest, macos-latest ]
-        experimental: [ false ]
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
+    uses: relaton/support/.github/workflows/rake.yml@master
 
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby }}
-          bundler-cache: true
-
-      - run: bundle exec rake

data/docs/README.adoc

@@ -62,6 +62,24 @@ e.g. `get("ISO 19115-1", "2014", all_parts: true)` is transformed into a referen
 
 == Usage
 
+=== Configuration
+
+* `logs` - is array of log levels. Allowed values: `:info`, `:warning`, `:error`, `:debug`. Default values are `[:info, :error]`.
+* `use_api` - `true` if it needs to use an online cache, `false` inf not. Default value is `true`.
+* `api_host` - url of an online cache. Default value is https://api.relaton.org.
+
+[source,ruby]
+----
+require "relaton"
+=> true
+
+Relaton.configure do |conf|
+  conf.logs = %i[info error]
+  conf.use_api = true
+  conf.api_host = "https://api.relaton.org"
+end
+----
+
 === Create DB
 
 `Relaton::Db#new(globalcache, localcache)` creates new DB. Returns Relaton::Db instance.
@@ -71,9 +89,6 @@ e.g. `get("ISO 19115-1", "2014", all_parts: true)` is transformed into a referen
 
 [source,ruby]
 ----
-require "relaton"
-=> true
-
 # Do not cache any entries retrieved
 db = Relaton::Db.new(nil, nil)
 => #<Relaton::Db:0x007faaaba77648

data/lib/relaton/config.rb

@@ -12,13 +12,14 @@ module Relaton
   end
 
   class Configuration
-    attr_accessor :logs, :use_api
+    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 = false
+      @api_host = "https://api.relaton.org"
     end
   end
 

data/lib/relaton/db.rb

@@ -1,10 +1,4 @@
-require "yaml"
-require_relative "registry"
-require_relative "db_cache"
-
 module Relaton
-  class RelatonError < StandardError; end
-
   class Db
     # @param global_cache [String] directory of global DB
     # @param local_cache [String] directory of local DB
@@ -24,10 +18,8 @@ module Relaton
     # @return [String, nil]
     def mv(new_dir, type: :global)
       case type
-      when :global
-        @db&.mv new_dir
-      when :local
-        @local_db&.mv new_dir
+      when :global then @db&.mv new_dir
+      when :local then @local_db&.mv new_dir
       end
     end
 
@@ -69,8 +61,7 @@ module Relaton
             end
       ref ||= code
       result = combine_doc ref, year, opts, stdclass
-      result ||= check_bibliocache(ref, year, opts, stdclass)
-      result
+      result || check_bibliocache(ref, year, opts, stdclass)
     end
 
     # @see Relaton::Db#fetch
@@ -167,11 +158,7 @@ module Relaton
     # @param key [String]
     # @return [Hash]
     def load_entry(key)
-      unless @local_db.nil?
-        entry = @local_db[key]
-        return entry if entry
-      end
-      @db[key]
+      (@local_db && @local_db[key]) || @db[key]
     end
 
     # @param key [String]
@@ -187,14 +174,52 @@ module Relaton
     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
+        xml.documents { xml.parent.add_child db.all.join(" ") }
       end.to_xml
     end
 
     private
 
+    # @param (see #fetch_api)
+    # @return (see #fetch_api)
+    def fetch_doc(code, year, opts, processor)
+      if Relaton.configuration.use_api then fetch_api(code, year, opts, processor)
+      else processor.get(code, year, opts)
+      end
+    end
+
+    #
+    # @param code [String]
+    # @param year [String]
+    #
+    # @param opts [Hash]
+    # @option opts [Boolean] :all_parts If all-parts reference is required
+    # @option opts [Boolean] :keep_year If undated reference should return
+    #   actual reference with year
+    #
+    # @param processor [Relaton::Processor]
+    # @return [RelatonBib::BibliographicItem, nil]
+    def fetch_api(code, year, opts, processor)
+      url = "#{Relaton.configuration.api_host}/api/v1/document?#{params(code, year, opts)}"
+      rsp = Net::HTTP.get_response URI(url)
+      processor.from_xml rsp.body if rsp.code == "200"
+    rescue Errno::ECONNREFUSED
+      processor.get(code, year, opts)
+    end
+
+    #
+    # Make string of parametrs
+    #
+    # @param [String] code
+    # @param [String] year
+    # @param [Hash] opts
+    #
+    # @return [String]
+    #
+    def params(code, year, opts)
+      opts.merge(code: code, year: year).map { |k, v| "#{k}=#{v}" }.join "&"
+    end
+
     # @param file [String] file path
     # @param xml [String] content in XML format
     # @param text [String, nil] text to serach
@@ -208,7 +233,7 @@ module Relaton
     end
 
     # @param file [String] file path
-    # @param content [String] content in XML or YAmL format
+    # @param content [String] content in XML or YAML format
     # @param edition [String, nil] edition to filter
     # @param year [Integer, nil] year to filter
     # @return [BibliographicItem, nil]
@@ -221,9 +246,14 @@ module Relaton
         item.date.detect { |d| d.type == "published" && d.on(:year).to_s == year.to_s })
     end
 
+    #
+    # Look up text in the XML elements attributes and content
+    #
     # @param xml [String] content in XML format
     # @param text [String, nil] text to serach
+    #
     # @return [Boolean]
+    #
     def match_xml_text(xml, text)
       %r{((?<attr>=((?<apstr>')|"))|>).*?#{text}.*?(?(<attr>)(?(<apstr>)'|")|<)}mi.match?(xml)
     end
@@ -258,10 +288,9 @@ module Relaton
 
       doc = @registry.processors[stdclass].hash_to_bib docid: { id: code }
       ref = refs[0]
-      updates = check_bibliocache(ref, year, opts, stdclass)
+      updates = check_bibliocache(refs[0], year, opts, stdclass)
       if updates
-        doc.relation << RelatonBib::DocumentRelation.new(bibitem: updates,
-                                                         type: "updates")
+        doc.relation << RelatonBib::DocumentRelation.new(bibitem: updates, type: "updates")
       end
       divider = stdclass == :relaton_itu ? " " : "/"
       refs[1..].each_with_object(doc) do |c, d|
@@ -305,8 +334,10 @@ module Relaton
       [prefix, code]
     end
 
-    # @param entry [String] XML string
+    #
+    # @param entry [String, nil] XML string
     # @param stdclass [Symbol]
+    #
     # @return [nil, RelatonBib::BibliographicItem,
     #   RelatonIsoBib::IsoBibliographicItem, RelatonItu::ItuBibliographicItem,
     #   RelatonIetf::IetfBibliographicItem, RelatonIec::IecBibliographicItem,
@@ -316,8 +347,8 @@ module Relaton
     #   RelatonBipm::BipmBibliographicItem, RelatonIho::IhoBibliographicItem,
     #   RelatonOmg::OmgBibliographicItem, RelatonW3c::W3cBibliographicItem]
     def bib_retval(entry, stdclass)
-      if entry.nil? || entry.match?(/^not_found/) then nil
-      else @registry.processors[stdclass].from_xml(entry)
+      if entry && !entry.match?(/^not_found/)
+        @registry.processors[stdclass].from_xml(entry)
       end
     end
 
@@ -346,8 +377,7 @@ module Relaton
       if db.nil?
         return if opts[:fetch_db]
 
-        bibentry = new_bib_entry(searchcode, year, opts, stdclass, db: db,
-                                                                   id: id)
+        bibentry = new_bib_entry(searchcode, year, opts, stdclass)
         return bib_retval(bibentry, stdclass)
       end
 
@@ -360,54 +390,85 @@ module Relaton
         @semaphore.synchronize do
           db.clone_entry id, altdb if altdb.valid_entry? id, year
         end
-        entry = new_bib_entry(searchcode, year, opts, stdclass, db: db, id: id) unless db[id]
+        new_bib_entry(searchcode, year, opts, stdclass, db: db, id: id)
         @semaphore.synchronize do
-          db[id] ||= entry
           altdb.clone_entry(id, db) if !altdb.valid_entry?(id, year)
         end
       else
         return bib_retval(db[id], stdclass) if opts[:fetch_db]
 
-        entry = new_bib_entry(searchcode, year, opts, stdclass, db: db, id: id) unless db[id]
-        @semaphore.synchronize { db[id] ||= entry }
+        new_bib_entry(searchcode, year, opts, stdclass, db: db, id: id)
       end
       bib_retval(db[id], stdclass)
     end
 
+    #
+    # Create new bibliographic entry if it doesn't exist in database
+    #
     # @param code [String]
     # @param year [String]
     #
     # @param opts [Hash]
-    # @option opts [Boolean] :all_parts If all-parts reference is required
-    # @option opts [Boolean] :keep_year If undated reference should return
-    #   actual reference with year
+    # @option opts [Boolean, nil] :all_parts If true then all-parts reference is
+    #   requested
+    # @option opts [Boolean, nil] :keep_year If true then undated reference
+    #   should return actual reference with year
     # @option opts [Integer] :retries (1) Number of network retries
     #
     # @param stdclass [Symbol]
-    # @param db [Relaton::DbCache,`NilClass]
-    # @param id [String] docid
-    # @return [String]
-    def new_bib_entry(code, year, opts, stdclass, **args) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-      bib = net_retry(code, year, opts, stdclass, opts.fetch(:retries, 1))
+    # @param db [Relaton::DbCache,`nil]
+    # @param id [String, nil] docid
+    #
+    # @return [String] bibliographic entry
+    #   XML or "redirection ID" or "not_found YYYY-MM-DD" string
+    #
+    def new_bib_entry(code, year, opts, stdclass, **args) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/MethodLength
+      entry = @semaphore.synchronize { args[:db] && args[:db][args[:id]] }
+      if entry
+        if entry&.match?(/^not_found/)
+          Util.log "[relaton] (#{code}) not found."
+          return
+        end
+        return entry
+      end
+
+      processor = @registry.processors[stdclass]
+      bib = net_retry(code, year, opts, processor, opts.fetch(:retries, 1))
       bib_id = bib&.docidentifier&.first&.id
 
       # when docid doesn't match bib's id then return a reference to bib's id
-      if args[:db] && args[:id] &&
-          bib_id && args[:id] !~ %r{#{Regexp.quote("(#{bib_id})")}}
-        bid = std_id(bib.docidentifier.first.id, nil, {}, stdclass).first
-        @semaphore.synchronize { args[:db][bid] ||= bib_entry bib }
-        "redirection #{bid}"
-      else bib_entry bib
-      end
+      entry = if args[:db] && args[:id] && bib_id && args[:id] !~ %r{#{Regexp.quote("(#{bib_id})")}}
+                bid = std_id(bib.docidentifier.first.id, nil, {}, stdclass).first
+                @semaphore.synchronize { args[:db][bid] ||= bib_entry bib }
+                "redirection #{bid}"
+              else bib_entry bib
+              end
+      return entry if args[:db].nil? || args[:id].nil?
+
+      @semaphore.synchronize { args[:db][args[:id]] ||= entry }
     end
 
+    #
+    # @param code [String]
+    # @param year [String]
+    #
+    # @param opts [Hash]
+    # @option opts [Boolean] :all_parts If all-parts reference is required
+    # @option opts [Boolean] :keep_year If undated reference should return
+    #   actual reference with year
+    #
+    # @param processor [Relaton::Processor]
+    # @param retries [Integer] remain Number of network retries
+    #
     # @raise [RelatonBib::RequestError]
-    def net_retry(code, year, opts, stdclass, retries)
-      @registry.processors[stdclass].get(code, year, opts)
+    # @return [RelatonBib::BibliographicItem]
+    #
+    def net_retry(code, year, opts, processor, retries)
+      fetch_doc code, year, opts, processor
     rescue RelatonBib::RequestError => e
       raise e unless retries > 1
 
-      net_retry(code, year, opts, stdclass, retries - 1)
+      net_retry(code, year, opts, processor, retries - 1)
     end
 
     # @param bib [RelatonBib::BibliographicItem,
@@ -420,11 +481,7 @@ module Relaton
     #   RelatonOmg::OmgBibliographicItem, RelatonW3c::W3cBibliographicItem]
     # @return [String] XML or "not_found mm-dd-yyyy"
     def bib_entry(bib)
-      if bib.respond_to? :to_xml
-        bib.to_xml(bibdata: true)
-      else
-        "not_found #{Date.today}"
-      end
+      bib.respond_to?(:to_xml) ? bib.to_xml(bibdata: true) : "not_found #{Date.today}"
     end
 
     # @param dir [String, nil] DB directory
@@ -454,10 +511,16 @@ module Relaton
     end
 
     class << self
+      #
       # 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
+      #
+      # @param local_cache [String, nil] local cache name;
+      #   "relaton" created if empty or nil
+      # @param global_cache [Boolean, nil] create global_cache if true
+      # @param flush_caches [Boolean, nil] flush caches if true
+      #
+      # @return [Relaton::Db] relaton DB instance
+      #
       def init_bib_caches(**opts) # rubocop:disable Metrics/CyclomaticComplexity
         globalname = global_bibliocache_name if opts[:global_cache]
         localname = local_bibliocache_name(opts[:local_cache])

data/lib/relaton/db_cache.rb

@@ -10,9 +10,7 @@ module Relaton
     def initialize(dir, ext = "xml")
       @dir = dir
       @ext = ext
-      FileUtils::mkdir_p @dir
-      # file_version = "#{@dir}/version"
-      # set_version # unless File.exist? file_version
+      FileUtils::mkdir_p dir
     end
 
     # Move caches to anothe dir
@@ -45,7 +43,7 @@ module Relaton
       end
 
       prefix_dir = "#{@dir}/#{prefix(key)}"
-      FileUtils::mkdir_p prefix_dir unless Dir.exist? prefix_dir
+      FileUtils::mkdir_p prefix_dir
       set_version prefix_dir
       file_safe_write "#{filename(key)}.#{ext(value)}", value
     end
@@ -72,6 +70,12 @@ module Relaton
       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? get(key))
@@ -96,10 +100,10 @@ module Relaton
 
     # Returns all items
     # @return [Array<String>]
-    def all
+    def all(&block)
       Dir.glob("#{@dir}/**/*.{xml,yml,yaml}").sort.map do |f|
         content = File.read(f, encoding: "utf-8")
-        block_given? ? yield(f, content) : content
+        block ? yield(f, content) : content
       end
     end
 
@@ -107,30 +111,19 @@ module Relaton
     # @param key [String]
     def delete(key)
       file = filename key
-      f = search_ext(file)
+      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 [TrueClass, FalseClass]
+    # @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 == grammar_hash(fdir)
-    end
-
-    # Set version of the DB to the gem grammar hash.
-    # @param fdir [String] dir pathe to flover cache
-    # @return [Relaton::DbCache]
-    def set_version(fdir)
-      file_version = "#{fdir}/version"
-      unless File.exist? file_version
-        file_safe_write file_version, grammar_hash(fdir)
-      end
-      self
+      v.strip == self.class.grammar_hash(fdir)
     end
 
     # if cached reference is undated, expire it after 60 days
@@ -144,15 +137,6 @@ module Relaton
       year || Date.today - date < 60
     end
 
-    protected
-
-    # @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
-
     # Reads file by a key
     #
     # @param key [String]
@@ -164,19 +148,16 @@ module Relaton
       File.read(f, encoding: "utf-8")
     end
 
-    private
-
-    # Check if a file content is redirection
-    #
-    # @prarm value [String] file content
-    # @return [String, NilClass] redirection code or nil
-    def redirect?(value)
-      %r{redirection\s(?<code>.*)} =~ value
-      code
+    # @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
 
-    # Return item's file name
-    # @param key [String]
+    private
+
+    # @param value [String]
     # @return [String]
     def filename(key)
       prefcode = key.downcase.match(/^(?<prefix>[^(]+)\((?<code>[^)]+)/)
@@ -204,13 +185,31 @@ module Relaton
       end
     end
 
-    # Return item's subdir
+    # 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?(value)
+      %r{redirection\s(?<code>.*)} =~ value
+      code
+    end
+
     # @param file [String]
     # @content [String]
     def file_safe_write(file, content)
@@ -219,37 +218,5 @@ module Relaton
         f.write content
       end
     end
-
-    class << self
-      private
-
-      def global_bibliocache_name
-        "#{Dir.home}/.relaton/cache"
-      end
-
-      def local_bibliocache_name(cachename)
-        return nil if cachename.nil?
-
-        cachename = "relaton" if cachename.empty?
-        "#{cachename}/cache"
-      end
-
-      public
-
-      # 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
-      def init_bib_caches(opts) # rubocop:disable Metrics/CyclomaticComplexity
-        globalname = global_bibliocache_name if opts[:global_cache]
-        localname = local_bibliocache_name(opts[:local_cache])
-        localname = "relaton" if localname&.empty?
-        if opts[:flush_caches]
-          FileUtils.rm_rf globalname unless globalname.nil?
-          FileUtils.rm_rf localname unless localname.nil?
-        end
-        Relaton::Db.new(globalname, localname)
-      end
-    end
   end
 end

data/lib/relaton/version.rb

@@ -1,3 +1,3 @@
 module Relaton
-  VERSION = "1.12.0".freeze
+  VERSION = "1.12.3".freeze
 end

data/lib/relaton.rb

@@ -1,5 +1,6 @@
 require "relaton/util"
 require "relaton/config"
+require "yaml"
 
 require "relaton/workers_pool"
 require "relaton/db"

data/spec/relaton/db_cache_spec.rb

@@ -6,8 +6,8 @@ RSpec.describe Relaton::DbCache do
     cache_path = File.expand_path("~/.relaton/cache")
     FileUtils.mv cache_path, "relaton1/cache", force: true
     FileUtils.rm_rf %w(relaton)
-    Relaton::DbCache.init_bib_caches(
-      global_cache: true, local_cache: "", flush_caches: true
+    Relaton::Db.init_bib_caches(
+      global_cache: true, local_cache: "", flush_caches: true,
     )
     expect(File.exist?(cache_path)).to be true
     expect(File.exist?("relaton")).to be true

data/spec/relaton/db_spec.rb

@@ -1,6 +1,40 @@
 RSpec.describe Relaton::Db do
   before(:each) { FileUtils.rm_rf %w[testcache testcache2] }
 
+  context "instance methods" do
+    subject { Relaton::Db.new nil, nil }
+
+    context "#search_edition_year" do
+      it "create bibitem from YAML content" do
+        h = { "docid" => [{ "id" => "ISO 123", type: "ISO", "primary" => true }] }
+        expect(YAML).to receive(:safe_load).with(:content).and_return h
+        item = subject.send :search_edition_year, "iso/item.yaml", :content, nil, nil
+        expect(item).to be_instance_of RelatonIsoBib::IsoBibliographicItem
+      end
+    end
+
+    context "#new_bib_entry" do
+      it "warn if cached entry is not_found" do
+        id = "ISO(ISO 123)"
+        db = double "db"
+        expect(db).to receive(:[]).with(id).and_return "not_found"
+        expect do
+          entry = subject.send :new_bib_entry, "ISO 123", nil, {}, :relaton_iso, db: db, id: id
+          expect(entry).to be_nil
+        end.to output("[relaton] (ISO 123) not found.\n").to_stderr
+      end
+    end
+  end
+
+  context "class methods" do
+    it "::init_bib_caches" do
+      expect(FileUtils).to receive(:rm_rf).with(/\/\.relaton\/cache$/)
+      expect(FileUtils).to receive(:rm_rf).with(/testcache\/cache$/)
+      expect(Relaton::Db).to receive(:new).with(/\/\.relaton\/cache$/, /testcache\/cache$/)
+      Relaton::Db.init_bib_caches(global_cache: true, local_cache: "testcache", flush_caches: true)
+    end
+  end
+
   context "modifing database" do
     let(:db) { Relaton::Db.new "testcache", "testcache2" }
 

data/spec/relaton/registry_spec.rb

@@ -2,7 +2,7 @@ RSpec.describe Relaton::Registry do
   it "outputs backend not present" do
     stub_const "Relaton::Registry::SUPPORTED_GEMS", ["not_supported_gem"]
     expect { Relaton::Registry.clone.instance }.to output(
-      /backend not_supported_gem not present/
+      /backend not_supported_gem not present/,
     ).to_stderr
   end