briard 2.4.1 → 2.6.0

data/lib/briard/metadata.rb

@@ -6,17 +6,13 @@ module Briard
   class Metadata
     include Briard::MetadataUtils
 
-    attr_accessor :string, :from, :sandbox, :meta, :regenerate, :issue, :show_errors
+    attr_accessor :string, :from, :sandbox, :meta, :regenerate, :issue, :show_errors, :depositor,
+                  :email, :registrant
     attr_reader :doc, :page_start, :page_end
-    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, :language, :sizes,
-                :formats, :schema_version, :meta, :container, :agency,
-                :format, :funding_references, :state, :geo_locations,
-                :types, :content_url, :related_identifiers, :related_items, :style, :locale, :date_registered,
-                :depositor, :email, :registrant
-
-    def initialize(options={})
+    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, :language, :sizes, :formats, :schema_version, :meta, :container, :agency, :format, :funding_references, :state, :geo_locations, :types, :content_url, :related_identifiers, :related_items, :style, :locale, :date_registered
+
+    def initialize(options = {})
       options.symbolize_keys!
 
       id = normalize_id(options[:input], options)
@@ -26,64 +22,69 @@ module Briard
         @from = options[:from] || find_from_format(id: id)
 
         # mEDRA, KISTI, JaLC and OP DOIs are found in the Crossref index
-        if @from == "medra"
-          ra = "mEDRA"
-        elsif @from == "kisti"
-          ra = "KISTI"
-        elsif @from == "jalc"
-          ra = "JaLC"
-        elsif @from == "op"
-          ra = "OP"
+        case @from
+        when 'medra'
+          ra = 'mEDRA'
+        when 'kisti'
+          ra = 'KISTI'
+        when 'jalc'
+          ra = 'JaLC'
+        when 'op'
+          ra = 'OP'
         end
 
         # generate name for method to call dynamically
-        hsh = @from.present? ? send("get_" + @from, id: id, sandbox: options[:sandbox]) : {}
-        string = hsh.fetch("string", nil)
+        hsh = @from.present? ? send("get_#{@from}", id: id, sandbox: options[:sandbox]) : {}
+        string = hsh.fetch('string', nil)
 
       elsif options[:input].present? && File.exist?(options[:input])
         filename = File.basename(options[:input])
         ext = File.extname(options[:input])
-        if %w(.bib .ris .xml .json .cff).include?(ext)
+        if %w[.bib .ris .xml .json .cff].include?(ext)
           hsh = {
-            "url" => options[:url],
-            "state" => options[:state],
-            "date_registered" => options[:date_registered],
-            "date_updated" => options[:date_updated],
-            "provider_id" => options[:provider_id],
-            "client_id" => options[:client_id],
-            "depositor" => options[:depositor],
-            "email" => options[:email],
-            "registrant" => options[:registrant],
-            "content_url" => options[:content_url] }
-          string = IO.read(options[:input])
+            'url' => options[:url],
+            'state' => options[:state],
+            'date_registered' => options[:date_registered],
+            'date_updated' => options[:date_updated],
+            'provider_id' => options[:provider_id],
+            'client_id' => options[:client_id],
+            'depositor' => options[:depositor],
+            'email' => options[:email],
+            'registrant' => options[:registrant],
+            'content_url' => options[:content_url]
+          }
+          string = File.read(options[:input])
           @from = options[:from] || find_from_format(string: string, filename: filename, ext: ext)
         else
-          $stderr.puts "File type #{ext} not supported"
+          warn "File type #{ext} not supported"
           exit 1
         end
       else
         hsh = {
-          "url" => options[:url],
-          "state" => options[:state],
-          "date_registered" => options[:date_registered],
-          "date_updated" => options[:date_updated],
-          "provider_id" => options[:provider_id],
-          "client_id" => options[:client_id],
-          "depositor" => options[:depositor],
-          "email" => options[:email],
-          "registrant" => options[:registrant],
-          "content_url" => options[:content_url],
-          "creators" => options[:creators],
-          "contributors" => options[:contributors],
-          "titles" => options[:titles],
-          "publisher" => options[:publisher],
-          "publication_year" => options[:publication_year] }
+          'url' => options[:url],
+          'state' => options[:state],
+          'date_registered' => options[:date_registered],
+          'date_updated' => options[:date_updated],
+          'provider_id' => options[:provider_id],
+          'client_id' => options[:client_id],
+          'depositor' => options[:depositor],
+          'email' => options[:email],
+          'registrant' => options[:registrant],
+          'content_url' => options[:content_url],
+          'creators' => options[:creators],
+          'contributors' => options[:contributors],
+          'titles' => options[:titles],
+          'publisher' => options[:publisher],
+          'publication_year' => options[:publication_year]
+        }
         string = options[:input]
         @from = options[:from] || find_from_format(string: string)
       end
 
       # make sure input is encoded as utf8
-      dup_string = string.dup.force_encoding("UTF-8").encode! if string.present? && string.is_a?(String)
+      if string.present? && string.is_a?(String)
+        dup_string = string.dup.force_encoding('UTF-8').encode!
+      end
       @string = dup_string
 
       # input options for citation formatting
@@ -93,19 +94,19 @@ module Briard
       @sandbox = options[:sandbox]
 
       # options that come from the datacite database
-      @url = hsh.to_h["url"].presence || options[:url].presence
-      @state = hsh.to_h["state"].presence
-      @date_registered = hsh.to_h["date_registered"].presence
-      @date_updated = hsh.to_h["date_updated"].presence
-      @provider_id = hsh.to_h["provider_id"].presence
-      @client_id = hsh.to_h["client_id"].presence
-      @content_url = hsh.to_h["content_url"].presence
+      @url = hsh.to_h['url'].presence || options[:url].presence
+      @state = hsh.to_h['state'].presence
+      @date_registered = hsh.to_h['date_registered'].presence
+      @date_updated = hsh.to_h['date_updated'].presence
+      @provider_id = hsh.to_h['provider_id'].presence
+      @client_id = hsh.to_h['client_id'].presence
+      @content_url = hsh.to_h['content_url'].presence
 
       # options that come from the submission, needed
       # for crossref doi registration
-      @depositor = hsh.to_h["depositor"].presence
-      @email = hsh.to_h["email"].presence
-      @registrant = hsh.to_h["registrant"].presence
+      @depositor = hsh.to_h['depositor'].presence
+      @email = hsh.to_h['email'].presence
+      @registrant = hsh.to_h['registrant'].presence
 
       # set attributes directly
       read_options = options.slice(
@@ -133,40 +134,29 @@ module Briard
 
       @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)
-      @meta = @from.present? ? send("read_" + @from, **opts) : {}
-    end
-
-    def depositor
-      @depositor
-    end
-
-    def email
-      @email
-    end
-
-    def registrant
-      @registrant
+      opts = { string: string, sandbox: options[:sandbox], doi: options[:doi], id: id,
+               ra: ra }.merge(read_options)
+      @meta = @from.present? ? send("read_#{@from}", **opts) : {}
     end
 
     def id
-      @id ||= meta.fetch("id", nil)
+      @id ||= meta.fetch('id', nil)
     end
 
     def doi
-      @doi ||= meta.fetch("doi", nil)
+      @doi ||= meta.fetch('doi', nil)
     end
 
     def provider_id
-      @provider_id ||= meta.fetch("provider_id", nil)
+      @provider_id ||= meta.fetch('provider_id', nil)
     end
 
     def client_id
-      @client_id ||= meta.fetch("client_id", nil)
+      @client_id ||= meta.fetch('client_id', nil)
     end
 
     def exists?
-      (@state || meta.fetch("state", nil)) != "not_found"
+      (@state || meta.fetch('state', nil)) != 'not_found'
     end
 
     def valid?
@@ -175,111 +165,111 @@ module Briard
 
     # validate against DataCite schema, unless already errors in the reader
     def errors
-      meta.fetch("errors", nil) || datacite_errors(xml: datacite, schema_version: schema_version)
+      meta.fetch('errors', nil) || datacite_errors(xml: datacite, schema_version: schema_version)
     end
 
     def descriptions
-      @descriptions ||= meta.fetch("descriptions", nil)
+      @descriptions ||= meta.fetch('descriptions', nil)
     end
 
     def rights_list
-      @rights_list ||= meta.fetch("rights_list", nil)
+      @rights_list ||= meta.fetch('rights_list', nil)
     end
 
     def subjects
-      @subjects ||= meta.fetch("subjects", nil)
+      @subjects ||= meta.fetch('subjects', nil)
     end
 
     def language
-      @language ||= meta.fetch("language", nil)
+      @language ||= meta.fetch('language', nil)
     end
 
     def sizes
-      @sizes ||= meta.fetch("sizes", nil)
+      @sizes ||= meta.fetch('sizes', nil)
     end
 
     def formats
-      @formats ||= meta.fetch("formats", nil)
+      @formats ||= meta.fetch('formats', nil)
     end
 
     def schema_version
-      @schema_version ||= meta.fetch("schema_version", nil)
+      @schema_version ||= meta.fetch('schema_version', nil)
     end
 
     def funding_references
-      @funding_references ||= meta.fetch("funding_references", nil)
+      @funding_references ||= meta.fetch('funding_references', nil)
     end
 
     def related_identifiers
-      @related_identifiers ||= meta.fetch("related_identifiers", nil)
+      @related_identifiers ||= meta.fetch('related_identifiers', nil)
     end
 
     def related_items
-      @related_items ||= meta.fetch("related_items", nil)
+      @related_items ||= meta.fetch('related_items', nil)
     end
 
     def url
-      @url ||= meta.fetch("url", nil)
+      @url ||= meta.fetch('url', nil)
     end
 
     def version_info
-      @version_info ||= meta.fetch("version_info", nil) || meta.fetch("version", nil)
+      @version_info ||= meta.fetch('version_info', nil) || meta.fetch('version', nil)
     end
 
     def publication_year
-      @publication_year ||= meta.fetch("publication_year", nil)
+      @publication_year ||= meta.fetch('publication_year', nil)
     end
 
     def container
-      @container ||= meta.fetch("container", nil)
+      @container ||= meta.fetch('container', nil)
     end
 
     def geo_locations
-      @geo_locations ||= meta.fetch("geo_locations", nil)
+      @geo_locations ||= meta.fetch('geo_locations', nil)
     end
 
     def dates
-      @dates ||= meta.fetch("dates", nil)
+      @dates ||= meta.fetch('dates', nil)
     end
 
     def publisher
-      @publisher ||= meta.fetch("publisher", nil)
+      @publisher ||= meta.fetch('publisher', nil)
     end
 
     def identifiers
-      @identifiers ||= meta.fetch("identifiers", nil)
+      @identifiers ||= meta.fetch('identifiers', nil)
     end
 
     def content_url
-      @content_url ||= meta.fetch("content_url", nil)
+      @content_url ||= meta.fetch('content_url', nil)
     end
 
     def agency
-      @agency ||= meta.fetch("agency", nil)
+      @agency ||= meta.fetch('agency', nil)
     end
 
     def state
-      @state ||= meta.fetch("state", nil)
+      @state ||= meta.fetch('state', nil)
     end
 
     def date_registered
-      @date_registered ||= meta.fetch("date_registered", nil)
+      @date_registered ||= meta.fetch('date_registered', nil)
     end
 
     def types
-      @types ||= meta.fetch("types", nil)
+      @types ||= meta.fetch('types', nil)
     end
 
     def titles
-      @titles ||= meta.fetch("titles", nil)
+      @titles ||= meta.fetch('titles', nil)
     end
 
     def creators
-      @creators ||= meta.fetch("creators", nil)
+      @creators ||= meta.fetch('creators', nil)
     end
 
     def contributors
-      @contributors ||= meta.fetch("contributors", nil)
+      @contributors ||= meta.fetch('contributors', nil)
     end
   end
-end
+end

data/lib/briard/metadata_utils.rb

@@ -86,25 +86,23 @@ module Briard
     # replace DOI in XML if provided in options
     def raw
       r = string.present? ? string.strip : nil
-      return r unless (from == "datacite" && r.present?)
+      return r unless from == 'datacite' && r.present?
 
       doc = Nokogiri::XML(string, nil, 'UTF-8', &:noblanks)
-      node = doc.at_css("identifier")
+      node = doc.at_css('identifier')
       node.content = doi.to_s.upcase if node.present? && doi.present?
       doc.to_xml.strip
     end
 
     def should_passthru
-      (from == "datacite") && regenerate.blank? && raw.present?
+      (from == 'datacite') && regenerate.blank? && raw.present?
     end
 
     def container_title
       if container.present?
-        container["title"]
-      elsif types["citeproc"] == "article-journal"
+        container['title']
+      elsif types['citeproc'] == 'article-journal'
         publisher
-      else
-        nil
       end
     end
 
@@ -114,16 +112,20 @@ module Briard
     end
 
     def reverse
-      { "citation" => Array.wrap(related_identifiers).select { |ri| ri["relationType"] == "IsReferencedBy" }.map do |r|
-        { "@id" => normalize_doi(r["relatedIdentifier"]),
-          "@type" => r["resourceTypeGeneral"] || "ScholarlyArticle",
-          "identifier" => r["relatedIdentifierType"] == "DOI" ? nil : to_identifier(r) }.compact
-        end.unwrap,
-        "isBasedOn" => Array.wrap(related_identifiers).select { |ri| ri["relationType"] == "IsSupplementTo" }.map do |r|
-          { "@id" => normalize_doi(r["relatedIdentifier"]),
-            "@type" => r["resourceTypeGeneral"] || "ScholarlyArticle",
-            "identifier" => r["relatedIdentifierType"] == "DOI" ? nil : to_identifier(r) }.compact
-        end.unwrap }.compact
+      { 'citation' => Array.wrap(related_identifiers).select do |ri|
+                        ri['relationType'] == 'IsReferencedBy'
+                      end.map do |r|
+                        { '@id' => normalize_doi(r['relatedIdentifier']),
+                          '@type' => r['resourceTypeGeneral'] || 'ScholarlyArticle',
+                          'identifier' => r['relatedIdentifierType'] == 'DOI' ? nil : to_identifier(r) }.compact
+                      end.unwrap,
+        'isBasedOn' => Array.wrap(related_identifiers).select do |ri|
+                         ri['relationType'] == 'IsSupplementTo'
+                       end.map do |r|
+                         { '@id' => normalize_doi(r['relatedIdentifier']),
+                           '@type' => r['resourceTypeGeneral'] || 'ScholarlyArticle',
+                           'identifier' => r['relatedIdentifierType'] == 'DOI' ? nil : to_identifier(r) }.compact
+                       end.unwrap }.compact
     end
 
     def graph
@@ -139,81 +141,88 @@ module Briard
     end
 
     def citeproc_hsh
-      page = container.to_h["firstPage"].present? ? [container["firstPage"], container["lastPage"]].compact.join("-") : nil
-      if Array.wrap(creators).size == 1 && Array.wrap(creators).first.fetch("name", nil) == ":(unav)"
-        author = nil
-      else
-        author = to_citeproc(creators)
-      end
-
-      if types["resourceTypeGeneral"] == "Software" && version_info.present?
-        type = "book"
-      else
-        type = types["citeproc"]
-      end
+      page = if container.to_h['firstPage'].present?
+               [container['firstPage'], container['lastPage']].compact.join('-')
+             end
+      author = if Array.wrap(creators).size == 1 && Array.wrap(creators).first.fetch('name',
+                                                                                     nil) == ':(unav)'
+                 nil
+               else
+                 to_citeproc(creators)
+               end
+
+      type = if types['resourceTypeGeneral'] == 'Software' && version_info.present?
+               'book'
+             else
+               types['citeproc']
+             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),
-        "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),
-        "abstract" => parse_attributes(descriptions, content: "description", first: true),
-        "container-title" => container_title,
-        "DOI" => doi,
-        "volume" => container.to_h["volume"],
-        "issue" => container.to_h["issue"],
-        "page" => page,
-        "publisher" => publisher,
-        "title" => parse_attributes(titles, content: "title", first: true),
-        "URL" => url,
-        "copyright" => Array.wrap(rights_list).map { |l| l["rights"] }.first,
-        "version" => version_info
+        'type' => type,
+        'id' => normalize_doi(doi),
+        'categories' => Array.wrap(subjects).map do |k|
+                          parse_attributes(k, content: 'subject', first: true)
+                        end.presence,
+        'language' => language,
+        'author' => author,
+        'contributor' => to_citeproc(contributors),
+        'issued' => get_date_parts(get_date(dates, 'Issued') || publication_year.to_s),
+        'submitted' => Array.wrap(dates).find do |d|
+                         d['dateType'] == 'Submitted'
+                       end.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'],
+        'page' => page,
+        'publisher' => publisher,
+        'title' => parse_attributes(titles, content: 'title', first: true),
+        'URL' => url,
+        'copyright' => Array.wrap(rights_list).map { |l| l['rights'] }.first,
+        'version' => version_info
       }.compact.symbolize_keys
     end
 
     def crosscite_hsh
       {
-        "id" => normalize_doi(doi),
-        "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,
-        "related_items" => related_items,
-        "schema_version" => schema_version,
-        "provider_id" => provider_id,
-        "client_id" => client_id,
-        "agency" => agency,
-        "state" => state
+        'id' => normalize_doi(doi),
+        '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,
+        'related_items' => related_items,
+        'schema_version' => schema_version,
+        'provider_id' => provider_id,
+        'client_id' => client_id,
+        'agency' => agency,
+        'state' => state
       }.compact
     end
 
     def style
-      @style ||= "apa"
+      @style ||= 'apa'
     end
 
     def locale
-      @locale ||= "en-US"
+      @locale ||= 'en-US'
     end
   end
 end