bolognese 0.7.2 → 0.8

data/lib/bolognese/metadata.rb

@@ -12,12 +12,36 @@ module Bolognese
     include Bolognese::DataciteUtils
     include Bolognese::Utils
 
+    DC_TO_SO_TRANSLATIONS = {
+      "Audiovisual" => "VideoObject",
+      "Collection" => "Collection",
+      "Dataset" => "Dataset",
+      "Event" => "Event",
+      "Image" => "ImageObject",
+      "InteractiveResource" => nil,
+      "Model" => nil,
+      "PhysicalObject" => nil,
+      "Service" => "Service",
+      "Software" => "SoftwareSourceCode",
+      "Sound" => "AudioObject",
+      "Text" => "ScholarlyArticle",
+      "Workflow" => nil,
+      "Other" => "CreativeWork"
+    }
+
     attr_reader :id, :raw, :provider, :schema_version, :license, :citation,
       :additional_type, :alternate_name, :url, :version, :keywords, :editor,
       :page_start, :page_end, :date_modified, :language, :spatial_coverage,
       :content_size, :funder, :journal, :bibtex_type, :date_created, :has_part,
-      :publisher, :contributor, :same_as, :predecessor_of,
-      :successor_of, :should_passthru, :datacite_errors
+      :publisher, :contributor, :same_as, :is_previous_version_of, :is_new_version_of,
+      :should_passthru, :datacite_errors, :date_accepted, :date_available,
+      :date_copyrighted, :date_collected, :date_submitted, :date_valid,
+      :is_cited_by, :cites, :is_supplement_to, :is_supplemented_by,
+      :is_continued_by, :continues, :has_metadata, :is_metadata_for,
+      :is_referenced_by, :references, :is_documented_by, :documents,
+      :is_compiled_by, :compiles, :is_variant_form_of, :is_original_form_of,
+      :is_reviewed_by, :reviews, :is_derived_from, :is_source_of, :format,
+      :related_identifier
 
     def publication_year
       date_published && date_published[0..3]
@@ -31,22 +55,19 @@ module Bolognese
       [page_start, page_end].compact.join("-").presence
     end
 
-    def publisher_string
-      publisher.to_h.fetch("name", nil)
-    end
-
     def schema_org
-      { "@context" => id.present? ? "http://schema.org" : nil,
+      hsh = {
+        "@context" => id.present? ? "http://schema.org" : nil,
         "@type" => type,
         "@id" => id,
         "url" => url,
         "additionalType" => additional_type,
-        "name" => name,
+        "name" => title,
         "alternateName" => alternate_name,
-        "author" => author,
+        "author" => to_schema_org(author),
         "editor" => editor,
-        "description" => description,
-        "license" => license,
+        "description" => description.present? ? description["text"] : nil,
+        "license" => license.present? ? license["id"] : nil,
         "version" => version,
         "keywords" => keywords,
         "language" => language,
@@ -60,32 +81,72 @@ module Bolognese
         "sameAs" => same_as,
         "isPartOf" => is_part_of,
         "hasPart" => has_part,
-        "predecessor_of" => predecessor_of,
-        "successor_of" => successor_of,
-        "citation" => citation,
+        "predecessor_of" => is_previous_version_of,
+        "successor_of" => is_new_version_of,
+        "citation" => references,
         "schemaVersion" => schema_version,
-        "publisher" => publisher,
+        "publisher" => { "@type" => "Organization", "name" => publisher },
         "funder" => funder,
+        "provider" => { "@type" => "Organization", "name" => provider }
+      }.compact
+      JSON.pretty_generate hsh
+    end
+
+    def datacite_json
+      hsh = {
+        "id" => id,
+        "doi" => doi,
+        "creator" => author,
+        "title" => title,
+        "publisher" => publisher,
+        "publication-year" => publication_year,
+        "resource-type-general" => resource_type_general,
+        "resource-type" => additional_type,
+        "subject" => keywords.present? ? keywords.split(", ") : nil,
+        "contributor" => contributor,
+        "date-accepted" => date_accepted,
+        "date-available" => date_available,
+        "date-copyrighted" => date_copyrighted,
+        "date-collected" => date_collected,
+        "date-created" => date_created,
+        "date-published" => date_published,
+        "date-modified" => date_modified,
+        "date-submitted" => date_submitted,
+        "date-valid" => date_valid,
+        "language" => language,
+        "alternate-identifier" => alternate_name,
+        "related_identifier" => related_identifier,
+        "size" => content_size,
+        "format" => format,
+        "version" => version,
+        "rights" => license,
+        "description" => description,
+        "geo-location" => spatial_coverage,
+        "funding-reference" => funder,
+        "schemaVersion" => schema_version,
         "provider" => provider
-      }.compact.to_json
+      }.compact
+      JSON.pretty_generate hsh
     end
 
     def codemeta
-      { "@context" => id.present? ? "https://raw.githubusercontent.com/codemeta/codemeta/master/codemeta.jsonld" : nil,
+      hsh = {
+        "@context" => id.present? ? "https://raw.githubusercontent.com/codemeta/codemeta/master/codemeta.jsonld" : nil,
         "@type" => type,
         "@id" => id,
         "identifier" => id,
         "codeRepository" => url,
-        "title" => name,
+        "title" => title,
         "agents" => author,
-        "description" => description,
+        "description" => description.present? ? description["text"] : nil,
         "version" => version,
         "tags" => keywords.to_s.split(", ").presence,
         "dateCreated" => date_created,
         "datePublished" => date_published,
         "dateModified" => date_modified,
         "publisher" => publisher
-      }.compact.to_json
+      }.compact
+      JSON.pretty_generate hsh
     end
 
     def bibtex
@@ -97,10 +158,10 @@ module Bolognese
         author: authors_as_string(author),
         keywords: keywords,
         language: language,
-        title: name,
+        title: title,
         journal: journal,
         pages: pagination,
-        publisher: publisher_string,
+        publisher: publisher,
         year: publication_year
       }.compact
       BibTeX::Entry.new(bib).to_s

data/lib/bolognese/schema_org.rb

@@ -1,6 +1,15 @@
 module Bolognese
   class SchemaOrg < Metadata
 
+    SO_TO_DC_RELATION_TYPES = {
+      "citation" => "References",
+      "sameAs" => "IsIdenticalTo",
+      "isPartOf" => "IsPartOf",
+      "hasPart" => "HasPart",
+      "isPredecessor" => "IsPreviousVersionOf",
+      "isSuccessor" => "IsNewVersionOf"
+    }
+
     def initialize(id: nil, string: nil)
       id = normalize_id(id) if id.present?
 
@@ -53,7 +62,7 @@ module Bolognese
       Bolognese::Bibtex::SO_TO_BIB_TRANSLATIONS[type] || "misc"
     end
 
-    def name
+    def title
       metadata.fetch("name", nil)
     end
 
@@ -62,21 +71,21 @@ module Bolognese
     end
 
     def author
-      arr = Array.wrap(metadata.fetch("author", nil)).map { |a| a.except("name") }
-      array_unwrap(arr)
+      authors = from_schema_org(Array.wrap(metadata.fetch("author", nil)))
+      get_authors(authors)
     end
 
     def editor
-      arr = Array.wrap(metadata.fetch("editor", nil)).map { |a| a.except("name") }
-      array_unwrap(arr)
+      editors = from_schema_org(Array.wrap(metadata.fetch("editor", nil)))
+      get_authors(editors)
     end
 
     def description
-      metadata.fetch("description", nil)
+      { "text" => metadata.fetch("description", nil) }
     end
 
     def license
-      metadata.fetch("license", nil)
+      { "id" => metadata.fetch("license", nil) }
     end
 
     def version
@@ -99,28 +108,45 @@ module Bolognese
       metadata.fetch("dateModified", nil)
     end
 
-    def related_identifiers(relation_type)
-      normalize_ids(metadata.fetch(relation_type, nil))
+    def related_identifier
+      Array.wrap(is_identical_to) +
+      Array.wrap(is_part_of) +
+      Array.wrap(has_part) +
+      Array.wrap(is_previous_version_of) +
+      Array.wrap(is_new_version_of) +
+      Array.wrap(references)
+    end
+
+    def get_related_identifier(relation_type: nil)
+      normalize_ids(metadata.fetch(relation_type, nil), SO_TO_DC_RELATION_TYPES[relation_type])
     end
 
-    def same_as
-      related_identifiers("isIdenticalTo")
+    def is_identical_to
+      get_related_identifier(relation_type: "sameAs")
     end
 
     def is_part_of
-      related_identifiers("isPartOf")
+      get_related_identifier(relation_type: "isPartOf")
     end
 
     def has_part
-      related_identifiers("hasPart")
+      get_related_identifier(relation_type: "hasPart")
+    end
+
+    def is_previous_version_of
+      get_related_identifier(relation_type: "isPredecessor")
+    end
+
+    def is_new_version_of
+      get_related_identifier(relation_type: "isSuccessor")
     end
 
-    def citation
-      related_identifiers("citation")
+    def references
+      get_related_identifier(relation_type: "citation")
     end
 
     def publisher
-      metadata.fetch("publisher", nil)
+      metadata.dig("publisher", "name")
     end
 
     def container_title

data/lib/bolognese/utils.rb

@@ -1,5 +1,13 @@
 module Bolognese
   module Utils
+    LICENSE_NAMES = {
+      "http://creativecommons.org/publicdomain/zero/1.0/" => "Public Domain (CC0 1.0)",
+      "http://creativecommons.org/licenses/by/3.0/" => "Creative Commons Attribution 3.0 (CC-BY 3.0)",
+      "http://creativecommons.org/licenses/by/4.0/" => "Creative Commons Attribution 4.0 (CC-BY 4.0)",
+      "http://creativecommons.org/licenses/by-nc/4.0/" => "Creative Commons Attribution Noncommercial 4.0 (CC-BY-NC 4.0)",
+      "http://creativecommons.org/licenses/by-sa/4.0/" => "Creative Commons Attribution Share Alike 4.0 (CC-BY-SA 4.0)",
+      "http://creativecommons.org/licenses/by-nc-nd/4.0/" => "Creative Commons Attribution Noncommercial No Derivatives 4.0 (CC-BY-NC-ND 4.0)"
+    }
 
     def find_from_format(id: nil, string: nil, ext: nil, filename: nil)
       if id.present?
@@ -30,6 +38,8 @@ module Bolognese
         "crossref"
       elsif options[:ext] == ".xml" && Maremma.from_xml(string).dig("resource", "xmlns").start_with?("http://datacite.org/schema/kernel")
         "datacite"
+      elsif options[:ext] == ".json" && Maremma.from_json(string).dig("resource", "xmlns").to_s.start_with?("http://datacite.org/schema/kernel")
+        "datacite_json"
       elsif options[:filename] == "codemeta.json"
         "codemeta"
       end
@@ -41,6 +51,7 @@ module Bolognese
             when "crossref" then Crossref.new(id: id, string: string)
             when "datacite" then Datacite.new(id: id, string: string, regenerate: options[:regenerate])
             when "codemeta" then Codemeta.new(id: id, string: string)
+            when "datacite_json" then DataciteJson.new(string: string)
             when "bibtex" then Bibtex.new(string: string)
             else SchemaOrg.new(id: id)
             end
@@ -83,21 +94,12 @@ module Bolognese
       elsif element.is_a?(Hash)
         element.fetch(content, nil)
       elsif element.is_a?(Array)
-        a = element.map { |e| e.fetch(content, nil) }.uniq
-        array_unwrap(a)
+        a = element.map { |e| e.fetch(content, nil) }.uniq.unwrap
       else
         nil
       end
     end
 
-    def array_unwrap(element)
-      case element.length
-      when 0 then nil
-      when 1 then element.first
-      else element
-      end
-    end
-
     def normalize_id(id)
       return nil unless id.present?
 
@@ -112,9 +114,73 @@ module Bolognese
       "http://orcid.org/" + Addressable::URI.encode(orcid)
     end
 
-    def normalize_ids(list)
-      arr = Array.wrap(list).map { |url| url.merge("@id" => normalize_id(url["@id"])) }
-      array_unwrap(arr)
+    def normalize_ids(list, relation_type = "References")
+      Array.wrap(list).map do |url|
+        { "id" => normalize_id(url["@id"]),
+          "type" => url["@type"],
+          "name" => url["name"],
+          "relationType" => relation_type }.compact
+      end.unwrap
+    end
+
+    # find Creative Commons or OSI license in licenses array, normalize url and name
+    def normalize_licenses(licenses)
+      standard_licenses = Array.wrap(licenses).map { |l| URI.parse(l["url"]) }.select { |li| li.host && li.host[/(creativecommons.org|opensource.org)$/] }
+      return licenses unless standard_licenses.present?
+
+      # use HTTPS
+      uri.scheme = "https"
+
+      # use host name without subdomain
+      uri.host = Array(/(creativecommons.org|opensource.org)/.match uri.host).last
+
+      # normalize URLs
+      if uri.host == "creativecommons.org"
+        uri.path = uri.path.split('/')[0..-2].join("/") if uri.path.split('/').last == "legalcode"
+        uri.path << '/' unless uri.path.end_with?('/')
+      else
+        uri.path = uri.path.gsub(/(-license|\.php|\.html)/, '')
+        uri.path = uri.path.sub(/(mit|afl|apl|osl|gpl|ecl)/) { |match| match.upcase }
+        uri.path = uri.path.sub(/(artistic|apache)/) { |match| match.titleize }
+        uri.path = uri.path.sub(/([^0-9\-]+)(-)?([1-9])?(\.)?([0-9])?$/) do
+          m = Regexp.last_match
+          text = m[1]
+
+          if m[3].present?
+            version = [m[3], m[5].presence || "0"].join(".")
+            [text, version].join("-")
+          else
+            text
+          end
+        end
+      end
+
+      uri.to_s
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def to_schema_org(element)
+      Array.wrap(element).map do |a|
+        a["@type"] = a["type"]
+        a["@id"] = a["id"]
+        a.except("type", "id").compact
+      end.unwrap
+    end
+
+    def from_schema_org(element)
+      Array.wrap(element).map do |a|
+        a["type"] = a["@type"]
+        a["id"] = a["@id"]
+        a.except("@type", "@id").compact
+      end.unwrap
+    end
+
+    def sanitize(text, options={})
+      options[:tags] ||= Set.new(%w(strong em b i code pre sub sup br))
+      custom_scrubber = Bolognese::WhitelistScrubber.new(options)
+
+      Loofah.scrub_fragment(text, custom_scrubber).to_s.gsub(/\u00a0/, ' ').strip
     end
 
     def github_from_url(url)

data/lib/bolognese/version.rb

@@ -1,3 +1,3 @@
 module Bolognese
-  VERSION = "0.7.2"
+  VERSION = "0.8"
 end

data/lib/bolognese/whitelist_scrubber.rb

@@ -0,0 +1,45 @@
+# modified from https://gist.github.com/ivan-kolmychek/ee2fdc53f3e2c637271d
+
+module Bolognese
+  class WhitelistScrubber < Loofah::Scrubber
+    def initialize(options={})
+      @direction = :bottom_up
+      @tags = options[:tags]
+      @attributes = options[:attributes]
+    end
+
+    def scrub(node)
+      scrub_node_attributes(node) and return CONTINUE if node_allowed?(node)
+      node.before node.children
+      node.remove
+    end
+
+    private
+
+    def scrub_node_attributes(node)
+      fallback_scrub_node_attributes(node) and return true unless @attributes.present? && @attributes.respond_to?(:include?)
+      node.attribute_nodes.each do |attr_node|
+        attr_node.remove unless @attributes.include?(attr_node.name)
+      end
+    end
+
+    def allowed_not_element_node_types
+      [ Nokogiri::XML::Node::TEXT_NODE, Nokogiri::XML::Node::CDATA_SECTION_NODE ]
+    end
+
+    def fallback_scrub_node_attributes(node)
+      Loofah::HTML5::Scrub.scrub_attributes(node)
+    end
+
+    def fallback_allowed_element_detection(node)
+      Loofah::HTML5::Scrub.allowed_element?(node.name)
+    end
+
+    def node_allowed?(node)
+      return fallback_allowed_element_detection(node) unless @tags.present? && @tags.respond_to?(:include?)
+      return true if allowed_not_element_node_types.include?(node.type)
+      return false unless node.type == Nokogiri::XML::Node::ELEMENT_NODE
+      @tags.include? node.name
+    end
+  end
+end