relaton 2.2.0.pre.alpha.1 → 3.0.0.pre.alpha.1

data/lib/relaton/core/hash_keys_sybolizer.rb

@@ -0,0 +1,19 @@
+module Relaton
+  module Core
+    module HashKeysSymbolizer
+      def symbolize_hash_keys(obj)
+        case obj
+        when Array
+          obj.map { |e| symbolize_hash_keys(e) }
+        when Hash
+          obj.each_with_object({}) do |(k, v), h|
+            key = k.is_a?(String) ? k.to_sym : k
+            h[key] = symbolize_hash_keys(v)
+          end
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/relaton/core/hit.rb

@@ -0,0 +1,49 @@
+require "weakref"
+
+module Relaton
+  module Core
+    class Hit
+      # @return [RelatonBib::HitCollection]
+      attr_accessor :hit_collection
+
+      # @return [Array<Hash>]
+      attr_reader :hit
+
+      # @param hit [Hash]
+      # @param hit_collection [RelatonBib::HitCollection]
+      def initialize(hit, hit_collection = nil)
+        @hit            = hit
+        @hit_collection = WeakRef.new hit_collection if hit_collection
+      end
+
+      # @return [String]
+      def to_s
+        inspect
+      end
+
+      # @return [String]
+      def inspect
+        "<#{self.class}:#{format('%<id>#.14x', id: object_id << 1)} " \
+          "@reference=\"#{@hit_collection&.ref}\" " \
+          "@fetched=\"#{fetched?}\" " \
+          "@docidentifier=\"#{@hit[:code]}\">"
+      end
+
+      # @return [RelatonBib::ItemData]
+      def item
+        raise "Not implemented"
+      end
+
+      def fetched?
+        !@item.nil?
+      end
+
+      # @param opts [Hash]
+      # @option opts [Boolean] :bibdata
+      # @return [String] XML
+      def to_xml(**opts)
+        item.to_xml(**opts)
+      end
+    end
+  end
+end

data/lib/relaton/core/hit_collection.rb

@@ -0,0 +1,118 @@
+require "forwardable"
+require "nokogiri"
+require "weakref"
+require_relative "hit"
+
+module Relaton
+  module Core
+    class HitCollection
+      extend Forwardable
+
+      def_delegators :@array, :<<, :[], :first, :empty?, :any?, :size, :each, :each_slice, :reduce, :map
+
+      # @return [TrueClass, FalseClass]
+      attr_reader :fetched
+
+      # @return [String]
+      attr_reader :ref
+
+      # @return [String]
+      attr_reader :year
+
+      #
+      # @param ref [String, Pubid] reference to search
+      # @param year [String, nil] year of publication
+      #
+      def initialize(ref, year = nil)
+        @array = []
+        @ref = ref
+        @year = year
+        @fetched = false
+      end
+
+      #
+      # Fetches hits from the data source
+      #
+      # @return [self] self object
+      #
+      def fetch
+        workers = WorkersPool.new 4
+        workers.worker(&:item)
+        each do |hit|
+          workers << hit
+        end
+        workers.end
+        workers.result
+        @fetched = true
+        self
+      end
+
+      #
+      # Renders the collection as XML
+      #
+      # @param opts [Hash] options
+      # @option opts [Nokogiri::XML::Builder] :builder XML builder
+      # @option opts [Boolean] :bibdata render bibdata if true
+      # @option opts [String, Symbol] :lang language
+      #
+      # @return [String] XML representation of the collection
+      #
+      def to_xml(**opts)
+        builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+          xml.documents do
+            @array.each do |hit|
+              xml << hit.to_xml(**opts)
+            end
+          end
+        end
+        builder.to_xml
+      end
+
+      #
+      # Selects matching hits and returns a new collection
+      #
+      # @param [Proc] &block proc to select hits
+      #
+      # @return [RelatonBib::HitCollection] new hit collection
+      #
+      def select!(&block)
+        @array.select!(&block)
+        self
+      end
+
+      def select(&block)
+        array = @array.select(&block)
+        self.class.new(@ref, @year).tap do |hc|
+          new_array = array.map do |hit|
+            hit.dup.tap { |h| h.hit_collection = WeakRef.new(hc) }
+          end
+          hc.instance_variable_set(:@array, new_array)
+          hc.instance_variable_set(:@fetched, @fetched)
+        end
+      end
+
+      def reduce!(sum, &block)
+        @array = @array.reduce sum, &block
+        self
+      end
+
+      #
+      # Returns String representation of the collection
+      #
+      # @return [String] String representation of the collection
+      #
+      def to_s
+        inspect
+      end
+
+      #
+      # Returns String representation of the collection
+      #
+      # @return [String] String representation of the collection
+      #
+      def inspect
+        "<#{self.class}:#{format('%#.14x', object_id << 1)} @ref=#{@ref} @fetched=#{@fetched}>"
+      end
+    end
+  end
+end

data/lib/relaton/core/processor.rb

@@ -0,0 +1,48 @@
+module Relaton
+  module Core
+    class Processor
+      # @rerurn [Symbol]
+      attr_reader :short
+
+      # @return [String]
+      attr_reader :prefix, :idtype
+
+      # @return [Regexp]
+      attr_reader :defaultprefix
+
+      # @return [Array<String>]
+      attr_reader :datasets
+
+      def initialize
+        raise "This is an abstract class!"
+      end
+
+      def get(_code, _date, _opts)
+        raise "This is an abstract class!"
+      end
+
+      def fetch_data(_source, _opts)
+        raise "This is an abstract class!"
+      end
+
+      def from_xml(_xml)
+        raise "This is an abstract class!"
+      end
+
+      def from_yaml(_hash)
+        raise "This is an abstract class!"
+      end
+
+      def grammar_hash
+        raise "This is an abstract class!"
+      end
+
+      # Retuns default number of workers. Should be overraded by childred classes if need.
+      #
+      # @return [Integer] nuber of wokrers
+      def threads
+        10
+      end
+    end
+  end
+end

data/lib/relaton/core/workers_pool.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Core
+    # Workers poll.
+    class WorkersPool
+      attr_accessor :nb_hits
+
+      def initialize(num_workers = 2)
+        @num_workers = num_workers < 2 ? 2 : num_workers
+        @queue = SizedQueue.new(num_workers * 2)
+        @result = []
+        @nb_hits = 0
+      end
+
+      def worker(&block)
+        @threads = Array.new @num_workers do
+          Thread.new do
+            until (item = @queue.pop) == :END
+              @result << yield(item) if block
+            end
+          end
+        end
+      end
+
+      def result
+        @threads.each(&:join)
+        @result
+      end
+
+      def <<(item)
+        @queue << item
+        self
+      end
+
+      def end
+        @num_workers.times { @queue << :END }
+      end
+
+      def size
+        @result.size
+      end
+    end
+  end
+end

data/lib/relaton/core.rb

@@ -0,0 +1,9 @@
+require "relaton/logger"
+require_relative "version"
+require_relative "core/array_wrapper"
+require_relative "core/hash_keys_sybolizer"
+require_relative "core/date_parser"
+require_relative "core/processor"
+require_relative "core/data_fetcher"
+require_relative "core/hit_collection"
+require_relative "core/workers_pool"

data/lib/relaton/db/registry.rb

@@ -11,6 +11,7 @@ module Relaton
         relaton/bsi relaton/cen relaton/iana relaton/3gpp
         relaton/oasis relaton/doi relaton/jis relaton/xsf
         relaton/ccsds relaton/etsi relaton/isbn relaton/plateau
+        relaton/oiml
       ].freeze
 
       include Singleton
@@ -24,10 +25,9 @@ module Relaton
 
       def register_gems
         SUPPORTED_GEMS.each do |b|
-          # Require the gem's top-level file so its internal modules
-          # (e.g. Relaton::Iso::Util) load in the right order before we
-          # poke at its Processor class.
-          require b
+          # Load ONLY the lightweight processor file; its heavy flavor code is
+          # lazy-required inside the processor's methods. This keeps
+          # `require "relaton"` from eagerly loading every flavor at start.
           require "#{b}/processor"
           register Kernel.const_get "#{gem_to_module_path(b)}::Processor"
         rescue LoadError => e

data/lib/relaton/db.rb

@@ -462,7 +462,6 @@ module Relaton
   end
 end
 
-require_relative "db/version"
 require_relative "db/util"
 require_relative "db/config"
 require_relative "db/workers_pool"

data/lib/relaton/doi/crossref.rb

@@ -0,0 +1,72 @@
+require "mechanize"
+
+module Relaton
+  module Doi
+    module Crossref
+      extend self
+
+      USER_AGENT = "Relaton::Doi (https://www.relaton.org/guides/doi/; mailto:open.source@ribose.com)"
+
+      #
+      # Get a document by DOI from the CrossRef API.
+      #
+      # @param [String] 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
+        if message
+          Util.info "Found: `#{message['DOI']}`", key: doi
+          Parser.parse message
+        else
+          Util.info "Not found.", key: doi
+          nil
+        end
+      end
+
+      #
+      # Get a document by DOI from the CrossRef API.
+      #
+      # @param [String] id The DOI.
+      #
+      # @return [Hash] The document.
+      #
+      def get_by_id(id) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        n = 0
+        url = "https://api.crossref.org/works/#{CGI.escape(id)}"
+        loop do
+          resp = agent.get url
+          work = JSON.parse resp.body
+          return work["message"] if work["status"] == "ok"
+
+          if n > 1
+            raise Relaton::RequestError, "Crossref error: #{resp.body}"
+          end
+
+          n += 1
+          sleep resp.response["x-rate-limit-interval"].to_i * n
+        rescue Mechanize::ResponseCodeError => e
+          return nil if e.response_code == "404"
+
+          if n > 1
+            raise Relaton::RequestError, "Crossref error: #{e.page.body}"
+          end
+
+          n += 1
+          sleep e.page.response["x-rate-limit-interval"].to_i * n
+        end
+      end
+
+      def agent
+        @agent ||= Mechanize.new do |a|
+          a.user_agent = USER_AGENT
+        end
+      end
+    end
+  end
+end