bolognese 2.0.1 → 2.7.0

data/lib/bolognese/author_utils.rb

@@ -4,9 +4,6 @@ require 'namae'
 
 module Bolognese
   module AuthorUtils
-    # include BenchmarkMethods
-    #
-    # benchmark :get_authors
 
     IDENTIFIER_SCHEME_URIS = {
       "ORCID" => "https://orcid.org/"
@@ -24,83 +21,45 @@ module Bolognese
       given_name = parse_attributes(author.fetch("givenName", nil))
       family_name = parse_attributes(author.fetch("familyName", nil))
       name = cleanup_author(name)
-      name = [family_name, given_name].join(", ") if family_name.present? && given_name.present?
       contributor_type = parse_attributes(author.fetch("contributorType", nil))
 
       name_type = parse_attributes(author.fetch("creatorName", nil), content: "nameType", first: true) || parse_attributes(author.fetch("contributorName", nil), content: "nameType", first: true)
 
       name_identifiers = Array.wrap(author.fetch("nameIdentifier", nil)).map do |ni|
-        ni["__content__"] = ni["__content__"].strip
+        name_identifier = ni["__content__"].strip if ni["__content__"].present?
         if ni["nameIdentifierScheme"] == "ORCID"
           {
-            "nameIdentifier" => normalize_orcid(ni["__content__"]),
+            "nameIdentifier" => normalize_orcid(name_identifier),
             "schemeUri" => "https://orcid.org",
             "nameIdentifierScheme" => "ORCID" }.compact
         elsif ni["nameIdentifierScheme"] == "ROR"
           {
-            "nameIdentifier" => normalize_ror(ni["__content__"]),
+            "nameIdentifier" => normalize_ror(name_identifier),
             "schemeUri" => "https://ror.org",
             "nameIdentifierScheme" => "ROR" }.compact
         else
           {
-            "nameIdentifier" => ni["__content__"],
+            "nameIdentifier" => name_identifier,
             "schemeUri" => ni.fetch("schemeURI", nil),
             "nameIdentifierScheme" => ni["nameIdentifierScheme"] }.compact
         end
       end.presence
 
-      author = { "nameType" => name_type,
+      { "nameType" => name_type,
                  "name" => name,
                  "givenName" => given_name,
                  "familyName" => family_name,
                  "nameIdentifiers" => name_identifiers,
                  "affiliation" => get_affiliations(author.fetch("affiliation", nil)),
                  "contributorType" => contributor_type }.compact
-
-      return author if family_name.present?
-
-      if is_personal_name?(author)
-        Namae.options[:include_particle_in_family] = true
-        names = Namae.parse(name)
-        parsed_name = names.first
-
-        if parsed_name.present?
-          given_name = parsed_name.given
-          family_name = parsed_name.family
-          name = [family_name, given_name].join(", ")
-        else
-          given_name = nil
-          family_name = nil
-        end
-
-        { "nameType" => "Personal",
-          "name" => name,
-          "givenName" => given_name,
-          "familyName" => family_name,
-          "nameIdentifiers" => Array.wrap(name_identifiers),
-          "affiliation" => Array.wrap(author.fetch("affiliation", nil)),
-          "contributorType" => contributor_type }.compact
-      else
-        { "nameType" => name_type,
-          "name" => name,
-          "nameIdentifiers" => Array.wrap(name_identifiers),
-          "affiliation" => Array.wrap(author.fetch("affiliation", nil)),
-          "contributorType" => contributor_type }.compact
-      end
     end
 
     def cleanup_author(author)
       return nil unless author.present?
 
-      # detect pattern "Smith J.", but not "Smith, John K."
-      author = author.gsub(/[[:space:]]([A-Z]\.)?(-?[A-Z]\.)$/, ', \1\2') unless author.include?(",")
-
-      # remove spaces around hyphens
-      author = author.gsub(" - ", "-")
-
       # titleize strings
       # remove non-standard space characters
-      author.my_titleize.gsub(/[[:space:]]/, ' ')
+      author.gsub(/[[:space:]]/, ' ')
     end
 
     def is_personal_name?(author)
@@ -158,7 +117,6 @@ module Bolognese
             # when `normalize_id` method could not normalize, it returns nil, hence we have following condition
             if affiliation_identifier.nil?
               if a["affiliationIdentifierScheme"] == "ROR"
-                scheme_uri = "https://ror.org"
                 affiliation_identifier = normalize_ror(a["affiliationIdentifier"])
               else
                 affiliation_identifier = a["affiliationIdentifier"]

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
@@ -96,7 +95,7 @@ module Bolognese
       if container.present?
         container["title"]
       elsif types["citeproc"] == "article-journal"
-        publisher
+        publisher["name"] if publisher.present?
       else
         nil
       end
@@ -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
@@ -101,7 +103,7 @@ module Bolognese
             { "name" => r.strip }
           elsif r.is_a?(Hash)
             {
-              "name" => r["__content__"].strip,
+              "name" => r["__content__"].present? ? r["__content__"].strip : nil,
               "publisherIdentifier" => r["publisherIdentifierScheme"] == "ROR" ? normalize_ror(r["publisherIdentifier"]) : r["publisherIdentifier"],
               "publisherIdentifierScheme" => r["publisherIdentifierScheme"],
               "schemeUri" => r["schemeURI"],
@@ -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