bolognese 2.2.0 → 2.7.0

data/lib/bolognese/citeproc_extensions.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Minimal patch for csl-ruby and citeproc-ruby compatibility
+# Root cause: 'contributor' is not recognized as a names variable in citeproc gem
+# https://github.com/inukshuk/citeproc/blob/121fa4a950b9bd71960e42d20db96bcea1165201/lib/citeproc/variable.rb#L20-L24
+
+module CiteProc
+  class Variable
+    # Unfreeze, modify, and refreeze the fields to add 'contributor' and 'accepted-date'
+    if @fields
+      # Unfreeze the fields hash temporarily
+      fields_dup = @fields.dup
+      
+      # Add contributor to names (make a new unfrozen array)
+      fields_dup[:names] = (@fields[:names] + [:contributor]).uniq
+      
+      # Add accepted-date to dates (make a new unfrozen array)
+      fields_dup[:date] = (@fields[:date] + [:'accepted-date']).uniq
+      
+      # Rebuild the types mapping - only use actual type keys, not aliases like :all, :any, etc.
+      types_hash = Hash[*[:date, :names, :number, :text].map { |k| fields_dup[k].map { |n| [n, k] } }.flatten]
+      
+      # Update the class instance variables
+      @fields = fields_dup
+      @types = Hash.new { |h,k| h.fetch(k.to_sym, nil) }.merge(types_hash).freeze
+      
+      # Rebuild @factories from the new @types
+      # This maps each field name to its Variable subclass (Names, Date, Text, Number)
+      @factories = Hash.new { |h,k| h.fetch(k.to_s.intern, CiteProc::Variable) }.merge(
+        Hash[*@types.map { |field_name, type|
+          [field_name, CiteProc.const_get(type.to_s.capitalize)]
+        }.flatten]
+      ).freeze
+      
+      # Recreate the aliases
+      @fields[:name] = @fields[:names]
+      @fields[:dates] = @fields[:date]
+      @fields[:numbers] = @fields[:number]
+      
+      # Recreate :all and :any
+      @fields[:all] = @fields[:any] =
+        [:date, :names, :text, :number].reduce([]) { |s,a| s.concat(@fields[a]) }.sort
+      
+      # Refreeze fields
+      @fields.freeze
+    end
+  end
+end

data/lib/bolognese/datacite_utils.rb

@@ -69,7 +69,7 @@ module Bolognese
 
       xml.contributors do
         Array.wrap(contributors).each do |con|
-          xml.contributor("contributorType" => con["contributorType"] || "Other") do
+          xml.contributor("contributorType" => con["contributorType"]) do
             insert_person(xml, con, "contributor")
           end
         end
@@ -128,7 +128,7 @@ module Bolognese
     def insert_resource_type(xml)
       return xml unless types.is_a?(Hash) && (types["schemaOrg"].present? || types["resourceTypeGeneral"])
 
-      xml.resourceType(types["resourceType"] || types["schemaOrg"],
+      xml.resourceType(types["resourceType"],
         'resourceTypeGeneral' => types["resourceTypeGeneral"] || Metadata::SO_TO_DC_TRANSLATIONS[types["schemaOrg"]] || "Other")
     end
 
@@ -209,7 +209,9 @@ module Bolognese
           attributes = {
             'relatedIdentifierType' => related_identifier["relatedIdentifierType"],
             'relationType' => related_identifier["relationType"],
-            'resourceTypeGeneral' => related_identifier["resourceTypeGeneral"] }.compact
+            'relationTypeInformation' => related_identifier["relationTypeInformation"],
+            'resourceTypeGeneral' => related_identifier["resourceTypeGeneral",
+            ] }.compact
 
           attributes.merge({ 'relatedMetadataScheme' => related_identifier["relatedMetadataSchema"],
             'schemeURI' => related_identifier["schemeUri"],
@@ -228,6 +230,7 @@ module Bolognese
           attributes = {
             'relatedItemType' => related_item["relatedItemType"],
             'relationType' => related_item["relationType"],
+            'relationTypeInformation' => related_item["relationTypeInformation"],
           }.compact
 
           xml.relatedItem(related_item["relatedItem"], attributes) do
@@ -337,7 +340,7 @@ module Bolognese
       return xml unless descriptions.present? || container && container["title"].present?
 
       xml.descriptions do
-        if container && container["title"].present?
+        if (respond_to?(:from) && !from.to_s.include?("datacite")) && container && container["title"].present?
           issue = container["issue"].present? ? "(#{container["issue"]})" : nil
           volume_issue = container["volume"].present? ? [container["volume"], issue].join("") : nil
           pages = [container["firstPage"], container["lastPage"]].compact.join("-") if container["firstPage"].present?
@@ -387,9 +390,16 @@ module Bolognese
             if geo_location["geoLocationPolygon"]
               xml.geoLocationPolygon do
                 Array.wrap(geo_location["geoLocationPolygon"]).each do |polygon_point|
-                  xml.polygonPoint do
-                    xml.pointLatitude(polygon_point.dig("polygonPoint", "pointLatitude"))
-                    xml.pointLongitude(polygon_point.dig("polygonPoint", "pointLongitude"))
+                  if polygon_point.has_key?("polygonPoint")
+                    xml.polygonPoint do
+                      xml.pointLatitude(polygon_point.dig("polygonPoint", "pointLatitude"))
+                      xml.pointLongitude(polygon_point.dig("polygonPoint", "pointLongitude"))
+                    end
+                  else
+                    xml.inPolygonPoint do
+                      xml.pointLatitude(polygon_point.dig("inPolygonPoint", "pointLatitude"))
+                      xml.pointLongitude(polygon_point.dig("inPolygonPoint", "pointLongitude"))
+                    end
                   end
                 end
               end

data/lib/bolognese/doi_utils.rb

@@ -13,11 +13,12 @@ module Bolognese
     end
 
     def validate_funder_doi(doi)
-      doi = Array(/\A(?:(http|https):\/(\/)?(dx\.)?(doi.org|handle.stage.datacite.org|handle.test.datacite.org)\/)?(doi:)?(10\.13039\/)?([1-9]\d+)\z/.match(doi)).last
+      match = Array(/\A(?:(http|https):\/(\/)?(dx\.)?(doi.org|handle.stage.datacite.org|handle.test.datacite.org)\/)?(doi:)?(10\.13039\/)?([1-9]\d+)\z/.match(doi)).last
+      return doi unless match
 
       # remove non-printing whitespace and downcase
-      if doi.present?
-        doi.delete("\u200B").downcase
+      if match.present?
+        doi = match.delete("\u200B").downcase
         "https://doi.org/10.13039/#{doi}"
       end
     end

data/lib/bolognese/metadata.rb

@@ -1,10 +1,11 @@
-# frozen_string_literal: true
+# frozen_string_literal: false
 
 require_relative 'metadata_utils'
 
 module Bolognese
   class Metadata
     include Bolognese::MetadataUtils
+    include Bolognese::Utils
 
     attr_accessor :string, :from, :sandbox, :meta, :regenerate, :issue, :show_errors
     attr_reader :doc, :page_start, :page_end
@@ -75,8 +76,8 @@ module Bolognese
       end
 
       # make sure input is encoded as utf8
-      string = string.force_encoding("UTF-8") if string.present?
-      @string = string
+      string1 = string.dup.force_encoding("UTF-8") if string.present?
+      @string = string1
 
       # input options for citation formatting
       @style = options[:style]
@@ -119,7 +120,7 @@ module Bolognese
 
       @regenerate = options[:regenerate] || read_options.present?
       # generate name for method to call dynamically
-      opts = { string: string, sandbox: options[:sandbox], doi: options[:doi], id: id, ra: ra }.merge(read_options)
+      opts = { string: string1, sandbox: options[:sandbox], doi: options[:doi], id: id, ra: ra }.merge(read_options)
       @meta = @from.present? ? send("read_" + @from, **opts) : {}
     end
 
@@ -205,7 +206,9 @@ module Bolognese
     end
 
     def container
-      @container ||= meta.fetch("container", nil)
+      @container ||= begin
+        generate_container(types, related_items, related_identifiers, descriptions) || meta.fetch("container", nil)
+      end
     end
 
     def geo_locations

data/lib/bolognese/metadata_utils.rb

@@ -33,7 +33,6 @@ require_relative 'writers/turtle_writer'
 
 module Bolognese
   module MetadataUtils
-    # include BenchmarkMethods
     include Bolognese::DoiUtils
     include Bolognese::AuthorUtils
     include Bolognese::DataciteUtils
@@ -140,27 +139,43 @@ module Bolognese
         author = to_citeproc(creators)
       end
 
-      if types["resourceTypeGeneral"] == "Software" && version_info.present?
-        type = "book"
+      if types["resourceTypeGeneral"] == "Software"
+        type = "software"
       else
         type = types["citeproc"]
       end
 
+      # Filter out contributors who are already creators, editors, or translators to avoid duplication
+      creator_names = Array.wrap(creators).map { |c| c["name"] || [c["givenName"], c["familyName"]].compact.join(" ") }.compact
+      unique_contributors = Array.wrap(contributors).reject do |c|
+        contributor_name = c["name"] || [c["givenName"], c["familyName"]].compact.join(" ")
+        creator_names.include?(contributor_name) ||
+        c["contributorType"] == "Editor" ||
+        c["contributorType"] == "Translator"
+      end
+
       {
         "type" => type,
         "id" => normalize_doi(doi),
         "categories" => Array.wrap(subjects).map { |k| parse_attributes(k, content: "subject", first: true) }.presence,
         "language" => language,
         "author" => author,
-        "contributor" => to_citeproc(contributors),
+        "contributor" => unique_contributors.presence ? to_citeproc(unique_contributors) : nil,
+        "editor" => contributors ? to_citeproc(contributors.select { |c| c["contributorType"] == "Editor" }) : nil,
+        "translator" => contributors ? to_citeproc(contributors.select { |c| c["contributorType"] == "Translator" }) : nil,
         "issued" => get_date(dates, "Issued") ? get_date_parts(get_date(dates, "Issued")) : get_date_parts(publication_year.to_s),
         "submitted" => Array.wrap(dates).find { |d| d["dateType"] == "Submitted" }.to_h.fetch("__content__", nil),
+        "available-date" => Array.wrap(dates).find { |d| d["dateType"] == "Available" }.to_h.fetch("__content__", nil),
         "abstract" => parse_attributes(descriptions, content: "description", first: true),
         "container-title" => container_title,
         "DOI" => doi,
         "volume" => container.to_h["volume"],
         "issue" => container.to_h["issue"],
+        "number" => container.to_h["number"],
+        "chapter-number" => container.to_h["chapterNumber"],
+        "edition" => container.to_h["edition"],
         "page" => page,
+        "page-first" => container.to_h["firstPage"],
         "publisher" => publisher["name"],
         "title" => parse_attributes(titles, content: "title", first: true),
         "URL" => url,

data/lib/bolognese/readers/citeproc_reader.rb

@@ -52,6 +52,12 @@ module Bolognese
           [{ "nameType" => "Organizational", "name" => ":(unav)" }]
         end
         contributors = get_authors(from_citeproc(Array.wrap(meta.fetch("editor", nil))))
+        translators = get_authors(from_citeproc(Array.wrap(meta.fetch("translator", nil))))
+        translators.each do |translator|
+          translator["contributorType"] = "Translator"
+        end
+        contributors += translators
+
         dates = if date = get_date_from_date_parts(meta.fetch("issued", nil))
                   if Date.edtf(date).present?
                     [{ "date" => date,
@@ -90,7 +96,7 @@ module Bolognese
 
         state = id.present? || read_options.present? ? "findable" : "not_found"
         subjects = Array.wrap(meta.fetch("categories", nil)).reduce([]) do |sum, subject|
-          sum += name_to_fos(subject)
+          sum += name_to_subject(subject)
 
           sum
         end

data/lib/bolognese/readers/codemeta_reader.rb

@@ -55,7 +55,7 @@ module Bolognese
           "ris" => Bolognese::Utils::SO_TO_RIS_TRANSLATIONS[schema_org] || "GEN"
         }.compact
         subjects = Array.wrap(meta.fetch("tags", nil)).reduce([]) do |sum, subject|
-          sum += name_to_fos(subject)
+          sum += name_to_subject(subject)
 
           sum
         end

data/lib/bolognese/readers/crossref_reader.rb

@@ -4,6 +4,12 @@ module Bolognese
   module Readers
     module CrossrefReader
       # CrossRef types from https://api.crossref.org/types
+
+      CR_TO_DC_CONTRIBUTOR_TYPES = {
+        "editor" => "Editor",
+        "translator" => "Translator",
+      }
+
       def get_crossref(id: nil, **options)
         return { "string" => nil, "state" => "not_found" } unless id.present?
 
@@ -138,7 +144,7 @@ module Bolognese
 
         state = meta.present? || read_options.present? ? "findable" : "not_found"
 
-        related_identifiers = Array.wrap(crossref_is_part_of(journal_metadata)) + Array.wrap(crossref_references(bibliographic_metadata))
+        related_identifiers = Array.wrap(crossref_is_part_of(journal_metadata)) + Array.wrap(crossref_references(bibliographic_metadata)) + Array.wrap(crossref_has_translation(program_metadata)) + Array.wrap(crossref_is_translation_of(program_metadata)) + Array.wrap(crossref_is_related_material(program_metadata))
 
         container = if journal_metadata.present?
                       issn = normalize_issn(journal_metadata.to_h.fetch("issn", nil))
@@ -187,7 +193,7 @@ module Bolognese
           "titles" => titles,
           "identifiers" => identifiers,
           "creators" => crossref_people(bibliographic_metadata, "author"),
-          "contributors" => crossref_people(bibliographic_metadata, "editor"),
+          "contributors" => crossref_people(bibliographic_metadata, "editor") + crossref_people(bibliographic_metadata, "translator"),
           "funding_references" => crossref_funding_reference(program_metadata),
           "publisher" => publisher,
           "container" => container,
@@ -282,10 +288,11 @@ module Bolognese
               "givenName" => given_name,
               "familyName" => family_name,
               "affiliation" => affiliation.presence,
-              "contributorType" => contributor_role == "editor" ? "Editor" : nil }.compact
+              "contributorType" => contributor_role == 'author' ? nil : CR_TO_DC_CONTRIBUTOR_TYPES[a["contributor_role"]] }.compact
           else
             { "nameType" => "Organizational",
-              "name" => a["name"] || a["__content__"] }
+              "name" => a["name"] || a["__content__"],
+              "contributorType" => contributor_role == 'author' ? nil : CR_TO_DC_CONTRIBUTOR_TYPES[a["contributor_role"]] }.compact
           end
         end
       end
@@ -362,6 +369,45 @@ module Bolognese
           end
         end.compact.unwrap
       end
+    
+      def crossref_has_translation(program_metadata)
+        refs = program_metadata.dig("related_item") if program_metadata.is_a?(Hash)
+        Array.wrap(refs).select { |a| a.dig("intra_work_relation", "relationship_type") == "hasTranslation" }.map do |c|
+          if c.dig("intra_work_relation", "identifier_type") == "doi"
+            { "relatedIdentifier" => parse_attributes(c["intra_work_relation"]).downcase,
+              "relationType" => "HasTranslation",
+              "relatedIdentifierType" => "DOI" }.compact
+          else
+            nil
+          end
+        end.compact.unwrap
+      end
+
+      def crossref_is_translation_of(program_metadata)
+        refs = program_metadata.dig("related_item") if program_metadata.is_a?(Hash)
+        Array.wrap(refs).select { |a| a.dig("intra_work_relation", "relationship_type") == "isTranslationOf" }.map do |c|
+          if c.dig("intra_work_relation", "identifier_type") == "doi"
+            { "relatedIdentifier" => parse_attributes(c["intra_work_relation"]).downcase,
+              "relationType" => "IsTranslationOf",
+              "relatedIdentifierType" => "DOI" }.compact
+          else
+            nil
+          end
+        end.compact.unwrap
+      end
+
+      def crossref_is_related_material(program_metadata)
+        refs = program_metadata.dig("related_item") if program_metadata.is_a?(Hash)
+        Array.wrap(refs).select { |a| a.dig("interwork_relation", "relationship_type") == "isRelatedMaterial" }.map do |c|
+          if c.dig("inter_work_relation", "identifier_type") == "doi"
+            { "relatedIdentifier" => parse_attributes(c["inter_work_relation"]).downcase,
+              "relationType" => "Other",
+              "relatedIdentifierType" => "DOI" }.compact
+          else
+            nil
+          end
+        end.compact.unwrap
+      end
     end
   end
 end

data/lib/bolognese/readers/datacite_reader.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'base64'
+
 module Bolognese
   module Readers
     module DataciteReader
@@ -131,9 +133,9 @@ module Bolognese
 
         subjects = Array.wrap(meta.dig("subjects", "subject")).reduce([]) do |sum, subject|
           if subject.is_a?(String)
-            sum += name_to_fos(subject)
+            sum += name_to_subject(subject)
           elsif subject.is_a?(Hash)
-            sum += hsh_to_fos(subject)
+            sum += hsh_to_subject(subject)
           end
 
           sum
@@ -141,15 +143,12 @@ module Bolognese
 
         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
+            { "date" => date,
+              "dateType" => parse_attributes(r, content: "dateType"),
+              "dateInformation" => parse_attributes(r, content: "dateInformation")
+            }.compact
           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")).map do |k|
           if k.blank?
             nil
@@ -177,8 +176,7 @@ module Bolognese
           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"
+            funder_identifier = normalize_ror(funder_identifier)
           else
             funder_identifier = normalize_id(funder_identifier) ? normalize_id(funder_identifier) : funder_identifier
           end
@@ -194,7 +192,8 @@ module Bolognese
         end
         related_identifiers = Array.wrap(meta.dig("relatedIdentifiers", "relatedIdentifier")).map do |ri|
           if ri["relatedIdentifierType"] == "DOI"
-            rid = validate_doi(ri["__content__"].to_s.downcase)
+            doi = ri["__content__"].to_s.downcase
+            rid = validate_doi(doi) || doi
           else
             rid = ri["__content__"]
           end
@@ -206,7 +205,8 @@ module Bolognese
             "resourceTypeGeneral" => ri["resourceTypeGeneral"],
             "relatedMetadataScheme" => ri["relatedMetadataScheme"],
             "schemeUri" => ri["schemeURI"],
-            "schemeType" => ri["schemeType"]
+            "schemeType" => ri["schemeType"],
+            "relationTypeInformation" => ri["relationTypeInformation"]
           }.compact
         end
 
@@ -216,7 +216,8 @@ module Bolognese
           relatedItemIdentifier = nil
           if rii
             if rii["relatedItemIdentifierType"] == "DOI"
-              rid = validate_doi(rii["__content__"].to_s.downcase)
+              doi = rii["__content__"].to_s.downcase
+              rid = validate_doi(doi) || doi
             else
               rid = rii["__content__"]
             end
@@ -226,14 +227,13 @@ module Bolognese
               "relatedItemIdentifierType" => rii["relatedItemIdentifierType"],
               "relatedMetadataScheme" => rii["relatedMetadataScheme"],
               "schemeURI" => rii["schemeURI"],
-              "schemeType" => rii["schemeType"]
+              "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")
@@ -241,6 +241,7 @@ module Bolognese
 
           a = {
             "relationType" => ri["relationType"],
+            "relationTypeInformation" => ri["relationTypeInformation"],
             "relatedItemType" => ri["relatedItemType"],
             "relatedItemIdentifier" => relatedItemIdentifier,
             "creators" => get_authors(Array.wrap(ri.dig("creators", "creator"))),
@@ -262,17 +263,13 @@ module Bolognese
           if !gl.is_a?(Hash) || gl["geoLocationPoint"].is_a?(String) || gl["geoLocationBox"].is_a?(String) || gl["geoLocationPolygon"].is_a?(String)
             nil
           else
-
-            # Handle scenario where multiple geoLocationPolygons are allowed within a single geoLocation
-            # we want to return an array if it's already an array (i.e. multiple geoLocationPolygons)
-            # vs if it's singular just return the object
-            # This is for backwards compatability to allow both scenarios.
+            ## Array of geoLocationPolygons within a geoLocation is Unsupported in JSON.
             if gl.dig("geoLocationPolygon").kind_of?(Array)
-              geoLocationPolygon = gl.dig("geoLocationPolygon").map do |glp|
-                Array.wrap(glp.dig("polygonPoint")).map { |glpp| { "polygonPoint" => glpp } }.compact.presence
-              end.compact.presence
+              geoLocationPolygon = nil
             else
-              geoLocationPolygon = Array.wrap(gl.dig("geoLocationPolygon", "polygonPoint")).map { |glp| { "polygonPoint" => glp } }.compact.presence
+              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
 
             {
@@ -302,7 +299,6 @@ module Bolognese
           "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" => publisher,
           "agency" => "datacite",
           "funding_references" => funding_references,
@@ -323,28 +319,6 @@ module Bolognese
         }.merge(read_options)
       end
 
-      def set_container(meta)
-        series_information = Array.wrap(meta.dig("descriptions", "description")).find { |r| r["descriptionType"] == "SeriesInformation" }.to_h.fetch("__content__", nil)
-        si = get_series_information(series_information)
-
-        is_part_of = Array.wrap(meta.dig("relatedIdentifiers", "relatedIdentifier")).find { |ri| ri["relationType"] == "IsPartOf" }.to_h
-
-        if si["title"].present? || is_part_of.present?
-          {
-            "type" => meta.dig("resourceType", "resourceTypeGeneral") == "Dataset" ? "DataRepository" : "Series",
-            "identifier" => is_part_of["__content__"],
-            "identifierType" => is_part_of["relatedIdentifierType"],
-            "title" => si["title"],
-            "volume" => si["volume"],
-            "issue" => si["issue"],
-            "firstPage" => si["firstPage"],
-            "lastPage" => si["lastPage"]
-          }.compact
-        else
-          {}
-        end
-      end
-
       def get_titles(meta)
         titles = Array.wrap(meta.dig("titles", "title")).map do |r|
           if r.blank?

data/lib/bolognese/readers/ris_reader.rb

@@ -78,7 +78,7 @@ module Bolognese
         end
         state = meta.fetch("DO", nil).present? || read_options.present? ? "findable" : "not_found"
         subjects = Array.wrap(meta.fetch("KW", nil)).reduce([]) do |sum, subject|
-          sum += name_to_fos(subject)
+          sum += name_to_subject(subject)
 
           sum
         end

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 = {
@@ -74,6 +76,12 @@ 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))))
+        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),
@@ -106,7 +114,9 @@ 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 = Array.wrap(meta.fetch("license", nil)).compact.map do |rl|
           hsh_to_spdx("__content__" => rl["name"], "rightsURI" => rl["id"])
@@ -127,6 +137,7 @@ module Bolognese
         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)
@@ -163,7 +174,7 @@ module Bolognese
         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 += name_to_subject(subject)
           sum
         end
 
@@ -240,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