bolognese 0.2.2

data/lib/bolognese/datacite.rb

@@ -0,0 +1,157 @@
+require_relative 'doi_utils'
+require_relative 'utils'
+
+module Bolognese
+  class Datacite < Metadata
+    include Bolognese::DoiUtils
+    include Bolognese::Utils
+
+    DATACITE_TYPE_TRANSLATIONS = {
+      "Audiovisual" => "VideoObject",
+      "Collection" => "Collection",
+      "Dataset" => "Dataset",
+      "Event" => "Event",
+      "Image" => "ImageObject",
+      "InteractiveResource" => nil,
+      "Model" => nil,
+      "PhysicalObject" => nil,
+      "Service" => "Service",
+      "Software" => "SoftwareSourceCode",
+      "Sound" => "AudioObject",
+      "Text" => "ScholarlyArticle",
+      "Workflow" => nil,
+      "Other" => "CreativeWork"
+    }
+
+    attr_reader = :id, :metadata, :schema_org
+
+    def initialize(doi)
+      @id = normalize_doi(doi)
+    end
+
+    def raw
+      response = Maremma.get(id, accept: "application/vnd.datacite.datacite+xml", raw: true)
+      @raw = response.body.fetch("data", nil)
+    end
+
+    def metadata
+      @metadata ||= raw.present? ? Maremma.from_xml(raw).fetch("resource", {}) : {}
+    end
+
+    def exists?
+      metadata.present?
+    end
+
+    def type
+      k = metadata.dig("resourceType", "resourceTypeGeneral")
+      DATACITE_TYPE_TRANSLATIONS[k.to_s.dasherize] || "CreativeWork"
+    end
+
+    def additional_type
+      metadata.fetch("resourceType", {}).fetch("text", nil) ||
+      metadata.fetch("resourceType", {}).fetch("resourceTypeGeneral", nil)
+    end
+
+    def name
+      metadata.dig("titles", "title")
+    end
+
+    def alternate_name
+      metadata.dig("alternateIdentifiers", "alternateIdentifier", "text")
+    end
+
+    def description
+      metadata.dig("descriptions", "description", "text")
+    end
+
+    def license
+      metadata.dig("rightsList", "rights", "rightsURI")
+    end
+
+    def keywords
+      Array(metadata.dig("subjects", "subject")).join(", ")
+    end
+
+    def author
+      authors = metadata.dig("creators", "creator")
+      authors = [authors] if authors.is_a?(Hash)
+      get_authors(authors)
+    end
+
+    def version
+      metadata.fetch("version", nil)
+    end
+
+    def dates
+      Array(metadata.dig("dates", "date"))
+    end
+
+    def date_created
+      created = dates.find { |d| d["dateType"] == "Created" } || {}
+      created.fetch("text", nil)
+    end
+
+    def date_published
+      published = dates.find { |d| d["dateType"] == "Issued" } || {}
+      published.fetch("text", nil) || metadata.fetch("publicationYear")
+    end
+
+    def date_modified
+      modified = dates.find { |d| d["dateType"] == "Updated" } || {}
+      modified.fetch("text", nil)
+    end
+
+    def related_identifiers(relation_type)
+      Array(metadata.dig("relatedIdentifiers", "relatedIdentifier"))
+        .select { |r| relation_type.split(" ").include?(r["relationType"]) && %w(DOI URL).include?(r["relatedIdentifierType"]) }
+        .map do |work|
+          work_id = work["relatedIdentifierType"] == "DOI" ? normalize_doi(work["text"]) : work["text"]
+          { "@type" => "CreativeWork",
+            "@id" => work_id }
+        end
+    end
+
+    def is_part_of
+      related_identifiers("IsPartOf").first
+    end
+
+    def has_part
+      related_identifiers("HasPart").presence
+    end
+
+    def citation
+      related_identifiers("Cites IsCitedBy Supplements IsSupplementTo References IsReferencedBy").presence
+    end
+
+    def publisher
+      metadata.fetch("publisher")
+    end
+
+    def provider
+      { "@type" => "Organization",
+        "name" => "DataCite" }
+    end
+
+    def as_schema_org
+      { "@context" => "http://schema.org",
+        "@type" => type,
+        "@id" => id,
+        "name" => name,
+        "alternateName" => alternate_name,
+        "author" => author,
+        "description" => description,
+        "license" => license,
+        "version" => version,
+        "keywords" => keywords,
+        "dateCreated" => date_created,
+        "datePublished" => date_published,
+        "dateModified" => date_modified,
+        "isPartOf" => is_part_of,
+        "hasPart" => has_part,
+        "citation" => citation,
+        "publisher" => publisher,
+        "provider" => provider
+      }.compact
+    end
+  end
+end

data/lib/bolognese/date_utils.rb

@@ -0,0 +1,48 @@
+module Bolognese
+  module DateUtils
+    def get_date_parts(iso8601_time)
+      return { "date_parts" => [[]] } if iso8601_time.nil?
+
+      year = iso8601_time[0..3].to_i
+      month = iso8601_time[5..6].to_i
+      day = iso8601_time[8..9].to_i
+      { 'date-parts' => [[year, month, day].reject { |part| part == 0 }] }
+    end
+
+    def get_year_month(iso8601_time)
+      return [] if iso8601_time.nil?
+
+      year = iso8601_time[0..3]
+      month = iso8601_time[5..6]
+
+      [year.to_i, month.to_i].reject { |part| part == 0 }
+    end
+
+    def get_year_month_day(iso8601_time)
+      return [] if iso8601_time.nil?
+
+      year = iso8601_time[0..3]
+      month = iso8601_time[5..6]
+      day = iso8601_time[8..9]
+
+      [year.to_i, month.to_i, day.to_i].reject { |part| part == 0 }
+    end
+
+    def get_date_parts_from_parts(year, month = nil, day = nil)
+      { 'date-parts' => [[year.to_i, month.to_i, day.to_i].reject { |part| part == 0 }] }
+    end
+
+    def get_date_from_parts(year, month = nil, day = nil)
+      [year.to_s.rjust(4, '0'), month.to_s.rjust(2, '0'), day.to_s.rjust(2, '0')].reject { |part| part == "00" }.join("-")
+    end
+
+    # parsing of incomplete iso8601 timestamps such as 2015-04 is broken
+    # in standard library
+    # return nil if invalid iso8601 timestamp
+    def get_datetime_from_iso8601(iso8601_time)
+      ISO8601::DateTime.new(iso8601_time).to_time.utc
+    rescue
+      nil
+    end
+  end
+end

data/lib/bolognese/doi_utils.rb

@@ -0,0 +1,48 @@
+module Bolognese
+  module DoiUtils
+    def validate_doi(doi)
+      Array(/\A(?:(http|https):\/\/(dx\.)?doi.org\/)?(doi:)?(10\.\d{4,5}\/.+)\z/.match(doi)).last
+    end
+
+    def normalize_doi(doi)
+      doi = validate_doi(doi)
+      return nil unless doi.present?
+
+      # remove non-printing whitespace and downcase
+      doi = doi.gsub(/\u200B/, '').downcase
+
+      # turn DOI into URL, escape unsafe characters
+      "https://doi.org/" + Addressable::URI.encode(doi)
+    end
+
+    def doi_from_url(url)
+      if /(http|https):\/\/(dx\.)?doi\.org\/(\w+)/.match(url)
+        uri = Addressable::URI.parse(url)
+        uri.path[1..-1].upcase
+      elsif url.is_a?(String) && url.starts_with?("doi:")
+        url[4..-1].upcase
+      end
+    end
+
+    def doi_as_url(doi)
+      "https://doi.org/#{clean_doi(doi)}" if doi.present?
+    end
+
+    # get DOI registration agency, assume a normalized DOI
+    def get_doi_ra(doi)
+      return {} if doi.blank?
+
+      url = "https://doi.crossref.org/doiRA/#{doi_from_url(doi)}"
+      response = Maremma.get(url, host: true, timeout: 120)
+
+      ra = response.body.fetch("data", {}).first.fetch("RA", nil)
+      if ra.present?
+        { "id" => ra.downcase,
+          "name" => ra }
+      else
+        { "errors" => response.body.fetch("errors", nil) || response.body.fetch("data", nil) }
+      end
+    end
+
+  end
+end

data/lib/bolognese/github.rb

@@ -0,0 +1,106 @@
+module Bolognese
+  class Github < Metadata
+    # def get_github_metadata(url, options = {})
+    #   return {} if url.blank?
+
+    #   github_hash = github_from_url(url)
+    #   repo_url = "https://api.github.com/repos/#{github_hash[:owner]}/#{github_hash[:repo]}"
+    #   response = Maremma.get(repo_url, options.merge(bearer: ENV['GITHUB_PERSONAL_ACCESS_TOKEN']))
+
+    #   return { error: 'Resource not found.', status: 404 } if response.body.fetch("errors", nil).present?
+
+    #   author = get_github_owner(github_hash[:owner])
+
+    #   language = response.body.fetch("data", {}).fetch('language', nil)
+    #   type = language.present? && language != "HTML" ? 'computer_program' : 'webpage'
+
+    #   { "author" => [get_one_author(author)],
+    #     "title" => response.body.fetch("data", {}).fetch('description', nil).presence || github_hash[:repo],
+    #     "container-title" => "Github",
+    #     "issued" => response.body.fetch("data", {}).fetch('created_at', nil).presence || "0000",
+    #     "URL" => url,
+    #     "type" => type }
+    # end
+
+    # def get_github_owner_metadata(url, options = {})
+    #   return {} if url.blank?
+
+    #   github_hash = github_from_url(url)
+    #   owner_url = "https://api.github.com/users/#{github_hash[:owner]}"
+    #   response = Maremma.get(owner_url, options.merge(bearer: ENV['GITHUB_PERSONAL_ACCESS_TOKEN']))
+
+    #   return { error: 'Resource not found.', status: 404 } if response.body.fetch("data", {}).fetch("message", nil) == "Not Found"
+
+    #   author = response.body.fetch("data", {}).fetch('name', nil).presence || github_hash[:owner]
+    #   title = "Github profile for #{author}"
+
+    #   { "author" => [get_one_author(author)],
+    #     "title" => title,
+    #     "container-title" => "Github",
+    #     "issued" => response.body.fetch("data", {}).fetch('created_at', nil).presence || "0000",
+    #     "URL" => url,
+    #     "type" => 'entry' }
+    # end
+
+    # def get_github_release_metadata(url, options = {})
+    #   return {} if url.blank?
+
+    #   github_hash = github_from_url(url)
+    #   release_url = "https://api.github.com/repos/#{github_hash[:owner]}/#{github_hash[:repo]}/releases/tags/#{github_hash[:release]}"
+    #   response = Maremma.get(release_url, options.merge(bearer: ENV['GITHUB_PERSONAL_ACCESS_TOKEN']))
+
+    #   return { error: 'Resource not found.', status: 404 } if response.body.fetch("data", {})["message"] == "Not Found"
+
+    #   author = get_github_owner(github_hash[:owner])
+
+    #   { "author" => [get_one_author(author)],
+    #     "title" => response.body.fetch("data", {}).fetch('name', nil),
+    #     "container-title" => "Github",
+    #     "issued" => response.body.fetch("data", {}).fetch('created_at', nil).presence || "0000",
+    #     "URL" => url,
+    #     "type" => 'computer_program' }
+    # end
+
+    # def get_github_owner(owner)
+    #   url = "https://api.github.com/users/#{owner}"
+    #   response = Maremma.get(url, bearer: ENV['GITHUB_PERSONAL_ACCESS_TOKEN'])
+
+    #   return nil if response.body.fetch("data", {}).fetch("message", nil) == "Not Found"
+
+    #   response.body.fetch("data", {}).fetch('name', nil).presence || owner
+    # end
+
+    # def github_from_url(url)
+    #   return {} unless /\Ahttps:\/\/github\.com\/(.+)(?:\/)?(.+)?(?:\/tree\/)?(.*)\z/.match(url)
+    #   words = URI.parse(url).path[1..-1].split('/')
+
+    #   { owner: words[0],
+    #     repo: words[1],
+    #     release: words[3] }.compact
+    # end
+
+    # def github_repo_from_url(url)
+    #   github_from_url(url).fetch(:repo, nil)
+    # end
+
+    # def github_release_from_url(url)
+    #   github_from_url(url).fetch(:release, nil)
+    # end
+
+    # def github_owner_from_url(url)
+    #   github_from_url(url).fetch(:owner, nil)
+    # end
+
+    # def github_as_owner_url(github_hash)
+    #   "https://github.com/#{github_hash[:owner]}" if github_hash[:owner].present?
+    # end
+
+    # def github_as_repo_url(github_hash)
+    #   "https://github.com/#{github_hash[:owner]}/#{github_hash[:repo]}" if github_hash[:repo].present?
+    # end
+
+    # def github_as_release_url(github_hash)
+    #   "https://github.com/#{github_hash[:owner]}/#{github_hash[:repo]}/tree/#{github_hash[:release]}" if github_hash[:release].present?
+    # end
+  end
+end

data/lib/bolognese/metadata.rb

@@ -0,0 +1,30 @@
+require_relative 'doi_utils'
+require_relative 'author_utils'
+require_relative 'date_utils'
+require_relative 'pid_utils'
+require_relative 'utils'
+
+module Bolognese
+  class Metadata
+    include Bolognese::DoiUtils
+    include Bolognese::AuthorUtils
+    include Bolognese::DateUtils
+    include Bolognese::PidUtils
+    include Bolognese::Utils
+
+    attr_reader :id, :provider
+
+    def initialize(id)
+      @id = normalize_id(id)
+      @provider = find_provider(@id)
+    end
+
+    def normalize_id(id)
+      normalize_doi(id) || normalize_orcid(id)
+    end
+
+    def find_provider(id)
+      get_doi_ra(id).fetch("id", nil) || "orcid"
+    end
+  end
+end

data/lib/bolognese/orcid.rb

@@ -0,0 +1,24 @@
+module Bolognese
+  class Orcid < Metadata
+    include Bolognese::PidUtils
+    # def get_orcid_metadata(orcid, options = {})
+    #   return {} if orcid.blank?
+
+    #   url = "https://pub.orcid.org/v2.0/#{orcid}/person"
+    #   response = Maremma.get(url, options.merge(accept: "json"))
+
+    #   name = response.body.fetch("data", {}).fetch("name", nil)
+    #   return { "errors" => 'Resource not found.' } unless name.present?
+
+    #   author = { "family" => name.fetch("family-name", {}).fetch("value", nil),
+    #              "given" => name.fetch("given-names", {}).fetch("value", nil) }
+
+    #   { "author" => [author],
+    #     "title" => "ORCID record for #{[author.fetch('given', nil), author.fetch('family', nil)].compact.join(' ')}",
+    #     "container-title" => "ORCID Registry",
+    #     "issued" => Time.now.year.to_s,
+    #     "URL" => orcid_as_url(orcid),
+    #     "type" => 'entry' }
+    # end
+  end
+end

data/lib/bolognese/pid_utils.rb

@@ -0,0 +1,23 @@
+module Bolognese
+  module PidUtils
+    def normalize_orcid(orcid)
+      orcid = validate_orcid(orcid)
+      return nil unless orcid.present?
+
+      # turn ORCID ID into URL
+      "http://orcid.org/" + Addressable::URI.encode(orcid)
+    end
+
+    def orcid_from_url(url)
+      Array(/\Ahttp:\/\/orcid\.org\/(.+)/.match(url)).last
+    end
+
+    def orcid_as_url(orcid)
+      "http://orcid.org/#{orcid}" if orcid.present?
+    end
+
+    def validate_orcid(orcid)
+      Array(/\A(?:http:\/\/orcid\.org\/)?(\d{4}-\d{4}-\d{4}-\d{3}[0-9X]+)\z/.match(orcid)).last
+    end
+  end
+end

data/lib/bolognese/pubmed.rb

@@ -0,0 +1,34 @@
+module Bolognese
+  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