bolognese 0.4.3 → 0.5

data/lib/bolognese/cli.rb

@@ -2,8 +2,14 @@
 
 require "thor"
 
+require_relative 'doi_utils'
+require_relative 'utils'
+
 module Bolognese
   class CLI < Thor
+    include Bolognese::DoiUtils
+    include Bolognese::Utils
+
     def self.exit_on_failure?
       true
     end
@@ -16,26 +22,21 @@ module Bolognese
       puts Bolognese::VERSION
     end
 
-    desc "read pid", "read metadata for PID"
+    desc "read id", "read metadata for ID"
     method_option :as, default: "schema_org"
-    def read(pid)
-      provider = Metadata.new(id: pid).provider
-
-      case
-      when provider == "crossref" && options[:as] == "crossref"
-        puts Crossref.new(id: pid).raw
-      when provider == "crossref" && options[:as] == "datacite"
-        puts Crossref.new(id: pid).as_datacite
-      when provider == "crossref"
-        puts Crossref.new(id: pid).as_schema_org
-      when provider == "datacite" && options[:as] == "datacite"
-        puts Datacite.new(id: pid).raw
-      when provider == "datacite"
-        puts Datacite.new(id: pid).as_schema_org
-      when provider == "schema_org" && options[:as] == "datacite"
-        puts SchemaOrg.new(id: pid).as_datacite
-      when provider == "schema_org"
-        puts SchemaOrg.new(id: pid).as_schema_org
+    def read(id)
+      id = normalize_id(id)
+      provider = find_provider(id)
+      output = options[:as] || "schema_org"
+
+      if provider.present?
+        p = case provider
+            when "crossref" then Crossref.new(id: id)
+            when "datacite" then Datacite.new(id: id)
+            else SchemaOrg.new(id: id)
+            end
+
+        puts p.send(output)
       else
         puts "not implemented"
       end

data/lib/bolognese/crossref.rb

@@ -31,8 +31,6 @@ module Bolognese
       "PostedContent" => nil
     }
 
-    attr_reader = :id, :raw, :metadata, :schema_org
-
     def initialize(id: nil, string: nil)
       id = normalize_doi(id) if id.present?
 
@@ -44,6 +42,10 @@ module Bolognese
       end
     end
 
+    alias_method :crossref, :raw
+    alias_method :as_crossref, :raw
+    alias_method :schema_org, :as_schema_org
+
     def metadata
       @metadata ||= raw.present? ? Maremma.from_xml(raw).fetch("doi_records", {}).fetch("doi_record", {}) : {}
     end
@@ -120,23 +122,17 @@ module Bolognese
       end
     end
 
-    def keywords
-
-    end
-
     def author
-      person = bibliographic_metadata.dig("contributors", "person_name")
-      Array(person).select { |a| a["contributor_role"] == "author" }.map do |a|
-        { "@type" => "Person",
-          "@id" => parse_attribute(a["ORCID"]),
-          "givenName" => a["given_name"],
-          "familyName" => a["surname"] }.compact
-      end
+      people("author")
     end
 
     def editor
+      people("editor")
+    end
+
+    def people(contributor_role)
       person = bibliographic_metadata.dig("contributors", "person_name")
-      Array(person).select { |a| a["contributor_role"] == "editor" }.map do |a|
+      Array(person).select { |a| a["contributor_role"] == contributor_role }.map do |a|
         { "@type" => "Person",
           "@id" => parse_attribute(a["ORCID"]),
           "givenName" => a["given_name"],
@@ -144,14 +140,6 @@ module Bolognese
       end.presence
     end
 
-    def version
-
-    end
-
-    def date_created
-
-    end
-
     def date_published
       pub_date = bibliographic_metadata.fetch("publication_date", nil) ||
         bibliographic_metadata.fetch("acceptance_date", nil)
@@ -188,15 +176,11 @@ module Bolognese
       is_part_of.fetch("name", nil)
     end
 
-    def has_part
-
-    end
-
     def citation
        citations = bibliographic_metadata.dig("citation_list", "citation")
        Array.wrap(citations).map do |c|
          { "@type" => "CreativeWork",
-           "@id" => normalize_url(c["doi"]),
+           "@id" => normalize_id(c["doi"]),
            "position" => c["key"],
            "name" => c["article_title"],
            "datePublished" => c["cYear"] }.compact
@@ -207,27 +191,5 @@ module Bolognese
       { "@type" => "Organization",
         "name" => "Crossref" }
     end
-
-    def as_schema_org
-      { "@context" => "http://schema.org",
-        "@type" => type,
-        "@id" => id,
-        "additionalType" => additional_type,
-        "name" => name,
-        "alternateName" => alternate_name,
-        "author" => author,
-        "editor" => editor,
-        "description" => description,
-        "license" => license,
-        "datePublished" => date_published,
-        "dateModified" => date_modified,
-        "pageStart" => page_start,
-        "pageEnd" => page_end,
-        "isPartOf" => is_part_of,
-        "hasPart" => has_part,
-        "citation" => citation,
-        "provider" => provider
-      }.compact
-    end
   end
 end

data/lib/bolognese/datacite.rb

@@ -18,8 +18,6 @@ module Bolognese
       "Other" => "CreativeWork"
     }
 
-    attr_reader = :id, :raw, :metadata, :schema_org
-
     def initialize(id: nil, string: nil)
       id = normalize_doi(id) if id.present?
 
@@ -31,6 +29,9 @@ module Bolognese
       end
     end
 
+    alias_method :datacite, :raw
+    alias_method :schema_org, :as_schema_org
+
     def metadata
       @metadata ||= raw.present? ? Maremma.from_xml(raw).fetch("resource", {}) : {}
     end
@@ -79,17 +80,19 @@ module Bolognese
     end
 
     def keywords
-      Array(metadata.dig("subjects", "subject")).join(", ")
+      Array.wrap(metadata.dig("subjects", "subject")).join(", ").presence
     end
 
     def author
       authors = metadata.dig("creators", "creator")
       authors = [authors] if authors.is_a?(Hash)
-      get_authors(authors)
+      get_authors(authors).presence
     end
 
     def editor
-
+      editors = metadata.dig("contributors", "contributor")
+      editors = [editors] if editors.is_a?(Hash)
+      get_authors(editors).presence
     end
 
     def version
@@ -100,19 +103,21 @@ module Bolognese
       Array.wrap(metadata.dig("dates", "date"))
     end
 
+    def date(date_type)
+      dd = dates.find { |d| d["dateType"] == date_type } || {}
+      dd.fetch("text", nil)
+    end
+
     def date_created
-      created = dates.find { |d| d["dateType"] == "Created" } || {}
-      created.fetch("text", nil)
+      date("Created")
     end
 
     def date_published
-      published = dates.find { |d| d["dateType"] == "Issued" } || {}
-      published.fetch("text", nil) || metadata.fetch("publicationYear")
+      date("Issued") || metadata.fetch("publicationYear")
     end
 
     def date_modified
-      modified = dates.find { |d| d["dateType"] == "Updated" } || {}
-      modified.fetch("text", nil)
+      date("Updated")
     end
 
     def related_identifiers(relation_type)
@@ -150,27 +155,5 @@ module Bolognese
       { "@type" => "Organization",
         "name" => "DataCite" }
     end
-
-    def as_schema_org
-      { "@context" => "http://schema.org",
-        "@type" => type,
-        "@id" => id,
-        "name" => name,
-        "alternateName" => alternate_name,
-        "author" => author,
-        "description" => description,
-        "license" => license,
-        "version" => version,
-        "keywords" => keywords,
-        "dateCreated" => date_created,
-        "datePublished" => date_published,
-        "dateModified" => date_modified,
-        "isPartOf" => is_part_of,
-        "hasPart" => has_part,
-        "citation" => citation,
-        "publisher" => publisher,
-        "provider" => provider
-      }.compact
-    end
   end
 end

data/lib/bolognese/datacite_utils.rb

@@ -2,16 +2,24 @@ module Bolognese
   module DataciteUtils
 
     SO_TO_DC_TRANSLATIONS = {
-      "VideoObject" => "Audiovisual",
+      "Article" => "Text",
+      "AudioObject" => "Sound",
+      "Blog" => "Text",
+      "BlogPosting" => "Text",
       "Collection" => "Collection",
+      "CreativeWork" => "Other",
+      "DataCatalog" => "Dataset",
       "Dataset" => "Dataset",
       "Event" => "Event",
       "ImageObject" => "Image",
+      "Movie" => "Audiovisual",
+      "PublicationIssue" => "Text",
+      "ScholarlyArticle" => "Text",
       "Service" => "Service",
       "SoftwareSourceCode" => "Software",
-      "AudioObject" => "Sound",
-      "ScholarlyArticle" => "Text",
-      "CreativeWork" => "Other"
+      "VideoObject" => "Audiovisual",
+      "WebPage" => "Text",
+      "WebSite" => "Text"
     }
 
     LICENSE_NAMES = {
@@ -114,13 +122,19 @@ module Bolognese
     end
 
     def insert_publication_year(xml)
-      xml.publicationYear(date_published[0..3])
+      xml.publicationYear(date_published && date_published[0..3])
+    end
+
+    def resource_type
+      { "resource_type_general" => SO_TO_DC_TRANSLATIONS[type] || "Other",
+        "text" => additional_type || type }
     end
 
     def insert_resource_type(xml)
       return xml unless type.present?
 
-      xml.resourceType(additional_type, 'resourceTypeGeneral' => SO_TO_DC_TRANSLATIONS[type])
+      xml.resourceType(resource_type["text"],
+        'resourceTypeGeneral' => resource_type["resource_type_general"])
     end
 
     def insert_alternate_identifiers(xml)
@@ -160,28 +174,17 @@ module Bolognese
     end
 
     def rel_identifiers
-      ipo = Array.wrap(is_part_of).map do |i|
-        {
-          "text" => i["@id"],
-          "related_identifier_type" => validate_url(i["@id"]),
-          "relation_type" => "IsPartOf" }
-      end.select { |i| i["related_identifier_type"].present? }
-
-      hp = Array.wrap(has_part).map do |i|
-        {
-          "text" => i["@id"],
-          "related_identifier_type" => validate_url(i["@id"]),
-          "relation_type" => "HasPart" }
-      end.select { |i| i["related_identifier_type"].present? }
+      rel_identifier(rel_ids: is_part_of, relation_type: "IsPartOf") +
+      rel_identifier(rel_ids: has_part, relation_type: "HasPart") +
+      rel_identifier(rel_ids: citation, relation_type: "References")
+    end
 
-      c = Array.wrap(citation).map do |i|
-        {
-          "text" => i["@id"],
+    def rel_identifier(rel_ids: nil, relation_type: nil)
+      Array.wrap(rel_ids).map do |i|
+        { "text" => i["@id"],
           "related_identifier_type" => validate_url(i["@id"]),
-          "relation_type" => "References" }
+          "relation_type" => relation_type }
       end.select { |i| i["related_identifier_type"].present? }
-
-      ipo + hp + c
     end
 
     def insert_related_identifiers(xml)

data/lib/bolognese/doi_utils.rb

@@ -9,7 +9,7 @@ module Bolognese
       return nil unless doi.present?
 
       # remove non-printing whitespace and downcase
-      doi = doi.gsub(/\u200B/, '').downcase
+      doi = doi.delete("\u200B").downcase
 
       # turn DOI into URL, escape unsafe characters
       "https://doi.org/" + Addressable::URI.encode(doi)

data/lib/bolognese/metadata.rb

@@ -14,23 +14,65 @@ module Bolognese
 
     attr_reader :id, :raw, :provider
 
-    def initialize(id: nil)
-      @id = normalize_id(id)
-      @provider = find_provider(@id)
+    alias_method :datacite, :as_datacite
+
+    def url
+
+    end
+
+    def version
+
+    end
+
+    def keywords
+
+    end
+
+    def date_created
+
     end
 
-    def normalize_id(id)
-      normalize_doi(id) || normalize_orcid(id)
+    def page_start
+
+    end
+
+    def page_end
+
+    end
+
+    def has_part
+
+    end
+
+    def publisher
+
     end
 
-    def find_provider(id)
-      if /\A(?:(http|https):\/\/(dx\.)?doi.org\/)?(doi:)?(10\.\d{4,5}\/.+)\z/.match(id)
-        get_doi_ra(id).fetch("id", nil)
-      elsif /\A(?:(http|https):\/\/orcid\.org\/)?(\d{4}-\d{4}-\d{4}-\d{3}[0-9X]+)\z/.match(id)
-        "orcid"
-      else
-        "schema_org"
-      end
+    def as_schema_org
+      { "@context" => "http://schema.org",
+        "@type" => type,
+        "@id" => id,
+        "url" => url,
+        "additionalType" => additional_type,
+        "name" => name,
+        "alternateName" => alternate_name,
+        "author" => author,
+        "editor" => editor,
+        "description" => description,
+        "license" => license,
+        "version" => version,
+        "keywords" => keywords,
+        "dateCreated" => date_created,
+        "datePublished" => date_published,
+        "dateModified" => date_modified,
+        "pageStart" => page_start,
+        "pageEnd" => page_end,
+        "isPartOf" => is_part_of,
+        "hasPart" => has_part,
+        "citation" => citation,
+        "publisher" => publisher,
+        "provider" => provider
+      }.compact.to_json
     end
   end
 end

data/lib/bolognese/schema_org.rb

@@ -1,46 +1,22 @@
 module Bolognese
   class SchemaOrg < Metadata
 
-    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, :metadata, :schema_org
-
     def initialize(id: nil, string: nil)
-      id = normalize_url(id) if id.present?
+      id = normalize_id(id) if id.present?
 
       if string.present?
         @raw = string
       elsif id.present?
         response = Maremma.get(id)
-        @raw = response.body.fetch("data", nil)
+        doc = Nokogiri::XML(response.body.fetch("data", nil))
+        @raw = doc.at_xpath('//script[@type="application/ld+json"]')
       end
     end
 
+    alias_method :schema_org, :as_schema_org
+
     def metadata
-      @metadata ||= begin
-        if raw.present?
-          doc = Nokogiri::XML(raw)
-          tag = doc.at_xpath('//script[@type="application/ld+json"]')
-          Maremma.from_json(tag)
-        else
-          {}
-        end
-      end
+      @metadata ||= raw.present? ? Maremma.from_json(raw) : {}
     end
 
     def exists?
@@ -52,11 +28,11 @@ module Bolognese
     end
 
     def id
-      normalize_url(metadata.fetch("@id", nil))
+      normalize_id(metadata.fetch("@id", nil))
     end
 
     def url
-      normalize_url(metadata.fetch("url", nil))
+      normalize_id(metadata.fetch("url", nil))
     end
 
     def type
@@ -76,11 +52,11 @@ module Bolognese
     end
 
     def author
-      Array(metadata.fetch("author", nil)).map { |a| a.except("name") }
+      Array(metadata.fetch("author", nil)).map { |a| a.except("name") }.presence
     end
 
     def editor
-      Array(metadata.fetch("editor", nil)).map { |a| a.except("name") }
+      Array(metadata.fetch("editor", nil)).map { |a| a.except("name") }.presence
     end
 
     def description
@@ -120,11 +96,11 @@ module Bolognese
     end
 
     def has_part
-      related_identifiers("hasPart")
+      related_identifiers("hasPart").presence
     end
 
     def citation
-      related_identifiers("citation")
+      related_identifiers("citation").presence
     end
 
     def publisher
@@ -142,29 +118,5 @@ module Bolognese
     def provider
       metadata.fetch("provider", nil)
     end
-
-    def as_schema_org
-      { "@context" => "http://schema.org",
-        "@type" => type,
-        "@id" => id,
-        "url" => url,
-        "name" => name,
-        "alternateName" => alternate_name,
-        "author" => author,
-        "editor" => editor,
-        "description" => description,
-        "license" => license,
-        "version" => version,
-        "keywords" => keywords,
-        "dateCreated" => date_created,
-        "datePublished" => date_published,
-        "dateModified" => date_modified,
-        "isPartOf" => is_part_of,
-        "hasPart" => has_part,
-        "citation" => citation,
-        "publisher" => publisher,
-        "provider" => provider
-      }.compact
-    end
   end
 end