commonmeta-ruby 3.0.0

data/lib/commonmeta/doi_utils.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Commonmeta
+  module DoiUtils
+    def validate_doi(doi)
+      doi = Array(%r{\A(?:(http|https):/(/)?(dx\.)?(doi\.org|handle\.stage\.datacite\.org|handle\.test\.datacite\.org)/)?(doi:)?(10\.\d{4,5}/.+)\z}.match(doi)).last
+      # remove non-printing whitespace and downcase
+      doi.delete("\u200B").downcase if doi.present?
+    end
+
+    def validate_funder_doi(doi)
+      doi = Array(%r{\A(?:(http|https):/(/)?(dx\.)?(doi\.org|handle\.stage\.datacite\.org|handle\.test\.datacite\.org)/)?(doi:)?(10\.13039/)?([1-9]\d+)\z}.match(doi)).last
+
+      # remove non-printing whitespace and downcase
+      return unless doi.present?
+
+      doi.delete("\u200B").downcase
+      "https://doi.org/10.13039/#{doi}"
+    end
+
+    def validate_prefix(doi)
+      Array(%r{\A(?:(http|https):/(/)?(dx\.)?(doi\.org|handle\.stage\.datacite\.org|handle\.test\.datacite\.org)/)?(doi:)?(10\.\d{4,5}).*\z}.match(doi)).last
+    end
+
+    def doi_resolver(doi, options = {})
+      sandbox = Array(/handle\.stage\.datacite\.org/.match(doi)).last
+      sandbox.present? || options[:sandbox] ? 'https://handle.stage.datacite.org/' : 'https://doi.org/'
+    end
+
+    def datacite_api_url(doi, options = {})
+      sandbox = Array(/handle\.stage\.datacite.\org/.match(doi)).last
+      sandbox.present? || options[:sandbox] ? "https://api.stage.datacite.org/dois/#{doi_from_url(doi)}?include=media,client" : "https://api.datacite.org/dois/#{doi_from_url(doi)}?include=media,client"
+    end
+
+    def crossref_api_url(doi, _options = {})
+      "https://api.crossref.org/works/#{doi_from_url(doi)}"
+    end
+
+    def normalize_doi(doi, options = {})
+      doi_str = validate_doi(doi)
+      return nil unless doi_str.present?
+
+      # turn DOI into URL, escape unsafe characters
+      doi_resolver(doi, options) + Addressable::URI.encode(doi_str)
+    end
+
+    def doi_from_url(url)
+      unless %r{\A(?:(http|https)://(dx\.)?(doi\.org|handle\.stage\.datacite\.org|handle\.test\.datacite\.org)/)?(doi:)?(10\.\d{4,5}/.+)\z}.match?(url)
+        return
+      end
+
+      uri = Addressable::URI.parse(url)
+      uri.path.gsub(%r{^/}, '').downcase
+    end
+
+    def doi_as_url(doi)
+      "https://doi.org/#{doi}" if doi.present?
+    end
+
+    # get DOI registration agency
+    def get_doi_ra(doi)
+      prefix = validate_prefix(doi)
+      return nil if prefix.blank?
+
+      url = "https://doi.org/ra/#{prefix}"
+      response = HTTP.get(url)
+      body = JSON.parse(response.body)
+      body.dig(0, 'RA')
+    end
+
+    # get Crossref member name from id
+    def get_crossref_member(member_id)
+      url = "https://api.crossref.org/members/#{member_id}"
+      response = HTTP.get(url)
+      body = JSON.parse(response.body)
+      name = body.dig('message', 'primary-name')
+
+      { 'id' => "https://api.crossref.org/members/#{member_id}", 'name' => name }
+    end
+  end
+end

data/lib/commonmeta/metadata.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require_relative 'metadata_utils'
+
+module Commonmeta
+  class Metadata
+    include Commonmeta::MetadataUtils
+
+    attr_accessor :string, :from, :sandbox, :meta, :regenerate, :issue, :show_errors, :depositor,
+                  :email, :registrant
+    attr_reader :doc, :page_start, :page_end
+    attr_writer :id, :provider_id, :client_id, :doi, :alternate_identifiers, :creators, :contributors,
+                :titles, :publisher, :license, :date, :volume, :url, :version, :subjects, :contributor, :descriptions, :language, :sizes, :formats, :schema_version, :meta, :container, :provider, :format, :funding_references, :state, :geo_locations, :type, :additional_type, :content_url, :references, :related_identifiers, :related_items, :style, :locale
+
+    def initialize(options = {})
+      options.symbolize_keys!
+
+      id = normalize_id(options[:input], options)
+      ra = nil
+
+      if id.present?
+        @from = options[:from] || find_from_format(id: id)
+
+        # mEDRA, KISTI, JaLC and OP DOIs are found in the Crossref index
+        case @from
+        when 'medra'
+          ra = 'mEDRA'
+        when 'kisti'
+          ra = 'KISTI'
+        when 'jalc'
+          ra = 'JaLC'
+        when 'op'
+          ra = 'OP'
+        end
+
+        # generate name for method to call dynamically
+        hsh = @from.present? ? send("get_#{@from}", id: id, **options) : {}
+        string = hsh.fetch('string', nil)
+      elsif options[:input].present? && File.exist?(options[:input])
+        filename = File.basename(options[:input])
+        ext = File.extname(options[:input])
+        if %w[.bib .ris .xml .json .cff].include?(ext)
+          hsh = {
+            'url' => options[:url],
+            'state' => options[:state],
+            'provider_id' => options[:provider_id],
+            'client_id' => options[:client_id],
+            'depositor' => options[:depositor],
+            'email' => options[:email],
+            'registrant' => options[:registrant],
+            'content_url' => options[:content_url]
+          }
+          string = File.read(options[:input])
+          @from = options[:from] || find_from_format(string: string, ext: ext)
+        else
+          warn "File type #{ext} not supported"
+          exit 1
+        end
+      else
+        hsh = {
+          'url' => options[:url],
+          'state' => options[:state],
+          'provider_id' => options[:provider_id],
+          'client_id' => options[:client_id],
+          'depositor' => options[:depositor],
+          'email' => options[:email],
+          'registrant' => options[:registrant],
+          'content_url' => options[:content_url],
+          'creators' => options[:creators],
+          'contributors' => options[:contributors],
+          'titles' => options[:titles],
+          'publisher' => options[:publisher]
+        }
+        string = options[:input]
+        @from = options[:from] || find_from_format(string: string)
+      end
+
+      # make sure input is encoded as utf8
+      if string.present? && string.is_a?(String)
+        dup_string = string.dup.force_encoding('UTF-8').encode!
+      end
+      @string = dup_string
+
+      # input options for citation formatting
+      @style = options[:style]
+      @locale = options[:locale]
+
+      @sandbox = options[:sandbox]
+
+      # options that come from the datacite database
+      @url = hsh.to_h['url'].presence || options[:url].presence
+      @state = hsh.to_h['state'].presence
+      @provider_id = hsh.to_h['provider_id'].presence
+      @client_id = hsh.to_h['client_id'].presence
+      @content_url = hsh.to_h['content_url'].presence
+
+      # options that come from the submission, needed
+      # for crossref doi registration
+      @depositor = hsh.to_h['depositor'].presence
+      @email = hsh.to_h['email'].presence
+      @registrant = hsh.to_h['registrant'].presence
+
+      # set attributes directly
+      read_options = options.slice(
+        :creators,
+        :contributors,
+        :titles,
+        :type,
+        :additional_type,
+        :container,
+        :publisher,
+        :funding_references,
+        :date,
+        :descriptions,
+        :rights_list,
+        :version,
+        :subjects,
+        :language,
+        :geo_locations,
+        :references,
+        :alternate_identifiers,
+        :related_identifiers,
+        :related_items,
+        :formats,
+        :sizes
+      ).compact
+
+      @regenerate = options[:regenerate] || read_options.present?
+      # generate name for method to call dynamically
+      opts = { string: @string, sandbox: options[:sandbox], doi: options[:doi], id: id,
+               ra: ra }.merge(read_options)
+      @meta = @from.present? ? send("read_#{@from}", **opts) : {}
+    end
+
+    def id
+      @id ||= meta.fetch('id', nil)
+    end
+
+    def doi
+      @doi ||= meta.fetch('doi', nil)
+    end
+
+    def provider_id
+      @provider_id ||= meta.fetch('provider_id', nil)
+    end
+
+    def client_id
+      @client_id ||= meta.fetch('client_id', nil)
+    end
+
+    def exists?
+      (@state || meta.fetch('state', nil)) != 'not_found'
+    end
+
+    def valid?
+      exists? && errors.nil?
+    end
+
+    # Catch errors in the reader
+    # Then validate against JSON schema for DataCite v4
+    def errors
+      meta.fetch('errors', nil) || json_schema_errors(schema_version: schema_version)
+    end
+
+    def descriptions
+      @descriptions ||= meta.fetch('descriptions', nil)
+    end
+
+    def license
+      @license ||= meta.fetch('license', nil)
+    end
+
+    def subjects
+      @subjects ||= meta.fetch('subjects', nil)
+    end
+
+    def language
+      @language ||= meta.fetch('language', nil)
+    end
+
+    def sizes
+      @sizes ||= meta.fetch('sizes', nil)
+    end
+
+    def formats
+      @formats ||= meta.fetch('formats', nil)
+    end
+
+    def schema_version
+      @schema_version ||= meta.fetch('schema_version', nil)
+    end
+
+    def funding_references
+      @funding_references ||= meta.fetch('funding_references', nil)
+    end
+
+    def references
+      @references ||= meta.fetch('references', nil)
+    end
+
+    def related_identifiers
+      @related_identifiers ||= meta.fetch('related_identifiers', nil)
+    end
+
+    def related_items
+      @related_items ||= meta.fetch('related_items', nil)
+    end
+
+    def url
+      @url ||= meta.fetch('url', nil)
+    end
+
+    def version
+      @version ||= meta.fetch('version', nil)
+    end
+
+    def container
+      @container ||= meta.fetch('container', nil)
+    end
+
+    def geo_locations
+      @geo_locations ||= meta.fetch('geo_locations', nil)
+    end
+
+    def date
+      @date ||= meta.fetch('date', nil)
+    end
+
+    def publisher
+      @publisher ||= meta.fetch('publisher', nil)
+    end
+
+    def alternate_identifiers
+      @alternate_identifiers ||= meta.fetch('alternate_identifiers', nil)
+    end
+
+    def content_url
+      @content_url ||= meta.fetch('content_url', nil)
+    end
+
+    def provider
+      @provider ||= meta.fetch('provider', nil)
+    end
+
+    def state
+      @state ||= meta.fetch('state', nil)
+    end
+
+    def type
+      @type ||= meta.fetch('type', nil)
+    end
+
+    def additional_type
+      @additional_type ||= meta.fetch('additional_type', nil)
+    end
+
+    def titles
+      @titles ||= meta.fetch('titles', nil)
+    end
+
+    def creators
+      @creators ||= meta.fetch('creators', nil)
+    end
+
+    def contributors
+      @contributors ||= meta.fetch('contributors', nil)
+    end
+  end
+end

data/lib/commonmeta/metadata_utils.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require_relative 'author_utils'
+require_relative 'crossref_utils'
+require_relative 'doi_utils'
+require_relative 'schema_utils'
+require_relative 'utils'
+
+require_relative 'readers/bibtex_reader'
+require_relative 'readers/cff_reader'
+require_relative 'readers/csl_reader'
+require_relative 'readers/codemeta_reader'
+require_relative 'readers/crossref_reader'
+require_relative 'readers/crossref_xml_reader'
+require_relative 'readers/datacite_reader'
+require_relative 'readers/npm_reader'
+require_relative 'readers/ris_reader'
+require_relative 'readers/schema_org_reader'
+
+require_relative 'writers/bibtex_writer'
+require_relative 'writers/citation_writer'
+require_relative 'writers/cff_writer'
+require_relative 'writers/codemeta_writer'
+require_relative 'writers/crossref_xml_writer'
+require_relative 'writers/csl_writer'
+require_relative 'writers/csv_writer'
+require_relative 'writers/datacite_writer'
+require_relative 'writers/jats_writer'
+require_relative 'writers/rdf_xml_writer'
+require_relative 'writers/ris_writer'
+require_relative 'writers/schema_org_writer'
+require_relative 'writers/turtle_writer'
+
+module Commonmeta
+  module MetadataUtils
+    include Commonmeta::AuthorUtils
+    include Commonmeta::CrossrefUtils
+    include Commonmeta::DoiUtils
+    include Commonmeta::SchemaUtils
+    include Commonmeta::Utils
+
+    include Commonmeta::Readers::BibtexReader
+    include Commonmeta::Readers::CffReader
+    include Commonmeta::Readers::CodemetaReader
+    include Commonmeta::Readers::CrossrefReader
+    include Commonmeta::Readers::CrossrefXmlReader
+    include Commonmeta::Readers::CslReader
+    include Commonmeta::Readers::DataciteReader
+    include Commonmeta::Readers::NpmReader
+    include Commonmeta::Readers::RisReader
+    include Commonmeta::Readers::SchemaOrgReader
+
+    include Commonmeta::Writers::BibtexWriter
+    include Commonmeta::Writers::CitationWriter
+    include Commonmeta::Writers::CffWriter
+    include Commonmeta::Writers::CodemetaWriter
+    include Commonmeta::Writers::CrossrefXmlWriter
+    include Commonmeta::Writers::CslWriter
+    include Commonmeta::Writers::CsvWriter
+    include Commonmeta::Writers::DataciteWriter
+    include Commonmeta::Writers::JatsWriter
+    include Commonmeta::Writers::RdfXmlWriter
+    include Commonmeta::Writers::RisWriter
+    include Commonmeta::Writers::SchemaOrgWriter
+    include Commonmeta::Writers::TurtleWriter
+
+    attr_reader :name_detector, :reverse
+
+    # some dois in the Crossref index are from other registration agencies
+    alias get_medra get_crossref
+    alias read_medra read_crossref
+    alias get_kisti get_crossref
+    alias read_kisti read_crossref
+    alias get_jalc get_crossref
+    alias read_jalc read_crossref
+    alias get_op get_crossref
+    alias read_op read_crossref
+
+    def raw
+      r = string.present? ? string.strip : nil
+      return r unless from == 'crossref_xml' && r.present?
+
+      r
+    end
+
+    def should_passthru
+      (from == 'crossref_xml') && regenerate.blank? && raw.present?
+    end
+
+    def container_title
+      if container.present?
+        container['title']
+      elsif type == 'Article'
+        publisher['name']
+      end
+    end
+
+    # recognize given name. Can be loaded once as ::NameDetector, e.g. in a Rails initializer
+    def name_detector
+      @name_detector ||= defined?(::NameDetector) ? ::NameDetector : nil
+    end
+
+    def reverse
+      { 'citation' => Array.wrap(related_identifiers).select do |ri|
+        ri['relationType'] == 'IsReferencedBy'
+      end.map do |r|
+        { '@id' => normalize_doi(r['relatedIdentifier']),
+          '@type' => r['resourceTypeGeneral'] || 'ScholarlyArticle',
+          'identifier' => r['relatedIdentifierType'] == 'DOI' ? nil : to_identifier(r) }.compact
+      end.unwrap,
+        'isBasedOn' => Array.wrap(related_identifiers).select do |ri|
+                         ri['relationType'] == 'IsSupplementTo'
+                       end.map do |r|
+                         { '@id' => normalize_doi(r['relatedIdentifier']),
+                           '@type' => r['resourceTypeGeneral'] || 'ScholarlyArticle',
+                           'identifier' => r['relatedIdentifierType'] == 'DOI' ? nil : to_identifier(r) }.compact
+                       end.unwrap }.compact
+    end
+
+    def graph
+      # preload schema_org context
+      JSON::LD::Context.add_preloaded(
+        'http://schema.org/',
+        JSON::LD::Context.new.parse('resources/schema_org/jsonldcontext.json')
+      )
+
+      RDF::Graph.new << JSON::LD::API.toRdf(schema_hsh)
+    rescue NameError
+      nil
+    end
+
+    def csl_hsh
+      page = if container.to_h['firstPage'].present?
+               [container['firstPage'], container['lastPage']].compact.join('-')
+             end
+      author = if Array.wrap(creators).size == 1 && Array.wrap(creators).first.fetch('name',
+                                                                                     nil) == ':(unav)'
+                 nil
+               else
+                 to_csl(creators)
+               end
+
+      type_ = if type == 'Software' && version.present?
+                'book'
+              else
+                CM_TO_CSL_TRANSLATIONS.fetch(type, 'document')
+              end
+
+      categories = Array.wrap(subjects).map do |k|
+        parse_attributes(k, content: 'subject', first: true)
+      end.presence
+
+      {
+        'type' => type_,
+        'id' => id,
+        'categories' => categories,
+        'language' => language,
+        'author' => author,
+        'contributor' => to_csl(contributors),
+        'issued' => get_date_parts(date['published']),
+        'submitted' => date['submitted'] ? get_date_parts(date['submitted']) : nil,
+        'abstract' => parse_attributes(descriptions, content: 'description', first: true),
+        'container-title' => container_title,
+        'DOI' => doi_from_url(id),
+        'volume' => container.to_h['volume'],
+        'issue' => container.to_h['issue'],
+        'page' => page,
+        'publisher' => publisher['name'],
+        'title' => parse_attributes(titles, content: 'title', first: true),
+        'URL' => url,
+        'copyright' => license.to_h['id'],
+        'version' => version
+      }.compact.symbolize_keys
+    end
+
+    def style
+      @style ||= 'apa'
+    end
+
+    def locale
+      @locale ||= 'en-US'
+    end
+  end
+end

data/lib/commonmeta/pubmed.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Commonmeta
+  module Pubmed
+    # def get_pubmed_metadata(pmid, options = {})
+    #   return {} if pmid.blank?
+
+    #   url = "http://www.ebi.ac.uk/europepmc/webservices/rest/search/query=ext_id:#{pmid}&format=json"
+    #   response = Maremma.get(url, options)
+
+    #   metadata = response.body.fetch("data", {}).fetch("resultList", {}).fetch("result", []).first
+    #   return { error: 'Resource not found.', status: 404 } if metadata.blank?
+
+    #   metadata["issued"] = metadata.fetch("pubYear", nil)
+
+    #   author_string = metadata.fetch("authorString", "").chomp(".")
+    #   metadata["author"] = get_authors(author_string.split(", "))
+
+    #   metadata["title"] = metadata.fetch("title", "").chomp(".")
+    #   metadata["container-title"] = metadata.fetch("journalTitle", nil)
+    #   metadata["volume"] = metadata.fetch("journalVolume", nil)
+    #   metadata["page"] = metadata.fetch("pageInfo", nil)
+    #   metadata["type"] = "article-journal"
+
+    #   metadata
+    # end
+
+    def pmid_as_url(pmid)
+      "http://www.ncbi.nlm.nih.gov/pubmed/#{pmid}" if pmid.present?
+    end
+
+    def pmcid_as_url(pmcid)
+      "http://www.ncbi.nlm.nih.gov/pmc/articles/PMC#{pmcid}" if pmcid.present?
+    end
+  end
+end

data/lib/commonmeta/readers/bibtex_reader.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Commonmeta
+  module Readers
+    module BibtexReader
+      def read_bibtex(string: nil, **options)
+        read_options = ActiveSupport::HashWithIndifferentAccess.new(options.except(:doi, :id, :url,
+                                                                                   :sandbox, :validate, :ra))
+
+        meta = string.present? ? BibTeX.parse(string).first : OpenStruct.new
+
+        bibtex_type = meta.try(:type).to_s
+        type = Commonmeta::Utils::BIB_TO_CM_TRANSLATIONS.fetch(bibtex_type, 'Other')
+
+        doi = meta.try(:doi).to_s.presence || options[:doi]
+
+        creators = Array(meta.try(:author)).map do |a|
+          { 'type' => 'Person', 'givenName' => a.first, 'familyName' => a.last }.compact
+        end
+
+        container = if meta.try(:journal).present?
+                      first_page = meta.try(:pages).present? ? meta.try(:pages).split('-').map(&:strip)[0] : nil
+                      last_page = meta.try(:pages).present? ? meta.try(:pages).split('-').map(&:strip)[1] : nil
+
+                      { 'type' => 'Journal',
+                        'title' => meta.journal.to_s,
+                        'identifier' => meta.try(:issn).to_s.presence,
+                        'identifierType' => meta.try(:issn).present? ? 'ISSN' : nil,
+                        'volume' => meta.try(:volume).to_s.presence,
+                        'firstPage' => first_page,
+                        'lastPage' => last_page }.compact
+                    end
+
+        state = meta.try(:doi).to_s.present? || read_options.present? ? 'findable' : 'not_found'
+
+        date = {}
+        date['published'] =
+          meta.try(:date).present? && Date.edtf(meta.date.to_s).present? ? meta.date.to_s : nil?
+
+        license = meta.try(:copyright).present? ? hsh_to_spdx('rightsURI' => meta[:copyright]) : nil
+
+        { 'id' => normalize_doi(doi),
+          'type' => type,
+          'url' => meta.try(:url).to_s.presence,
+          'titles' => meta.try(:title).present? ? [{ 'title' => meta.try(:title).to_s }] : [],
+          'creators' => creators,
+          'container' => container,
+          'publisher' => meta.try(:publisher).to_s ? { 'name' => meta.publisher.to_s } : nil,
+          'date' => date,
+          'descriptions' => if meta.try(:abstract).present?
+                              [{
+                                'description' => meta.try(:abstract) && sanitize(meta.abstract.to_s).presence, 'descriptionType' => 'Abstract'
+                              }]
+                            else
+                              []
+                            end,
+          'license' => license,
+          'state' => state }.merge(read_options)
+      end
+    end
+  end
+end