bolognese 0.7.2 → 0.8

data/lib/bolognese/datacite.rb

@@ -1,23 +1,6 @@
 module Bolognese
   class Datacite < Metadata
 
-    DC_TO_SO_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"
-    }
-
     SCHEMA = File.expand_path("../../../resources/kernel-4.0/metadata.xsd", __FILE__)
 
     def initialize(id: nil, string: nil, regenerate: false)
@@ -28,6 +11,7 @@ module Bolognese
       elsif id.present?
         response = Maremma.get(id, accept: "application/vnd.datacite.datacite+xml", raw: true)
         @raw = response.body.fetch("data", nil)
+        @raw = Nokogiri::XML(@raw, &:noblanks).to_s if @raw.present?
       end
 
       @should_passthru = !regenerate
@@ -51,8 +35,7 @@ module Bolognese
     end
 
     def errors
-      arr = schema.validate(Nokogiri::XML(raw)).map { |error| error.to_s }
-      array_unwrap(arr)
+      schema.validate(Nokogiri::XML(raw)).map { |error| error.to_s }.unwrap
     end
 
     def schema_version
@@ -90,24 +73,26 @@ module Bolognese
       Bolognese::Bibtex::SO_TO_BIB_TRANSLATIONS[type] || "misc"
     end
 
-    def name
+    def title
       metadata.dig("titles", "title")
     end
 
     def alternate_name
-      parse_attributes(metadata.dig("alternateIdentifiers", "alternateIdentifier"))
-    end
-
-    def descriptions
-      Array.wrap(metadata.dig("descriptions", "description"))
+      Array.wrap(metadata.dig("alternateIdentifiers", "alternateIdentifier")).map do |r|
+        { "type" => r["alternateIdentifierType"], "name" => r["__content__"] }.compact
+      end.unwrap
     end
 
     def description
-      parse_attributes(descriptions)
+      Array.wrap(metadata.dig("descriptions", "description")).map do |r|
+        { "type" => r["descriptionType"], "text" => sanitize(r["__content__"]) }.compact
+      end.unwrap
     end
 
     def license
-      parse_attributes(Array.wrap(metadata.dig("rightsList", "rights")), content: "rightsURI")
+      Array.wrap(metadata.dig("rightsList", "rights")).map do |r|
+        { "url" => r["rightsURI"], "name" => r["__content__"] }.compact
+      end.unwrap
     end
 
     def keywords
@@ -115,15 +100,12 @@ module Bolognese
     end
 
     def author
-      authors = metadata.dig("creators", "creator")
-      authors = [authors] if authors.is_a?(Hash)
-      array_unwrap(get_authors(authors))
+      get_authors(metadata.dig("creators", "creator"))
     end
 
     def editor
-      editors = Array.wrap(metadata.dig("contributors", "contributor"))
-                     .select { |r| r["contributorType"] == "Editor" }
-      array_unwrap(get_authors(editors))
+      get_authors(Array.wrap(metadata.dig("contributors", "contributor"))
+                          .select { |r| r["contributorType"] == "Editor" })
     end
 
     def funder
@@ -134,7 +116,7 @@ module Bolognese
     def funder_contributor
       Array.wrap(metadata.dig("contributors", "contributor")).reduce([]) do |sum, f|
         if f["contributorType"] == "Funder"
-          sum << { "@type" => "Organization", "name" => f["contributorName"] }
+          sum << { "name" => f["contributorName"] }
         else
           sum
         end
@@ -144,8 +126,7 @@ module Bolognese
     def funding_reference
       Array.wrap(metadata.dig("fundingReferences", "fundingReference")).map do |f|
         funder_id = parse_attributes(f["funderIdentifier"])
-        { "@type" => "Organization",
-          "@id" => normalize_id(funder_id),
+        { "identifier" => normalize_id(funder_id),
           "name" => f["funderName"] }.compact
       end.uniq
     end
@@ -165,18 +146,44 @@ module Bolognese
       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")
     end
@@ -193,52 +200,45 @@ module Bolognese
       metadata.fetch("size", nil)
     end
 
-    def related_identifiers(relation_type)
-      arr = Array.wrap(metadata.dig("relatedIdentifiers", "relatedIdentifier"))
-        .select { |r| relation_type.split(" ").include?(r["relationType"]) && %w(DOI URL).include?(r["relatedIdentifierType"]) }
-        .map do |work|
-          { "@type" => "CreativeWork",
-            "@id" => normalize_id(work["__content__"]) }
-        end
-      array_unwrap(arr)
+    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 same_as
-      related_identifiers("IsIdenticalTo")
+    def is_identical_to
+      related_identifier(relation_type: "IsIdenticalTo")
     end
 
     def is_part_of
-      related_identifiers("IsPartOf")
+      related_identifier(relation_type: "IsPartOf")
     end
 
     def has_part
-      related_identifiers("HasPart")
+      related_identifier(relation_type: "HasPart")
     end
 
-    def predecessor_of
-      related_identifiers("IsPreviousVersionOf")
+    def is_previous_version_of
+      related_identifier(relation_type: "IsPreviousVersionOf")
     end
 
-    def successor_of
-      related_identifiers("IsNewVersionOf")
+    def is_new_version_of
+      related_identifier(relation_type: "IsNewVersionOf")
     end
 
-    def citation
-      related_identifiers("Cites IsCitedBy Supplements IsSupplementTo References IsReferencedBy").presence
+    def references
+      related_identifier(relation_type: "Cites IsCitedBy Supplements IsSupplementTo References IsReferencedBy").presence
     end
 
     def publisher
-      { "@type" => "Organization",
-        "name" => metadata.fetch("publisher") }
+      metadata.fetch("publisher")
     end
 
-    def container_title
-      publisher.fetch("name", nil)
-    end
+    alias_method :container_title, :publisher
 
     def provider
-      { "@type" => "Organization",
-        "name" => "DataCite" }
+      "DataCite"
     end
   end
 end

data/lib/bolognese/datacite_json.rb

@@ -0,0 +1,208 @@
+module Bolognese
+  class DataciteJson < Metadata
+
+    def initialize(string: nil, regenerate: false)
+      if string.present?
+        @raw = string
+      end
+    end
+
+    def metadata
+      @metadata ||= raw.present? ? Maremma.from_json(raw) : {}
+    end
+
+    def valid?
+      true
+    end
+
+    def datacite
+      datacite_xml
+    end
+
+    def doi
+      metadata.fetch("doi", nil)
+    end
+
+    def id
+      metadata.fetch("id", nil)
+    end
+
+    def resource_type_general
+      metadata.fetch("resource-type-general", nil)
+    end
+
+    def type
+      DC_TO_SO_TRANSLATIONS[resource_type_general.to_s.dasherize] || "CreativeWork"
+    end
+
+    def additional_type
+      metadata.fetch("resource-type", nil)
+    end
+
+    def bibtex_type
+      Bolognese::Bibtex::SO_TO_BIB_TRANSLATIONS[type] || "misc"
+    end
+
+    def title
+      metadata.fetch("title", nil)
+    end
+
+    def alternate_name
+      metadata.fetch("alternate-identifier", nil)
+    end
+
+    def description
+      metadata.fetch("description", nil)
+    end
+
+    def license
+      metadata.fetch("license", nil)
+    end
+
+    def keywords
+      metadata.fetch("subject", nil)
+    end
+
+    def author
+      metadata.fetch("creator", nil)
+    end
+
+    def editor
+      metadata.fetch("contributor", nil)
+    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
+      metadata.fetch("date-accepted", nil)
+    end
+
+    def date_available
+      metadata.fetch("date-available", nil)
+    end
+
+    def date_copyrighted
+      metadata.fetch("date-copyrighted", nil)
+    end
+
+    def date_collected
+      metadata.fetch("date-collected", nil)
+    end
+
+    def date_created
+      metadata.fetch("date-created", nil)
+    end
+
+    # use datePublished for date issued
+    def date_published
+      metadata.fetch("date-published", nil)
+    end
+
+    def date_submitted
+      metadata.fetch("date-submitted", nil)
+    end
+
+    # use dateModified for date updated
+    def date_modified
+      metadata.fetch("date-modified", nil)
+    end
+
+    def date_valid
+      metadata.fetch("date-valid", nil)
+    end
+
+    def publication_year
+      metadata.fetch("publication-year")
+    end
+
+    def language
+      metadata.fetch("language", nil)
+    end
+
+    def spatial_coverage
+
+    end
+
+    def content_size
+      metadata.fetch("size", nil)
+    end
+
+    def related_identifier
+      metadata.fetch("related_identifier", nil)
+    end
+
+    def get_related_identifier(relation_type: nil)
+      Array.wrap(related_identifier).select { |r| relation_type.split(" ").include?(r["relationType"]) }.unwrap
+    end
+
+    def is_identical_to
+      get_related_identifier(relation_type: "IsIdenticalTo")
+    end
+
+    def is_part_of
+      get_related_identifier(relation_type: "IsPartOf")
+    end
+
+    def has_part
+      get_related_identifier(relation_type: "HasPart")
+    end
+
+    def is_previous_version_of
+      get_related_identifier(relation_type: "IsPreviousVersionOf")
+    end
+
+    def is_new_version_of
+      get_related_identifier(relation_type: "IsNewVersionOf")
+    end
+
+    def references
+      get_related_identifier(relation_type: "Cites IsCitedBy Supplements IsSupplementTo References IsReferencedBy").presence
+    end
+
+    def publisher
+      metadata.fetch("publisher")
+    end
+
+    alias_method :container_title, :publisher
+
+    def provider
+      "DataCite"
+    end
+  end
+end

data/lib/bolognese/datacite_utils.rb

@@ -22,15 +22,6 @@ module Bolognese
       "WebSite" => "Text"
     }
 
-    LICENSE_NAMES = {
-      "http://creativecommons.org/publicdomain/zero/1.0/" => "Public Domain (CC0 1.0)",
-      "http://creativecommons.org/licenses/by/3.0/" => "Creative Commons Attribution 3.0 (CC-BY 3.0)",
-      "http://creativecommons.org/licenses/by/4.0/" => "Creative Commons Attribution 4.0 (CC-BY 4.0)",
-      "http://creativecommons.org/licenses/by-nc/4.0/" => "Creative Commons Attribution Noncommercial 4.0 (CC-BY-NC 4.0)",
-      "http://creativecommons.org/licenses/by-sa/4.0/" => "Creative Commons Attribution Share Alike 4.0 (CC-BY-SA 4.0)",
-      "http://creativecommons.org/licenses/by-nc-nd/4.0/" => "Creative Commons Attribution Noncommercial No Derivatives 4.0 (CC-BY-NC-ND 4.0)"
-    }
-
     SCHEMA = File.expand_path("../../../resources/kernel-4.0/metadata.xsd", __FILE__)
 
     def schema
@@ -103,7 +94,7 @@ module Bolognese
       xml.send(type + "Name", person_name)
       xml.givenName(person["givenName"]) if person["givenName"].present?
       xml.familyName(person["familyName"]) if person["familyName"].present?
-      xml.nameIdentifier(person["@id"], 'schemeURI' => 'http://orcid.org/', 'nameIdentifierScheme' => 'ORCID') if person["@id"].present?
+      xml.nameIdentifier(person["id"], 'schemeURI' => 'http://orcid.org/', 'nameIdentifierScheme' => 'ORCID') if person["id"].present?
     end
 
     def insert_titles(xml)
@@ -113,7 +104,7 @@ module Bolognese
     end
 
     def insert_title(xml)
-      xml.title(name)
+      xml.title(title)
     end
 
     def insert_publisher(xml)
@@ -140,7 +131,9 @@ module Bolognese
       return xml unless alternate_name.present?
 
       xml.alternateIdentifiers do
-        xml.alternateIdentifier(alternate_name, 'alternateIdentifierType' => "Local accession number")
+        Array.wrap(alternate_name).each do |alt|
+          xml.alternateIdentifier(alt["name"], 'alternateIdentifierType' => alt["type"])
+        end
       end
     end
 
@@ -170,7 +163,7 @@ module Bolognese
 
     def insert_funding_reference(xml, funding_reference)
       xml.funderName(funding_reference["name"]) if funding_reference["name"].present?
-      xml.funderIdentifier(funding_reference["@id"], "funderIdentifierType" => "Crossref Funder ID") if funding_reference["@id"].present?
+      xml.funderIdentifier(funding_reference["id"], "funderIdentifierType" => "Crossref Funder ID") if funding_reference["id"].present?
     end
 
     def insert_subjects(xml)
@@ -189,25 +182,19 @@ module Bolognese
       xml.version(version)
     end
 
-    def rel_identifiers
-      rel_identifier(rel_ids: is_part_of, relation_type: "IsPartOf") +
-      rel_identifier(rel_ids: has_part, relation_type: "HasPart") +
-      rel_identifier(rel_ids: citation, relation_type: "References")
-    end
-
-    def rel_identifier(rel_ids: nil, relation_type: nil)
-      Array.wrap(rel_ids).map do |i|
-        { "__content__" => i["@id"],
-          "related_identifier_type" => validate_url(i["@id"]),
-          "relation_type" => relation_type }
-      end.select { |i| i["related_identifier_type"].present? }
+    def rel_identifier
+      Array.wrap(related_identifier).map do |r|
+        { "__content__" => r["id"],
+          "related_identifier_type" => validate_url(r["id"]),
+          "relation_type" => r["relationType"] }
+      end
     end
 
     def insert_related_identifiers(xml)
-      return xml unless rel_identifiers.present?
+      return xml unless rel_identifier.present?
 
       xml.relatedIdentifiers do
-        rel_identifiers.each do |related_identifier|
+        rel_identifier.each do |related_identifier|
           xml.relatedIdentifier(related_identifier["__content__"], 'relatedIdentifierType' => related_identifier["related_identifier_type"], 'relationType' => related_identifier["relation_type"])
         end
       end
@@ -218,37 +205,19 @@ module Bolognese
 
       xml.rightsList do
         Array.wrap(license).each do |lic|
-          xml.rights(LICENSE_NAMES[lic], 'rightsURI' => lic)
+          xml.rights(lic["name"], 'rightsURI' => lic["url"])
         end
       end
     end
 
     def insert_descriptions(xml)
-      return xml unless descriptions.present?
+      return xml unless description.present?
 
       xml.descriptions do
         Array.wrap(description).each do |des|
-          insert_description(xml, des)
-        end
-      end
-    end
-
-    def insert_description(xml, des)
-      if des.is_a?(String)
-        xml.description(des.strip, 'descriptionType' => "Abstract")
-      elsif des.is_a?(Hash)
-        xml.description(des["__content__"].strip, 'descriptionType' => des["descriptionType"],)
-      end
-    end
-
-    def without_control(s)
-      r = ''
-      s.each_codepoint do |c|
-        if c >= 32
-          r << c
+          xml.description(des["text"], 'descriptionType' => des["type"] || "Abstract")
         end
       end
-      r
     end
 
     def root_attributes