bolognese 0.9.8 → 0.9.9

data/lib/bolognese/crossref.rb

@@ -1,281 +0,0 @@
-module Bolognese
-  class Crossref < Metadata
-    # CrossRef types from https://api.crossref.org/types
-    CR_TO_SO_TRANSLATIONS = {
-      "Proceedings" => nil,
-      "ReferenceBook" => "Book",
-      "JournalIssue" => "PublicationIssue",
-      "ProceedingsArticle" => nil,
-      "Other" => "CreativeWork",
-      "Dissertation" => "Thesis",
-      "Dataset" => "Dataset",
-      "EditedBook" => "Book",
-      "JournalArticle" => "ScholarlyArticle",
-      "Journal" => nil,
-      "Report" => nil,
-      "BookSeries" => nil,
-      "ReportSeries" => nil,
-      "BookTrack" => nil,
-      "Standard" => nil,
-      "BookSection" => nil,
-      "BookPart" => nil,
-      "Book" => "Book",
-      "BookChapter" => "Chapter",
-      "StandardSeries" => nil,
-      "Monograph" => "Book",
-      "Component" => "CreativeWork",
-      "ReferenceEntry" => nil,
-      "JournalVolume" => "PublicationVolume",
-      "BookSet" => nil,
-      "PostedContent" => "ScholarlyArticle"
-    }
-
-    CR_TO_BIB_TRANSLATIONS = {
-      "Proceedings" => "proceedings",
-      "ReferenceBook" => "book",
-      "JournalIssue" => nil,
-      "ProceedingsArticle" => nil,
-      "Other" => nil,
-      "Dissertation" => "phdthesis",
-      "Dataset" => nil,
-      "EditedBook" => "book",
-      "JournalArticle" => "article",
-      "Journal" => nil,
-      "Report" => nil,
-      "BookSeries" => nil,
-      "ReportSeries" => nil,
-      "BookTrack" => nil,
-      "Standard" => nil,
-      "BookSection" => "inbook",
-      "BookPart" => nil,
-      "Book" => "book",
-      "BookChapter" => "inbook",
-      "StandardSeries" => nil,
-      "Monograph" => "book",
-      "Component" => nil,
-      "ReferenceEntry" => nil,
-      "JournalVolume" => nil,
-      "BookSet" => nil,
-      "PostedContent" => "article"
-    }
-
-    CONTACT_EMAIL = "tech@datacite.org"
-
-    def initialize(id: nil, string: nil)
-      id = normalize_doi(id) if id.present?
-
-      if string.present?
-        @raw = string
-      elsif id.present?
-        doi = doi_from_url(id)
-        url = "http://www.crossref.org/openurl/?id=doi:#{doi}&noredirect=true&pid=#{CONTACT_EMAIL}&format=unixref"
-        response = Maremma.get(url, accept: "text/xml", raw: true)
-        @raw = response.body.fetch("data", nil)
-        @raw = Nokogiri::XML(@raw, nil, 'UTF-8', &:noblanks).to_s if @raw.present?
-      end
-    end
-
-    alias_method :crossref, :raw
-
-    def metadata
-      @metadata ||= if raw.present?
-        m = Maremma.from_xml(raw).fetch("doi_records", {}).fetch("doi_record", {})
-        m.dig("crossref", "error").nil? ? m : {}
-      else
-        {}
-      end
-    end
-
-    def exists?
-      metadata.present?
-    end
-
-    def valid?
-      crossref.present?
-    end
-
-    def doi
-      bibliographic_metadata.dig("doi_data", "doi")
-    end
-
-    def url
-      bibliographic_metadata.dig("doi_data", "resource")
-    end
-
-    def id
-      normalize_doi(doi)
-    end
-
-    def journal_metadata
-      @journal_metadata ||=
-      metadata.dig("crossref", "journal", "journal_metadata").presence || {}
-    end
-
-    def journal_issue
-      metadata.dig("crossref", "journal", "journal_issue").presence || {}
-    end
-
-    def bibliographic_metadata
-      @bibliographic_metadata ||=
-      metadata.dig("crossref", "journal", "journal_article").presence ||
-      metadata.dig("crossref", "conference", "conference_paper").presence ||
-      metadata.dig("crossref", metadata.fetch("crossref", {}).keys.last).presence || {}
-    end
-
-    def program_metadata
-      @program_metadata ||=
-      bibliographic_metadata.dig("program") ||
-      bibliographic_metadata.dig("crossmark", "custom_metadata", "program") || {}
-    end
-
-    def resource_type_general
-      SO_TO_DC_TRANSLATIONS[type]
-    end
-
-    def type
-      CR_TO_SO_TRANSLATIONS[additional_type] || "ScholarlyArticle"
-    end
-
-    def citeproc_type
-      CR_TO_CP_TRANSLATIONS[additional_type] || "article-journal"
-    end
-
-    def ris_type
-      CR_TO_RIS_TRANSLATIONS[additional_type] || "JOUR"
-    end
-
-    def additional_type
-      if metadata.dig("crossref", "journal").present?
-        metadata.dig("crossref", "journal").keys.last.camelize
-      else
-        metadata.dig("crossref").keys.last.camelize
-      end
-    end
-
-    def bibtex_type
-      CR_TO_BIB_TRANSLATIONS[additional_type] || "misc"
-    end
-
-    def title
-      parse_attributes(bibliographic_metadata.dig("titles", "title"))
-    end
-
-    def alternate_name
-      if bibliographic_metadata.fetch("publisher_item", nil).present?
-        parse_attributes(bibliographic_metadata.dig("publisher_item", "item_number"))
-      else
-        parse_attributes(bibliographic_metadata.fetch("item_number", nil))
-      end
-    end
-
-    def description
-      des = bibliographic_metadata.fetch("abstract", {}).values.first
-      if des.is_a?(Hash)
-        des.to_xml
-      elsif des.is_a?(String)
-        des
-      end
-    end
-
-    def license
-      access_indicator = Array.wrap(program_metadata).find { |m| m["name"] == "AccessIndicators" }
-      if access_indicator.present?
-        { "url" => parse_attributes(access_indicator["license_ref"]) }
-      else
-        nil
-      end
-    end
-
-    def author
-      people("author")
-    end
-
-    def editor
-      people("editor")
-    end
-
-    def people(contributor_role)
-      person = bibliographic_metadata.dig("contributors", "person_name")
-      Array.wrap(person).select { |a| a["contributor_role"] == contributor_role }.map do |a|
-        { "type" => "Person",
-          "id" => parse_attributes(a["ORCID"]),
-          "name" => [a["given_name"], a["surname"]].join(" "),
-          "givenName" => a["given_name"],
-          "familyName" => a["surname"] }.compact
-      end.unwrap
-    end
-
-    def funder
-      fundref = Array.wrap(program_metadata).find { |a| a["name"] == "fundref" } || {}
-      Array.wrap(fundref.fetch("assertion", [])).select { |a| a["name"] == "fundgroup" }.map do |f|
-        { "id" => normalize_id(f.dig("assertion", "assertion", "__content__")),
-          "name" => f.dig("assertion", "__content__").strip }.compact
-      end.unwrap
-    end
-
-    def date_published
-      pub_date = Array.wrap(bibliographic_metadata.fetch("publication_date", nil)).presence ||
-        Array.wrap(bibliographic_metadata.fetch("acceptance_date", nil))
-      if pub_date.present?
-        get_date_from_parts(pub_date.first["year"], pub_date.first["month"], pub_date.first["day"])
-      else
-        nil
-      end
-    end
-
-    def date_modified
-      Time.parse(metadata.fetch("timestamp", "")).utc.iso8601
-    end
-
-    def volume
-      journal_issue.dig("journal_volume", "volume")
-    end
-
-    def issue
-      journal_issue.dig("issue")
-    end
-
-    def page_start
-      bibliographic_metadata.dig("pages", "first_page")
-    end
-
-    def page_end
-      bibliographic_metadata.dig("pages", "last_page")
-    end
-
-    def is_part_of
-      if journal_metadata.present?
-        { "type" => "Periodical",
-          "name" => journal_metadata["full_title"],
-          "issn" => parse_attributes(journal_metadata.fetch("issn", nil)) }.compact
-      else
-        nil
-      end
-    end
-
-    def container_title
-      is_part_of.to_h.fetch("name", nil)
-    end
-
-    alias_method :journal, :container_title
-
-    def related_identifier(relation_type: nil)
-      references
-    end
-
-    def references
-       refs = bibliographic_metadata.dig("citation_list", "citation")
-       Array.wrap(refs).map do |c|
-         { "id" => normalize_id(c["doi"]),
-           "relationType" => "Cites",
-           "position" => c["key"],
-           "name" => c["article_title"],
-           "datePublished" => c["cYear"] }.compact
-       end.unwrap
-    end
-
-    def provider
-      "Crossref"
-    end
-  end
-end

data/lib/bolognese/datacite.rb

@@ -1,288 +0,0 @@
-module Bolognese
-  class Datacite < Metadata
-    def initialize(id: nil, string: nil, regenerate: false)
-      id = normalize_doi(id) if id.present?
-
-      if string.present?
-        @raw = string
-      elsif id.present?
-        doi = doi_from_url(id)
-        url = "https://search.datacite.org/api?q=doi:#{doi}&fl=doi,xml,media,minted,updated&wt=json"
-        response = Maremma.get url
-        attributes = response.body.dig("data", "response", "docs").first
-        @raw = attributes.fetch('xml', "PGhzaD48L2hzaD4=\n")
-        @raw = Base64.decode64(@raw)
-        @doc = Nokogiri::XML(@raw, nil, 'UTF-8', &:noblanks) if @raw.present?
-        @raw = @doc.to_s if @raw.present?
-      end
-
-      @should_passthru = !regenerate
-    end
-
-    # generate new DataCite XML version 4.0 if regenerate (!should_passthru) option is provided
-    def datacite
-      should_passthru ? raw : datacite_xml
-    end
-
-    def metadata
-      @metadata ||= raw.present? ? Maremma.from_xml(raw).fetch("resource", {}) : {}
-    end
-
-    def exists?
-      metadata.present?
-    end
-
-    def valid?
-      datacite.present? && errors.blank?
-    end
-
-    def errors
-      doc && doc.errors.map { |error| error.to_s }.unwrap
-    end
-
-    def schema_version
-      metadata.fetch("xmlns", nil)
-    end
-
-    def doi
-      metadata.fetch("identifier", {}).fetch("__content__", nil)
-    end
-
-    def id
-      normalize_doi(doi)
-    end
-
-    def resource_type_general
-      metadata.dig("resourceType", "resourceTypeGeneral")
-    end
-
-    def type
-      DC_TO_SO_TRANSLATIONS[resource_type_general.to_s.dasherize] || "CreativeWork"
-    end
-
-    def citeproc_type
-      DC_TO_CP_TRANSLATIONS[resource_type_general.to_s.dasherize] || "other"
-    end
-
-    def ris_type
-      DC_TO_RIS_TRANSLATIONS[resource_type_general.to_s.dasherize] || "GEN"
-    end
-
-    def additional_type
-      metadata.fetch("resourceType", {}).fetch("__content__", nil) ||
-      metadata.fetch("resourceType", {}).fetch("resourceTypeGeneral", nil)
-    end
-
-    def bibtex_type
-      Bolognese::Bibtex::SO_TO_BIB_TRANSLATIONS[type] || "misc"
-    end
-
-    def title
-      Array.wrap(metadata.dig("titles", "title")).map do |r|
-        if r.is_a?(String)
-          sanitize(r)
-        else
-          { "title_type" => r["titleType"], "lang" => r["xml:lang"], "text" => sanitize(r["__content__"]) }.compact
-        end
-      end.unwrap
-    end
-
-    def alternate_name
-      Array.wrap(metadata.dig("alternateIdentifiers", "alternateIdentifier")).map do |r|
-        { "type" => r["alternateIdentifierType"], "name" => r["__content__"] }.compact
-      end.unwrap
-    end
-
-    def description
-      Array.wrap(metadata.dig("descriptions", "description")).map do |r|
-        { "type" => r["descriptionType"], "text" => sanitize(r["__content__"]) }.compact
-      end.unwrap
-    end
-
-    def license
-      Array.wrap(metadata.dig("rightsList", "rights")).map do |r|
-        { "url" => r["rightsURI"], "name" => r["__content__"] }.compact
-      end.unwrap
-    end
-
-    def keywords
-      Array.wrap(metadata.dig("subjects", "subject")).map do |k|
-        if k.is_a?(String)
-          sanitize(k)
-        else
-          k.fetch("__content__", nil)
-        end
-      end.compact.join(", ").presence
-    end
-
-    def author
-      get_authors(metadata.dig("creators", "creator"))
-    end
-
-    def editor
-      get_authors(Array.wrap(metadata.dig("contributors", "contributor"))
-                          .select { |r| r["contributorType"] == "Editor" })
-    end
-
-    def funder
-      f = funder_contributor + funding_reference
-      f.length > 1 ? f : f.first
-    end
-
-    def funder_contributor
-      Array.wrap(metadata.dig("contributors", "contributor")).reduce([]) do |sum, f|
-        if f["contributorType"] == "Funder"
-          sum << { "name" => f["contributorName"] }
-        else
-          sum
-        end
-      end
-    end
-
-    def funding_reference
-      Array.wrap(metadata.dig("fundingReferences", "fundingReference")).map do |f|
-        funder_id = parse_attributes(f["funderIdentifier"])
-        { "identifier" => normalize_id(funder_id),
-          "name" => f["funderName"] }.compact
-      end.uniq
-    end
-
-    def version
-      metadata.fetch("version", nil)
-    end
-
-    def dates
-      Array.wrap(metadata.dig("dates", "date"))
-    end
-
-    #Accepted Available Copyrighted Collected Created Issued Submitted Updated Valid
-
-    def date(date_type)
-      dd = dates.find { |d| d["dateType"] == date_type } || {}
-      dd.fetch("__content__", nil)
-    end
-
-    def date_accepted
-      date("Accepted")
-    end
-
-    def date_available
-      date("Available")
-    end
-
-    def date_copyrighted
-      date("Copyrighted")
-    end
-
-    def date_collected
-      date("Collected")
-    end
-
-    def date_created
-      date("Created")
-    end
-
-    # use datePublished for date issued
-    def date_published
-      date("Issued") || publication_year
-    end
-
-    def date_submitted
-      date("Submitted")
-    end
-
-    # use dateModified for date updated
-    def date_modified
-      date("Updated")
-    end
-
-    def date_valid
-      date("Valid")
-    end
-
-    def publication_year
-      metadata.fetch("publicationYear", nil)
-    end
-
-    def language
-      metadata.fetch("language", nil)
-    end
-
-    def spatial_coverage
-
-    end
-
-    def content_size
-      metadata.fetch("size", nil)
-    end
-
-    def related_identifier(relation_type: nil)
-      arr = Array.wrap(metadata.dig("relatedIdentifiers", "relatedIdentifier")).select { |r| %w(DOI URL).include?(r["relatedIdentifierType"]) }
-      arr = arr.select { |r| relation_type.split(" ").include?(r["relationType"]) } if relation_type.present?
-
-      arr.map { |work| { "id" => normalize_id(work["__content__"]), "relationType" => work["relationType"] } }.unwrap
-    end
-
-    def is_identical_to
-      related_identifier(relation_type: "IsIdenticalTo")
-    end
-
-    def is_part_of
-      related_identifier(relation_type: "IsPartOf")
-    end
-
-    def has_part
-      related_identifier(relation_type: "HasPart")
-    end
-
-    def is_previous_version_of
-      related_identifier(relation_type: "IsPreviousVersionOf")
-    end
-
-    def is_new_version_of
-      related_identifier(relation_type: "IsNewVersionOf")
-    end
-
-    def is_variant_form_of
-      related_identifier(relation_type: "IsVariantFormOf")
-    end
-
-    def is_original_form_of
-      related_identifier(relation_type: "IsOriginalFormOf")
-    end
-
-    def references
-      related_identifier(relation_type: "References Cites").presence
-    end
-
-    def is_referenced_by
-      related_identifier(relation_type: "IsCitedBy IsReferencedBy").presence
-    end
-
-    def is_supplement_to
-      related_identifier(relation_type: "IsSupplementTo")
-    end
-
-    def is_supplemented_by
-      get_related_identifier(relation_type: "isSupplementedBy")
-    end
-
-    def reviews
-      related_identifier(relation_type: "Reviews").presence
-    end
-
-    def is_reviewed_by
-      related_identifier(relation_type: "IsReviewedBy").presence
-    end
-
-    def publisher
-      metadata.fetch("publisher")
-    end
-
-    alias_method :container_title, :publisher
-
-    def provider
-      "DataCite"
-    end
-  end
-end