bolognese 1.0.7 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb41752abec17479d1f11b7b7f0f7a4c5aad50698eae00d55e0e8adc71d2b5ce
-  data.tar.gz: d5b6df042eccfd780f2af437d79a12c26a28d99e6c740a06644f84a651cc458d
+  metadata.gz: b10b2f30664bc415fa1bcc606b4c2db35132391c72294cc4d20ec10652906c3c
+  data.tar.gz: ad15c83b54c9d02b3af165d44c83bb20029e30f33e902c5ba8c61f5356b66171
 SHA512:
-  metadata.gz: 54669b2f390738ea6232ffde8866b4e57d829784b96168f5d0fde43b7672250be828e4c62cab815670cbac7056569e012338539022a78b0ef8979c4a05f8a52b
-  data.tar.gz: fc73f2fd0a8306c71458b0eff727f6b338d65623c5bf58079bb08eb711a02d90e57895599ba2b499a9fbf23f8a22f22e02490f12cf2a2c6af4afadcd8857d018
+  metadata.gz: 62fb8fa37d0b75f493410e74335b76d3a1cd7c8d31331478c4da873355059bc50831e4a71f05f8f0021fe7c72628c687107155c79e05b0d9cb97ba17fddcdd71
+  data.tar.gz: ab4a88be3953d2303ab47b17efe90e59e4aee8624b62f91566652a3bf37856d370237cf11cb438d0266af8d46181b59b0271ff90019b53cc34f6b114b39453eb

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bolognese (1.0.7)
+    bolognese (1.0.8)
       activesupport (>= 4.2.5, < 6)
       benchmark_methods (~> 0.7)
       bibtex-ruby (~> 4.1)

data/lib/bolognese/datacite_utils.rb

@@ -58,7 +58,7 @@ module Bolognese
 
       xml.contributors do
         Array.wrap(contributor).each do |con|
-          xml.contributor("contributorType" => con["contributor_type"] || "Other") do
+          xml.contributor("contributorType" => con["contributorType"] || "Other") do
             insert_person(xml, con, "contributor")
           end
         end
@@ -85,7 +85,7 @@ module Bolognese
             t["title"] = title
           end
 
-          attributes = { 'titleType' => t["title_type"], 'lang' => t["lang"] }.compact
+          attributes = { 'titleType' => t["titleType"], 'lang' => t["lang"] }.compact
           xml.title(t["title"], attributes)
         end
       end
@@ -100,10 +100,10 @@ module Bolognese
     end
 
     def insert_resource_type(xml)
-      return xml unless types["type"].present?
+      return xml unless types["schemaOrg"].present?
 
-      xml.resourceType(types["resource_type"] || types["type"],
-        'resourceTypeGeneral' => types["resource_type_general"] || Metadata::SO_TO_DC_TRANSLATIONS[types["type"]] || "Other")
+      xml.resourceType(types["resourceType"] || types["schemaOrg"],
+        'resourceTypeGeneral' => types["resourceTypeGeneral"] || Metadata::SO_TO_DC_TRANSLATIONS[types["schemaOrg"]] || "Other")
     end
 
     def insert_alternate_identifiers(xml)
@@ -111,7 +111,7 @@ module Bolognese
 
       xml.alternateIdentifiers do
         Array.wrap(alternate_identifiers).each do |alternate_identifier|
-          xml.alternateIdentifier(alternate_identifier["alternate_identifier"], 'alternateIdentifierType' => alternate_identifier["alternate_identifier_type"])
+          xml.alternateIdentifier(alternate_identifier["alternateIdentifier"], 'alternateIdentifierType' => alternate_identifier["alternateIdentifierType"])
         end
       end
     end
@@ -121,7 +121,7 @@ module Bolognese
 
       xml.dates do
         Array.wrap(dates).each do |date|
-          attributes = { 'dateType' => date["date_type"] || "Issued", 'dateInformation' => date["date_information"] }.compact
+          attributes = { 'dateType' => date["dateType"] || "Issued", 'dateInformation' => date["dateInformation"] }.compact
           xml.date(date["date"], attributes)
         end
       end
@@ -133,10 +133,10 @@ module Bolognese
       xml.fundingReferences do
         Array.wrap(funding_references).each do |funding_reference|
           xml.fundingReference do
-            xml.funderName(funding_reference["funder_name"])
-            xml.funderIdentifier(funding_reference["funder_identifier"], { "funderIdentifierType" => funding_reference["funder_identifier_type"] }.compact) if funding_reference["funder_identifier"].present?
-            xml.awardNumber(funding_reference["award_number"], { "awardURI" => funding_reference["award_uri"] }.compact) if funding_reference["award_number"].present? || funding_reference["award_uri"].present?
-            xml.awardTitle(funding_reference["award_title"]) if funding_reference["award_title"].present?
+            xml.funderName(funding_reference["funderName"])
+            xml.funderIdentifier(funding_reference["funderIdentifier"], { "funderIdentifierType" => funding_reference["funderIdentifierType"] }.compact) if funding_reference["funderIdentifier"].present?
+            xml.awardNumber(funding_reference["awardNumber"], { "awardURI" => funding_reference["awardUri"] }.compact) if funding_reference["awardNumber"].present? || funding_reference["awardUri"].present?
+            xml.awardTitle(funding_reference["awardTitle"]) if funding_reference["awardTitle"].present?
           end
         end
       end
@@ -154,7 +154,7 @@ module Bolognese
             s["subject"] = subject
           end
 
-          attributes = { "subjectScheme" => s["subject_scheme"], "schemeURI" => s["scheme_uri"], "valueURI" => s["value_uri"], "lang" => s["lang"] }.compact
+          attributes = { "subjectScheme" => s["subjectScheme"], "schemeURI" => s["schemeUri"], "valueURI" => s["valueUri"], "lang" => s["lang"] }.compact
 
           xml.subject(s["subject"], attributes)
         end
@@ -173,15 +173,15 @@ module Bolognese
       xml.relatedIdentifiers do
         related_identifiers.each do |related_identifier|
           attributes = {
-            'relatedIdentifierType' => related_identifier["related_identifier_type"],
-            'relationType' => related_identifier["relation_type"],
-            'resourceTypeGeneral' => related_identifier["resource_type_general"] }.compact
+            'relatedIdentifierType' => related_identifier["relatedIdentifierType"],
+            'relationType' => related_identifier["relationType"],
+            'resourceTypeGeneral' => related_identifier["resourceTypeGeneral"] }.compact
 
-          attributes.merge({ 'relatedMetadataScheme' => related_identifier["related_metadata_schema"],
-            'schemeURI' => related_identifier["scheme_uri"],
-            'schemeType' => related_identifier["scheme_type"]}.compact) if %w(HasMetadata IsMetadataFor).include?(related_identifier["relation_type"])
+          attributes.merge({ 'relatedMetadataScheme' => related_identifier["relatedMetadataSchema"],
+            'schemeURI' => related_identifier["schemeUri"],
+            'schemeType' => related_identifier["schemeType"]}.compact) if %w(HasMetadata IsMetadataFor).include?(related_identifier["relationType"])
 
-          xml.relatedIdentifier(related_identifier["related_identifier"], attributes)
+          xml.relatedIdentifier(related_identifier["relatedIdentifier"], attributes)
         end
       end
     end
@@ -196,10 +196,10 @@ module Bolognese
           else
             r = {}
             r["rights"] = rights
-            r["rights_uri"] = normalize_id(rights)
+            r["rightsUri"] = normalize_id(rights)
           end
 
-          attributes = { 'rightsURI' => r["rights_uri"], 'lang' => r["lang"] }.compact
+          attributes = { 'rightsURI' => r["rightsUri"], 'lang' => r["lang"] }.compact
 
           xml.rights(r["rights"], attributes)
         end
@@ -220,10 +220,10 @@ module Bolognese
           else
             d = {}
             d["description"] = description
-            d["description_type"] = "Abstract"
+            d["descriptionType"] = "Abstract"
           end
 
-          attributes = { 'lang' => d["lang"], 'descriptionType' => d["description_type"] || "Abstract" }.compact
+          attributes = { 'lang' => d["lang"], 'descriptionType' => d["descriptionType"] || "Abstract" }.compact
 
           xml.description(d["description"], attributes)
         end

data/lib/bolognese/metadata.rb

@@ -9,7 +9,7 @@ module Bolognese
     attr_writer :id, :provider_id, :client_id, :doi, :identifier, :creator, :contributor, :titles, :publisher, 
                 :rights_list, :dates, :publication_year, :volume, :first_page, :last_page, :url, :version,
                 :subjects, :contributor, :descriptions, :alternate_identifiers, :language, :sizes,
-                :formats, :schema_version, :meta, :periodical,
+                :formats, :schema_version, :meta, :periodical, :source,
                 :format, :funding_references, :state, :geo_locations,
                 :types, :content_url, :related_identifiers
 
@@ -176,6 +176,10 @@ module Bolognese
       @content_url ||= meta.fetch("content_url", nil)
     end
 
+    def source
+      @source ||= meta.fetch("source", nil)
+    end
+
     def state
       @state ||= meta.fetch("state", nil)
     end

data/lib/bolognese/metadata_utils.rb

@@ -62,7 +62,7 @@ module Bolognese
     include Bolognese::Writers::TurtleWriter
 
     attr_accessor :string, :from, :sandbox, :meta, :regenerate, :issue
-    attr_reader :doc, :service_provider, :page_start, :page_end, :reverse, :name_detector
+    attr_reader :doc, :page_start, :page_end, :reverse, :name_detector
     attr_writer :style, :locale
 
     # replace DOI in XML if provided in options
@@ -80,10 +80,6 @@ module Bolognese
       (from == "datacite") && regenerate.blank? && raw.present?
     end
 
-    def service_provider
-      @service_provider ||= meta.fetch("service_provider", nil)
-    end
-
     def volume
       @volume ||= meta.fetch("volume", nil)
     end
@@ -102,15 +98,15 @@ module Bolognese
     end
 
     def reverse
-      { "citation" => Array.wrap(related_identifiers).select { |ri| ri["relation_type"] == "IsReferencedBy" }.map do |r| 
-        { "@id" => normalize_doi(r["related_identifier"]),
-          "@type" => r["resource_type_general"] || "CreativeWork",
-          "identifier" => r["related_identifier_type"] == "DOI" ? nil : to_identifier(r) }.compact
+      { "citation" => Array.wrap(related_identifiers).select { |ri| ri["relationType"] == "IsReferencedBy" }.map do |r| 
+        { "@id" => normalize_doi(r["relatedIdentifier"]),
+          "@type" => r["resourceTypeGeneral"] || "CreativeWork",
+          "identifier" => r["relatedIdentifierType"] == "DOI" ? nil : to_identifier(r) }.compact
         end.unwrap,
-        "isBasedOn" => Array.wrap(related_identifiers).select { |ri| ri["relation_type"] == "IsSupplementTo" }.map do |r| 
-          { "@id" => normalize_doi(r["related_identifier"]),
-            "@type" => r["resource_type_general"] || "CreativeWork",
-            "identifier" => r["related_identifier_type"] == "DOI" ? nil : to_identifier(r) }.compact
+        "isBasedOn" => Array.wrap(related_identifiers).select { |ri| ri["relationType"] == "IsSupplementTo" }.map do |r| 
+          { "@id" => normalize_doi(r["relatedIdentifier"]),
+            "@type" => r["resourceTypeGeneral"] || "CreativeWork",
+            "identifier" => r["relatedIdentifierType"] == "DOI" ? nil : to_identifier(r) }.compact
         end.unwrap }.compact
     end
 
@@ -127,7 +123,7 @@ module Bolognese
         "author" => to_citeproc(creator),
         "contributor" => to_citeproc(contributor),
         "issued" => get_date(dates, "Issued") ? get_date_parts(get_date(dates, "Issued")) : nil,
-        "submitted" => Array.wrap(dates).find { |d| d["type"] == "Submitted" }.to_h.fetch("__content__", nil),
+        "submitted" => Array.wrap(dates).find { |d| d["dateType"] == "Submitted" }.to_h.fetch("__content__", nil),
         "abstract" => parse_attributes(descriptions, content: "description", first: true),
         "container-title" => periodical && periodical["title"],
         "DOI" => doi,

data/lib/bolognese/readers/bibtex_reader.rb

@@ -29,11 +29,11 @@ module Bolognese
       def read_bibtex(string: nil, **options)
         meta = string.present? ? BibTeX.parse(string).first : OpenStruct.new
 
-        type = BIB_TO_SO_TRANSLATIONS[meta.try(:type).to_s] || "ScholarlyArticle"
+        schema_org = BIB_TO_SO_TRANSLATIONS[meta.try(:type).to_s] || "ScholarlyArticle"
         types = {
-          "type" => type,
-          "resource_type_general" => Metadata::SO_TO_DC_TRANSLATIONS[type],
+          "resourceTypeGeneral" => Metadata::SO_TO_DC_TRANSLATIONS[schema_org],
           "resource_type" => Bolognese::Utils::BIB_TO_CR_TRANSLATIONS[meta.try(:type).to_s] || meta.try(:type).to_s,
+          "schemaOrg" => schema_org,
           "bibtex" => meta.type.to_s,
           "citeproc" => BIB_TO_CP_TRANSLATIONS[meta.try(:type).to_s] || "misc",
           "ris" => BIB_TO_RIS_TRANSLATIONS[meta.try(:type).to_s] || "GEN"
@@ -49,10 +49,10 @@ module Bolognese
 
         related_identifiers = if meta.try(:journal).present? && meta.try(:issn).to_s.presence
           [{ "type" => "Periodical",
-             "relation_type" => "IsPartOf",
-             "related_identifier_type" => "ISSN",
+             "relationType" => "IsPartOf",
+             "relatedIdentifierType" => "ISSN",
              "title" => meta.journal.to_s,
-             "related_identifier" => meta.try(:issn).to_s.presence }.compact]
+             "relatedIdentifier" => meta.try(:issn).to_s.presence }.compact]
         else
           nil
         end
@@ -69,7 +69,7 @@ module Bolognese
         state = doi.present? ? "findable" : "not_found"
         dates = if meta.try(:date).present?
           [{ "date" => meta.date.to_s,
-             "date_type" => "Issued" }]
+             "dateType" => "Issued" }]
         else
           nil
         end
@@ -89,8 +89,8 @@ module Bolognese
           "volume" => meta.try(:volume).to_s.presence,
           "page_first" => page_first,
           "page_last" => page_last,
-          "descriptions" => [{ "description" => meta.try(:abstract) && sanitize(meta.abstract.to_s).presence }],
-          "rights_list" => [{ "rights_uri" => meta.try(:copyright).to_s.presence }.compact],
+          "descriptions" => [{ "description" => meta.try(:abstract) && sanitize(meta.abstract.to_s).presence, "descriptionType" => "Abstract" }],
+          "rights_list" => [{ "rightsUri" => meta.try(:copyright).to_s.presence }.compact],
           "state" => state
         }
       end

data/lib/bolognese/readers/citeproc_reader.rb

@@ -34,36 +34,36 @@ module Bolognese
         meta = string.present? ? Maremma.from_json(string) : {}
 
         citeproc_type = meta.fetch("type", nil)
-        type = CP_TO_SO_TRANSLATIONS[citeproc_type] || "CreativeWork"
+        schema_org = CP_TO_SO_TRANSLATIONS[citeproc_type] || "CreativeWork"
         types = {
-          "type" => type,
-          "resource_type_general" => Bolognese::Utils::SO_TO_DC_TRANSLATIONS[type],
-          "reource_type" => meta.fetch("additionalType", nil),
+          "resourceTypeGeneral" => Bolognese::Utils::SO_TO_DC_TRANSLATIONS[schema_org],
+          "reourceType" => meta.fetch("additionalType", nil),
+          "schemaOrg" => schema_org,
           "citeproc" => citeproc_type,
-          "bibtex" => Bolognese::Utils::SO_TO_BIB_TRANSLATIONS[type] || "misc",
-          "ris" => CP_TO_RIS_TRANSLATIONS[type] || "GEN"
+          "bibtex" => Bolognese::Utils::SO_TO_BIB_TRANSLATIONS[schema_org] || "misc",
+          "ris" => CP_TO_RIS_TRANSLATIONS[schema_org] || "GEN"
         }.compact
         doi = normalize_doi(meta.fetch("DOI", nil))
         creator = get_authors(from_citeproc(Array.wrap(meta.fetch("author", nil))))
         contributor = get_authors(from_citeproc(Array.wrap(meta.fetch("editor", nil))))
         dates = if meta.fetch("issued", nil).present?
           [{ "date" => get_date_from_date_parts(meta.fetch("issued", nil)),
-             "date_type" => "Issued" }]
+             "dateType" => "Issued" }]
         else
           nil
         end
         publication_year = get_date_from_date_parts(meta.fetch("issued", nil)).to_s[0..3]
         rights_list = if meta.fetch("copyright", nil)
-          [{ "rights_uri" => normalize_url(meta.fetch("copyright")) }.compact]
+          [{ "rightsUri" => normalize_url(meta.fetch("copyright")) }.compact]
         else
           nil
         end
         related_identifiers = if meta.fetch("container-title", nil).present? && meta.fetch("ISSN", nil).present?
           [{ "type" => "Periodical",
-             "relation_type" => "IsPartOf",
-             "related_identifier_type" => "ISSN",
+             "relationType" => "IsPartOf",
+             "relatedIdentifierType" => "ISSN",
              "title" => meta.fetch("container-title", nil),
-             "id" => meta.fetch("ISSN", nil) }.compact]
+             "relatedIdentifier" => meta.fetch("ISSN", nil) }.compact]
         else
           nil
         end
@@ -94,7 +94,7 @@ module Bolognese
           "publication_year" => publication_year,
           "volume" => meta.fetch("volume", nil),
           #{}"pagination" => meta.pages.to_s.presence,
-          "descriptions" => meta.fetch("abstract", nil).present? ? [{ "description" => sanitize(meta.fetch("abstract")) }] : [],
+          "descriptions" => meta.fetch("abstract", nil).present? ? [{ "description" => sanitize(meta.fetch("abstract")), "descriptionType" => "Abstract" }] : [],
           "rights_list" => rights_list,
           "version" => meta.fetch("version", nil),
           "subjects" => subjects,

data/lib/bolognese/readers/codemeta_reader.rb

@@ -24,20 +24,20 @@ module Bolognese
         author = get_authors(from_schema_org(Array.wrap(meta.fetch("agents", nil))))
         contributor = get_authors(from_schema_org(Array.wrap(meta.fetch("editor", nil))))
         dates = []
-        dates << { "date" => meta.fetch("datePublished"), "date_type" => "Issued" } if meta.fetch("datePublished", nil).present?
-        dates << { "date" => meta.fetch("dateCreated"), "date_type" => "Created" } if meta.fetch("dateCreated", nil).present?
-        dates << { "date" => meta.fetch("dateModified"), "date_type" => "Updated" } if meta.fetch("dateModified", nil).present?
+        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?
         publication_year = meta.fetch("datePublished")[0..3] if meta.fetch("datePublished", nil).present?
         publisher = meta.fetch("publisher", nil)
         state = meta.present? ? "findable" : "not_found"
-        type = meta.fetch("@type", nil)
+        schema_org = meta.fetch("@type", nil)
         types = {
-          "type" => type,
-          "resource_type_general" => Bolognese::Utils::SO_TO_DC_TRANSLATIONS[type],
-          "resource_type" => meta.fetch("additionalType", nil),
-          "citeproc" => Bolognese::Utils::SO_TO_CP_TRANSLATIONS[type] || "article-journal",
-          "bibtex" => Bolognese::Utils::SO_TO_BIB_TRANSLATIONS[type] || "misc",
-          "ris" => Bolognese::Utils::SO_TO_RIS_TRANSLATIONS[type] || "GEN"
+          "resourceTypeGeneral" => Bolognese::Utils::SO_TO_DC_TRANSLATIONS[schema_org],
+          "resourceType" => meta.fetch("additionalType", nil),
+          "schemaOrg" => schema_org,
+          "citeproc" => Bolognese::Utils::SO_TO_CP_TRANSLATIONS[schema_org] || "article-journal",
+          "bibtex" => Bolognese::Utils::SO_TO_BIB_TRANSLATIONS[schema_org] || "misc",
+          "ris" => Bolognese::Utils::SO_TO_RIS_TRANSLATIONS[schema_org] || "GEN"
         }.compact
         subjects = Array.wrap(meta.fetch("tags", nil)).map do |s|
           { "subject" => s }
@@ -55,8 +55,8 @@ module Bolognese
           #{}"is_part_of" => is_part_of,
           "dates" => dates,
           "publication_year" => publication_year,
-          "descriptions" => meta.fetch("description", nil).present? ? [{ "description" => sanitize(meta.fetch("description")) }] : nil,
-          "rights_list" => [{ "rights_uri" => meta.fetch("license", nil) }.compact],
+          "descriptions" => meta.fetch("description", nil).present? ? [{ "description" => sanitize(meta.fetch("description")), "descriptionType" => "Abstract" }] : nil,
+          "rights_list" => [{ "rightsUri" => meta.fetch("license", nil) }.compact],
           "version" => meta.fetch("version", nil),
           "subjects" => subjects,
           "state" => state

data/lib/bolognese/readers/crossref_reader.rb

@@ -71,11 +71,11 @@ module Bolognese
         end
 
         resource_type = (resource_type || model).to_s.underscore.camelize.presence
-        type = Bolognese::Utils::CR_TO_SO_TRANSLATIONS[resource_type] || "ScholarlyArticle"
+        schema_org = Bolognese::Utils::CR_TO_SO_TRANSLATIONS[resource_type] || "ScholarlyArticle"
         types = {
-          "type" => type,
-          "resource_type_general" => Bolognese::Utils::SO_TO_DC_TRANSLATIONS[type],
-          "resource_type" => resource_type,
+          "resourceTypeGeneral" => Bolognese::Utils::SO_TO_DC_TRANSLATIONS[schema_org],
+          "resourceType" => resource_type,
+          "schemaOrg" => schema_org,
           "citeproc" => Bolognese::Utils::CR_TO_CP_TRANSLATIONS[resource_type] || "article-journal",
           "bibtex" => Bolognese::Utils::CR_TO_BIB_TRANSLATIONS[resource_type] || "misc",
           "ris" => Bolognese::Utils::CR_TO_RIS_TRANSLATIONS[resource_type] || "JOUR"
@@ -86,9 +86,9 @@ module Bolognese
         Time.zone = 'Eastern Time (US & Canada)'
         dates = [
           { "date" => crossref_date_published(bibliographic_metadata),
-            "date_type" => "Issued" },
+            "dateType" => "Issued" },
           { "date" => Time.zone.parse(meta.fetch("timestamp", "2018-01-01")).utc.iso8601,
-            "date_type" => "Updated" }
+            "dateType" => "Updated" }
         ]
         publication_year = crossref_date_published(bibliographic_metadata).present? ? crossref_date_published(bibliographic_metadata)[0..3] : nil
         state = meta.present? ? "findable" : "not_found"
@@ -113,7 +113,7 @@ module Bolognese
           "funding_references" => crossref_funding_reference(program_metadata),
           "publisher" => publisher,
           "periodical" => periodical,
-          "service_provider" => "Crossref",
+          "source" => "Crossref",
           "related_identifiers" => related_identifiers,
           "dates" => dates,
           "publication_year" => publication_year,
@@ -134,21 +134,21 @@ module Bolognese
 
       def crossref_alternate_identifiers(bibliographic_metadata)
         if bibliographic_metadata.fetch("publisher_item", nil).present?
-          { "alternate_identifier" => parse_attributes(bibliographic_metadata.dig("publisher_item", "item_number")),
-            "alternate_identifier_type" => "Publisher ID" }
+          { "alternateIdentifier" => parse_attributes(bibliographic_metadata.dig("publisher_item", "item_number")),
+            "alternateIdentifierType" => "Publisher ID" }
         else
-          { "alternate_identifier" => parse_attributes(bibliographic_metadata.fetch("item_number", nil)),
-            "alternate_identifier_type" => "Publisher ID" }
+          { "alternateIdentifier" => parse_attributes(bibliographic_metadata.fetch("item_number", nil)),
+            "alternateIdentifierType" => "Publisher ID" }
         end
       end
 
       def crossref_description(bibliographic_metadata)
         abstract = Array.wrap(bibliographic_metadata.dig("abstract")).map do |r|
-          { "description_type" => "Abstract", "description" => sanitize(parse_attributes(r, content: 'p')) }.compact
+          { "descriptionType" => "Abstract", "description" => sanitize(parse_attributes(r, content: 'p')) }.compact
         end
 
         description = Array.wrap(bibliographic_metadata.dig("description")).map do |r|
-          { "description_type" => "Other", "description" => sanitize(parse_attributes(r)) }.compact
+          { "descriptionType" => "Other", "description" => sanitize(parse_attributes(r)) }.compact
         end
 
         (abstract + description)
@@ -158,7 +158,7 @@ module Bolognese
         access_indicator = Array.wrap(program_metadata).find { |m| m["name"] == "AccessIndicators" }
         if access_indicator.present?
           Array.wrap(access_indicator["license_ref"]).map do |license|
-            { "rights_uri" => normalize_url(parse_attributes(license)) }
+            { "rightsUri" => normalize_url(parse_attributes(license)) }
           end.uniq
         else
           nil
@@ -185,12 +185,12 @@ module Bolognese
           funder_identifier_type = funder_identifier.present? ?  "Crossref Funder ID" : nil
           award_title = f.fetch("awardTitle", nil).present? ? f.fetch("awardTitle") : nil
 
-          { "funder_identifier" => funder_identifier,
-            "funder_identifier_type" => funder_identifier_type,
-            "funder_name" => f.fetch("__content__", "").strip,
-            "award_title" => award_title,
-            "award_number" => f.dig("awardNumber", "__content__"),
-            "award_uri" => f.dig("awardNumber", "awardURI") }.compact
+          { "funderIdentifier" => funder_identifier,
+            "funderIdentifierType" => funder_identifier_type,
+            "funderName" => f.fetch("__content__", "").strip,
+            "awardTitle" => award_title,
+            "awardNumber" => f.dig("awardNumber", "__content__"),
+            "awardUri" => f.dig("awardNumber", "awardURI") }.compact
         end
       end
 
@@ -206,11 +206,10 @@ module Bolognese
 
       def crossref_is_part_of(model_metadata)
         if model_metadata.present? && model_metadata.fetch("issn", nil).present?
-          { "related_identifier" => parse_attributes(model_metadata.fetch("issn", nil), first: true),
-            "relation_type" => "IsPartOf",
-            "related_identifier_type" => "ISSN",
-            "type" => "Periodical",
-            "title" => model_metadata["full_title"] }.compact
+          { "relatedIdentifier" => parse_attributes(model_metadata.fetch("issn", nil), first: true),
+            "relationType" => "IsPartOf",
+            "relatedIdentifierType" => "ISSN",
+            "resourceTypeGeneral" => "Collection" }.compact
         else
           nil
         end
@@ -220,10 +219,9 @@ module Bolognese
         refs = bibliographic_metadata.dig("citation_list", "citation")
         Array.wrap(refs).select { |a| a["doi"].present? }.map do |c|
           if c["doi"].present?
-            { "related_identifier" => parse_attributes(c["doi"]).downcase,
-              "relation_type" => "References",
-              "related_identifier_type" => "DOI",
-              "title" => c["article_title"] }.compact
+            { "relatedIdentifier" => parse_attributes(c["doi"]).downcase,
+              "relationType" => "References",
+              "relatedIdentifierType" => "DOI" }.compact
           else
             nil
           end