bolognese 0.15.9 → 1.0

data/lib/bolognese/readers/ris_reader.rb

@@ -41,16 +41,24 @@ module Bolognese
 
         doi = validate_doi(meta.fetch("DO", nil))
         author = Array.wrap(meta.fetch("AU", nil)).map { |a| { "name" => a } }
-        container_title = meta.fetch("T2", nil)
         date_parts = meta.fetch("PY", nil).to_s.split("/")
         date_published = get_date_from_parts(*date_parts)
-        is_part_of = if container_title.present?
-                       { "type" => "Periodical",
-                         "title" => container_title,
-                         "issn" => meta.fetch("SN", nil) }.compact
-                     else
-                       nil
-                     end
+        related_identifiers = if meta.fetch("T2", nil).present? && meta.fetch("SN", nil).present?
+          [{ "type" => "Periodical",
+             "id" => meta.fetch("SN", nil),
+             "related_identifier_type" => "ISSN",
+             "relation_type" => "IsPartOf",
+             "title" => meta.fetch("T2", nil), }.compact]
+        else
+          []
+        end
+        periodical = if meta.fetch("T2", nil).present?
+          { "type" => "Periodical",
+            "title" => meta.fetch("T2", nil), 
+            "id" => meta.fetch("SN", nil) }.compact
+        else
+          nil
+        end
         state = doi.present? ? "findable" : "not_found"
 
         { "id" => normalize_doi(doi),
@@ -61,9 +69,10 @@ module Bolognese
           "doi" => doi,
           "b_url" => meta.fetch("UR", nil),
           "title" => meta.fetch("T1", nil),
-          "author" => get_authors(author),
-          "publisher" => meta.fetch("PB", nil),
-          "is_part_of" => is_part_of,
+          "creator" => get_authors(author),
+          "publisher" => meta.fetch("PB", "(:unav)"),
+          "periodical" => periodical,
+          "related_identifiers" => related_identifiers,
           "date_created" => meta.fetch("Y1", nil),
           "date_published" => date_published,
           "date_accessed" => meta.fetch("Y2", nil),

data/lib/bolognese/readers/schema_org_reader.rb

@@ -37,7 +37,7 @@ module Bolognese
 
         identifier = Array.wrap(meta.fetch("identifier", nil))
         if identifier.length > 1
-          alternate_identifier = identifier[1..-1].map do |r|
+          alternate_identifiers = identifier[1..-1].map do |r|
             if r.is_a?(String)
               { "type" => "URL", "name" => r }
             elsif r.is_a?(Hash)
@@ -45,7 +45,7 @@ module Bolognese
             end
           end.unwrap
         else
-          alternate_identifier = nil
+          alternate_identifiers = nil
         end
         identifier = identifier.first
 
@@ -57,24 +57,61 @@ module Bolognese
         editor = get_authors(from_schema_org(Array.wrap(meta.fetch("editor", nil))))
         publisher = parse_attributes(meta.fetch("publisher", nil), content: "name", first: true)
 
-        included_in_data_catalog = from_schema_org(Array.wrap(meta.fetch("includedInDataCatalog", nil)))
-        included_in_data_catalog = Array.wrap(included_in_data_catalog).reduce([]) do |sum, dc| 
-          sum << { "title" => dc["name"], "url" => dc["url"] } if dc["url"].present?
-          sum
-        end.unwrap
-        is_part_of = schema_org_is_part_of(meta) || included_in_data_catalog
+        ct = (type == "Dataset") ? "includedInDataCatalog" : "Periodical"
+        periodical = if meta.fetch(ct, nil).present?
+          {
+            "type" => (type == "Dataset") ? "DataCatalog" : "Periodical",
+            "title" => parse_attributes(from_schema_org(meta.fetch(ct, nil)), content: "name", first: true),
+            "url" => parse_attributes(from_schema_org(meta.fetch(ct, nil)), content: "url", first: true)
+          }.compact
+        else
+          nil
+        end
 
-        license = {
+        related_identifiers = Array.wrap(schema_org_is_identical_to(meta)) +
+          Array.wrap(schema_org_is_part_of(meta)) +
+          Array.wrap(schema_org_has_part(meta)) +
+          Array.wrap(schema_org_is_previous_version_of(meta)) +
+          Array.wrap(schema_org_is_new_version_of(meta)) +
+          Array.wrap(schema_org_references(meta)) +
+          Array.wrap(schema_org_is_referenced_by(meta)) +
+          Array.wrap(schema_org_is_supplement_to(meta)) +
+          Array.wrap(schema_org_is_supplemented_by(meta))
+
+        rights = {
           "id" => parse_attributes(meta.fetch("license", nil), content: "id", first: true),
           "name" => parse_attributes(meta.fetch("license", nil), content: "name", first: true)
         }
 
-        funding = from_schema_org(Array.wrap(meta.fetch("funding", nil)))
+        funding_references = from_schema_org(Array.wrap(meta.fetch("funder", nil)))
+        funding_references = Array.wrap(meta.fetch("funder", nil)).compact.map do |fr|
+          {
+            "funder_name" => fr["name"],
+            "funder_identifier" => fr["@id"],
+            "funder_identifier_type" => fr["@id"].to_s.start_with?("https://doi.org/10.13039") ? "Crossref Funder ID" : nil }.compact
+        end
         date_published = meta.fetch("datePublished", nil)
         state = meta.present? ? "findable" : "not_found"
-        
-        ct = (type == "Dataset") ? "includedInDataCatalog" : "Periodical"
-        container_title = parse_attributes(from_schema_org(meta.fetch(ct, nil)), content: "name", first: true)
+        geo_location = 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 = {
+              "west_bound_longitude" => w,
+              "east_bound_longitude" => e,
+              "south_bound_latitude" => s,
+              "north_bound_latitude" => n
+            }.compact.presence
+          else
+            geo_location_box = nil
+          end
+          geo_location_point = { "point_longitude" => gl.dig("geo", "longitude"), "point_latitude" => gl.dig("geo", "latitude") }.compact.presence
+
+          {
+            "geo_location_place" => gl.dig("geo", "address"),
+            "geo_location_point" => geo_location_point,
+            "geo_location_box" => geo_location_box
+          }.compact
+        end
 
         { "id" => id,
           "type" => type,
@@ -85,43 +122,38 @@ module Bolognese
           "resource_type_general" => resource_type_general,
           "doi" => validate_doi(id),
           "identifier" => identifier,
-          "alternate_identifier" => alternate_identifier,
+          "alternate_identifiers" => alternate_identifiers,
           "b_url" => normalize_id(meta.fetch("url", nil)),
           "content_url" => Array.wrap(meta.fetch("contentUrl", nil)).unwrap,
-          "content_size" => meta.fetch("contenSize", nil),
-          "content_format" => Array.wrap(meta.fetch("encodingFormat", nil) || meta.fetch("fileFormat", nil)).unwrap,
+          "size" => meta.fetch("contenSize", nil),
+          "format" => Array.wrap(meta.fetch("encodingFormat", nil) || meta.fetch("fileFormat", nil)).unwrap,
           "title" => meta.fetch("name", nil),
-          "author" => author,
+          "creator" => author,
           "editor" => editor,
           "publisher" => publisher,
           "service_provider" => parse_attributes(meta.fetch("provider", nil), content: "name", first: true),
-          "container_title" => container_title,
-          "is_identical_to" => schema_org_is_identical_to(meta),
-          "is_part_of" => is_part_of,
-          "has_part" => schema_org_has_part(meta),
-          "references" => schema_org_references(meta),
-          "is_referenced_by" => schema_org_is_referenced_by(meta),
-          "is_supplement_to" => schema_org_is_supplement_to(meta),
-          "is_supplemented_by" => schema_org_is_supplemented_by(meta),
+          "periodical" => periodical,
+          "related_identifiers" => related_identifiers,
           "date_created" => meta.fetch("dateCreated", nil),
           "date_published" => date_published,
           "date_modified" => meta.fetch("dateModified", nil),
           "description" => meta.fetch("description", nil).present? ? { "text" => sanitize(meta.fetch("description")) } : nil,
-          "license" => license,
+          "rights" => rights,
           "b_version" => meta.fetch("version", nil),
           "keywords" => meta.fetch("keywords", nil).to_s.split(", "),
           "state" => state,
           "schema_version" => meta.fetch("schemaVersion", nil),
-          "funding" => funding
+          "funding_references" => funding_references,
+          "geo_location" => geo_location
         }
       end
 
       def schema_org_related_identifier(meta, relation_type: nil)
-        normalize_ids(ids: meta.fetch(relation_type, nil))
+        normalize_ids(ids: meta.fetch(relation_type, nil), relation_type: SO_TO_DC_RELATION_TYPES[relation_type])
       end
 
       def schema_org_reverse_related_identifier(meta, relation_type: nil)
-        normalize_ids(ids: meta.dig("@reverse", relation_type))
+        normalize_ids(ids: meta.dig("@reverse", relation_type), relation_type: SO_TO_DC_RELATION_TYPES[relation_type])
       end
 
       def schema_org_is_identical_to(meta)
@@ -159,6 +191,7 @@ module Bolognese
       def schema_org_is_supplemented_by(meta)
         schema_org_related_identifier(meta, relation_type: "isBasedOn")
       end
+
     end
   end
 end

data/lib/bolognese/utils.rb

@@ -25,7 +25,10 @@ module Bolognese
       "Sound" => "AudioObject",
       "Text" => "ScholarlyArticle",
       "Workflow" => nil,
-      "Other" => "CreativeWork"
+      "Other" => "CreativeWork",
+      # not part of DataCite schema, but used internally
+      "Periodical" => "Periodical",
+      "DataCatalog" => "DataCatalog"
     }
 
     DC_TO_CP_TRANSLATIONS = {
@@ -173,7 +176,6 @@ module Bolognese
       "BlogPosting" => "Text",
       "Chapter" => "Text",
       "Collection" => "Collection",
-      "CreativeWork" => "Other",
       "DataCatalog" => "Dataset",
       "Dataset" => "Dataset",
       "Event" => "Event",
@@ -362,7 +364,7 @@ module Bolognese
         "codemeta"
       elsif options[:ext] == ".json" && Maremma.from_json(string).to_h.dig("ris_type")
         "crosscite"
-      elsif options[:ext] == ".json" && Maremma.from_json(string).to_h.dig("schemaVersion").to_s.start_with?("http://datacite.org/schema/kernel")
+      elsif options[:ext] == ".json" && Maremma.from_json(string).to_h.dig("schema-version").to_s.start_with?("http://datacite.org/schema/kernel")
         "datacite_json"
       elsif options[:ext] == ".json" && Maremma.from_json(string).to_h.dig("issued", "date-parts").present?
         "citeproc"
@@ -471,11 +473,17 @@ module Bolognese
       "http://orcid.org/" + Addressable::URI.encode(orcid)
     end
 
-    def normalize_ids(ids: nil)
-      Array.wrap(ids).map do |id|
-        { "id" => normalize_id(id["@id"]),
-          "type" => id["@type"] || Metadata::DC_TO_SO_TRANSLATIONS[id["resourceTypeGeneral"]] || "CreativeWork",
-          "title" => id["title"] || id["name"] }.compact
+    def normalize_ids(ids: nil, relation_type: nil)
+      Array.wrap(ids).select { |idx| idx["@id"].present? }.map do |idx|
+        id = normalize_id(idx["@id"])
+        related_identifier_type = doi_from_url(id).present? ? "DOI" : "URL"
+        id = doi_from_url(id) || id
+
+        { "id" => id,
+          "relation_type" => relation_type,
+          "related_identifier_type" => related_identifier_type,
+          "resource_type_general" => Metadata::SO_TO_DC_TRANSLATIONS[idx["@type"]],
+          "title" => idx["title"] || idx["name"] }.compact
       end.unwrap
     end
 
@@ -525,13 +533,10 @@ module Bolognese
     def to_schema_org_container(element, options={})
       return nil unless (element.is_a?(Hash) || (element.nil? && options[:container_title].present?))
 
-      mapping = { "type" => "@type", "id" => "@id", "title" => "name" }
-
-      element ||= {}
-      element["type"] = (options[:type] == "Dataset") ? "DataCatalog" : "Periodical"
-      element["title"] ||= options[:container_title]
-
-      map_hash_keys(element: element, mapping: mapping)
+      { 
+        "@id" => element["id"],
+        "@type" => (options[:type] == "Dataset") ? "DataCatalog" : "Periodical",
+        "name" => element["title"] || options[:container_title] }
     end
 
     def to_schema_org_identifier(element, options={})
@@ -540,8 +545,8 @@ module Bolognese
         "propertyID" => normalize_doi(element) ? "doi" : "url",
         "value" => element }
 
-      if options[:alternate_identifier].present?
-        [ident] + Array.wrap(options[:alternate_identifier]).map do |ai|
+      if options[:alternate_identifiers].present?
+        [ident] + Array.wrap(options[:alternate_identifiers]).map do |ai|
                     if ai["type"].to_s.downcase == "url"
                       ai["name"]
                     else
@@ -556,6 +561,67 @@ module Bolognese
       end
     end
 
+    def to_schema_org_relation(related_identifiers: nil, relation_type: nil)
+      return nil unless related_identifiers.present? && relation_type.present?
+
+      relation_type = relation_type == "References" ? ["References", "Cites", "Documents"] : [relation_type] 
+
+      Array.wrap(related_identifiers).select { |ri| relation_type.include?(ri["relation_type"]) }.map do |r|
+        if r["related_identifier_type"] == "ISSN" && r["relation_type"] == "IsPartOf"
+          {
+            "@type" => "Periodical",
+            "issn" => r["id"],
+            "name" => r["title"] }.compact
+        else
+        {
+          "@id" => normalize_id(r["id"]),
+          "@type" => DC_TO_SO_TRANSLATIONS[r["resource_type_general"]] || "CreativeWork",
+          "name" => r["title"] }.compact
+        end
+      end.unwrap
+    end
+
+    def to_schema_org_funder(funding_references)
+      return nil unless funding_references.present?
+
+      Array.wrap(funding_references).map do |fr|
+        {
+          "@id" => fr["funder_identifier"],
+          "@type" => "Organization",
+          "name" => fr["funder_name"] }.compact
+      end.unwrap
+    end
+
+    def to_schema_org_spatial_coverage(geo_location)
+      return nil unless geo_location.present?
+
+      Array.wrap(geo_location).map do |gl|
+        if gl.fetch("geo_location_point", nil)
+          { 
+            "@type" => "Place",
+            "geo" => {
+              "@type" => "GeoCoordinates",
+              "address" => gl["geo_location_place"],
+              "latitude" => gl.dig("geo_location_point", "point_latitude"),
+              "longitude" => gl.dig("geo_location_point", "point_longitude")
+            }.compact
+          }
+        elsif gl.fetch("geo_location_box", nil)
+          { 
+            "@type" => "Place",
+            "geo" => {
+              "@type" => "GeoShape",
+              "address" => gl["geo_location_place"],
+              "box" => [gl.dig("geo_location_box", "south_bound_latitude"),
+                        gl.dig("geo_location_box", "west_bound_longitude"),
+                        gl.dig("geo_location_box", "north_bound_latitude"),
+                        gl.dig("geo_location_box", "east_bound_longitude")].join(" ")
+            }.compact
+          }
+        end
+      end.compact.unwrap
+    end
+
     def from_schema_org(element)
       mapping = { "@type" => "type", "@id" => "id" }
 
@@ -576,6 +642,13 @@ module Bolognese
       end.unwrap
     end
 
+    def to_identifier(identifier)
+      {
+        "@type" => "PropertyValue",
+        "propertyID" => identifier["related_identifier_type"],
+        "value" => identifier["id"] }
+    end
+
     def from_citeproc(element)
       Array.wrap(element).map do |a|
         if a["literal"].present?

data/lib/bolognese/version.rb

@@ -1,3 +1,3 @@
 module Bolognese
-  VERSION = "0.15.9"
+  VERSION = "1.0"
 end

data/lib/bolognese/writers/bibtex_writer.rb

@@ -11,11 +11,11 @@ module Bolognese
           bibtex_key: identifier,
           doi: doi,
           url: b_url,
-          author: authors_as_string(author),
+          author: authors_as_string(creator),
           keywords: keywords.present? ? Array.wrap(keywords).map { |k| parse_attributes(k, content: "text", first: true) }.join(", ") : nil,
           language: language,
           title: parse_attributes(title, content: "text", first: true),
-          journal: container_title,
+          journal: periodical && periodical["title"],
           volume: volume,
           issue: issue,
           pages: [first_page, last_page].compact.join("-").presence,

data/lib/bolognese/writers/codemeta_writer.rb

@@ -13,11 +13,10 @@ module Bolognese
           "identifier" => identifier,
           "codeRepository" => b_url,
           "title" => title,
-          "agents" => author,
+          "agents" => creator,
           "description" => parse_attributes(description, content: "text", first: true),
           "version" => b_version,
           "tags" => keywords.to_s.split(", ").presence,
-          "dateCreated" => date_created,
           "datePublished" => date_published,
           "dateModified" => date_modified,
           "publisher" => publisher

data/lib/bolognese/writers/crosscite_writer.rb

@@ -15,48 +15,29 @@ module Bolognese
           "ris_type" => ris_type,
           "resource_type_general" => resource_type_general,
           "resource_type" => additional_type,
-          "author" => author,
+          "creator" => creator,
           "title" => title,
           "publisher" => publisher,
-          "container_title" => container_title,
+          "container_title" => periodical && periodical["title"],
           "keywords" => keywords,
           "contributor" => contributor,
-          "date_accepted" => date_accepted,
-          "date_available" => date_available,
-          "date_copyrighted" => date_copyrighted,
-          "date_collected" => date_collected,
-          "date_created" => date_created,
+          "dates" => dates,
           "date_published" => date_published,
           "date_modified" => date_modified,
-          "date_submitted" => date_submitted,
-          "date_registered" => date_registered,
-          "date_updated" => date_updated,
-          "date_valid" => date_valid,
           "language" => language,
-          "alternate_identifier" => alternate_identifier,
-          "content_size" => content_size,
+          "alternate_identifiers" => alternate_identifiers,
+          "size" => size,
+          "format" => b_format,
           "version" => b_version,
-          "license" => license,
+          "rights" => rights,
           "description" => description,
           "volume" => volume,
           "issue" => issue,
           "first_page" => first_page,
           "last_page" => last_page,
-          "spatial_coverage" => spatial_coverage,
-          "funding" => funding,
-          "is_identical_to" => is_identical_to,
-          "is_part_of" => is_part_of,
-          "has_part" => has_part,
-          "is_previous_version_of" => is_previous_version_of,
-          "is_new_version_of" => is_new_version_of,
-          "is_variant_form_of" => is_variant_form_of,
-          "is_original_form_of" => is_original_form_of,
-          "references" => references,
-          "is_referenced_by" => is_referenced_by,
-          "is_supplement_to" => is_supplement_to,
-          "is_supplemented_by" => is_supplemented_by,
-          "reviews" => reviews,
-          "is_reviewed_by" => is_reviewed_by,
+          "geo_location" => geo_location,
+          "funding_references" => funding_references,
+          "related_identifiers" => related_identifiers,
           "schema_version" => schema_version,
           "provider_id" => provider_id,
           "client_id" => client_id,