bolognese 0.9.95 → 0.9.96

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b547ee2da8a99773f7e3e3ae870c07de56eb6319ea6636260d903c8af20d44f6
-  data.tar.gz: ad9fcfcb5d4f89e6fc33b8a65bf6aceb0b6ac2255a455893c693e911815a6085
+  metadata.gz: 287cf1f78523ddfcae6883ae9fb97e722481978f2c6d2eceb7fe8b2e5d21fd4f
+  data.tar.gz: 9b21f0508c2f690614312b95623fc1c79185df7af0fcbd7ed32bf99e41213da0
 SHA512:
-  metadata.gz: fb50d4f15b0b9af2998cb0e2e68ced3c1b8dd4bfdcfcc5ad6d5796c9fc45c5abb6cb1950d11c1728536a24ae69377fcab9c55e108789b4baf09c977e70ac9c45
-  data.tar.gz: 84940b910aecadbadfdbe95ce3d86d6b4294ca5bdb17323bfb7be7f29021bdeacda52e049b64ebf4339bdd070ca45781c62e20b183496bc911f7903e47cc9a5b
+  metadata.gz: 1d340dcd70c9f0a9235ebfc56474a1e711a2a818c516d82f46b901b51b6915b2d014bbe8c53c29563b441b3b2865b63e48a0de13f32963b9f1d4148e61c0b688
+  data.tar.gz: 924501ab8bf513ff19106696ecf530bc3b151a6f1e3ff1e72b22cc2b03a5c6535789eff8b12fde01ba297dc3686e568758874eca222dce01afc5a1ddb24a2bac

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bolognese (0.9.95)
+    bolognese (0.9.96)
       activesupport (>= 4.2.5, < 6)
       benchmark_methods (~> 0.7)
       bibtex-ruby (~> 4.1)
@@ -48,7 +48,7 @@ GEM
       rdf (>= 2.2, < 4.0)
       sxp (~> 1.0)
     excon (0.62.0)
-    faraday (0.14.0)
+    faraday (0.15.0)
       multipart-post (>= 1.2, < 3)
     faraday-encoding (0.0.4)
       faraday
@@ -102,7 +102,7 @@ GEM
       nokogiri (>= 1.6.1, < 1.9)
       public_suffix (>= 2.0.0, < 2.1)
     public_suffix (2.0.5)
-    rack (2.0.4)
+    rack (2.0.5)
     rack-test (0.8.3)
       rack (>= 1.0, < 3)
     rake (12.3.1)
@@ -160,7 +160,7 @@ GEM
       thread_safe (~> 0.1)
     unicode_utils (1.4.0)
     vcr (3.0.3)
-    webmock (3.3.0)
+    webmock (3.4.1)
       addressable (>= 2.3.6)
       crack (>= 0.3.2)
       hashdiff

data/lib/bolognese/doi_utils.rb

@@ -3,24 +3,24 @@ module Bolognese
     def validate_doi(doi)
       doi = Array(/\A(?:(http|https):\/(\/)?(dx\.)?(doi.org|handle.test.datacite.org)\/)?(doi:)?(10\.\d{4,5}\/.+)\z/.match(doi)).last
       # remove non-printing whitespace and downcase
-      doi = doi.delete("\u200B").downcase if doi.present?
+      doi.delete("\u200B").downcase if doi.present?
     end
 
     def validate_prefix(doi)
       Array(/\A(?:(http|https):\/(\/)?(dx\.)?(doi.org|handle.test.datacite.org)\/)?(doi:)?(10\.\d{4,5}).*\z/.match(doi)).last
     end
 
-    def doi_resolver(doi, options={})
+    def doi_resolver(doi, options = {})
       sandbox = Array(/handle.test.datacite.org/.match(doi)).last
       sandbox.present? || options[:sandbox] ? "https://handle.test.datacite.org/" : "https://doi.org/"
     end
 
-    def doi_search(doi, options={})
+    def doi_search(doi, options = {})
       sandbox = Array(/handle.test.datacite.org/.match(doi)).last
       sandbox.present? || options[:sandbox] ? "https://search.test.datacite.org/api" : "https://search.datacite.org/api"
     end
 
-    def normalize_doi(doi, options={})
+    def normalize_doi(doi, options = {})
       doi_str = validate_doi(doi)
       return nil unless doi_str.present?
 

data/lib/bolognese/metadata.rb

@@ -1,84 +1,10 @@
-require_relative 'doi_utils'
-require_relative 'author_utils'
-require_relative 'datacite_utils'
-require_relative 'utils'
-
-require_relative 'readers/bibtex_reader'
-require_relative 'readers/citeproc_reader'
-require_relative 'readers/codemeta_reader'
-require_relative 'readers/crosscite_reader'
-require_relative 'readers/crossref_reader'
-require_relative 'readers/datacite_json_reader'
-require_relative 'readers/datacite_reader'
-require_relative 'readers/ris_reader'
-require_relative 'readers/schema_org_reader'
-
-require_relative 'writers/bibtex_writer'
-require_relative 'writers/citation_writer'
-require_relative 'writers/citeproc_writer'
-require_relative 'writers/codemeta_writer'
-require_relative 'writers/crosscite_writer'
-require_relative 'writers/crossref_writer'
-require_relative 'writers/datacite_writer'
-require_relative 'writers/datacite_json_writer'
-require_relative 'writers/jats_writer'
-require_relative 'writers/rdf_xml_writer'
-require_relative 'writers/ris_writer'
-require_relative 'writers/schema_org_writer'
-require_relative 'writers/turtle_writer'
+require_relative 'metadata_utils'
 
 module Bolognese
   class Metadata
-    # include BenchmarkMethods
-    include Bolognese::DoiUtils
-    include Bolognese::AuthorUtils
-    include Bolognese::DataciteUtils
-    include Bolognese::Utils
-
-    include Bolognese::Readers::BibtexReader
-    include Bolognese::Readers::CiteprocReader
-    include Bolognese::Readers::CodemetaReader
-    include Bolognese::Readers::CrossciteReader
-    include Bolognese::Readers::CrossrefReader
-    include Bolognese::Readers::DataciteReader
-    include Bolognese::Readers::DataciteJsonReader
-    include Bolognese::Readers::RisReader
-    include Bolognese::Readers::SchemaOrgReader
-
-    include Bolognese::Writers::BibtexWriter
-    include Bolognese::Writers::CitationWriter
-    include Bolognese::Writers::CiteprocWriter
-    include Bolognese::Writers::CodemetaWriter
-    include Bolognese::Writers::CrossciteWriter
-    include Bolognese::Writers::CrossrefWriter
-    include Bolognese::Writers::DataciteWriter
-    include Bolognese::Writers::DataciteJsonWriter
-    include Bolognese::Writers::JatsWriter
-    include Bolognese::Writers::RdfXmlWriter
-    include Bolognese::Writers::RisWriter
-    include Bolognese::Writers::SchemaOrgWriter
-    include Bolognese::Writers::TurtleWriter
-
-    attr_accessor :id, :identifier, :doi, :author, :creator, :title, :publisher, :contributor, :license,
-      :date_accepted, :date_available, :date_copyrighted, :date_collected,
-      :date_submitted, :date_valid, :date_created, :date_modified,
-      :date_registered, :date_updated, :provider_id, :client_id, :journal,
-      :volume, :issue, :first_page, :last_page, :b_url, :b_version, :keywords, :editor,
-      :description, :alternate_name, :language, :content_size, :spatial_coverage,
-      :schema_version, :additional_type, :has_part, :same_as,
-      :is_previous_version_of, :is_new_version_of, :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, :funding, :type, :bibtex_type,
-      :citeproc_type, :ris_type, :style, :locale, :state
+    include Bolognese::MetadataUtils
 
-    attr_reader :id, :from, :raw, :metadata, :doc, :service_provider,
-      :page_start, :page_end, :should_passthru, :errors,
-      :related_identifier, :reverse, :name_detector
-
-    def initialize(input: nil, from: nil, style: nil, locale: nil, regenerate: false, **options)
+    def initialize(input: nil, from: nil, **options)
       id = normalize_id(input, options)
 
       if id.present?
@@ -109,310 +35,23 @@ module Bolognese
 
       # make sure input is encoded as utf8
       string = string.force_encoding("UTF-8") if string.present?
+      @string = string
 
-      # generate name for method to call dynamically
-      @metadata = @from.present? ? send("read_" + @from, string: string, id: id, sandbox: options[:sandbox], doi: options[:doi], b_url: options[:b_url]) : {}
-      @raw = string.present? ? string.strip : nil
-
-      # input specific metadata elements required for DataCite
-      @doi = options[:doi].presence
-      @author = options[:author].presence
-      @title = options[:title].presence
-      @publisher = options[:publisher].presence
-      @resource_type_general = options[:resource_type_general].presence
-
-      # input specific metadata elements recommended for DataCite
-      @additional_type = options[:additional_type].presence
-      @description = options[:description].presence
-      @license = options[:license].presence
-      @date_published = options[:date_published].presence
-
-      # replace DOI in XML if provided in options
-      if @from == "datacite" && options[:doi].present? && string.present?
-        doc = Nokogiri::XML(string, nil, 'UTF-8', &:noblanks)
-        node = doc.at_css("identifier")
-        node.content = options[:doi].upcase
-        @raw = doc.to_xml.strip
-      end
+      # input options for citation formatting
+      @style = options[:style]
+      @locale = options[:locale]
 
-      @should_passthru = (@from == "datacite") && !regenerate
+      @regenerate = options[:regenerate]
+      @sandbox = options[:sandbox]
 
-      @b_url = hsh.to_h["b_url"].presence
+      # options that come from the datacite database
+      @b_doi = normalize_doi(options[:doi] || input, options)
+      @b_url = hsh.to_h["b_url"].presence || options[:b_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
-
-      @style = style || "apa"
-      @locale = locale || "en-US"
-    end
-
-    def exists?
-      metadata.fetch("state", "not_found") != "not_found"
-    end
-
-    def valid?
-      exists? && errors.nil?
-    end
-
-    # validate against DataCite schema, unless there are already errors in the reader
-    def errors
-      xml = should_passthru ? raw : datacite_xml
-      metadata.fetch("errors", nil) || datacite_errors(xml: xml,
-                                                       schema_version: schema_version)
-    end
-
-    def id
-      @id ||= metadata.fetch("id", nil)
-    end
-
-    def type
-      @type ||= metadata.fetch("type", nil)
-    end
-
-    def additional_type
-      @additional_type ||= metadata.fetch("additional_type", nil)
-    end
-
-    def citeproc_type
-      @citeproc_type ||= metadata.fetch("citeproc_type", nil)
-    end
-
-    def bibtex_type
-      @bibtex_type ||= metadata.fetch("bibtex_type", nil)
-    end
-
-    def ris_type
-      @ris_type ||= metadata.fetch("ris_type", nil)
-    end
-
-    def resource_type_general
-      @resource_type_general ||= metadata.fetch("resource_type_general", nil)
-    end
-
-    def doi
-      @doi ||= @id.present? ? doi_from_url(@id) : metadata.fetch("doi", nil)
-    end
-
-    def b_url
-      @b_url ||= metadata.fetch("b_url", nil)
-    end
-
-    def identifier
-      @identifier ||= metadata.fetch("id", nil)
-    end
-
-    def state
-      @state ||= metadata.fetch("state", nil)
-    end
-
-    def title
-      @title ||= metadata.fetch("title", nil)
-    end
-
-    def alternate_name
-      @alternate_name ||= metadata.fetch("alternate_name", nil)
-    end
-
-    def author
-      @author ||= metadata.fetch("author", nil)
-    end
-
-    def editor
-      @editor ||= metadata.fetch("editor", nil)
-    end
-
-    def publisher
-      @publisher ||= metadata.fetch("publisher", nil)
-    end
-
-    def service_provider
-      @service_provider ||= metadata.fetch("service_provider", nil)
-    end
-
-    def date_created
-      @date_created ||= metadata.fetch("date_created", nil)
-    end
-
-    def date_accepted
-      @date_accepted ||= metadata.fetch("date_accepted", nil)
-    end
-
-    def date_available
-      @date_available ||= metadata.fetch("date_available", nil)
-    end
-
-    def date_copyrighted
-      @date_copyrighted ||= metadata.fetch("date_copyrighted", nil)
-    end
-
-    def date_collected
-      @date_collected ||= metadata.fetch("date_collected", nil)
-    end
-
-    def date_submitted
-      @date_submitted ||= metadata.fetch("date_submitted", nil)
-    end
-
-    def date_valid
-      @date_valid ||= metadata.fetch("date_valid", nil)
-    end
-
-    def date_published
-      @date_published ||= metadata.fetch("date_published", nil)
-    end
-
-    def date_modified
-      @date_modified ||= metadata.fetch("date_modified", nil)
-    end
-
-    def date_registered
-      @date_registered ||= metadata.fetch("date_registered", nil)
-    end
-
-    def date_updated
-      @date_updated ||= metadata.fetch("date_updated", nil)
-    end
-
-    def volume
-      @volume ||= metadata.fetch("volume", nil)
-    end
-
-    def first_page
-      @first_page ||= metadata.fetch("first_page", nil)
-    end
-
-    def last_page
-      @last_page ||= metadata.fetch("last_page", nil)
-    end
-
-    def description
-      @description ||= metadata.fetch("description", nil)
-    end
-
-    def license
-      @license ||= metadata.fetch("license", nil)
-    end
-
-    def b_version
-      @b_version ||= metadata.fetch("b_version", nil)
-    end
-
-    def keywords
-      @keywords ||= metadata.fetch("keywords", nil)
-    end
-
-    def language
-      @language ||= metadata.fetch("language", nil)
-    end
-
-    def content_size
-      @content_size ||= metadata.fetch("content_size", nil)
-    end
-
-    def schema_version
-      @schema_version ||= metadata.fetch("schema_version", nil)
-    end
-
-    def funding
-      @funding ||= metadata.fetch("funding", nil)
-    end
-
-    def provider_id
-      @provider_id ||= metadata.fetch("provider_id", nil)
-    end
-
-    def client_id
-      @client_id ||= metadata.fetch("client_id", nil)
-    end
-
-    def is_identical_to
-      metadata.fetch("is_identical_to", nil)
-    end
-
-    def is_part_of
-      metadata.fetch("is_part_of", nil)
-    end
-
-    def has_part
-      metadata.fetch("has_part", nil)
-    end
-
-    def is_previous_version_of
-      metadata.fetch("is_previous_of", nil)
-    end
-
-    def is_new_version_of
-      metadata.fetch("is_new_version_of", nil)
-    end
-
-    def is_variant_form_of
-      metadata.fetch("is_variant_form_of", nil)
-    end
-
-    def is_original_form_of
-      metadata.fetch("is_original_form_of", nil)
-    end
-
-    def references
-      metadata.fetch("references", nil)
-    end
-
-    def is_referenced_by
-      metadata.fetch("is_referenced_by", nil)
-    end
-
-    def is_supplement_to
-      metadata.fetch("is_supplement_to", nil)
-    end
-
-    def is_supplemented_by
-      metadata.fetch("is_supplemented_by", nil)
-    end
-
-    def reviews
-      metadata.fetch("reviews", nil)
-    end
-
-    def is_reviewed_by
-      metadata.fetch("is_reviewed_by", nil)
-    end
-
-    def related_identifier_hsh(relation_type)
-      Array.wrap(send(relation_type)).select { |r| r["id"] || r["issn"] }
-        .map { |r| r.merge("relationType" => relation_type.camelize) }
-    end
-
-    def related_identifier
-      relation_types = %w(is_part_of has_part references is_referenced_by is_supplement_to is_supplemented_by)
-      relation_types.reduce([]) { |sum, r| sum += related_identifier_hsh(r) }
-    end
-
-    # recognize given name. Can be loaded once as ::NameDetector, e.g. in a Rails initializer
-    def name_detector
-      @name_detector ||= defined?(::NameDetector) ? ::NameDetector : nil
-    end
-
-    def publication_year
-      date_published.present? ? date_published[0..3].to_i.presence : nil
-    end
-
-    def container_title
-      Array.wrap(is_part_of).first.to_h.fetch("title", nil)
-    end
-
-    def descriptions
-      Array.wrap(description)
-    end
-
-    def reverse
-      { "citation" => Array.wrap(is_referenced_by).map { |r| { "@id" => r["id"] }}.unwrap,
-        "isBasedOn" => Array.wrap(is_supplement_to).map { |r| { "@id" => r["id"] }}.unwrap }.compact
-    end
-
-    def graph
-      RDF::Graph.new << JSON::LD::API.toRdf(schema_hsh)
     end
   end
-end
+end