bolognese 1.0.29 → 1.0.30

data/lib/bolognese/utils.rb

@@ -425,12 +425,12 @@ module Bolognese
     def parse_attributes(element, options={})
       content = options[:content] || "__content__"
 
-      if element.is_a?(String)
-        element
+      if element.is_a?(String) && options[:content].nil?
+        CGI.unescapeHTML(element)
       elsif element.is_a?(Hash)
-        element.fetch(content, nil)
+        element.fetch( CGI.unescapeHTML(content), nil)
       elsif element.is_a?(Array)
-        a = element.map { |e| e.is_a?(Hash) ? e.fetch(content, nil) : e }.uniq
+        a = element.map { |e| e.is_a?(Hash) ? e.fetch( CGI.unescapeHTML(content), nil) : e }.uniq
         a = options[:first] ? a.first : a.unwrap
       else
         nil
@@ -476,7 +476,7 @@ module Bolognese
       return nil unless orcid.present?
 
       # turn ORCID ID into URL
-      "http://orcid.org/" + Addressable::URI.encode(orcid)
+      "https://orcid.org/" + Addressable::URI.encode(orcid)
     end
 
     def normalize_ids(ids: nil, relation_type: nil)
@@ -548,35 +548,42 @@ module Bolognese
       map_hash_keys(element: element, mapping: mapping)
     end
 
+    def to_schema_org_creators(element)
+      element = Array.wrap(element).map do |c|
+        c["affiliation"] = { "@type" => "Organization", "name" => c["affiliation"] } if c["affiliation"].present?
+        c["@type"] = c["nameType"].present? ? c["nameType"][0..-3] : nil
+        c["@id"] = Array.wrap(c["nameIdentifiers"]).first.to_h.fetch("nameIdentifier", nil)
+        c["name"] = c["familyName"].present? ? [c["givenName"], c["familyName"]].join(" ") : c["name"]
+        c.except("nameIdentifiers", "nameType").compact
+      end.unwrap
+    end
+
+    def to_schema_org_contributors(element)
+      element = Array.wrap(element).map do |c|
+        c["affiliation"] = { "@type" => "Organization", "name" => c["affiliation"] } if c["affiliation"].present?
+        c["@type"] = c["nameType"].present? ? c["nameType"][0..-3] : nil
+        c["@id"] = Array.wrap(c["nameIdentifiers"]).first.to_h.fetch("nameIdentifier", nil)
+        c["name"] = c["familyName"].present? ? [c["givenName"], c["familyName"]].join(" ") : c["name"]
+        c.except("nameIdentifiers", "nameType").compact
+      end.unwrap
+    end
+
     def to_schema_org_container(element, options={})
       return nil unless (element.is_a?(Hash) || (element.nil? && options[:container_title].present?))
 
       { 
-        "@id" => element["relatedIdentifier"],
+        "@id" => element["identifier"],
         "@type" => (options[:type] == "Dataset") ? "DataCatalog" : "Periodical",
-        "name" => element["title"] || options[:container_title] }
+        "name" => element["title"] || options[:container_title] }.compact
     end
 
-    def to_schema_org_identifier(element, options={})
-      ident = { 
-        "@type" => "PropertyValue",
-        "propertyID" => normalize_doi(element) ? "doi" : "url",
-        "value" => element }
-
-      if options[:alternate_identifiers].present?
-        [ident] + Array.wrap(options[:alternate_identifiers]).map do |ai|
-                    if ai["alternateIdentifierType"].to_s.downcase == "url"
-                      ai["alternateIdentifier"]
-                    else
-                      { 
-                        "@type" => "PropertyValue",
-                        "propertyID" => ai["alternateIdentifierType"],
-                        "value" => ai["alternateIdentifier"] }
-                    end
-                  end
-      else
-        ident
-      end
+    def to_schema_org_identifiers(element, options={})
+      Array.wrap(element).map do |ai|
+        { 
+          "@type" => "PropertyValue",
+          "propertyID" => ai["identifierType"],
+          "value" => ai["identifier"] }
+      end.unwrap
     end
 
     def to_schema_org_relation(related_identifiers: nil, relation_type: nil)
@@ -611,19 +618,20 @@ module Bolognese
     def to_schema_org_spatial_coverage(geo_location)
       return nil unless geo_location.present?
 
-      Array.wrap(geo_location).map do |gl|
+      Array.wrap(geo_location).reduce([]) do |sum, gl|
         if gl.fetch("geoLocationPoint", nil)
-          { 
+          sum << { 
             "@type" => "Place",
             "geo" => {
               "@type" => "GeoCoordinates",
               "address" => gl["geoLocationPlace"],
               "latitude" => gl.dig("geoLocationPoint", "pointLatitude"),
-              "longitude" => gl.dig("geoLocationPoint", "pointLongitude")
-            }.compact
-          }
-        elsif gl.fetch("geoLocationBox", nil)
-          { 
+              "longitude" => gl.dig("geoLocationPoint", "pointLongitude") }
+          }.compact
+        end
+
+        if gl.fetch("geoLocationBox", nil)
+          sum << { 
             "@type" => "Place",
             "geo" => {
               "@type" => "GeoShape",
@@ -631,11 +639,33 @@ module Bolognese
               "box" => [gl.dig("geoLocationBox", "southBoundLatitude"),
                         gl.dig("geoLocationBox", "westBoundLongitude"),
                         gl.dig("geoLocationBox", "northBoundLatitude"),
-                        gl.dig("geoLocationBox", "eastBoundLongitude")].join(" ")
-            }.compact
+                        gl.dig("geoLocationBox", "eastBoundLongitude")].compact.join(" ").presence }.compact
+          }.compact
+        end
+
+        if gl.fetch("geoLocationPolygon", nil)
+          sum << { 
+            "@type" => "Place",
+            "geo" => {
+              "@type" => "GeoShape",
+              "address" => gl["geoLocationPlace"],
+              "polygon" => Array.wrap(gl.dig("geoLocationPolygon")).map do |glp| 
+                [glp.dig("polygonPoint", "pointLongitude"), glp.dig("polygonPoint", "pointLatitude")].compact
+              end.compact }
           }
         end
-      end.compact.unwrap
+
+        if gl.fetch("geoLocationPlace", nil) && !gl.fetch("geoLocationPoint", nil) && !gl.fetch("geoLocationBox", nil) && !gl.fetch("geoLocationPolygon", nil)
+          sum << { 
+            "@type" => "Place",
+            "geo" => {
+              "@type" => "GeoCoordinates",
+              "address" => gl["geoLocationPlace"] }
+          }.compact
+        end
+
+        sum
+      end.unwrap
     end
 
     def from_schema_org(element)
@@ -644,6 +674,22 @@ module Bolognese
       map_hash_keys(element: element, mapping: mapping)
     end
 
+    def from_schema_org_creators(element)
+      element = Array.wrap(element).map do |c|
+        c["nameIdentifier"] = [{ "__content__" => c["@id"], "nameIdentifierScheme" => "ORCID" }] if normalize_orcid(c["@id"])
+        c["creatorName"] = { "nameType" => c["@type"].present? ? c["@type"].titleize + "al" : nil, "__content__" => c["name"] }.compact
+        c.except("@id", "@type", "name") 
+      end
+    end
+
+    def from_schema_org_contributors(element)
+      element = Array.wrap(element).map do |c|
+        c["nameIdentifier"] = [{ "__content__" => c["@id"], "nameIdentifierScheme" => "ORCID" }] if normalize_orcid(c["@id"])
+        c["contributorName"] = { "nameType" => c["@type"].present? ? c["@type"].titleize + "al" : nil, "__content__" => c["name"] }.compact
+        c.except("@id", "@type", "name") 
+      end
+    end
+
     def map_hash_keys(element: nil, mapping: nil)
       Array.wrap(element).map do |a|
         a.map {|k, v| [mapping.fetch(k, k), v] }.reduce({}) do |hsh, (k, v)|
@@ -685,7 +731,7 @@ module Bolognese
         a["family"] = a["familyName"]
         a["given"] = a["givenName"]
         a["literal"] = a["name"] unless a["familyName"].present?
-        a.except("type", "@type", "id", "@id", "name", "familyName", "givenName").compact
+        a.except("nameType", "type", "@type", "id", "@id", "name", "familyName", "givenName", "affiliation", "nameIdentifiers").compact
       end.presence
     end
 
@@ -816,7 +862,7 @@ module Bolognese
     end
 
     def get_date(dates, date_type)
-      dd = dates.find { |d| d["dateType"] == date_type } || {}
+      dd = Array.wrap(dates).find { |d| d["dateType"] == date_type } || {}
       dd.fetch("date", nil)
     end
 
@@ -824,6 +870,60 @@ module Bolognese
       contributor.select { |c| c["contributorType"] == contributor_type }
     end
 
+    def get_identifier(identifiers, identifier_type)
+      id = Array.wrap(identifiers).find { |i| i["identifierType"] == identifier_type } || {}
+      id.fetch("identifier", nil)
+    end
+
+    def get_identifier_type(identifier_type)
+      identifierTypes = {
+        "ark" => "ARK",
+        "arxiv" => "arXiv",
+        "bibcode" => "bibcode",
+        "doi" => "DOI",
+        "ean13" => "EAN13",
+        "eissn" => "EISSN",
+        "handle" => "Handle",
+        "igsn" => "IGSN",
+        "isbn" => "ISBN",
+        "issn" => "ISSN",
+        "istc" => "ISTC",
+        "lissn" => "LISSN",
+        "lsid" => "LSID",
+        "pmid" => "PMID",
+        "purl" => "PURL",
+        "upc" => "UPC",
+        "url" => "URL",
+        "urn" => "URN",
+        "md5" => "md5",
+        "minid" => "minid",
+        "dataguid" => "dataguid"
+      }
+
+      identifierTypes[identifier_type.downcase] || identifier_type
+    end
+
+    def get_series_information(str)
+      return {} unless str.present?
+
+      str = str.split(",").map(&:strip)
+
+      title = str.first
+      volume_issue = str.length > 2 ? str[1].rpartition(/\(([^)]+)\)/) : nil
+      volume = volume_issue.present? ? volume_issue[0].presence || volume_issue[2].presence : nil
+      issue = volume_issue.present? ? volume_issue[1][1...-1].presence : nil
+      pages = str.length > 1 ? str.last : nil
+      first_page = pages.present? ? pages.split("-").map(&:strip).first : nil
+      last_page = pages.present? ? pages.split("-").map(&:strip).last : nil
+
+      { 
+        "title" => title,
+        "volume" => volume,
+        "issue" => issue,
+        "firstPage" => first_page,
+        "lastPage" => last_page }.compact
+    end
+
     def jsonlint(json)
       return ["No JSON provided"] unless json.present?
 

data/lib/bolognese/version.rb

@@ -1,3 +1,3 @@
 module Bolognese
-  VERSION = "1.0.29"
+  VERSION = "1.0.30"
 end

data/lib/bolognese/writers/bibtex_writer.rb

@@ -6,19 +6,21 @@ module Bolognese
       def bibtex
         return nil unless valid?
 
+        pages = container.to_h["firstPage"].present? ? [container["firstPage"], container["lastPage"]].join("-") : nil
+
         bib = {
           bibtex_type: types["bibtex"].presence || "misc",
-          bibtex_key: identifier,
+          bibtex_key: id,
           doi: doi,
           url: url,
           author: authors_as_string(creators),
           keywords: subjects.present? ? Array.wrap(subjects).map { |k| parse_attributes(k, content: "subject", first: true) }.join(", ") : nil,
           language: language,
           title: parse_attributes(titles, content: "title", first: true),
-          journal: periodical && periodical["title"],
-          volume: volume,
-          issue: issue,
-          pages: [first_page, last_page].compact.join("-").presence,
+          journal: container && container["title"],
+          volume: container.to_h["volume"],
+          issue: container.to_h["issue"],
+          pages: pages,
           publisher: publisher,
           year: publication_year
         }.compact

data/lib/bolognese/writers/citation_writer.rb

@@ -6,7 +6,7 @@ module Bolognese
       def citation
         cp = CiteProc::Processor.new(style: style, locale: locale, format: 'html')
         cp.import Array.wrap(citeproc_hsh)
-        bibliography = cp.render :bibliography, id: identifier
+        bibliography = cp.render :bibliography, id: id
         bibliography.first
       end
     end

data/lib/bolognese/writers/codemeta_writer.rb

@@ -9,8 +9,8 @@ module Bolognese
         hsh = {
           "@context" => id.present? ? "https://raw.githubusercontent.com/codemeta/codemeta/master/codemeta.jsonld" : nil,
           "@type" => types["schemaOrg"],
-          "@id" => identifier,
-          "identifier" => identifier,
+          "@id" => id,
+          "identifier" => to_schema_org_identifiers(identifiers),
           "codeRepository" => url,
           "title" => parse_attributes(titles, content: "title", first: true),
           "agents" => creators,

data/lib/bolognese/writers/crosscite_writer.rb

@@ -4,40 +4,7 @@ module Bolognese
   module Writers
     module CrossciteWriter
       def crosscite
-        hsh = {
-          "id" => identifier,
-          "doi" => doi,
-          "url" => url,
-          "types" => types,
-          "creators" => creators,
-          "titles" => titles,
-          "publisher" => publisher,
-          "periodical" => periodical,
-          "subjects" => subjects,
-          "contributors" => contributors,
-          "dates" => dates,
-          "publication_year" => publication_year,
-          "language" => language,
-          "alternate_identifiers" => alternate_identifiers,
-          "sizes" => sizes,
-          "formats" => formats,
-          "version" => version_info,
-          "rights_list" => rights_list,
-          "descriptions" => descriptions,
-          "volume" => volume,
-          "issue" => issue,
-          "first_page" => first_page,
-          "last_page" => last_page,
-          "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
-        JSON.pretty_generate hsh.presence
+        JSON.pretty_generate crosscite_hsh.presence
       end
     end
   end

data/lib/bolognese/writers/datacite_json_writer.rb

@@ -4,35 +4,7 @@ module Bolognese
   module Writers
     module DataciteJsonWriter
       def datacite_json
-        hsh = {
-          "id" => identifier,
-          "doi" => doi,
-          "url" => url,
-          "creators" => creators,
-          "titles" => titles,
-          "publisher" => publisher,
-          "periodical" => periodical,
-          "types" => to_datacite_json(types, first: true),
-          "subjects" => to_datacite_json(subjects),
-          "contributors" => contributors,
-          "dates" => to_datacite_json(dates),
-          "publicationYear" => publication_year,
-          "language" => language,
-          "alternateIdentifiers" => to_datacite_json(alternate_identifiers),
-          "relatedIdentifiers" => to_datacite_json(related_identifiers),
-          "sizes" => sizes,
-          "formats" => formats,
-          "version" => version_info,
-          "rightsList" => to_datacite_json(rights_list),
-          "descriptions" => to_datacite_json(descriptions),
-          "geoLocations" => to_datacite_json(geo_locations),
-          "fundingReferences" => to_datacite_json(funding_references),
-          "schemaVersion" => schema_version,
-          "providerId" => provider_id,
-          "clientIsd" => client_id,
-          "agency" => agency
-        }.compact
-        JSON.pretty_generate hsh.presence
+        JSON.pretty_generate crosscite_hsh.transform_keys! { |key| key.camelcase(uppercase_first_letter = :lower) } if crosscite_hsh.present?
       end
     end
   end

data/lib/bolognese/writers/jats_writer.rb

@@ -18,10 +18,10 @@ module Bolognese
         insert_source(xml)
         insert_publisher_name(xml) if publisher.present? && !is_data?
         insert_publication_date(xml)
-        insert_volume(xml) if volume.present?
-        insert_issue(xml) if issue.present?
-        insert_fpage(xml) if first_page.present?
-        insert_lpage(xml) if last_page.present?
+        insert_volume(xml) if container.to_h["volume"].present?
+        insert_issue(xml) if container.to_h["issue"].present?
+        insert_fpage(xml) if container.to_h["firstPage"].present?
+        insert_lpage(xml) if container.to_h["lastPage"].present?
         insert_version(xml) if version_info.present?
         insert_pub_id(xml)
       end
@@ -77,7 +77,7 @@ module Bolognese
 
       def insert_source(xml)
         if is_article? || is_data? || is_chapter?
-          xml.source(periodical && periodical["title"] || publisher)
+          xml.source(container && container["title"] || publisher)
         else
           xml.source(parse_attributes(titles, content: "title", first: true))
         end
@@ -96,19 +96,19 @@ module Bolognese
       end
 
       def insert_volume(xml)
-        xml.volume(volume)
+        xml.volume(container["volume"])
       end
 
       def insert_issue(xml)
-        xml.issue(issue)
+        xml.issue(container["issue"])
       end
 
       def insert_fpage(xml)
-        xml.fpage(first_page)
+        xml.fpage(container["firstPage"])
       end
 
       def insert_lpage(xml)
-        xml.lpage(last_page)
+        xml.lpage(container["lastPage"])
       end
 
       def insert_version(xml)

data/lib/bolognese/writers/ris_writer.rb

@@ -7,7 +7,7 @@ module Bolognese
         {
           "TY" => types["ris"],
           "T1" => parse_attributes(titles, content: "title", first: true),
-          "T2" => periodical && periodical["title"],
+          "T2" => container && container["title"],
           "AU" => to_ris(creators),
           "DO" => doi,
           "UR" => url,
@@ -16,10 +16,10 @@ module Bolognese
           "PY" => publication_year,
           "PB" => publisher,
           "LA" => language,
-          "VL" => volume,
-          "IS" => issue,
-          "SP" => first_page,
-          "EP" => last_page,
+          "VL" => container.to_h["volume"],
+          "IS" => container.to_h["issue"],
+          "SP" => container.to_h["firstPage"],
+          "EP" => container.to_h["lastPage"],
           "SN" => Array.wrap(related_identifiers).find { |ri| ri["relationType"] == "IsPartOf" }.to_h.fetch("relatedIdentifier", nil),
           "ER" => ""
         }.compact.map { |k, v| v.is_a?(Array) ? v.map { |vi| "#{k}  - #{vi}" }.join("\r\n") : "#{k}  - #{v}" }.join("\r\n")