relaton 3.0.0.pre.alpha.4 → 3.0.0.pre.alpha.6

data/lib/relaton/db.rb

@@ -1,11 +1,13 @@
 require "relaton/bib"
 require "yaml"
 require "net/http"
-require "nokogiri"
+require "moxml"
 require "fileutils"
 require "date"
 
 module Relaton
+  autoload :Cloud, "relaton/cloud"
+
   class Db
     # @param global_cache [String] directory of global DB
     # @param local_cache [String] directory of local DB
@@ -61,18 +63,23 @@ module Relaton
     #  or "YYYY-MM-DD")
     #
     # @return [nil, RelatonBib::BibliographicItem, ...]
+    # @raise [Relaton::UnknownReferenceError] no flavor recognizes the
+    #   reference (see Registry#route)
     ##
-    def fetch(text, year = nil, opts = {})
+    def fetch(text, year = nil, opts = {}) # rubocop:disable Metrics/MethodLength
       reference = text.strip
-      stdclass = @registry.class_by_ref(reference) || return
+      stdclass, pubid = @registry.route(reference)
       processor = @registry[stdclass]
       ref = if processor.respond_to?(:urn_to_code)
               processor.urn_to_code(reference)&.first
             else reference
             end
       ref ||= reference
+      # The routed pubid is the parse of `reference`; a URN rewritten to a
+      # code is parsed again by the flavor.
+      pubid = nil unless ref == reference
       result = combine_doc ref, year, opts, stdclass
-      result || check_bibliocache(ref, year, opts, stdclass)
+      result || fetch_routed(ref, year, opts, stdclass, pubid)
     end
 
     # @see Relaton::Db#fetch
@@ -90,8 +97,8 @@ module Relaton
       result = []
       db = @db || @local_db
       if db
-        result += db.all do |file, xml|
-          search_xml file, xml, text, edition, year
+        result += db.all do |processor, xml|
+          search_xml processor, xml, text, edition, year
         end.compact
       end
       result
@@ -110,7 +117,7 @@ module Relaton
     #   nil if document not found
     #
     def fetch_async(ref, year = nil, opts = {}, &block) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-      stdclass = @registry.class_by_ref ref
+      stdclass = async_route ref
       if stdclass
         unless @queues[stdclass]
           processor = @registry[stdclass]
@@ -132,23 +139,32 @@ module Relaton
       end
     end
 
+    #
+    # Fetch with the flavor the caller names, else the routed one.
+    #
+    # @param stdclass [Symbol, String, nil] a processor short name
+    #   (`:relaton_iso`, as relaton-cli passes it) or a prefix (`"ISO"`)
+    # @raise [Relaton::UnknownReferenceError] no flavor is named and none
+    #   recognizes the reference
+    #
     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
+      std = named_class(stdclass)
+      # A flavor the caller names is the one asked: no co-publisher.
+      return check_bibliocache(code, year, opts, std) if std
 
-      check_bibliocache(code, year, opts, std)
+      std, pubid = @registry.route(code)
+      fetch_routed(code, year, opts, std, pubid)
     end
 
     # The document identifier class corresponding to the given code
     # @param code [String]
     # @return [Array]
     def docid_type(code)
-      stdclass = @registry.class_by_ref(code) or return [nil, code]
+      stdclass, = @registry.route(code)
       _, code = strip_id_wrapper(code, stdclass)
       [@registry[stdclass].idtype, code]
+    rescue UnknownReferenceError
+      [nil, code]
     end
 
     # @param key [String]
@@ -169,43 +185,65 @@ module Relaton
     # @return [String]
     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
+      parts = db.all.join(" ")
+      Moxml.parse(
+        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<documents>#{parts}</documents>",
+      ).to_xml(indent: 0, expand_empty: false)
     end
 
     private
 
-    def fetch_doc(code, year, opts, processor)
-      if Db.configuration.use_api then fetch_api(code, year, opts, processor)
-      else processor.get(code, year, opts)
+    # The flavor routing picks for `fetch_async`'s per-flavor queue; nil
+    # (logged) when no flavor recognizes the reference.
+    def async_route(ref)
+      @registry.route(ref).first
+    rescue UnknownReferenceError => e
+      Util.info e.message, key: ref
+      nil
+    end
+
+    # The processor a caller names by short name (`:relaton_iso`) or prefix.
+    def named_class(stdclass)
+      return unless stdclass
+
+      short = stdclass.to_sym
+      return short if @registry.processors.key?(short)
+
+      @registry.processors.detect { |_, p| p.prefix == stdclass.to_s }&.first
+    end
+
+    # The flavor's `get` receives the parsed pubid when there is one
+    # (relaton#205), else the String. The API request sends the String the
+    # caller wrote.
+    def fetch_doc(code, year, opts, processor, query = nil)
+      if Db.configuration.use_api
+        fetch_api(code, year, opts, processor, query)
+      else processor.get(query || code, year, opts)
       end
     end
 
-    def fetch_api(code, year, opts, processor)
+    def fetch_api(code, year, opts, processor, query = nil)
       url = "#{Db.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)
+      processor.get(query || code, year, opts)
     end
 
     def params(code, year, opts)
       opts.merge(code: code, year: year).map { |k, v| "#{k}=#{v}" }.join "&"
     end
 
-    def search_xml(file, xml, text, edition, year)
+    def search_xml(processor, xml, text, edition, year)
+      return unless processor
       return unless text.nil? || match_xml_text?(xml, text)
 
-      search_edition_year(file, xml, edition, year)
+      search_edition_year(processor, xml, edition, year)
     end
 
-    def search_edition_year(file, content, edition, year) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-      processor = @registry.processor_by_ref(file.split("/")[-2])
-      item = if file.match?(/xml$/) then processor.from_xml(content)
-             else processor.from_yaml(content)
-             end
+    def search_edition_year(processor, content, edition, year) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      item = processor.from_xml(content)
       item if (edition.nil? || item.edition.content == edition) && (year.nil? ||
         item.date.detect do |d|
           d.type == "published" && d.at.to_date.year.to_s == year.to_s
@@ -240,7 +278,9 @@ module Relaton
       if updates
         doc.relation << Bib::Relation.new(bibitem: updates, type: "updates")
       end
-      divider = stdclass == :relaton_itu ? " " : "/"
+      # The supplement joins its base as the flavor's identifier spells it:
+      # `NIST SP 800-38A Add`, not `/Add`, which pubid does not parse.
+      divider = %i[relaton_itu relaton_nist].include?(stdclass) ? " " : "/"
       refs[1..].each_with_object(doc) do |c, d|
         bib = check_bibliocache(ref + divider + c, year, opts, stdclass)
         if bib
@@ -251,18 +291,73 @@ module Relaton
       end
     end
 
+    # The legacy string cache key, for a processor with no pubid class. The
+    # publication date range is not part of it: it filters, it is not
+    # identity.
     def std_id(code, year, opts, stdclass)
       prefix, code = strip_id_wrapper(code, stdclass)
       ret = code
       ret += (stdclass == :relaton_gb ? "-" : ":") + year if year
       ret += " (all parts)" if opts[:all_parts]
-      after = opts[:publication_date_after]
-      ret += " after-#{after}" if after
-      before = opts[:publication_date_before]
-      ret += " before-#{before}" if before
       ["#{prefix}(#{ret.strip})", code]
     end
 
+    #
+    # The cache key of a query: the flavor's parsed pubid, with the `year`
+    # and `all_parts` options folded in. A reference the flavor cannot parse
+    # raises `Pubid::Errors::ParseError`. Nil when the flavor has a pubid
+    # class but gives no key for this query (a miss by the flavor's own rule,
+    # or a query whose answer the cache cannot hold, such as a CCSDS format):
+    # that query is not cached. A processor with no pubid class gets the
+    # legacy string key.
+    #
+    # @param pubid [Pubid::Identifier, nil] the reference as routing parsed
+    #   it, so the processor does not parse it again
+    # @return [Pubid::Identifier, String, nil]
+    #
+    def cache_key(code, year, opts, stdclass, pubid = nil)
+      processor = @registry[stdclass]
+      unless processor.pubid_class
+        return std_id(code, year, opts, stdclass).first
+      end
+
+      processor.cache_key(code, year, opts, pubid)
+    end
+
+    #
+    # The pubid `get` receives, and the cache key folded from it: one parse
+    # of the reference serves both (relaton#205). A processor with no pubid
+    # class gets the String and the legacy string key.
+    #
+    # @param pubid [Pubid::Identifier, nil] routing's parse
+    # @return [Array(Pubid::Identifier, Object)] the query pubid (nil: `get`
+    #   gets the String) and the key (nil: not cached)
+    #
+    def query_and_key(code, year, opts, stdclass, pubid)
+      processor = @registry[stdclass]
+      unless processor.pubid_class
+        return [nil, std_id(code, year, opts, stdclass).first]
+      end
+
+      query = processor.query_pubid(code, opts, pubid)
+      [query, query && processor.cache_key(code, year, opts, query)]
+    end
+
+    # The key of a fetched document, from its primary identifier. The
+    # identifier is data, so an unparseable one gives no key.
+    def item_key(bib, stdclass)
+      docid = bib.docidentifier.detect(&:primary) || bib.docidentifier.first
+      return unless docid&.content
+
+      cache_key docid.content, nil, {}, stdclass
+    rescue ::Pubid::Errors::Error, Parslet::ParseFailed
+      nil
+    end
+
+    def date_range?(opts)
+      opts[:publication_date_before] || opts[:publication_date_after]
+    end
+
     def strip_id_wrapper(code, stdclass)
       prefix = @registry[stdclass].prefix
       code =
@@ -273,66 +368,112 @@ module Relaton
       [prefix, code]
     end
 
-    def bib_retval(entry, stdclass)
-      if entry && !entry.match?(/^not_found/)
-        @registry[stdclass].from_xml(entry)
+    # The routed flavor, then its co-publishers' flavors (relaton#205).
+    def fetch_routed(code, year, opts, stdclass, pubid)
+      check_bibliocache(code, year, opts, stdclass, pubid: pubid) ||
+        copublisher_fetch(code, year, opts, stdclass, pubid)
+    end
+
+    #
+    # A co-published document the lead flavor's catalog does not have:
+    # ask the co-publishers' flavors, in the order the parsed pubid holds
+    # them (relaton#205; pubid#469, #472). Each one keys, caches and fetches
+    # with its own flavor, so a second fetch is answered from the caches.
+    # A co-publisher whose flavor gives no pubid for the lead's printed form
+    # is skipped. Only that probe parse is rescued: an error from inside the
+    # co-publisher's fetch propagates.
+    #
+    # @return [Relaton::Bib::ItemData, nil]
+    #
+    def copublisher_fetch(code, year, opts, stdclass, pubid)
+      # The reference as the lead read it: no `PREFIX(...)` wrapper, no en dash.
+      _, code = strip_id_wrapper(code, stdclass)
+      copublisher_classes(code, opts, stdclass, pubid).each do |publisher, co|
+        Util.info "Not found; trying co-publisher `#{publisher}`", key: code
+        query = copublisher_query(code, opts, co, publisher) or next
+        bib = check_bibliocache(code, year, opts, co, pubid: query)
+        return bib if bib
       end
+      nil
     end
 
-    def check_bibliocache(code, year, opts, stdclass) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-      if opts[:publication_date_before] || opts[:publication_date_after]
-        base_opts = opts.except(
-          :publication_date_before, :publication_date_after
-        )
-        base_id, = std_id(code, year, base_opts, stdclass)
-        db = @local_db || @db
-        if db&.valid_entry?(base_id, year)
-          entry = db[base_id]
-          if entry && !entry.match?(/^not_found/) &&
-              pub_date_in_range?(entry, opts)
-            return bib_retval(entry, stdclass)
-          end
-        end
+    # @return [Array<Array(String, Symbol)>] each co-publisher that a flavor
+    #   other than the lead serves, with that flavor
+    def copublisher_classes(code, opts, stdclass, pubid)
+      processor = @registry[stdclass]
+      query = processor.query_pubid(code, opts, pubid) or return []
+
+      processor.copublishers(query).filter_map do |publisher|
+        co = @registry.class_by_publisher(publisher)
+        [publisher, co] if co && co != stdclass
+      end.uniq(&:last)
+    end
+
+    # The co-publisher flavor's own parse of the reference, or nil when it
+    # gives none (a parse error, or a flavor that reads it as a miss: IEEE),
+    # which is logged.
+    #
+    # @return [Pubid::Identifier, nil]
+    def copublisher_query(code, opts, stdclass, publisher)
+      query = begin
+        @registry[stdclass].query_pubid(code, opts)
+      rescue ::Pubid::Errors::Error, Parslet::ParseFailed
+        nil
       end
+      return query if query
+
+      Util.info "Not found; co-publisher `#{publisher}` cannot read it",
+                key: code
+      nil
+    end
+
+    def bib_retval(entry, stdclass)
+      @registry[stdclass].from_xml(entry) if entry.is_a?(String)
+    end
 
-      id, searchcode = std_id(code, year, opts, stdclass)
-      db = @local_db || @db
+    def check_bibliocache(code, year, opts, stdclass, pubid: nil) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      _, searchcode = strip_id_wrapper(code, stdclass)
+      query, id = query_and_key(searchcode, year, opts, stdclass, pubid)
+      db = id && (@local_db || @db)
       altdb = @local_db && @db ? @db : nil
       if db.nil?
         return if opts[:fetch_db]
 
-        bibentry = new_bib_entry(searchcode, year, opts, stdclass)
+        bibentry = new_bib_entry(searchcode, year, opts, stdclass, query: query)
         return bib_retval(bibentry, stdclass)
       end
-
-      @semaphore.synchronize do
-        db.delete(id) unless db.valid_entry?(id, year)
+      if date_range?(opts)
+        return check_date_range(searchcode, id, year, opts, stdclass, query)
       end
+
+      @semaphore.synchronize { db.expire id, year }
       if altdb
-        return bib_retval(altdb[id], stdclass) if opts[:fetch_db]
+        return bib_retval(altdb.read(id), stdclass) if opts[:fetch_db]
 
         @semaphore.synchronize do
           db.clone_entry id, altdb if altdb.valid_entry? id, year
         end
-        new_bib_entry(searchcode, year, opts, stdclass, db: db, id: id)
+        new_bib_entry(searchcode, year, opts, stdclass, db: db, id: id,
+                      query: query)
         @semaphore.synchronize do
           altdb.clone_entry(id, db) if !altdb.valid_entry?(id, year)
         end
       else
-        return bib_retval(db[id], stdclass) if opts[:fetch_db]
+        return bib_retval(db.read(id), stdclass) if opts[:fetch_db]
 
-        new_bib_entry(searchcode, year, opts, stdclass, db: db, id: id)
+        new_bib_entry(searchcode, year, opts, stdclass, db: db, id: id,
+                      query: query)
       end
-      bib_retval(db[id], stdclass)
+      bib_retval(db.read(id), stdclass)
     end
 
     def new_bib_entry(code, year, opts, stdclass, **args)
-      entry = @semaphore.synchronize { args[:db] && args[:db][args[:id]] }
+      entry = @semaphore.synchronize { args[:db]&.read(args[:id]) }
       if !entry || opts[:no_cache]
         return fetch_entry(code, year, opts, stdclass, **args)
       end
 
-      if entry&.match?(/^not_found/)
+      if entry.is_a?(NotFound)
         Util.info "not found in cache, if you wish to " \
                   "ignore cache please use `no-cache` option.", key: code
         return
@@ -340,59 +481,101 @@ module Relaton
       entry
     end
 
-    def fetch_entry(code, year, opts, stdclass, **args)
+    def fetch_entry(code, year, opts, stdclass, **args) # rubocop:disable Metrics/AbcSize
       processor = @registry[stdclass]
-      bib = net_retry(code, year, opts, processor, opts.fetch(:retries, 1))
-
-      entry = check_entry(bib, stdclass, **args)
+      bib = net_retry(code, year, opts, processor, opts.fetch(:retries, 1),
+                      args[:query])
+      entry = bib_entry bib
       return entry if args[:db].nil?
 
-      @semaphore.synchronize { args[:db][args[:id]] ||= entry }
-      args[:no_cache] ? bib_entry(bib) : entry
+      # `no_cache` refreshes a cached entry, but a failed fetch does not
+      # replace a cached document with a not-found entry.
+      refresh = opts[:no_cache] && bib.respond_to?(:to_xml)
+      @semaphore.synchronize do
+        if refresh || !args[:db].read(args[:id])
+          save_bib args[:db], args[:id], bib, entry, stdclass
+        end
+      end
+      entry
+    end
+
+    #
+    # Cache a fetched document. The document's own identifier gets a row;
+    # when the query key differs from it (an undated or incomplete query),
+    # the query gets a row that points to the same document.
+    #
+    def save_bib(db, key, bib, entry, stdclass)
+      item = bib.respond_to?(:docidentifier) && item_key(bib, stdclass)
+      db.store key, entry, item_key: item || nil
     end
 
-    def check_entry(bib, stdclass, **args) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-      bib_id = bib && bib.docidentifier.first&.content
+    #
+    # A publication date range selects among the cached editions of the
+    # reference, so it is not part of the key. On a miss the flavor is asked
+    # with the range, and its answer is cached under its own identifier only:
+    # the query row keeps pointing to the latest edition.
+    #
+    def check_date_range(code, key, year, opts, stdclass, query = nil) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      caches = [@local_db, @db].compact
+      cached = caches.flat_map { |c| c.candidates(key) }.filter_map do |_, xml|
+        date = published_date(xml)
+        [date, xml] if date && pub_date_in_range?(xml, opts)
+      end.max_by(&:first)
+      return bib_retval(cached.last, stdclass) if cached && !opts[:no_cache]
+      return if opts[:fetch_db]
+
+      processor = @registry[stdclass]
+      bib = net_retry(code, year, opts, processor, opts.fetch(:retries, 1),
+                      query)
+      return unless bib.respond_to?(:to_xml)
 
-      quoted = Regexp.quote("(#{bib_id})")
-      if args[:db] && args[:id] && bib_id &&
-          args[:id] !~ /#{quoted}/
-        bid = std_id(bib.docidentifier.first.content, nil, {}, stdclass).first
-        @semaphore.synchronize { args[:db][bid] ||= bib_entry bib }
-        "redirection #{bid}"
-      else bib_entry bib
+      entry = bib_entry bib
+      item = item_key(bib, stdclass)
+      if item
+        @semaphore.synchronize do
+          [@local_db, @db].compact.each { |c| c.store item, entry }
+        end
       end
+      bib_retval entry, stdclass
     end
 
-    def net_retry(code, year, opts, processor, retries)
-      fetch_doc code, year, opts, processor
+    # @param query [Pubid::Identifier, nil] what `get` receives in place of
+    #   the String +code+ (Db#query_and_key)
+    def net_retry(code, year, opts, processor, retries, query = nil)
+      fetch_doc code, year, opts, processor, query
     rescue Relaton::RequestError => e
       raise e unless retries > 1
 
-      net_retry(code, year, opts, processor, retries - 1)
+      net_retry(code, year, opts, processor, retries - 1, query)
     end
 
     def bib_entry(bib)
       if bib.respond_to?(:to_xml)
         bib.to_xml(bibdata: true)
       else
-        "not_found #{Date.today}"
+        NotFound.new(fetched: Date.today.to_s)
       end
     end
 
-    def pub_date_in_range?(entry, opts) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-      doc = Nokogiri::XML(entry)
-      date_str = doc.at("//date[@type='published']/on")&.text
-      return false unless date_str
+    # @param entry [String] document XML
+    # @return [Date, nil] the published date
+    def published_date(entry)
+      date_str = Moxml.parse(entry)
+        .at_xpath("//date[@type='published']/on")&.text
+      date_str && parse_pub_date(date_str)
+    end
 
-      date = parse_pub_date(date_str)
+    def pub_date_in_range?(entry, opts) # rubocop:disable Metrics/CyclomaticComplexity
+      date = published_date(entry)
       return false unless date
 
+      # `parse_pub_date`, not `Date.parse`: a bound may be "YYYY" or
+      # "YYYY-MM", which `Date.parse` rejects.
       after = opts[:publication_date_after]
-      return false if after && date < Date.parse(after.to_s)
+      return false if after && date < parse_pub_date(after.to_s)
 
       before = opts[:publication_date_before]
-      return false if before && date >= Date.parse(before.to_s)
+      return false if before && date >= parse_pub_date(before.to_s)
 
       true
     end
@@ -407,18 +590,8 @@ module Relaton
       nil
     end
 
-    def open_cache_biblio(dir) # rubocop:disable Metrics/MethodLength
-      return nil if dir.nil?
-
-      db = Cache.new dir
-
-      Dir["#{dir}/*/"].each do |fdir|
-        next if db.check_version?(fdir)
-
-        FileUtils.rm_rf(fdir, secure: true)
-        Util.info "cache #{fdir}: version is obsolete and cache is cleared."
-      end
-      db
+    def open_cache_biblio(dir)
+      dir && Cache.new(dir)
     end
 
     def process_queue(qwp)

data/lib/relaton/doi/crossref.rb

@@ -10,25 +10,42 @@ module Relaton
       #
       # Get a document by DOI from the CrossRef API.
       #
-      # @param [String] doi The DOI.
+      # @param [String, Pubid::Doi::Identifier] doi The DOI.
       #
       # @return [RelatonBib::BibliographicItem, RelatonIetf::IetfBibliographicItem,
       #   RelatonBipm::BipmBibliographicItem, RelatonIeee::IeeeBibliographicItem,
       #   RelatonNist::NistBibliographicItem] The bibitem.
       #
       def get(doi)
-        Util.info "Fetching from search.crossref.org ...", key: doi
-        id = doi.sub(%r{^doi:}, "")
-        message = get_by_id id
+        key = doi.to_s
+        Util.info "Fetching from search.crossref.org ...", key: key
+        message = get_by_id doi_of(doi)
         if message
-          Util.info "Found: `#{message['DOI']}`", key: doi
+          Util.info "Found: `#{message['DOI']}`", key: key
           Parser.parse message
         else
-          Util.info "Not found.", key: doi
+          Util.info "Not found.", key: key
           nil
         end
       end
 
+      #
+      # The DOI itself (`<prefix>/<suffix>`), as the Crossref API takes it.
+      #
+      # A parsed pubid gives it from its components. A String may carry a
+      # `doi:` scheme (in any case) or a `doi.org` URL: Relaton::Db keys every
+      # form Pubid::Doi reads as one DOI, so all of them must reach the same
+      # DOI here, or a miss on one form is cached for the others.
+      #
+      # @param [String, Pubid::Doi::Identifier] doi
+      # @return [String]
+      #
+      def doi_of(doi)
+        return "#{doi.prefix}/#{doi.suffix}" unless doi.is_a?(String)
+
+        doi.sub(%r{\A(?:doi:|https?://(?:dx\.)?doi\.org/)}i, "")
+      end
+
       #
       # Get a document by DOI from the CrossRef API.
       #

data/lib/relaton/doi/processor.rb

@@ -8,6 +8,7 @@ module Relaton
       def initialize # rubocop:disable Lint/MissingSuper
         @short = :relaton_doi
         @prefix = "DOI"
+        @pubid_identifier = :Doi # Db cache key
         @defaultprefix = %r{^doi:}
         @idtype = "DOI"
       end

data/lib/relaton/easc/processor.rb

@@ -12,6 +12,7 @@ module Relaton
       def initialize
         @short = :relaton_easc
         @prefix = "EASC"
+        @pubid_identifier = :Easc # Db cache key
         # Both Cyrillic and Latin series prefixes route here.
         @defaultprefix = %r{^(?:ПМГ|РМГ|PMG|RMG)\b}
         @idtype = "EASC"