bolognese 1.0.6 → 1.0.7

data/lib/bolognese/readers/datacite_json_reader.rb

@@ -11,34 +11,36 @@ module Bolognese
 
         state = meta.fetch("doi", nil).present? ? "findable" : "not_found"
         related_identifiers = Array.wrap(meta.fetch("related-identifiers", nil)).map do |ri|
-          { "id" => ri["id"],
+          { "related_identifier" => ri["related-identifier"],
             "relation_type" => ri["relation-type"],
             "related_identifier_type" => ri["related-identifier-type"],
             "resource_type_general" => ri["resource-type-general"] }.compact
         end
+        alternate_identifiers = Array.wrap(meta.fetch("alternate-identifiers", nil)).map do |ai|
+          { "alternate_identifier" => ai["alternate-identifier"],
+            "alternate_identifier_type" => ai["alternate-identifier-type"] }.compact
+        end
         dates = Array.wrap(meta.fetch("dates", nil)).map do |d|
           { "date" => d["date"],
-            "date_type" => d["date-type"] }.compact
+            "date_type" => d["date-type"],
+            "date_information" => d["date-information"] }.compact
         end
         dates << { "date" => meta.fetch("publication-year", nil), "date_type" => "Issued" } if meta.fetch("publication-year", nil).present? && get_date(dates, "Issued").blank?
-        resource_type_general = meta.fetch("resource-type-general", nil)
-        resource_type = meta.fetch("resource-type", nil)
-        type = Bolognese::Utils::CR_TO_SO_TRANSLATIONS[resource_type.to_s.underscore.camelcase] || Bolognese::Utils::DC_TO_SO_TRANSLATIONS[resource_type_general.to_s.dasherize] || "CreativeWork"
-        types = {
+        type = meta.dig("types", "type") || Bolognese::Utils::CR_TO_SO_TRANSLATIONS[meta.dig("types", "resource-type").to_s.underscore.camelcase] || Bolognese::Utils::DC_TO_SO_TRANSLATIONS[meta.dig("types", "resource-type-general").to_s.dasherize] || "CreativeWork"
+        types = { 
           "type" => type,
-          "resource_type_general" => resource_type_general,
-          "resource_type" => resource_type,
-          "citeproc" => Bolognese::Utils::CR_TO_CP_TRANSLATIONS[resource_type.to_s.underscore.camelcase] || Bolognese::Utils::SO_TO_CP_TRANSLATIONS[type] || "article",
-          "bibtex" => Bolognese::Utils::CR_TO_BIB_TRANSLATIONS[resource_type.to_s.underscore.camelcase] || Bolognese::Utils::SO_TO_BIB_TRANSLATIONS[type] || "misc",
-          "ris" => Bolognese::Utils::CR_TO_RIS_TRANSLATIONS[resource_type.to_s.underscore.camelcase] || Bolognese::Utils::DC_TO_RIS_TRANSLATIONS[resource_type_general.to_s.dasherize] || "GEN"
-        }.compact
+          "resource_type_general" => meta.dig("types", "resource-type-general"),
+          "resource_type" => meta.dig("types", "resource-type"),
+          "bibtex" => meta.dig("types", "bibtex") || Bolognese::Utils::CR_TO_BIB_TRANSLATIONS[meta.dig("types", "resource-type").to_s.underscore.camelcase] || Bolognese::Utils::SO_TO_BIB_TRANSLATIONS[type] || "misc",
+          "citeproc" => meta.dig("types", "citeproc") || Bolognese::Utils::CR_TO_CP_TRANSLATIONS[meta.dig("types", "resource-type").to_s.underscore.camelcase] || Bolognese::Utils::SO_TO_CP_TRANSLATIONS[type] || "article",
+          "ris" => meta.dig("types", "ris") || Bolognese::Utils::CR_TO_RIS_TRANSLATIONS[meta.dig("types", "resource-type").to_s.underscore.camelcase] || Bolognese::Utils::DC_TO_RIS_TRANSLATIONS[meta.dig("types", "resource-type-general").to_s.dasherize] || "GEN" }.compact
 
         { "id" => meta.fetch("id", nil),
           "types" => types,
           "doi" => validate_doi(meta.fetch("doi", nil)),
           "url" => normalize_id(meta.fetch("url", nil)),
-          "title" => meta.fetch("title", nil),
-          "alternate_identifiers" => meta.fetch("alternate-identifiers", nil),
+          "titles" => meta.fetch("titles", nil),
+          "alternate_identifiers" => alternate_identifiers,
           "creator" => meta.fetch("creator", nil),
           "contributor" => meta.fetch("contributor", nil),
           "publisher" => meta.fetch("publisher", nil),
@@ -48,14 +50,14 @@ module Bolognese
           "related_identifiers" => related_identifiers,
           "dates" => dates,
           "publication_year" => meta.fetch("publication-year", nil),
-          "description" => meta.fetch("description", nil),
-          "rights" => meta.fetch("rights", nil),
+          "descriptions" => meta.fetch("descriptions", nil),
+          "rights_list" => meta.fetch("rights-list", nil),
           "version" => meta.fetch("version", nil),
-          "keywords" => meta.fetch("subject", nil),
+          "subjects" => meta.fetch("subjects", nil),
           "language" => meta.fetch("language", nil),
-          "size" => meta.fetch("size", nil),
+          "sizes" => meta.fetch("sizes", nil),
           "formats" => meta.fetch("formats", nil),
-          "geo_location" => meta.fetch("geo-location", nil),
+          "geo_locations" => meta.fetch("geo-locations", nil),
           "schema_version" => meta.fetch("schema-version", nil),
           "state" => state
         }

data/lib/bolognese/readers/datacite_reader.rb

@@ -84,37 +84,38 @@ module Bolognese
           "ris" => Bolognese::Utils::CR_TO_RIS_TRANSLATIONS[resource_type.to_s.underscore.camelcase] || Bolognese::Utils::DC_TO_RIS_TRANSLATIONS[resource_type_general.to_s.dasherize] || "GEN"
         }.compact
         
-        title = Array.wrap(meta.dig("titles", "title")).map do |r|
+        titles = Array.wrap(meta.dig("titles", "title")).map do |r|
           if r.is_a?(String)
-            { "text" => sanitize(r) }
+            { "title" => sanitize(r) }
           else
-            { "title_type" => r["titleType"], "lang" => r["lang"], "text" => sanitize(r["__content__"]) }.compact
+            { "title" => sanitize(r["__content__"]), "title_type" => r["titleType"], "lang" => r["lang"] }.compact
           end
         end
 
         alternate_identifiers = Array.wrap(meta.dig("alternateIdentifiers", "alternateIdentifier")).map do |r|
-          { "type" => r["alternateIdentifierType"], "name" => r["__content__"] }
-        end.unwrap
-        description = Array.wrap(meta.dig("descriptions", "description")).select { |r| r["descriptionType"] != "SeriesInformation" }.map do |r|
-          { "type" => r["descriptionType"], "lang" => r["lang"], "text" => sanitize(r["__content__"]) }.compact
+          { "alternate_identifier_type" => r["alternateIdentifierType"], "alternate_identifier" => r["__content__"] }
         end
-        rights = Array.wrap(meta.dig("rightsList", "rights")).map do |r|
-          { "id" => normalize_url(r["rightsURI"]), "name" => r["__content__"] }.compact
+        descriptions = Array.wrap(meta.dig("descriptions", "description")).select { |r| r["descriptionType"] != "SeriesInformation" }.map do |r|
+          { "description" => sanitize(r["__content__"]), "description_type" => r["descriptionType"], "lang" => r["lang"] }.compact
         end
-        keywords = Array.wrap(meta.dig("subjects", "subject")).map do |k|
+        rights_list = Array.wrap(meta.dig("rightsList", "rights")).map do |r|
+          { "rights" => r["__content__"], "rights_uri" => normalize_url(r["rightsURI"]), "lang" => r["lang"] }.compact
+        end
+        subjects = Array.wrap(meta.dig("subjects", "subject")).map do |k|
           if k.nil?
             nil
           elsif k.is_a?(String)
-            { "text" => sanitize(k) }
+            { "subject" => sanitize(k) }
           else
-            { "subject_scheme" => k["subjectScheme"], "scheme_uri" => k["schemeURI"], "text" => sanitize(k["__content__"]) }.compact
+            { "subject" => sanitize(k["__content__"]), "subject_scheme" => k["subjectScheme"], "scheme_uri" => k["schemeURI"], "value_uri" => k["valueURI"], "lang" => k["lang"] }.compact
           end
         end.compact
         dates = Array.wrap(meta.dig("dates", "date")).map do |d|
           {
             "date" => parse_attributes(d),
-            "date_type" => parse_attributes(d, content: "dateType")
-          }
+            "date_type" => parse_attributes(d, content: "dateType"),
+            "date_information" => parse_attributes(d, content: "dateInformation")
+          }.compact
         end
         dates << { "date" => meta.fetch("publicationYear", nil), "date_type" => "Issued" } if meta.fetch("publicationYear", nil).present? && get_date(dates, "Issued").blank?
         sizes = Array.wrap(meta.dig("sizes", "size"))
@@ -130,24 +131,26 @@ module Bolognese
         end
         related_identifiers = Array.wrap(meta.dig("relatedIdentifiers", "relatedIdentifier")).map do |ri|
           if ri["relatedIdentifierType"] == "DOI"
-            rid = ri["__content__"].downcase
+            rid = ri["__content__"].to_s.downcase
           else
             rid = ri["__content__"]
           end
 
           { 
-            "id" => rid,
+            "related_identifier" => rid,
             "related_identifier_type" => ri["relatedIdentifierType"],
             "relation_type" => ri["relationType"],
-            "resource_type_general" => ri["resourceTypeGeneral"]
+            "resource_type_general" => ri["resourceTypeGeneral"],
+            "related_metadata_scheme" => ri["relatedMetadataScheme"],
+            "scheme_uri" => ri["schemeURI"],
+            "scheme_type" => ri["schemeType"]
           }.compact
         end
-        geo_location = Array.wrap(meta.dig("geoLocations", "geoLocation")).map do |gl|
+        geo_locations = Array.wrap(meta.dig("geoLocations", "geoLocation")).map do |gl|
           if gl["geoLocationPoint"].is_a?(String) || gl["geoLocationBox"].is_a?(String)
             nil
           else
             {
-              "geo_location_place" => gl["geoLocationPlace"],
               "geo_location_point" => {
                 "point_latitude" => gl.dig("geoLocationPoint", "pointLatitude"),
                 "point_longitude" => gl.dig("geoLocationPoint", "pointLongitude")
@@ -157,7 +160,8 @@ module Bolognese
                 "east_bound_longitude" => gl.dig("geoLocationBox", "eastBoundLongitude"),
                 "south_bound_latitude" => gl.dig("geoLocationBox", "southBoundLatitude"),
                 "north_bound_latitude" => gl.dig("geoLocationBox", "northBoundLatitude")
-              }.compact.presence
+              }.compact.presence,
+              "geo_location_place" => gl["geoLocationPlace"],
             }.compact
           end
         end
@@ -169,7 +173,7 @@ module Bolognese
           "doi" => doi,
           "alternate_identifiers" => alternate_identifiers,
           "url" => options.fetch(:url, nil),
-          "title" => title,
+          "titles" => titles,
           "creator" => get_authors(Array.wrap(meta.dig("creators", "creator"))),
           "contributor" => get_authors(Array.wrap(meta.dig("contributors", "contributor"))),
           "periodical" => periodical,
@@ -178,15 +182,15 @@ module Bolognese
           "funding_references" => funding_references,
           "dates" => dates,
           "publication_year" => meta.fetch("publicationYear", nil),
-          "description" => description,
-          "rights" => rights,
+          "descriptions" => descriptions,
+          "rights_list" => rights_list,
           "version" => meta.fetch("version", nil),
-          "keywords" => keywords,
+          "subjects" => subjects,
           "language" => meta.fetch("language", nil),
-          "geo_location" => geo_location,
+          "geo_locations" => geo_locations,
           "related_identifiers" => related_identifiers,
           "formats" => formats,
-          "size" => sizes,
+          "sizes" => sizes,
           "schema_version" => schema_version,
           "state" => state
         }
@@ -205,46 +209,6 @@ module Bolognese
           }.compact
         end
       end
-
-      def datacite_funding_reference(meta)
-        Array.wrap(meta.dig("fundingReferences", "fundingReference")).compact.map do |f|
-          funder_id = parse_attributes(f["funderIdentifier"])
-          funder = { "type" => "Organization",
-                     "id" => normalize_id(funder_id),
-                     "name" => f["funderName"] }.compact
-          if f["awardNumber"].present? || f["awardTitle"].present?
-            { "type" => "Award",
-              "name" => f.fetch("awardTitle", nil),
-              "identifier" => f["awardNumber"].is_a?(Hash) ? f.dig("awardNumber", "__content__") : f["awardNumber"],
-              "url" => f["awardNumber"].is_a?(Hash) ? f.dig("awardNumber", "awardURI") : nil,
-              "funder" => funder }.compact
-          else
-            funder
-          end
-        end.uniq
-      end
-
-      def datacite_funder_contributor(meta)
-        Array.wrap(meta.dig("contributors", "contributor")).reduce([]) do |sum, f|
-          if f["contributorType"] == "Funder"
-            # handle special case of OpenAIRE metadata
-            id = f.dig("nameIdentifier", "__content__").to_s.start_with?("info:eu-repo/grantAgreement/EC") ? "https://doi.org/10.13039/501100000780" : nil
-
-            funder = { "type" => "Organization",
-                       "id" => id,
-                       "name" => f["contributorName"] }.compact
-            if f.dig("nameIdentifier", "nameIdentifierScheme") == "info"
-              sum << { "type" => "Award",
-                       "identifier" => f.dig("nameIdentifier", "__content__").split("/").last,
-                       "funder" => funder }
-            else
-              sum << funder
-            end
-          else
-            sum
-          end
-        end
-      end
     end
   end
 end

data/lib/bolognese/readers/ris_reader.rb

@@ -70,24 +70,27 @@ module Bolognese
           nil
         end
         state = doi.present? ? "findable" : "not_found"
+        subjects = Array.wrap(meta.fetch("KW", nil)).map do |s|
+          { "subject" => s }
+        end
 
         { "id" => normalize_doi(doi),
           "types" => types,
           "doi" => doi,
           "url" => meta.fetch("UR", nil),
-          "title" => meta.fetch("T1", nil).present? ? [{ "text" => meta.fetch("T1", nil) }] : nil,
+          "titles" => meta.fetch("T1", nil).present? ? [{ "title" => meta.fetch("T1", nil) }] : nil,
           "creator" => get_authors(author),
           "publisher" => meta.fetch("PB", "(:unav)"),
           "periodical" => periodical,
           "related_identifiers" => related_identifiers,
           "dates" => dates,
           "publication_year" => publication_year,
-          "description" => meta.fetch("AB", nil).present? ? [{ "text" => sanitize(meta.fetch("AB")) }] : nil,
+          "descriptions" => meta.fetch("AB", nil).present? ? [{ "description" => sanitize(meta.fetch("AB")) }] : nil,
           "volume" => meta.fetch("VL", nil),
           "issue" => meta.fetch("IS", nil),
           "first_page" => meta.fetch("SP", nil),
           "last_page" => meta.fetch("EP", nil),
-          "keywords" => meta.fetch("KW", nil),
+          "subjects" => subjects,
           "language" => meta.fetch("LA", nil),
           "state" => state
         }

data/lib/bolognese/readers/schema_org_reader.rb

@@ -39,11 +39,11 @@ module Bolognese
         if identifier.length > 1
           alternate_identifiers = identifier[1..-1].map do |r|
             if r.is_a?(String)
-              { "type" => "URL", "name" => r }
+              { "alternate_identifier_type" => "URL", "alternate_identifier" => r }
             elsif r.is_a?(Hash)
-              { "type" => r["propertyID"], "name" => r["value"] }
+              { "alternate_identifier_type" => r["propertyID"], "alternate_identifier" => r["value"] }
             end
-          end.unwrap
+          end
         else
           alternate_identifiers = nil
         end
@@ -104,7 +104,7 @@ module Bolognese
         publication_year = meta.fetch("datePublished")[0..3] if meta.fetch("datePublished", nil).present?
         
         state = meta.present? ? "findable" : "not_found"
-        geo_location = Array.wrap(meta.fetch("spatialCoverage", nil)).map do |gl|
+        geo_locations = Array.wrap(meta.fetch("spatialCoverage", nil)).map do |gl|
           if gl.dig("geo", "box")
             s, w, n, e = gl.dig("geo", "box").split(" ", 4)
             geo_location_box = {
@@ -124,6 +124,9 @@ module Bolognese
             "geo_location_box" => geo_location_box
           }.compact
         end
+        subjects = Array.wrap(meta.fetch("keywords", nil).to_s.split(", ")).map do |s|
+          { "subject" => s }
+        end
 
         { "id" => id,
           "types" => types,
@@ -132,9 +135,9 @@ module Bolognese
           "alternate_identifiers" => alternate_identifiers,
           "url" => normalize_id(meta.fetch("url", nil)),
           "content_url" => Array.wrap(meta.fetch("contentUrl", nil)),
-          "size" => Array.wrap(meta.fetch("contenSize", nil)).presence,
+          "sizes" => Array.wrap(meta.fetch("contenSize", nil)).presence,
           "formats" => Array.wrap(meta.fetch("encodingFormat", nil) || meta.fetch("fileFormat", nil)),
-          "title" => meta.fetch("name", nil).present? ? [{ "text" => meta.fetch("name", nil) }] : nil,
+          "titles" => meta.fetch("name", nil).present? ? [{ "title" => meta.fetch("name", nil) }] : nil,
           "creator" => author,
           "contributor" => contributor,
           "publisher" => publisher,
@@ -143,14 +146,14 @@ module Bolognese
           "related_identifiers" => related_identifiers,
           "publication_year" => publication_year,
           "dates" => dates,
-          "description" => meta.fetch("description", nil).present? ? [{ "text" => sanitize(meta.fetch("description")) }] : nil,
+          "descriptions" => meta.fetch("description", nil).present? ? [{ "description" => sanitize(meta.fetch("description")) }] : nil,
           "rights" => rights,
           "version" => meta.fetch("version", nil),
-          "keywords" => meta.fetch("keywords", nil).to_s.split(", "),
+          "subjects" => subjects,
           "state" => state,
           "schema_version" => meta.fetch("schemaVersion", nil),
           "funding_references" => funding_references,
-          "geo_location" => geo_location
+          "geo_locations" => geo_locations
         }
       end
 

data/lib/bolognese/utils.rb

@@ -479,7 +479,7 @@ module Bolognese
         related_identifier_type = doi_from_url(id).present? ? "DOI" : "URL"
         id = doi_from_url(id) || id
 
-        { "id" => id,
+        { "related_identifier" => id,
           "relation_type" => relation_type,
           "related_identifier_type" => related_identifier_type,
           "resource_type_general" => Metadata::SO_TO_DC_TRANSLATIONS[idx["@type"]],
@@ -524,16 +524,17 @@ module Bolognese
       nil
     end
 
-    def to_datacite_json(element)
-      Array.wrap(element).each do |e|
+    def to_datacite_json(element, options={})
+      a = Array.wrap(element).map do |e|
         e.inject({}) {|h, (k,v)| h[k.dasherize] = v; h }
-      end.unwrap
+      end
+      options[:first] ? a.unwrap : a.presence
     end
 
     def from_datacite_json(element)
-      Array.wrap(element).each do |e|
+      Array.wrap(element).map do |e|
         e.inject({}) {|h, (k,v)| h[k.underscore] = v; h }
-      end.unwrap
+      end
     end
 
     def to_schema_org(element)
@@ -546,7 +547,7 @@ module Bolognese
       return nil unless (element.is_a?(Hash) || (element.nil? && options[:container_title].present?))
 
       { 
-        "@id" => element["id"],
+        "@id" => element["related_identifier"],
         "@type" => (options[:type] == "Dataset") ? "DataCatalog" : "Periodical",
         "name" => element["title"] || options[:container_title] }
     end
@@ -559,13 +560,13 @@ module Bolognese
 
       if options[:alternate_identifiers].present?
         [ident] + Array.wrap(options[:alternate_identifiers]).map do |ai|
-                    if ai["type"].to_s.downcase == "url"
-                      ai["name"]
+                    if ai["alternate_identifier_type"].to_s.downcase == "url"
+                      ai["alternate_identifier"]
                     else
                       { 
                         "@type" => "PropertyValue",
-                        "propertyID" => ai["type"],
-                        "value" => ai["name"] }
+                        "propertyID" => ai["alternate_identifier_type"],
+                        "value" => ai["alternate_identifier"] }
                     end
                   end
       else
@@ -582,11 +583,11 @@ module Bolognese
         if r["related_identifier_type"] == "ISSN" && r["relation_type"] == "IsPartOf"
           {
             "@type" => "Periodical",
-            "issn" => r["id"],
+            "issn" => r["related_identifier"],
             "name" => r["title"] }.compact
         else
         {
-          "@id" => normalize_id(r["id"]),
+          "@id" => normalize_id(r["related_identifier"]),
           "@type" => DC_TO_SO_TRANSLATIONS[r["resource_type_general"]] || "CreativeWork",
           "name" => r["title"] }.compact
         end
@@ -658,7 +659,7 @@ module Bolognese
       {
         "@type" => "PropertyValue",
         "propertyID" => identifier["related_identifier_type"],
-        "value" => identifier["id"] }
+        "value" => identifier["related_identifier"] }
     end
 
     def from_citeproc(element)

data/lib/bolognese/version.rb

@@ -1,3 +1,3 @@
 module Bolognese
-  VERSION = "1.0.6"
+  VERSION = "1.0.7"
 end

data/lib/bolognese/writers/bibtex_writer.rb

@@ -12,9 +12,9 @@ module Bolognese
           doi: doi,
           url: url,
           author: authors_as_string(creator),
-          keywords: keywords.present? ? Array.wrap(keywords).map { |k| parse_attributes(k, content: "text", first: true) }.join(", ") : nil,
+          keywords: subjects.present? ? Array.wrap(subjects).map { |k| parse_attributes(k, content: "subject", first: true) }.join(", ") : nil,
           language: language,
-          title: parse_attributes(title, content: "text", first: true),
+          title: parse_attributes(titles, content: "title", first: true),
           journal: periodical && periodical["title"],
           volume: volume,
           issue: issue,

data/lib/bolognese/writers/codemeta_writer.rb

@@ -12,11 +12,11 @@ module Bolognese
           "@id" => identifier,
           "identifier" => identifier,
           "codeRepository" => url,
-          "title" => parse_attributes(title, content: "text", first: true),
+          "title" => parse_attributes(titles, content: "title", first: true),
           "agents" => creator,
-          "description" => parse_attributes(description, content: "text", first: true),
+          "description" => parse_attributes(descriptions, content: "description", first: true),
           "version" => version,
-          "tags" => keywords.to_s.split(", ").presence,
+          "tags" => subjects.present? ? Array.wrap(subjects).map { |k| parse_attributes(k, content: "subject", first: true) } : nil,
           "datePublished" => get_date(dates, "Issued"),
           "dateModified" => get_date(dates, "Updated"),
           "publisher" => publisher

data/lib/bolognese/writers/crosscite_writer.rb

@@ -10,25 +10,25 @@ module Bolognese
           "url" => url,
           "types" => types,
           "creator" => creator,
-          "title" => title,
+          "titles" => titles,
           "publisher" => publisher,
           "periodical" => periodical,
-          "keywords" => keywords,
+          "subjects" => subjects,
           "contributor" => contributor,
           "dates" => dates,
           "publication_year" => publication_year,
           "language" => language,
           "alternate_identifiers" => alternate_identifiers,
-          "size" => size,
+          "sizes" => sizes,
           "formats" => formats,
           "version" => version,
-          "rights" => rights,
-          "description" => description,
+          "rights_list" => rights_list,
+          "descriptions" => descriptions,
           "volume" => volume,
           "issue" => issue,
           "first_page" => first_page,
           "last_page" => last_page,
-          "geo_location" => geo_location,
+          "geo_locations" => geo_locations,
           "funding_references" => funding_references,
           "related_identifiers" => related_identifiers,
           "schema_version" => schema_version,