bolognese 0.4.3 → 2.6.1

data/Rakefile

@@ -1,4 +1,5 @@
 #!/usr/bin/env rake
+# frozen_string_literal: true
 
 require 'bundler'
 require 'rake'

data/bin/bolognese

@@ -2,4 +2,8 @@
 
 require File.expand_path("../../lib/bolognese", __FILE__)
 
-Bolognese::CLI.start
+if (ARGV & %w(--version -v help --help)).empty?
+  Bolognese::CLI.start(ARGV.dup.unshift("convert"))
+else
+  Bolognese::CLI.start
+end

data/bolognese.gemspec

@@ -8,33 +8,45 @@ Gem::Specification.new do |s|
   s.homepage      = "https://github.com/datacite/bolognese"
   s.summary       = "Ruby client library for conversion of DOI Metadata"
   s.date          = Date.today
-  s.description   = "Convert DOI metadata to and from Crossref and DataCite XML, as well as schema.org/JSON-LD"
+  s.description   = "Ruby gem and command-line utility for conversion of DOI metadata from and to different metadata formats, including schema.org."
   s.require_paths = ["lib"]
   s.version       = Bolognese::VERSION
   s.extra_rdoc_files = ["README.md"]
   s.license       = 'MIT'
+  s.required_ruby_version = ['>= 3.2', '< 4.1']
 
-  # Declary dependencies here, rather than in the Gemfile
-  s.add_dependency 'maremma', '~> 3.5'
-  s.add_dependency 'nokogiri', '~> 1.6', '>= 1.6.8'
-  s.add_dependency 'builder', '~> 3.2', '>= 3.2.2'
-  s.add_dependency 'activesupport', '~> 4.2', '>= 4.2.5'
-  s.add_dependency 'dotenv', '~> 2.1', '>= 2.1.1'
-  s.add_dependency 'thor', '~> 0.19'
-  s.add_dependency 'namae', '~> 0.10.2'
-  s.add_dependency 'postrank-uri', '~> 1.0', '>= 1.0.18'
-  s.add_development_dependency 'bundler', '~> 1.0'
-  s.add_development_dependency 'rspec', '~> 3.4'
-  s.add_development_dependency 'rspec-xsd', '~> 0.1.0'
-  s.add_development_dependency 'rake', '~> 12.0'
-  s.add_development_dependency 'rack-test', '~> 0'
-  s.add_development_dependency 'vcr', '~> 3.0', '>= 3.0.3'
-  s.add_development_dependency 'webmock', '~> 1.22', '>= 1.22.3'
-  s.add_development_dependency 'codeclimate-test-reporter', '~> 1.0', '>= 1.0.0'
-  s.add_development_dependency 'simplecov', '~> 0.12.0'
+  # Declare dependencies here, rather than in the Gemfile
+  s.add_dependency 'maremma', '~> 6.0'
+  s.add_dependency 'nokogiri', '~> 1.19', '>= 1.19.1'
+  s.add_dependency 'loofah', '~> 2.25'
+  s.add_dependency 'builder', '~> 3.3'
+  s.add_dependency 'activesupport', "~> 8.1", ">= 8.1.2"
+  s.add_dependency 'bibtex-ruby', '~> 6.2'
+  s.add_dependency 'thor', '~> 1.5'
+  s.add_dependency 'namae', '~> 1.2'
+  s.add_dependency 'edtf', '~> 3.2'
+  s.add_dependency 'citeproc-ruby', '~> 2.1', '>= 2.1.8'
+  s.add_dependency 'csl-styles', '~> 2.0', '>= 2.0.2'
+  s.add_dependency 'iso8601', '~> 0.13.0'
+  s.add_dependency 'json-ld-preloaded', '~> 3.3', '>= 3.3.2'
+  s.add_dependency 'jsonlint', '~> 0.4.0'
+  s.add_dependency 'oj', '~> 3.16', '>= 3.16.15'
+  s.add_dependency 'rdf-turtle', '~> 3.3', '>= 3.3.1'
+  s.add_dependency 'rdf-rdfxml', '~> 3.3'
+  s.add_dependency 'gender_detector', '~> 2.1'
+  s.add_dependency 'concurrent-ruby', '~> 1.3', '>= 1.3.6'
+  s.add_dependency 'csv', '~> 3.3', '>= 3.3.5'
+  s.add_development_dependency 'bundler', '>= 2.0'
+  s.add_development_dependency 'irb'
+  s.add_development_dependency 'rspec', '~> 3.13', '>= 3.13.2'
+  s.add_development_dependency 'rake', '~> 13.3', '>= 13.3.1'
+  s.add_development_dependency 'rack-test', '~> 2.2'
+  s.add_development_dependency 'vcr', '~> 6.4'
+  s.add_development_dependency 'webmock', '~> 3.26', '>= 3.26.1'
+  s.add_development_dependency 'simplecov', '0.22.0'
+  s.add_development_dependency 'byebug'
 
   s.require_paths = ["lib"]
-  s.files       = `git ls-files`.split($/)
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.files = `git ls-files`.split($/).reject { |f| f.match(%r{^(test|spec|features)/}) }
   s.executables = ["bolognese"]
 end

data/lib/bolognese/array.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# turn array into hash or nil, depending on array size.
+# Reverses Array.wrap, but uses self to allow chaining with Array.wrap
+class Array
+  def unwrap
+    case self.length
+    when 0 then nil
+    when 1 then self.first
+    else self
+    end
+  end
+end

data/lib/bolognese/author_utils.rb

@@ -1,62 +1,176 @@
+# frozen_string_literal: true
+
 require 'namae'
 
 module Bolognese
   module AuthorUtils
-    # only assume personal name when using sort-order: "Turing, Alan"
-    def get_one_author(author, options = {})
-      orcid = get_name_identifier(author)
-      author = author.fetch("creatorName", nil)
 
-      return { "Name" => "" } if author.strip.blank?
+    IDENTIFIER_SCHEME_URIS = {
+      "ORCID" => "https://orcid.org/"
+    }
 
-      author = cleanup_author(author)
-      names = Namae.parse(author)
+    def get_one_author(author)
+      # author is a string
+      author = { "creatorName" => author } if author.is_a?(String)
 
-      if names.blank? || is_personal_name?(author).blank?
-        { "@type" => "Agent",
-          "@id" => orcid,
-          "Name" => author }.compact
-      else
-        name = names.first
+      # malformed XML
+      return nil if author.fetch("creatorName", nil).is_a?(Array)
+
+      name = parse_attributes(author.fetch("creatorName", nil)) ||
+             parse_attributes(author.fetch("contributorName", nil))
+      given_name = parse_attributes(author.fetch("givenName", nil))
+      family_name = parse_attributes(author.fetch("familyName", nil))
+      name = cleanup_author(name)
+      name = [family_name, given_name].join(", ") if family_name.present? && given_name.present?
+      contributor_type = parse_attributes(author.fetch("contributorType", nil))
+
+      name_type = parse_attributes(author.fetch("creatorName", nil), content: "nameType", first: true) || parse_attributes(author.fetch("contributorName", nil), content: "nameType", first: true)
+
+      name_identifiers = Array.wrap(author.fetch("nameIdentifier", nil)).map do |ni|
+        name_identifier = ni["__content__"].strip if ni["__content__"].present?
+        if ni["nameIdentifierScheme"] == "ORCID"
+          {
+            "nameIdentifier" => normalize_orcid(name_identifier),
+            "schemeUri" => "https://orcid.org",
+            "nameIdentifierScheme" => "ORCID" }.compact
+        elsif ni["nameIdentifierScheme"] == "ROR"
+          {
+            "nameIdentifier" => normalize_ror(name_identifier),
+            "schemeUri" => "https://ror.org",
+            "nameIdentifierScheme" => "ROR" }.compact
+        else
+          {
+            "nameIdentifier" => name_identifier,
+            "schemeUri" => ni.fetch("schemeURI", nil),
+            "nameIdentifierScheme" => ni["nameIdentifierScheme"] }.compact
+        end
+      end.presence
 
-        { "@type" => "Person",
-          "@id" => orcid,
-          "givenName" => name.given,
-          "familyName" => name.family }.compact
+      author = { "nameType" => name_type,
+                 "name" => name,
+                 "givenName" => given_name,
+                 "familyName" => family_name,
+                 "nameIdentifiers" => name_identifiers,
+                 "affiliation" => get_affiliations(author.fetch("affiliation", nil)),
+                 "contributorType" => contributor_type }.compact
+
+      return author if family_name.present?
+
+      if is_personal_name?(author)
+        Namae.options[:include_particle_in_family] = true
+        names = Namae.parse(name)
+        parsed_name = names.first
+
+        if parsed_name.present?
+          given_name = parsed_name.given
+          family_name = parsed_name.family
+          name = [family_name, given_name].join(", ")
+        else
+          given_name = nil
+          family_name = nil
+        end
+
+        { "nameType" => "Personal",
+          "name" => name,
+          "givenName" => given_name,
+          "familyName" => family_name,
+          "nameIdentifiers" => Array.wrap(name_identifiers),
+          "affiliation" => Array.wrap(author.fetch("affiliation", nil)),
+          "contributorType" => contributor_type }.compact
+      else
+        { "nameType" => name_type,
+          "name" => name,
+          "nameIdentifiers" => Array.wrap(name_identifiers),
+          "affiliation" => Array.wrap(author.fetch("affiliation", nil)),
+          "contributorType" => contributor_type }.compact
       end
     end
 
     def cleanup_author(author)
+      return nil unless author.present?
+
       # detect pattern "Smith J.", but not "Smith, John K."
       author = author.gsub(/[[:space:]]([A-Z]\.)?(-?[A-Z]\.)$/, ', \1\2') unless author.include?(",")
 
+      # remove spaces around hyphens
+      author = author.gsub(" - ", "-")
+
       # titleize strings
       # remove non-standard space characters
-      author.my_titleize
-            .gsub(/[[:space:]]/, ' ')
+      author.gsub(/[[:space:]]/, ' ')
     end
 
     def is_personal_name?(author)
-      return true if author.include?(",")
+      return false if author.fetch("nameType", nil) == "Organizational"
+      return true if Array.wrap(author.fetch("nameIdentifiers", nil)).find { |a| a["nameIdentifierScheme"] == "ORCID" }.present? ||
+                     author.fetch("familyName", "").present? ||
+                     (author.fetch("name", "").include?(",") &&
+                     author.fetch("name", "").exclude?(";")) ||
+                     name_exists?(author.fetch("name", "").split(" ").first)
+      false
+    end
 
-      # lookup given name
-      #::NameDetector.name_exists?(author.split.first)
+    # recognize given name if we have loaded ::NameDetector data, e.g. in a Rails initializer
+    def name_exists?(name)
+      return false unless name_detector.present?
+
+      name_detector.name_exists?(name)
     end
 
     # parse array of author strings into CSL format
-    def get_authors(authors, options={})
-      Array(authors).map { |author| get_one_author(author, options) }
+    def get_authors(authors)
+      Array.wrap(authors).map { |author| get_one_author(author) }.compact
     end
 
-    # pase nameIdentifier from DataCite
-    def get_name_identifier(author)
-      name_identifier = author.dig("nameIdentifier", "text")
-      name_identifier_scheme = author.dig("nameIdentifier", "nameIdentifierScheme") || "ORCID"
-      if name_identifier_scheme.downcase == "orcid" && name_identifier = validate_orcid(name_identifier)
-        "http://orcid.org/#{name_identifier}"
-      else
-        nil
-      end
+    def authors_as_string(authors)
+      Array.wrap(authors).map do |a|
+        if a["familyName"].present?
+          [a["familyName"], a["givenName"]].join(", ")
+        elsif a["type"] == "Person"
+          a["name"]
+        elsif a["name"].present?
+          "{" + a["name"] + "}"
+        end
+      end.join(" and ").presence
+    end
+
+    def get_affiliations(affiliations)
+      Array.wrap(affiliations).map do |a|
+        affiliation_identifier = nil
+        if a.is_a?(String)
+          name = a.squish
+          affiliation_identifier_scheme = nil
+          scheme_uri = nil
+        else
+          scheme_uri = a["schemeURI"]
+          if a["affiliationIdentifier"].present?
+            affiliation_identifier = a["affiliationIdentifier"]
+            if a["schemeURI"].present?
+              schemeURI = a["schemeURI"].end_with?("/") ? a["schemeURI"] : a["schemeURI"] + "/"
+            end
+            affiliation_identifier = !affiliation_identifier.to_s.start_with?("https://") && schemeURI.present? ? normalize_id(schemeURI + affiliation_identifier) : normalize_id(affiliation_identifier)
+            # The normalize_id(affiliation_identifier) method currently discards affiliation identifiers that don't start with a URL, 
+            # for example: affiliation_identifier = "05bp8ka05".
+            # To address this issue, we are introducing the following change to handle such affiliation identifiers.
+            # when `normalize_id` method could not normalize, it returns nil, hence we have following condition
+            if affiliation_identifier.nil?
+              if a["affiliationIdentifierScheme"] == "ROR"
+                scheme_uri = "https://ror.org"
+                affiliation_identifier = normalize_ror(a["affiliationIdentifier"])
+              else
+                affiliation_identifier = a["affiliationIdentifier"]
+              end
+            end
+          end
+          name = a["__content__"].to_s.squish.presence
+          affiliation_identifier_scheme = a["affiliationIdentifierScheme"]
+        end
+
+        { "name" => name,
+          "affiliationIdentifier" => affiliation_identifier,
+          "affiliationIdentifierScheme" => affiliation_identifier_scheme,
+          "schemeUri" => scheme_uri }.compact
+      end.presence
     end
   end
 end

data/lib/bolognese/citeproc_extensions.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Minimal patch for csl-ruby and citeproc-ruby compatibility
+# Root cause: 'contributor' is not recognized as a names variable in citeproc gem
+# https://github.com/inukshuk/citeproc/blob/121fa4a950b9bd71960e42d20db96bcea1165201/lib/citeproc/variable.rb#L20-L24
+
+module CiteProc
+  class Variable
+    # Unfreeze, modify, and refreeze the fields to add 'contributor' and 'accepted-date'
+    if @fields
+      # Unfreeze the fields hash temporarily
+      fields_dup = @fields.dup
+      
+      # Add contributor to names (make a new unfrozen array)
+      fields_dup[:names] = (@fields[:names] + [:contributor]).uniq
+      
+      # Add accepted-date to dates (make a new unfrozen array)
+      fields_dup[:date] = (@fields[:date] + [:'accepted-date']).uniq
+      
+      # Rebuild the types mapping - only use actual type keys, not aliases like :all, :any, etc.
+      types_hash = Hash[*[:date, :names, :number, :text].map { |k| fields_dup[k].map { |n| [n, k] } }.flatten]
+      
+      # Update the class instance variables
+      @fields = fields_dup
+      @types = Hash.new { |h,k| h.fetch(k.to_sym, nil) }.merge(types_hash).freeze
+      
+      # Rebuild @factories from the new @types
+      # This maps each field name to its Variable subclass (Names, Date, Text, Number)
+      @factories = Hash.new { |h,k| h.fetch(k.to_s.intern, CiteProc::Variable) }.merge(
+        Hash[*@types.map { |field_name, type|
+          [field_name, CiteProc.const_get(type.to_s.capitalize)]
+        }.flatten]
+      ).freeze
+      
+      # Recreate the aliases
+      @fields[:name] = @fields[:names]
+      @fields[:dates] = @fields[:date]
+      @fields[:numbers] = @fields[:number]
+      
+      # Recreate :all and :any
+      @fields[:all] = @fields[:any] =
+        [:date, :names, :text, :number].reduce([]) { |s,a| s.concat(@fields[a]) }.sort
+      
+      # Refreeze fields
+      @fields.freeze
+    end
+  end
+end

data/lib/bolognese/cli.rb

@@ -1,9 +1,16 @@
 # encoding: UTF-8
+# frozen_string_literal: true
 
 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,29 +23,29 @@ module Bolognese
       puts Bolognese::VERSION
     end
 
-    desc "read pid", "read metadata for PID"
-    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
+    desc "", "convert metadata"
+    method_option :from, aliases: "-f"
+    method_option :to, aliases: "-t", default: "schema_org"
+    method_option :regenerate, :type => :boolean, :force => false
+    method_option :style, aliases: "-s", default: "apa"
+    method_option :locale, aliases: "-l", default: "en-US"
+    method_option :show_errors, :type => :boolean, :force => false
+    def convert(input)
+      metadata = Metadata.new(input: input,
+                              from: options[:from],
+                              regenerate: options[:regenerate],
+                              style: options[:style],
+                              locale: options[:locale],
+                              show_errors: options[:show_errors])
+      to = options[:to] || "schema_org"
+
+      if options[:show_errors] && !metadata.valid?
+        $stderr.puts metadata.errors
       else
-        puts "not implemented"
+        puts metadata.send(to)
       end
     end
+
+    default_task :convert
   end
 end