bolognese 1.3.1 → 2.3.9

data/lib/bolognese/readers/datacite_reader.rb

@@ -7,7 +7,7 @@ module Bolognese
         return { "string" => nil, "state" => "not_found" } unless id.present?
 
         api_url = doi_api_url(id, options)
-        response = Maremma.get api_url
+        response = Maremma.get(api_url)
         attributes = response.body.dig("data", "attributes")
         return { "string" => nil, "state" => "not_found" } unless attributes.present?
 
@@ -74,14 +74,12 @@ module Bolognese
           id = normalize_doi(meta.dig("identifier", "__content__") || options[:id], sandbox: options[:sandbox])
         end
 
-        identifiers = [{ "identifierType" => "DOI", "identifier" => id }] + Array.wrap(meta.dig("alternateIdentifiers", "alternateIdentifier")).map do |r|
+        identifiers = Array.wrap(meta.dig("alternateIdentifiers", "alternateIdentifier")).map do |r|
           if r["__content__"].present?
             { "identifierType" => get_identifier_type(r["alternateIdentifierType"]), "identifier" => r["__content__"] }
           end
         end.compact
 
-        doi = Array.wrap(identifiers).find { |r| r["identifierType"] == "DOI" }.to_h.fetch("identifier", nil)
-
         resource_type_general = meta.dig("resourceType", "resourceTypeGeneral")
         resource_type = meta.dig("resourceType", "__content__")
         schema_org = 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"
@@ -93,75 +91,115 @@ module Bolognese
           "bibtex" => Bolognese::Utils::CR_TO_BIB_TRANSLATIONS[resource_type.to_s.underscore.camelcase] || Bolognese::Utils::SO_TO_BIB_TRANSLATIONS[schema_org] || "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
-        
-        titles = Array.wrap(meta.dig("titles", "title")).map do |r|
+
+        titles = get_titles(meta)
+
+        publisher = Array.wrap(meta.dig("publisher")).map do |r|
           if r.blank?
             nil
           elsif r.is_a?(String)
-            { "title" => sanitize(r) }
-          else
-            { "title" => sanitize(r["__content__"]), "titleType" => r["titleType"], "lang" => r["lang"] }.compact
+            { "name" => r.strip }
+          elsif r.is_a?(Hash)
+            {
+              "name" => r["__content__"].present? ? r["__content__"].strip : nil,
+              "publisherIdentifier" => r["publisherIdentifierScheme"] == "ROR" ? normalize_ror(r["publisherIdentifier"]) : r["publisherIdentifier"],
+              "publisherIdentifierScheme" => r["publisherIdentifierScheme"],
+              "schemeUri" => r["schemeURI"],
+              "lang" => r["lang"],
+            }.compact
           end
-        end.compact
+        end.compact.first
 
         descriptions = Array.wrap(meta.dig("descriptions", "description")).map do |r|
           if r.blank?
             nil
           elsif r.is_a?(String)
-            { "description" => sanitize(r), "descriptionType" => "Abstract" }
+            { "description" => sanitize(r, new_line: true), "descriptionType" => "Abstract" }
           elsif r.is_a?(Hash)
-            { "description" => sanitize(r["__content__"]), "descriptionType" => r["descriptionType"], "lang" => r["lang"] }.compact
+            { "description" => sanitize(r["__content__"], new_line: true), "descriptionType" => r["descriptionType"], "lang" => r["lang"] }.compact
           end
         end.compact
         rights_list = Array.wrap(meta.dig("rightsList", "rights")).map do |r|
           if r.blank?
             nil
           elsif r.is_a?(String)
-            { "rights" => r }
+            name_to_spdx(r)
           elsif r.is_a?(Hash)
-            { "rights" => r["__content__"], "rightsUri" => normalize_url(r["rightsURI"]), "lang" => r["lang"] }.compact
+            hsh_to_spdx(r)
+          end
+        end.compact
+
+        subjects = Array.wrap(meta.dig("subjects", "subject")).reduce([]) do |sum, subject|
+          if subject.is_a?(String)
+            sum += name_to_fos(subject)
+          elsif subject.is_a?(Hash)
+            sum += hsh_to_fos(subject)
+          end
+
+          sum
+        end.uniq
+
+        dates = Array.wrap(meta.dig("dates", "date")).map do |r|
+          if r.is_a?(Hash) && date = sanitize(r["__content__"]).presence
+            if Date.edtf(date).present? || Bolognese::Utils::UNKNOWN_INFORMATION.key?(date)
+              { "date" => date,
+                "dateType" => parse_attributes(r, content: "dateType"),
+                "dateInformation" => parse_attributes(r, content: "dateInformation")
+              }.compact
+            end
           end
         end.compact
-        subjects = Array.wrap(meta.dig("subjects", "subject")).map do |k|
+        dates << { "date" => meta.fetch("publicationYear", nil), "dateType" => "Issued" } if meta.fetch("publicationYear", nil).present? && get_date(dates, "Issued").blank?
+        sizes = Array.wrap(meta.dig("sizes", "size")).map do |k|
           if k.blank?
             nil
           elsif k.is_a?(String)
-            { "subject" => sanitize(k) }
-          else
-            { "subject" => sanitize(k["__content__"]), "subjectScheme" => k["subjectScheme"], "schemeUri" => k["schemeURI"], "valueUri" => k["valueURI"], "lang" => k["lang"] }.compact
+            sanitize(k).presence
+          elsif k.is_a?(Hash)
+            sanitize(k["__content__"]).presence
           end
         end.compact
-        dates = Array.wrap(meta.dig("dates", "date")).map do |d|
-          {
-            "date" => parse_attributes(d),
-            "dateType" => parse_attributes(d, content: "dateType"),
-            "dateInformation" => parse_attributes(d, content: "dateInformation")
-          }.compact
+        formats = Array.wrap(meta.dig("formats", "format")).map do |k|
+          if k.blank?
+            nil
+          elsif k.is_a?(String)
+            sanitize(k).presence
+          elsif k.is_a?(Hash)
+            sanitize(k["__content__"]).presence
+          end
         end.compact
-        dates << { "date" => meta.fetch("publicationYear", nil), "dateType" => "Issued" } if meta.fetch("publicationYear", nil).present? && get_date(dates, "Issued").blank?
-        sizes = Array.wrap(meta.dig("sizes", "size"))
-        formats = Array.wrap(meta.dig("formats", "format"))
+        .map { |s| s.to_s.squish.presence }.compact
         funding_references = Array.wrap(meta.dig("fundingReferences", "fundingReference")).compact.map do |fr|
           scheme_uri = parse_attributes(fr["funderIdentifier"], content: "schemeURI")
           funder_identifier = parse_attributes(fr["funderIdentifier"])
-          funder_identifier = !funder_identifier.to_s.start_with?("https://") && scheme_uri.present? ? normalize_id(scheme_uri + funder_identifier) : normalize_id(funder_identifier)
-          
+          funder_identifier_type = parse_attributes(fr["funderIdentifier"], content: "funderIdentifierType")
+
+          if funder_identifier_type == "Crossref Funder ID"
+            funder_identifier = validate_funder_doi(funder_identifier)
+          elsif funder_identifier_type == "ROR"
+            funder_identifier =  normalize_ror(funder_identifier)
+            scheme_uri = "https://ror.org"
+          else
+            funder_identifier = normalize_id(funder_identifier) ? normalize_id(funder_identifier) : funder_identifier
+          end
+
           {
             "funderName" => fr["funderName"],
             "funderIdentifier" => funder_identifier,
-            "funderIdentifierType" => parse_attributes(fr["funderIdentifier"], content: "funderIdentifierType"),
+            "funderIdentifierType" => funder_identifier_type,
+            "schemeUri" => scheme_uri,
             "awardNumber" => parse_attributes(fr["awardNumber"]),
             "awardUri" => parse_attributes(fr["awardNumber"], content: "awardURI"),
             "awardTitle" => fr["awardTitle"] }.compact
         end
         related_identifiers = Array.wrap(meta.dig("relatedIdentifiers", "relatedIdentifier")).map do |ri|
           if ri["relatedIdentifierType"] == "DOI"
-            rid = ri["__content__"].to_s.downcase
+            rid = validate_doi(ri["__content__"].to_s.downcase)
           else
             rid = ri["__content__"]
           end
 
-          { 
+          {
             "relatedIdentifier" => rid,
             "relatedIdentifierType" => ri["relatedIdentifierType"],
             "relationType" => ri["relationType"],
@@ -171,10 +209,68 @@ module Bolognese
             "schemeType" => ri["schemeType"]
           }.compact
         end
+
+        related_items = Array.wrap(meta.dig("relatedItems", "relatedItem")).map do |ri|
+
+          rii = ri["relatedItemIdentifier"]
+          relatedItemIdentifier = nil
+          if rii
+            if rii["relatedItemIdentifierType"] == "DOI"
+              rid = validate_doi(rii["__content__"].to_s.downcase)
+            else
+              rid = rii["__content__"]
+            end
+
+            relatedItemIdentifier = {
+              "relatedItemIdentifier" => rid,
+              "relatedItemIdentifierType" => rii["relatedItemIdentifierType"],
+              "relatedMetadataScheme" => rii["relatedMetadataScheme"],
+              "schemeURI" => rii["schemeURI"],
+              "schemeType" => rii["schemeType"]
+            }.compact
+          end
+
+          number = ri["number"]
+          if number.is_a?(String)
+            number = number
+            numberType = nil
+          else
+            number = ri.dig("number", "__content__")
+            numberType = ri.dig("number", "numberType")
+          end
+
+          a = {
+            "relationType" => ri["relationType"],
+            "relatedItemType" => ri["relatedItemType"],
+            "relatedItemIdentifier" => relatedItemIdentifier,
+            "creators" => get_authors(Array.wrap(ri.dig("creators", "creator"))),
+            "titles" => get_titles(ri),
+            "publicationYear" => ri["publicationYear"],
+            "volume" => parse_attributes(ri["volume"]),
+            "issue" => parse_attributes(ri["issue"]),
+            "number" => number,
+            "numberType" => numberType,
+            "firstPage" => parse_attributes(ri["firstPage"]),
+            "lastPage" => parse_attributes(ri["lastPage"]),
+            "publisher" => parse_attributes(ri["publisher"]),
+            "edition" => parse_attributes(ri["edition"]),
+            "contributors" => get_authors(Array.wrap(ri.dig("contributors", "contributor"))),
+          }.compact
+        end
+
         geo_locations = Array.wrap(meta.dig("geoLocations", "geoLocation")).map do |gl|
           if !gl.is_a?(Hash) || gl["geoLocationPoint"].is_a?(String) || gl["geoLocationBox"].is_a?(String) || gl["geoLocationPolygon"].is_a?(String)
             nil
           else
+            ## Array of geoLocationPolygons within a geoLocation is Unsupported in JSON.
+            if gl.dig("geoLocationPolygon").kind_of?(Array)
+              geoLocationPolygon = nil
+            else
+              geoLocationPolygon = Array.wrap(gl.dig("geoLocationPolygon", "polygonPoint")).map { |glp| { "polygonPoint" => glp } }
+                .push(Array.wrap(gl.dig("geoLocationPolygon", "inPolygonPoint")).map { |glp| { "inPolygonPoint" => glp } }.first)
+                .compact.presence             
+            end
+
             {
               "geoLocationPoint" => {
                 "pointLatitude" => gl.dig("geoLocationPoint", "pointLatitude"),
@@ -186,35 +282,36 @@ module Bolognese
                 "southBoundLatitude" => gl.dig("geoLocationBox", "southBoundLatitude"),
                 "northBoundLatitude" => gl.dig("geoLocationBox", "northBoundLatitude")
               }.compact.presence,
-              "geoLocationPolygon" => Array.wrap(gl.dig("geoLocationPolygon", "polygonPoint")).map { |glp| { "polygonPoint" => glp } }.compact.presence,
+              "geoLocationPolygon" => geoLocationPolygon,
               "geoLocationPlace" => parse_attributes(gl["geoLocationPlace"], first: true).to_s.strip.presence
             }.compact
           end
         end.compact
 
-        state = doi.present? || read_options.present? ? "findable" : "not_found"
+        state = id.present? || read_options.present? ? "findable" : "not_found"
 
         { "id" => id,
           "types" => types,
-          "doi" => doi_from_url(doi),
+          "doi" => doi_from_url(id),
           "identifiers" => identifiers,
           "url" => options.fetch(:url, nil).to_s.strip.presence,
           "titles" => titles,
           "creators" => get_authors(Array.wrap(meta.dig("creators", "creator"))),
           "contributors" => get_authors(Array.wrap(meta.dig("contributors", "contributor"))),
           "container" => set_container(meta),
-          "publisher" => parse_attributes(meta.fetch("publisher", nil), first: true).to_s.strip.presence,
-          "agency" => "DataCite",
+          "publisher" => publisher,
+          "agency" => "datacite",
           "funding_references" => funding_references,
           "dates" => dates,
           "publication_year" => parse_attributes(meta.fetch("publicationYear", nil), first: true).to_s.strip.presence,
           "descriptions" => descriptions,
-          "rights_list" => rights_list,
+          "rights_list" => Array.wrap(rights_list),
           "version_info" => meta.fetch("version", nil).to_s.presence,
           "subjects" => subjects,
           "language" => parse_attributes(meta.fetch("language", nil), first: true).to_s.strip.presence,
           "geo_locations" => geo_locations,
           "related_identifiers" => related_identifiers,
+          "related_items" => related_items,
           "formats" => formats,
           "sizes" => sizes,
           "schema_version" => schema_version,
@@ -243,6 +340,21 @@ module Bolognese
           {}
         end
       end
+
+      def get_titles(meta)
+        titles = Array.wrap(meta.dig("titles", "title")).map do |r|
+          if r.blank?
+            nil
+          elsif r.is_a?(String)
+            { "title" => sanitize(r) }
+          else
+            { "title" => sanitize(r["__content__"]), "titleType" => r["titleType"], "lang" => r["lang"] }.compact
+          end
+        end.compact
+
+        titles
+      end
+
     end
   end
 end

data/lib/bolognese/readers/npm_reader.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Readers
+    module NpmReader
+      def get_npm(id: nil, **options)
+        return { "string" => nil, "state" => "not_found" } unless id.present?
+        id = normalize_id(id)
+        response = Maremma.get(id, accept: "json", raw: true)
+        string = response.body.fetch("data", nil)
+
+        { "string" => string }
+      end
+
+      def read_npm(string: nil, **options)
+        if string.present?
+          errors = jsonlint(string)
+          return { "errors" => errors } if errors.present?
+        end
+
+        read_options = ActiveSupport::HashWithIndifferentAccess.new(options.except(:doi, :id, :url, :sandbox, :validate, :ra))
+
+        meta = string.present? ? Maremma.from_json(string) : {}
+
+        types = {
+          "resourceTypeGeneral" => "Software",
+          "reourceType" => "NPM Package",
+          "schemaOrg" => "SoftwareSourceCode",
+          "citeproc" => "article",
+          "bibtex" => "misc",
+          "ris" => "GEN"
+        }.compact
+
+        creators = if meta.fetch("author", nil).present?
+          get_authors(Array.wrap(meta.fetch("author", nil)))
+        else
+          [{ "nameType" => "Organizational", "name" => ":(unav)" }]
+        end
+        # contributors = get_authors(from_citeproc(Array.wrap(meta.fetch("editor", nil))))
+        # dates = if date = get_date_from_date_parts(meta.fetch("issued", nil))
+        #           if Date.edtf(date).present?
+        #             [{ "date" => date,
+        #               "dateType" => "Issued" }]
+        #           end
+        #         end
+        # publication_year = get_date_from_date_parts(meta.fetch("issued", nil)).to_s[0..3]
+        rights_list = if meta.fetch("license", nil)
+                        [{ "rights" => meta.fetch("license") }.compact]
+                      end
+        # related_identifiers = if meta.fetch("container-title", nil).present? && meta.fetch("ISSN", nil).present?
+        #                         [{ "type" => "Periodical",
+        #                           "relationType" => "IsPartOf",
+        #                           "relatedIdentifierType" => "ISSN",
+        #                           "title" => meta.fetch("container-title", nil),
+        #                           "relatedIdentifier" => meta.fetch("ISSN", nil) }.compact]
+        #                       end
+        # container = if meta.fetch("container-title", nil).present?
+        #   first_page = meta.fetch("page", nil).present? ? meta.fetch("page").split("-").map(&:strip)[0] : nil
+        #   last_page = meta.fetch("page", nil).present? ? meta.fetch("page").split("-").map(&:strip)[1] : nil
+
+        #   { "type" => "Periodical",
+        #     "title" => meta.fetch("container-title", nil),
+        #     "identifier" => meta.fetch("ISSN", nil),
+        #     "identifierType" => meta.fetch("ISSN", nil).present? ? "ISSN" : nil,
+        #     "volume" => meta.fetch("volume", nil),
+        #     "issue" => meta.fetch("issue", nil),
+        #     "firstPage" => first_page,
+        #     "lastPage" => last_page
+        #    }.compact
+        # else
+        #   nil
+        # end
+
+        # identifiers = [normalize_id(meta.fetch("id", nil)), normalize_doi(meta.fetch("DOI", nil))].compact.map do |r|
+        #   r = normalize_id(r)
+
+        #   if r.start_with?("https://doi.org")
+        #     { "identifierType" => "DOI", "identifier" => r }
+        #   else
+        #       { "identifierType" => "URL", "identifier" => r }
+        #   end
+        # end.uniq
+
+        # id = Array.wrap(identifiers).first.to_h.fetch("identifier", nil)
+        # doi = Array.wrap(identifiers).find { |r| r["identifierType"] == "DOI" }.to_h.fetch("identifier", nil)
+          
+        # state = id.present? || read_options.present? ? "findable" : "not_found"
+        subjects = Array.wrap(meta.fetch("keywords", nil)).map do |s|
+          { "subject" => s }
+        end
+
+        { 
+          #"id" => id,
+          #"identifiers" => identifiers,
+          "types" => types,
+          #"doi" => doi_from_url(doi),
+          #"url" => normalize_id(meta.fetch("URL", nil)),
+          "titles" => [{ "title" => meta.fetch("name", nil) }],
+          "creators" => creators,
+          #"contributors" => contributors,
+          #"container" => container,
+          #"publisher" => meta.fetch("publisher", nil),
+          #"related_identifiers" => related_identifiers,
+          #"dates" => dates,
+          #"publication_year" => publication_year,
+          "descriptions" => meta.fetch("description", nil).present? ? [{ "description" => sanitize(meta.fetch("description"), new_line: true), "descriptionType" => "Abstract" }] : [],
+          "rights_list" => rights_list,
+          "version_info" => meta.fetch("version", nil),
+          "subjects" => subjects
+          #"state" => state
+        }.merge(read_options)
+      end
+    end
+  end
+end

data/lib/bolognese/readers/ris_reader.rb

@@ -41,18 +41,13 @@ module Bolognese
         ris_type = meta.fetch("TY", nil) || "GEN"
         schema_org = RIS_TO_SO_TRANSLATIONS[ris_type] || "CreativeWork"
         types = {
-          "resourceTypeGeneral" => Metadata::SO_TO_DC_TRANSLATIONS[schema_org],
+          "resourceTypeGeneral" => Metadata::RIS_TO_DC_TRANSLATIONS[ris_type],
           "schemaOrg" => schema_org,
           "citeproc" => RIS_TO_CP_TRANSLATIONS[schema_org] || "misc",
           "ris" => ris_type
         }.compact
 
-        identifiers = [normalize_doi(options[:doi]) || normalize_doi(meta.fetch("DO", nil))].map do |r|
-          { "identifierType" => "DOI", "identifier" => normalize_id(r) }
-        end.compact
-
-        id = Array.wrap(identifiers).first.to_h.fetch("identifier", nil)
-        doi = Array.wrap(identifiers).find { |r| r["identifierType"] == "DOI" }.to_h.fetch("identifier", nil)
+        id = normalize_doi(options[:doi] || meta.fetch("DO", nil))
 
         author = Array.wrap(meta.fetch("AU", nil)).map { |a| { "creatorName" => a } }
         date_parts = meta.fetch("PY", nil).to_s.split("/")
@@ -72,7 +67,7 @@ module Bolognese
         end
         container = if meta.fetch("T2", nil).present?
           { "type" => "Journal",
-            "title" => meta.fetch("T2", nil), 
+            "title" => meta.fetch("T2", nil),
             "identifier" => meta.fetch("SN", nil),
             "volume" => meta.fetch("VL", nil),
             "issue" => meta.fetch("IS", nil),
@@ -82,23 +77,24 @@ module Bolognese
           nil
         end
         state = meta.fetch("DO", nil).present? || read_options.present? ? "findable" : "not_found"
-        subjects = Array.wrap(meta.fetch("KW", nil)).map do |s|
-          { "subject" => s }
+        subjects = Array.wrap(meta.fetch("KW", nil)).reduce([]) do |sum, subject|
+          sum += name_to_fos(subject)
+
+          sum
         end
 
         { "id" => id,
           "types" => types,
-          "identifiers" => identifiers,
-          "doi" => doi_from_url(doi),
+          "doi" => doi_from_url(id),
           "url" => meta.fetch("UR", nil),
           "titles" => meta.fetch("T1", nil).present? ? [{ "title" => meta.fetch("T1", nil) }] : nil,
           "creators" => get_authors(author),
-          "publisher" => meta.fetch("PB", "(:unav)"),
+          "publisher" => { "name" => meta.fetch("PB", "(:unav)") },
           "container" => container,
           "related_identifiers" => related_identifiers,
           "dates" => dates,
           "publication_year" => publication_year,
-          "descriptions" => meta.fetch("AB", nil).present? ? [{ "description" => sanitize(meta.fetch("AB")), "descriptionType" => "Abstract" }] : nil,
+          "descriptions" => meta.fetch("AB", nil).present? ? [{ "description" => sanitize(meta.fetch("AB"), new_line: true), "descriptionType" => "Abstract" }] : nil,
           "subjects" => subjects,
           "language" => meta.fetch("LA", nil),
           "state" => state

data/lib/bolognese/readers/schema_org_reader.rb

@@ -10,7 +10,9 @@ module Bolognese
         "isPartOf" => "IsPartOf",
         "hasPart" => "HasPart",
         "isPredecessor" => "IsPreviousVersionOf",
-        "isSuccessor" => "IsNewVersionOf"
+        "isSuccessor" => "IsNewVersionOf",
+        "workTranslation" => "HasTranslation",
+        "translationOfWork" => "IsTranslationOf"
       }
 
       SO_TO_DC_REVERSE_RELATION_TYPES = {
@@ -26,13 +28,12 @@ module Bolognese
       def get_schema_org(id: nil, **options)
         return { "string" => nil, "state" => "not_found" } unless id.present?
 
-        id = normalize_id(id)
-        response = Maremma.get(id)
-        doc = Nokogiri::XML(response.body.fetch("data", nil), nil, 'UTF-8')
+        url = normalize_id(id)
+        response = Maremma.get(url)
 
-        # workaround for xhtml documents
-        nodeset = doc.css("script")
-        string = nodeset.find { |element| element["type"] == "application/ld+json" }
+        # Find the schema.org json from the html body
+        doc = Nokogiri::HTML(response.body.fetch("data", nil))
+        string = doc.at('script[type="application/ld+json"]')
         string = string.text if string.present?
 
         { "string" => string }
@@ -48,18 +49,16 @@ module Bolognese
 
         meta = string.present? ? Maremma.from_json(string) : {}
 
-        identifiers = ([options[:doi] || meta.fetch("@id", nil)] + Array.wrap(meta.fetch("identifier", nil))).map do |r|
+        identifiers = Array.wrap(meta.fetch("identifier", nil)).map do |r|
           r = normalize_id(r) if r.is_a?(String)
-          if r.is_a?(String) && r.start_with?("https://doi.org")
-            { "identifierType" => "DOI", "identifier" => r }
-          elsif r.is_a?(String)
+          if r.is_a?(String) && !r.start_with?("https://doi.org")
               { "identifierType" => "URL", "identifier" => r }
           elsif r.is_a?(Hash)
             { "identifierType" => get_identifier_type(r["propertyID"]), "identifier" => r["value"] }
           end
         end.compact.uniq
 
-        id = Array.wrap(identifiers).first.to_h.fetch("identifier", nil)
+        id = normalize_id(options[:doi] || meta.fetch("@id", nil) || meta.fetch("identifier", nil))
 
         schema_org = meta.fetch("@type", nil) && meta.fetch("@type").camelcase
         resource_type_general = Bolognese::Utils::SO_TO_DC_TRANSLATIONS[schema_org]
@@ -77,7 +76,17 @@ module Bolognese
           creators = get_authors(from_schema_org_creators(Array.wrap(authors)))
         end
         contributors = get_authors(from_schema_org_contributors(Array.wrap(meta.fetch("editor", nil))))
-        publisher = parse_attributes(meta.fetch("publisher", nil), content: "name", first: true)
+        translators = get_authors(from_schema_org_contributors(Array.wrap(meta.fetch("translator", nil))))
+        translators.map! do |translator|
+          translator["contributorType"] = "Translator"
+          translator
+        end
+        contributors += translators
+
+        publisher = {
+          "name" => parse_attributes(meta.fetch("publisher", nil), content: "name", first: true),
+          "publisherIdentifier" => parse_attributes(meta.fetch("publisher", nil), content: "@id", first: true),
+        }.compact if meta.fetch("publisher", nil).present?
 
         ct = (schema_org == "Dataset") ? "includedInDataCatalog" : "Periodical"
         container = if meta.fetch(ct, nil).present?
@@ -105,12 +114,13 @@ module Bolognese
           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))
+          Array.wrap(schema_org_is_supplemented_by(meta)) +
+          Array.wrap(schema_org_has_translation(meta)) +
+          Array.wrap(schema_org_is_translation_of(meta))
 
-        rights_list = {
-          "rightsUri" => parse_attributes(meta.fetch("license", nil), content: "id", first: true),
-          "rights" => parse_attributes(meta.fetch("license", nil), content: "name", first: true)
-        }
+        rights_list = Array.wrap(meta.fetch("license", nil)).compact.map do |rl|
+          hsh_to_spdx("__content__" => rl["name"], "rightsURI" => rl["id"])
+        end
 
         funding_references = Array.wrap(meta.fetch("funder", nil)).compact.map do |fr|
           if fr["@id"].present?
@@ -124,11 +134,20 @@ module Bolognese
           end
         end
         dates = []
-        dates << { "date" => meta.fetch("datePublished"), "dateType" => "Issued" } if meta.fetch("datePublished", nil).present?
-        dates << { "date" => meta.fetch("dateCreated"), "dateType" => "Created" } if meta.fetch("dateCreated", nil).present?
-        dates << { "date" => meta.fetch("dateModified"), "dateType" => "Updated" } if meta.fetch("dateModified", nil).present?
+        dates << { "date" => meta.fetch("datePublished"), "dateType" => "Issued" } if Date.edtf(meta.fetch("datePublished", nil)).present?
+        dates << { "date" => meta.fetch("dateCreated"), "dateType" => "Created" } if Date.edtf(meta.fetch("dateCreated", nil)).present?
+        dates << { "date" => meta.fetch("dateModified"), "dateType" => "Updated" } if Date.edtf(meta.fetch("dateModified", nil)).present?
+        dates << { "date" => meta.fetch("temporalCoverage"), "dateType" => "Coverage" } if Date.edtf(meta.fetch("temporalCoverage", nil)).present?
         publication_year = meta.fetch("datePublished")[0..3] if meta.fetch("datePublished", nil).present?
 
+        if meta.fetch("inLanguage", nil).is_a?(String)
+          language = meta.fetch("inLanguage")
+        elsif meta.fetch("inLanguage", nil).is_a?(Object)
+          language = meta.dig("inLanguage", 'alternateName') || meta.dig("inLanguage", 'name')
+        else
+          language = nil
+        end
+
         state = meta.present? || read_options.present? ? "findable" : "not_found"
         geo_locations = Array.wrap(meta.fetch("spatialCoverage", nil)).map do |gl|
           if gl.dig("geo", "box")
@@ -137,7 +156,7 @@ module Bolognese
               "westBoundLongitude" => w,
               "eastBoundLongitude" => e,
               "southBoundLatitude" => s,
-              "northBoundLatitude" => n
+              "northBoundLatitude" => n,
             }.compact.presence
           else
             geo_location_box = nil
@@ -150,8 +169,13 @@ module Bolognese
             "geoLocationBox" => geo_location_box
           }.compact
         end
-        subjects = Array.wrap(meta.fetch("keywords", nil).to_s.split(", ")).map do |s|
-          { "subject" => s }
+
+        # handle keywords as array and as comma-separated string
+        subjects = meta.fetch("keywords", nil)
+        subjects = subjects.to_s.split(", ") if subjects.is_a?(String)
+        subjects = Array.wrap(subjects).reduce([]) do |sum, subject|
+          sum += name_to_fos(subject)
+          sum
         end
 
         { "id" => id,
@@ -171,10 +195,11 @@ module Bolognese
           "related_identifiers" => related_identifiers,
           "publication_year" => publication_year,
           "dates" => dates,
-          "descriptions" => meta.fetch("description", nil).present? ? [{ "description" => sanitize(meta.fetch("description")), "descriptionType" => "Abstract" }] : nil,
+          "descriptions" => meta.fetch("description", nil).present? ? [{ "description" => sanitize(meta.fetch("description"), new_line: true), "descriptionType" => "Abstract" }] : nil,
           "rights_list" => rights_list,
           "version_info" => meta.fetch("version", nil).to_s.presence,
           "subjects" => subjects,
+          "language" => language,
           "state" => state,
           "schema_version" => meta.fetch("schemaVersion", nil).to_s.presence,
           "funding_references" => funding_references,
@@ -226,6 +251,14 @@ module Bolognese
         schema_org_related_identifier(meta, relation_type: "isBasedOn")
       end
 
+      def schema_org_has_translation(meta)
+        schema_org_related_identifier(meta, relation_type: "workTranslation", )
+      end
+
+      def schema_org_is_translation_of(meta)
+        schema_org_related_identifier(meta, relation_type: "translationOfWork")
+      end
+
     end
   end
 end