bolognese 1.0.29 → 1.0.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4687acb1f204f7cea2f87698c0dc2a2a1dcd65d0ce129287623ade20dc812cd9
-  data.tar.gz: 2e0630eb9f1325afad5a18f3887924397f713627d7101db54611a0be0eff58f4
+  metadata.gz: 968c22fa1751729204364c0b2e5bf39b7718402122babccde0f6eaf0ccca71a6
+  data.tar.gz: fded31c2e41b95272b2bcb42ccd3a6e7760c82ed98dbceea022d2d7b90cd5029
 SHA512:
-  metadata.gz: 20c58ca184e77626ead3101a5d7cda2e77812413a200435a4908140a1559db398375ab129fc31dc956aa9246f1e7b50ab30ebb19737e854b1e5d20592a98c34a
-  data.tar.gz: 6613ff4527370e1683fb345e64cc41060c038f5ab732011ebfc568df4c25caf3eb1d6e797166e613bc41b61aaa859bb1c8ea0cb371ce0552ff887558a6388db5
+  metadata.gz: 7e67269661948b71dc7c398594835e800eab6261aed23abe970125d68c19dfcfd30476993ac923bd23923e1a5f8d6fb66a766fadf93cfd1c42745811f36ed8e7
+  data.tar.gz: 81fd6cd2910f372d232c329e8187a85d3e89ffa039dc769df56d104f1d6314b15cbb80d4d9b08dab900389c5f2600446016458d141cfec37d251f653a1de95b1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bolognese (1.0.29)
+    bolognese (1.0.30)
       activesupport (>= 4.2.5, < 6)
       benchmark_methods (~> 0.7)
       bibtex-ruby (~> 4.1)
@@ -120,7 +120,7 @@ GEM
     rack (2.0.6)
     rack-test (0.8.3)
       rack (>= 1.0, < 3)
-    rake (12.3.1)
+    rake (12.3.2)
     rdf (3.0.7)
       hamster (~> 3.0)
       link_header (~> 0.0, >= 0.0.8)

data/lib/bolognese/author_utils.rb

@@ -13,36 +13,42 @@ module Bolognese
     }
 
     def get_one_author(author)
-      if author.fetch("creatorName", nil).is_a?(Array)
-        # malformed XML
-        return nil
-      elsif author.fetch("type", nil).present?
-        type = author.fetch("type").titleize
-      elsif author.fetch("creatorName", nil).is_a?(Hash)
-        type = author.dig("creatorName", "nameType") == "Organizational" ? "Organization" : "Person"
-      else
-        type = nil
-      end
+      # malformed XML
+      return nil if author.fetch("creatorName", nil).is_a?(Array)
 
-      name_identifiers = get_name_identifiers(author)
-      id = author.fetch("id", nil).presence || name_identifiers.first
-      identifier = name_identifiers.length > 1 ? name_identifiers.unwrap : nil
       name = parse_attributes(author.fetch("creatorName", nil)) ||
-             parse_attributes(author.fetch("contributorName", nil)) ||
-             author.fetch("name", nil)
-
+             parse_attributes(author.fetch("contributorName", nil))
       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 name.blank? && family_name.present?
+      name = [family_name, given_name].join(", ") if family_name.present? && given_name.present?
       contributor_type = parse_attributes(author.fetch("contributorType", nil))
 
-      author = { "type" => type || "Person",
-                 "id" => id,
+      name_type = parse_attributes(author.fetch("creatorName", nil), content: "nameType", first: true) || parse_attributes(author.fetch("contributorName", nil), content: "nameType", first: true)
+      name_type = family_name.present? ? "Personal" : nil if name_type.blank?
+
+      name_identifiers = Array.wrap(author.fetch("nameIdentifier", nil)).map do |ni|
+        if ni["nameIdentifierScheme"] == "ORCID"
+          { 
+            "nameIdentifier" => normalize_orcid(ni["__content__"]),
+            "nameIdentifierScheme" => "ORCID" }.compact
+        elsif ni["schemeURI"].present?
+          { 
+            "nameIdentifier" => ni["schemeURI"].to_s + ni["__content__"].to_s,
+            "nameIdentifierScheme" => ni["nameIdentifierScheme"] }.compact
+        else
+          { 
+            "nameIdentifier" => ni["__content__"],
+            "nameIdentifierScheme" => ni["nameIdentifierScheme"] }.compact
+        end
+      end.presence
+
+      author = { "nameType" => name_type,
                  "name" => name,
                  "givenName" => given_name,
                  "familyName" => family_name,
-                 "identifier" => identifier,
+                 "nameIdentifiers" => name_identifiers,
+                 "affiliation" => parse_attributes(author.fetch("affiliation", nil), first: true),
                  "contributorType" => contributor_type }.compact
 
       return author if family_name.present?
@@ -54,21 +60,21 @@ module Bolognese
         if parsed_name.present?
           given_name = parsed_name.given
           family_name = parsed_name.family
-          name = [given_name, family_name].join(" ")
+          name = [family_name, given_name].join(", ")
         else
           given_name = nil
           family_name = nil
         end
 
-        { "type" => "Person",
-          "id" => id,
+        { "nameType" => "Personal",
           "name" => name,
           "givenName" => given_name,
           "familyName" => family_name,
-          "identifier" => identifier,
+          "nameIdentifiers" => name_identifiers,
+          "affiliation" => parse_attributes(author.fetch("affiliation", nil), first: true),
           "contributorType" => contributor_type }.compact
       else
-        { "type" => type, "name" => name }.compact
+        { "nameType" => name_type, "name" => name }.compact
       end
     end
 
@@ -87,8 +93,8 @@ module Bolognese
     end
 
     def is_personal_name?(author)
-      return false if author.fetch("type", "").downcase == "organization"
-      return true if author.fetch("id", "").start_with?("https://orcid.org") ||
+      return false if author.fetch("nameType", nil) == "Organizational"
+      return true if Array.wrap(author.fetch("nameIdentifiers", nil)).find { |a| a["nameIdentifierScheme"] == "ORCID" }.present? ||
                      author.fetch("familyName", "").present? ||
                      (author.fetch("name", "").include?(",") &&
                      author.fetch("name", "").exclude?(";")) ||
@@ -108,35 +114,6 @@ module Bolognese
       Array.wrap(authors).map { |author| get_one_author(author) }.compact
     end
 
-    # parse nameIdentifier from DataCite
-    def get_name_identifiers(author)
-      name_identifiers = Array.wrap(author.fetch("nameIdentifier", nil)).reduce([]) do |sum, n|
-        n = { "__content__" => n } if n.is_a?(String)
-
-        scheme = n.fetch("nameIdentifierScheme", nil)
-        scheme_uri = n.fetch("schemeURI", nil) || IDENTIFIER_SCHEME_URIS.fetch(scheme, "https://orcid.org")
-        scheme_uri = "https://orcid.org/" if validate_orcid_scheme(scheme_uri)
-        scheme_uri << '/' unless scheme_uri.present? && scheme_uri.end_with?('/')
-
-        identifier = n.fetch("__content__", nil)
-        if scheme_uri == "https://orcid.org/"
-          identifier = validate_orcid(identifier)
-        else
-          identifier = identifier.gsub(" ", "-")
-        end
-
-        if identifier.present? && scheme_uri.present?
-          sum << scheme_uri + identifier
-        else
-          sum
-        end
-      end
-
-      # return array of name identifiers, ORCID ID is first element if multiple
-      name_identifiers.select { |n| n.start_with?("https://orcid.org") } +
-      name_identifiers.reject { |n| n.start_with?("https://orcid.org") }
-    end
-
     def authors_as_string(authors)
       Array.wrap(authors).map do |a|
         if a["familyName"].present?

data/lib/bolognese/datacite_utils.rb

@@ -67,12 +67,14 @@ module Bolognese
 
     def insert_person(xml, person, type)
       person_name = person["familyName"].present? ? [person["familyName"], person["givenName"]].compact.join(", ") : person["name"]
-      attributes = person["type"].present? ? { "nameType" => person["type"] + "al" } : {}
+      attributes = { "nameType" => person["nameType"] }.compact
 
       xml.send(type + "Name", person_name, attributes)
       xml.givenName(person["givenName"]) if person["givenName"].present?
       xml.familyName(person["familyName"]) if person["familyName"].present?
-      xml.nameIdentifier(person["id"], 'schemeURI' => 'http://orcid.org/', 'nameIdentifierScheme' => 'ORCID') if person["id"].present?
+      Array.wrap(person["nameIdentifiers"]).each do |ni|
+        xml.nameIdentifier(ni["nameIdentifier"], 'nameIdentifierScheme' => ni["nameIdentifierScheme"])
+      end
     end
 
     def insert_titles(xml)
@@ -92,7 +94,7 @@ module Bolognese
     end
 
     def insert_publisher(xml)
-      xml.publisher(publisher || periodical && periodical["title"])
+      xml.publisher(publisher || container && container["title"])
     end
 
     def insert_publication_year(xml)
@@ -107,11 +109,12 @@ module Bolognese
     end
 
     def insert_alternate_identifiers(xml)
+      alternate_identifiers = Array.wrap(identifiers).select { |r| r["identifierType"] != "DOI" }
       return xml unless alternate_identifiers.present?
 
       xml.alternateIdentifiers do
         Array.wrap(alternate_identifiers).each do |alternate_identifier|
-          xml.alternateIdentifier(alternate_identifier["alternateIdentifier"], 'alternateIdentifierType' => alternate_identifier["alternateIdentifierType"])
+          xml.alternateIdentifier(alternate_identifier["identifier"], 'alternateIdentifierType' => alternate_identifier["identifierType"])
         end
       end
     end
@@ -207,11 +210,16 @@ module Bolognese
     end
 
     def insert_descriptions(xml)
-      return xml unless descriptions.present? || periodical && periodical["title"].present?
+      return xml unless descriptions.present? || container && container["title"].present?
 
       xml.descriptions do
-        if periodical && periodical["title"].present?
-          xml.description(periodical["title"], 'descriptionType' => "SeriesInformation")
+        if container && container["title"].present?
+          title = [container["title"]]
+          volume = "#{container["volume"]}" if container["volume"].present?
+          volume += "(#{container["issue"]})" if container["issue"].present?
+          pages = [container["firstPage"], container["lastPage"]].compact.join("-") if container["firstPage"].present?
+          series_information = [title, volume, pages].compact.join(", ")
+          xml.description(series_information, 'descriptionType' => "SeriesInformation")
         end
 
         Array.wrap(descriptions).each do |description|

data/lib/bolognese/metadata.rb

@@ -8,10 +8,10 @@ module Bolognese
 
     attr_accessor :string, :from, :sandbox, :meta, :regenerate, :issue
     attr_reader :doc, :page_start, :page_end
-    attr_writer :id, :provider_id, :client_id, :doi, :identifier, :creators, :contributors, :titles, :publisher, 
+    attr_writer :id, :provider_id, :client_id, :doi, :identifiers, :creators, :contributors, :titles, :publisher, 
                 :rights_list, :dates, :publication_year, :volume, :url, :version_info,
-                :subjects, :contributor, :descriptions, :alternate_identifiers, :language, :sizes,
-                :formats, :schema_version, :meta, :periodical, :agency,
+                :subjects, :contributor, :descriptions, :language, :sizes,
+                :formats, :schema_version, :meta, :container, :agency,
                 :format, :funding_references, :state, :geo_locations,
                 :types, :content_url, :related_identifiers, :style, :locale
 
@@ -49,7 +49,7 @@ module Bolognese
                 "client_id" => options[:client_id],
                 "content_url" => options[:content_url],
                 "creators" => options[:creators],
-                "contributors" => options[:creators],
+                "contributors" => options[:contributors],
                 "titles" => options[:titles],
                 "publisher" => options[:publisher],
                 "publication_year" => options[:publication_year] }
@@ -83,8 +83,8 @@ module Bolognese
         :contributors,
         :titles,
         :types,
-        :alternate_identifiers,
-        :periodical,
+        :identifiers,
+        :container,
         :publisher,
         :funding_references,
         :dates,
@@ -101,8 +101,7 @@ module Bolognese
       ).compact
 
       # generate name for method to call dynamically
-      @meta = @from.present? ? send("read_" + @from, { string: string, sandbox: options[:sandbox] }.merge(read_options)) : {}
-      @identifier = normalize_doi(options[:doi] || input, options) || @meta.fetch("id", nil) || @meta.fetch("identifier", nil)
+      @meta = @from.present? ? send("read_" + @from, { string: string, sandbox: options[:sandbox], doi: options[:doi], id: id }.merge(read_options)) : {}
     end
 
     def id
@@ -110,7 +109,7 @@ module Bolognese
     end
 
     def doi
-      @doi ||= @identifier.present? ? doi_from_url(@identifier) : meta.fetch("doi", nil)
+      @doi ||= meta.fetch("doi", nil)
     end
 
     def provider_id
@@ -122,7 +121,7 @@ module Bolognese
     end
 
     def exists?
-      (@state || meta.fetch("state", "not_found")) != "not_found"
+      (@state || meta.fetch("state", nil)) != "not_found"
     end
 
     def valid?
@@ -182,8 +181,8 @@ module Bolognese
       @publication_year ||= meta.fetch("publication_year", nil)
     end
 
-    def periodical
-      @periodical ||= meta.fetch("periodical", nil)
+    def container
+      @container ||= meta.fetch("container", nil)
     end
 
     def geo_locations
@@ -198,8 +197,8 @@ module Bolognese
       @publisher ||= meta.fetch("publisher", nil)
     end
 
-    def alternate_identifiers
-      @alternate_identifiers ||= meta.fetch("alternate_identifiers", nil)
+    def identifiers
+      @identifiers ||= meta.fetch("identifiers", nil)
     end
 
     def content_url
@@ -214,10 +213,6 @@ module Bolognese
       @state ||= meta.fetch("state", nil)
     end
 
-    def identifier
-      @identifier ||= meta.fetch("id", nil)
-    end
-
     def types
       @types ||= meta.fetch("types", nil)
     end

data/lib/bolognese/metadata_utils.rb

@@ -62,7 +62,6 @@ module Bolognese
     include Bolognese::Writers::TurtleWriter
 
     attr_reader :name_detector, :reverse
-    attr_writer :first_page, :last_page
 
     # replace DOI in XML if provided in options
     def raw
@@ -79,21 +78,9 @@ module Bolognese
       (from == "datacite") && regenerate.blank? && raw.present?
     end
 
-    def volume
-      @volume ||= meta.fetch("volume", nil)
-    end
-
-    def first_page
-      @first_page ||= meta.fetch("first_page", nil)
-    end
-
-    def last_page
-      @last_page ||= meta.fetch("last_page", nil)
-    end
-
     def container_title
-      if periodical.present?
-        periodical["title"]
+      if container.present?
+        container["title"]
       elsif types["citeproc"] == "article-journal"
         publisher
       else
@@ -124,9 +111,11 @@ module Bolognese
     end
 
     def citeproc_hsh
+      page = container.to_h["firstPage"].present? ? [container["firstPage"], container["lastPage"]].join("-") : nil
+
       {
         "type" => types["citeproc"],
-        "id" => identifier,
+        "id" => id,
         "categories" => Array.wrap(subjects).map { |k| parse_attributes(k, content: "subject", first: true) }.presence,
         "language" => language,
         "author" => to_citeproc(creators),
@@ -136,16 +125,48 @@ module Bolognese
         "abstract" => parse_attributes(descriptions, content: "description", first: true),
         "container-title" => container_title,
         "DOI" => doi,
-        "issue" => issue,
-        "page" => [first_page, last_page].compact.join("-").presence,
+        "volume" => container.to_h["volume"],
+        "issue" => container.to_h["issue"],
+        "page" => page,
         "publisher" => publisher,
         "title" => parse_attributes(titles, content: "title", first: true),
         "URL" => url,
-        "version" => version_info,
-        "volume" => volume
+        "version" => version_info
       }.compact.symbolize_keys
     end
 
+    def crosscite_hsh
+      {
+        "id" => id,
+        "doi" => doi,
+        "url" => url,
+        "types" => types,
+        "creators" => creators,
+        "titles" => titles,
+        "publisher" => publisher,
+        "container" => container,
+        "subjects" => subjects,
+        "contributors" => contributors,
+        "dates" => dates,
+        "publication_year" => publication_year,
+        "language" => language,
+        "identifiers" => identifiers,
+        "sizes" => sizes,
+        "formats" => formats,
+        "version" => version_info,
+        "rights_list" => rights_list,
+        "descriptions" => descriptions,
+        "geo_locations" => geo_locations,
+        "funding_references" => funding_references,
+        "related_identifiers" => related_identifiers,
+        "schema_version" => schema_version,
+        "provider_id" => provider_id,
+        "client_id" => client_id,
+        "agency" => agency,
+        "state" => state
+      }.compact
+    end
+
     def style
       @style ||= "apa"
     end

data/lib/bolognese/readers/bibtex_reader.rb

@@ -40,14 +40,14 @@ module Bolognese
           "citeproc" => BIB_TO_CP_TRANSLATIONS[meta.try(:type).to_s] || "misc",
           "ris" => BIB_TO_RIS_TRANSLATIONS[meta.try(:type).to_s] || "GEN"
         }.compact
-        doi = meta.try(:doi).to_s.presence
+        doi = meta.try(:doi).to_s.presence || options[:doi]
 
-        author = Array(meta.try(:author)).map do |a|
-                  { "type" => "Person",
-                    "name" => [a.first, a.last].join(" "),
-                    "givenName" => a.first,
-                    "familyName" => a.last }.compact
-                end
+        creators = Array(meta.try(:author)).map do |a|
+          { "nameType" => "Personal",
+            "name" => [a.last, a.first].join(", "),
+            "givenName" => a.first,
+            "familyName" => a.last }.compact
+        end
 
         related_identifiers = if meta.try(:journal).present? && meta.try(:issn).to_s.presence
           [{ "type" => "Periodical",
@@ -59,16 +59,22 @@ module Bolognese
           nil
         end
 
-        periodical = if meta.try(:journal).present?
-          { "type" => "Periodical",
+        container = if meta.try(:journal).present?
+          first_page = meta.try(:pages).present? ? meta.try(:pages).split("-").map(&:strip).first : nil
+          last_page = meta.try(:pages).present? ? meta.try(:pages).split("-").map(&:strip).last : nil
+          
+          { "type" => "Journal",
             "title" => meta.journal.to_s,
-            "issn" => meta.try(:issn).to_s.presence }.compact
+            "identifier" => meta.try(:issn).to_s.presence,
+            "identifierType" => meta.try(:issn).present? ? "ISSN" : nil,
+            "volume" => meta.try(:volume).to_s.presence,
+            "firstPage" => first_page,
+            "lastPage" => last_page }.compact
         else
           nil
         end
 
-        page_first, page_last = meta.try(:pages).to_s.split("-")
-        state = doi.present? || read_options.present? ? "findable" : "not_found"
+        state = meta.try(:doi).to_s.present? || read_options.present? ? "findable" : "not_found"
         dates = if meta.try(:date).present?
           [{ "date" => meta.date.to_s,
              "dateType" => "Issued" }]
@@ -79,18 +85,16 @@ module Bolognese
 
         { "id" => normalize_doi(doi),
           "types" => types,
+          "identifiers" => [{ "identifier" => normalize_doi(doi), "identifierType" => "DOI" }],
           "doi" => doi,
           "url" => meta.try(:url).to_s.presence,
           "titles" => meta.try(:title).present? ? [{ "title" => meta.try(:title).to_s }] : [],
-          "creators" => author,
-          "periodical" => periodical,
+          "creators" => creators,
+          "container" => container,
           "publisher" => meta.try(:publisher).to_s.presence,
           "related_identifiers" => related_identifiers,
           "dates" => dates,
           "publication_year" => publication_year,
-          "volume" => meta.try(:volume).to_s.presence,
-          "page_first" => page_first,
-          "page_last" => page_last,
           "descriptions" => meta.try(:abstract).present? ? [{ "description" => meta.try(:abstract) && sanitize(meta.abstract.to_s).presence, "descriptionType" => "Abstract" }] : [],
           "rights_list" =>  meta.try(:copyright).present? ? [{ "rightsUri" => meta.try(:copyright).to_s.presence }.compact] : [],
           "state" => state