commonmeta-ruby 3.0.0

data/Rakefile

@@ -0,0 +1,13 @@
+#!/usr/bin/env rake
+# frozen_string_literal: true
+
+require 'bundler'
+require 'rake'
+require 'yaml'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+RSpec::Core::RakeTask.new('spec')
+
+# default task is running rspec tests
+task default: :spec

data/bin/commonmeta

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require File.expand_path("../../lib/commonmeta", __FILE__)
+
+if (ARGV & %w(--version -v help --help encode decode)).empty?
+  Commonmeta::CLI.start(ARGV.dup.unshift("convert"))
+else
+  Commonmeta::CLI.start
+end

data/commonmeta.gemspec

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'date'
+require File.expand_path('lib/commonmeta/version', __dir__)
+
+Gem::Specification.new do |s|
+  s.authors       = 'Martin Fenner'
+  s.email         = 'martin@front-matter.io'
+  s.name          = 'commonmeta-ruby'
+  s.homepage      = 'https://github.com/front-matter/commonmeta-ruby'
+  s.summary       = 'Ruby client library for conversion of scholarly metadata'
+  s.description   = 'Ruby gem and command-line utility for conversion of scholarly metadata from and to different metadata formats, including schema.org. Based on the bolognese gem, but using commonmeta as the intermediate format.'
+  s.require_paths = ['lib']
+  s.version       = Commonmeta::VERSION.dup
+  s.extra_rdoc_files = ['README.md']
+  s.license = 'MIT'
+  s.required_ruby_version = '>= 3.0.0'
+
+  # Declare dependencies here, rather than in the Gemfile
+  s.add_dependency 'activesupport', '>= 4.2.5', '< 8.0'
+  s.add_dependency 'base32-url', '>= 0.5.0', '< 1'
+  s.add_dependency 'benchmark_methods', '~> 0.7'
+  s.add_dependency 'bibtex-ruby', '~> 6.0'
+  s.add_dependency 'builder', '~> 3.2', '>= 3.2.2'
+  s.add_dependency 'citeproc-ruby', '~> 2.0'
+  s.add_dependency 'colorize', '~> 0.8.1'
+  s.add_dependency 'concurrent-ruby', '~> 1.1', '>= 1.1.5'
+  s.add_dependency 'csl-styles', '~> 2.0'
+  s.add_dependency 'dotenv', '~> 2.1', '>= 2.1.1'
+  s.add_dependency 'edtf', '~> 3.0', '>= 3.0.4'
+  s.add_dependency 'gender_detector', '~> 0.1.2'
+  s.add_dependency 'http', '~> 5.1', '>= 5.1.1'
+  s.add_dependency 'iso8601', '~> 0.9.1'
+  s.add_dependency 'json-ld-preloaded', '~> 3.1', '>= 3.1.3'
+  s.add_dependency 'jsonlint', '~> 0.3.0'
+  s.add_dependency 'json_schemer', '~> 0.2.23'
+  s.add_dependency 'loofah', '~> 2.19'
+  s.add_dependency 'namae', '~> 1.0'
+  s.add_dependency 'nokogiri', '~> 1.14', '>= 1.14.2'
+  s.add_dependency 'oj', '~> 3.10'
+  s.add_dependency 'oj_mimic_json', '~> 1.0', '>= 1.0.1'
+  s.add_dependency 'postrank-uri', '~> 1.0', '>= 1.0.18'
+  s.add_dependency 'public_suffix', '2.0.5'
+  s.add_dependency 'rdf-rdfxml', '~> 3.2'
+  s.add_dependency 'rdf-turtle', '~> 3.2'
+  s.add_dependency 'thor', '~> 1.1', '>= 1.1.0'
+  s.add_development_dependency 'bundler', '~> 2.3', '>= 2.3.1'
+  s.add_development_dependency 'code-scanning-rubocop', '~> 0.6.1'
+  s.add_development_dependency 'hashdiff', '~> 1.0.1'
+  s.add_development_dependency 'rack-test', '~> 2.0'
+  s.add_development_dependency 'rake', '~> 13.0'
+  s.add_development_dependency 'rspec', '~> 3.4'
+  s.add_development_dependency 'rspec-xsd', '~> 0.1.0'
+  s.add_development_dependency 'rubocop', '~> 1.36'
+  s.add_development_dependency 'rubocop-performance', '~> 1.15'
+  s.add_development_dependency 'rubocop-rake', '~> 0.6.0'
+  s.add_development_dependency 'rubocop-rspec', '~> 2.13'
+  s.add_development_dependency 'simplecov', '0.22.0'
+  s.add_development_dependency 'simplecov_json_formatter', '~> 0.1.4'
+  s.add_development_dependency 'vcr', '~> 6.0', '>= 6.1.0'
+  s.add_development_dependency 'webmock', '~> 3.0', '>= 3.0.1'
+
+  s.require_paths = ['lib']
+  s.files = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  s.executables = ['commonmeta']
+  s.metadata['rubygems_mfa_required'] = 'true'
+end

data/lib/commonmeta/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 length
+    when 0 then nil
+    when 1 then first
+    else self
+    end
+  end
+end

data/lib/commonmeta/author_utils.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'namae'
+
+module Commonmeta
+  module AuthorUtils
+    def get_one_author(author)
+      # basic sanity checks
+      return nil if author.blank?
+
+      # author is a string
+      author = { 'name' => author } if author.is_a?(String)
+
+      # malformed XML
+      return nil if author.fetch('name', nil).is_a?(Array)
+
+      # parse author name attributes
+      name = parse_attributes(author.fetch('name', nil)) ||
+             parse_attributes(author.fetch('creatorName', nil)) ||
+             parse_attributes(author.fetch('contributorName', nil))
+
+      given_name = parse_attributes(author.fetch('givenName', nil)) ||
+                   parse_attributes(author.fetch('given', nil))
+      family_name = parse_attributes(author.fetch('familyName', nil)) ||
+                    parse_attributes(author.fetch('family', nil))
+
+      # parse author identifier
+      id = parse_attributes(author.fetch('id', nil), first: true) ||
+           parse_attributes(author.fetch('identifier', nil), first: true) ||
+           parse_attributes(author.fetch('sameAs', nil), first: true)
+
+      # DataCite metadata
+      if id.nil? && author['nameIdentifiers'].present?
+        id = Array.wrap(author.dig('nameIdentifiers')).find do |ni|
+          ni['nameIdentifierScheme'] == 'ORCID'
+        end
+        id = id['nameIdentifier'] if id.present?
+        # Crossref metadata
+      elsif id.nil? && author['ORCID'].present?
+        id = author.fetch('ORCID')
+      end
+      id = normalize_orcid(id)
+
+      # parse author type, i.e. "Person", "Organization" or not specified
+      type = author.fetch('type', nil)
+      type = type.first if type.is_a?(Array)
+      # DataCite metadata
+      type = type[0..-3] if type.is_a?(String) && type.end_with?('al')
+
+      if type.blank? && id.is_a?(String) && URI.parse(id).host == 'ror.org'
+        type = 'Organization'
+      elsif type.blank? && id.is_a?(String) && URI.parse(id).host == 'orcid.org'
+        type = 'Person'
+      elsif type.blank? && (given_name.present? || family_name.present?)
+        type = 'Person'
+      elsif type.blank? && is_personal_name?(name: name) && name.to_s.exclude?(';')
+        type = 'Person'
+      end
+
+      # parse author contributor role
+      contributor_type = parse_attributes(author.fetch('contributorType', nil))
+
+      name = cleanup_author(name)
+
+      # split name for type Person into given/family name if not already provided
+      if type == 'Person' && given_name.blank? && family_name.blank?
+        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
+        else
+          given_name = nil
+          family_name = nil
+        end
+      end
+
+      # return author in commonmeta format, using name vs. given/family name
+      # depending on type
+      { 'id' => id,
+        'type' => type,
+        'name' => type == 'Person' ? nil : name,
+        'givenName' => type == 'Organization' ? nil : given_name,
+        'familyName' => type == 'Organization' ? nil : family_name,
+        'affiliation' => get_affiliations(author.fetch('affiliation', nil)),
+        'contributorType' => contributor_type }.compact
+    end
+
+    def cleanup_author(author)
+      return nil unless author.present?
+
+      # detect pattern "Smith J.", but not "Smith, John K."
+      unless author.include?(',')
+        author = author.gsub(/[[:space:]]([A-Z]\.)?(-?[A-Z]\.)$/, ', \1\2')
+      end
+
+      # remove spaces around hyphens
+      author = author.gsub(' - ', '-')
+
+      # remove non-standard space characters
+      author.gsub(/[[:space:]]/, ' ')
+    end
+
+    # check if given name is in the database of known given names:
+    # https://github.com/bmuller/gender_detector
+    def is_personal_name?(name: nil)
+      return true if name_exists?(name.to_s.split.first) || name_exists?(name.to_s.split(', ').last)
+
+      false
+    end
+
+    # 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 commonmeta format
+    def get_authors(authors)
+      Array.wrap(authors).map { |author| get_one_author(author) }.compact
+    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)
+      return nil unless affiliations.present?
+
+      Array.wrap(affiliations).map do |a|
+        affiliation_identifier = nil
+        if a.is_a?(String)
+          name = a.squish
+        elsif a.is_a?(Hash)
+          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)
+          end
+          name = (a['name'] || a['__content__']).to_s.squish.presence
+        end
+
+        next unless name.present?
+
+        { 'id' => affiliation_identifier, 'name' => name }.compact
+      end.compact.presence
+    end
+
+    def author_name_identifiers(id)
+      return nil unless id.present?
+
+      Array.wrap(id).map do |i|
+        { 'nameIdentifier' => i,
+          'nameIdentifierScheme' => 'ORCID',
+          'schemeUri' => 'https://orcid.org' }.compact
+      end.compact.presence
+    end
+  end
+end

data/lib/commonmeta/cli.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+require_relative 'doi_utils'
+require_relative 'utils'
+
+module Commonmeta
+  class CLI < Thor
+    include Commonmeta::DoiUtils
+    include Commonmeta::Utils
+
+    def self.exit_on_failure?
+      true
+    end
+
+    # from http://stackoverflow.com/questions/22809972/adding-a-version-option-to-a-ruby-thor-cli
+    map %w[--version -v] => :__print_version
+
+    desc '--version, -v', 'print the version'
+
+    def __print_version
+      puts Commonmeta::VERSION
+    end
+
+    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
+    method_option :depositor
+    method_option :email
+    method_option :registrant
+
+    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],
+                              depositor: options[:depositor],
+                              email: options[:email],
+                              registrant: options[:registrant])
+      to = options[:to] || 'schema_org'
+
+      if options[:show_errors] && !metadata.valid?
+        warn metadata.errors
+      else
+        puts metadata.send(to)
+      end
+    end
+
+    desc '', 'encode'
+
+    def encode(prefix)
+      puts encode_doi(prefix)
+    end
+
+    desc '', 'decode'
+
+    def decode(doi)
+      puts decode_doi(doi)
+    end
+
+    default_task :convert
+  end
+end

data/lib/commonmeta/crossref_utils.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+module Commonmeta
+  module CrossrefUtils
+    # To configure the writing of Crossref metadata, use environmental
+    # variables CROSSREF_DEPOSITOR_NAME, CROSSREF_DEPOSITOR_EMAIL and CROSSREF_REGISTRANT,
+    # e.g. in a .env file
+    def write_crossref_xml
+      @crossref_xml ||= Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+        xml.doi_batch(crossref_root_attributes) do
+          xml.head do
+            # we use a uuid as batch_id
+            xml.doi_batch_id(SecureRandom.uuid)
+            xml.timestamp(Time.now.utc.strftime('%Y%m%d%H%M%S'))
+            xml.depositor do
+              xml.depositor_name(ENV.fetch('CROSSREF_DEPOSITOR_NAME', nil))
+              xml.email_address(ENV.fetch('CROSSREF_DEPOSITOR_EMAIL', nil))
+            end
+            xml.registrant(ENV.fetch('CROSSREF_REGISTRANT', nil))
+          end
+          xml.body do
+            insert_crossref_work(xml)
+          end
+        end
+      end.to_xml
+    end
+
+    def crossref_errors(xml: nil)
+      filepath = File.expand_path('../../resources/crossref/crossref5.3.1.xsd', __dir__)
+      schema = Nokogiri::XML::Schema(open(filepath))
+
+      schema.validate(Nokogiri::XML(xml, nil, 'UTF-8')).map(&:to_s).unwrap
+    rescue Nokogiri::XML::SyntaxError => e
+      e.message
+    end
+
+    def insert_crossref_work(xml)
+      return xml if doi_from_url(id).blank?
+
+      case type
+      when 'JournalArticle'
+        insert_journal(xml)
+      when 'Article'
+        insert_posted_content(xml)
+      end
+    end
+
+    def insert_journal(xml)
+      xml.journal do
+        if language.present?
+          xml.journal_metadata('language' => language[0..1]) do
+            xml.full_title(container['title'])
+          end
+        else
+          xml.journal_metadata do
+            xml.full_title(container['title'])
+          end
+        end
+        xml.journal_article('publication_type' => 'full_text') do
+          insert_crossref_titles(xml)
+          insert_crossref_creators(xml)
+          insert_crossref_publication_date(xml)
+          insert_crossref_abstract(xml)
+          insert_crossref_issn(xml)
+          insert_crossref_alternate_identifiers(xml)
+          insert_crossref_access_indicators(xml)
+          insert_doi_data(xml)
+          insert_citation_list(xml)
+        end
+      end
+    end
+
+    def insert_posted_content(xml)
+      posted_content = { 'type' => 'other', 'language' => language ? language[0..1] : nil }.compact
+
+      xml.posted_content(posted_content) do
+        insert_group_title(xml)
+        insert_crossref_creators(xml)
+        insert_crossref_titles(xml)
+        insert_posted_date(xml)
+        insert_institution(xml)
+        insert_crossref_abstract(xml)
+        insert_crossref_alternate_identifiers(xml)
+        insert_crossref_access_indicators(xml)
+        insert_doi_data(xml)
+        insert_citation_list(xml)
+      end
+    end
+
+    def insert_group_title(xml)
+      return xml if subjects.blank?
+
+      xml.group_title(subjects.first['subject'].titleize)
+    end
+
+    def insert_crossref_creators(xml)
+      xml.contributors do
+        Array.wrap(creators).each_with_index do |person, index|
+          xml.person_name('contributor_role' => 'author',
+                          'sequence' => index.zero? ? 'first' : 'additional') do
+            insert_crossref_person(xml, person)
+          end
+        end
+      end
+    end
+
+    def insert_crossref_person(xml, person)
+      xml.given_name(person['givenName']) if person['givenName'].present?
+      xml.surname(person['familyName']) if person['familyName'].present?
+      if person.dig('id') && URI.parse(person.dig('id')).host == 'orcid.org'
+        xml.ORCID(person.dig('id'))
+      end
+      Array.wrap(person['affiliation']).each do |affiliation|
+        attributes = { 'affiliationIdentifier' => affiliation['affiliationIdentifier'],
+                       'affiliationIdentifierScheme' => affiliation['affiliationIdentifierScheme'], 'schemeURI' => affiliation['schemeUri'] }.compact
+        xml.affiliation(affiliation['name'], attributes)
+      end
+    end
+
+    def insert_crossref_titles(xml)
+      xml.titles do
+        Array.wrap(titles).each do |title|
+          if title.is_a?(Hash)
+            xml.title(title['title'])
+          else
+            xml.title(title)
+          end
+        end
+      end
+    end
+
+    def insert_citation_list(xml)
+      xml.citation_list do
+        references.each do |ref|
+          xml.citation('key' => ref['key']) do
+            xml.journal_article(ref['journal_title'])
+            xml.author(ref['author'])
+            xml.volume(ref['volume'])
+            xml.first_page(ref['first_page'])
+            xml.cYear(ref['cYear'])
+            xml.article_title(ref['article_title'])
+            xml.doi(ref['doi']) if ref['doi'].present?
+          end
+        end
+      end
+    end
+
+    # def insert_publisher(xml)
+    #   xml.publisher(publisher || container && container["title"])
+    # end
+
+    # def insert_publication_year(xml)
+    #   xml.publicationYear(publication_year)
+    # end
+
+    # def insert_resource_type(xml)
+    #   return xml unless types.is_a?(Hash) && (types["schemaOrg"].present? || types["resourceTypeGeneral"])
+
+    #   xml.resourceType(types["resourceType"] || types["schemaOrg"],
+    #     'resourceTypeGeneral' => types["resourceTypeGeneral"] || Metadata::SO_TO_DC_TRANSLATIONS[types["schemaOrg"]] || "Other")
+    # end
+
+    def insert_crossref_alternate_identifiers(xml)
+      alternate_identifier = Array.wrap(alternate_identifiers).reject do |r|
+        %w[DOI, URL].include?(r['alternate_identifier_type'])
+      end.first
+      return xml if alternate_identifier.blank?
+
+      xml.item_number(alternate_identifier['alternateIdentifier'],
+                      'item_number_type' => alternate_identifier['alternateIdentifierType'])
+    end
+
+    def insert_crossref_access_indicators(xml)
+      return xml if license.blank?
+
+      rights_uri = license['url']
+
+      xml.program('xmlns' => 'http://www.crossref.org/AccessIndicators.xsd',
+                  'name' => 'AccessIndicators') do
+        xml.license_ref(rights_uri, 'applies_to' => 'vor')
+        xml.license_ref(rights_uri, 'applies_to' => 'tdm')
+      end
+    end
+
+    # def insert_dates(xml)
+    #   return xml unless Array.wrap(dates).present?
+
+    #   xml.dates do
+    #     Array.wrap(dates).each do |date|
+    #       attributes = { 'dateType' => date["dateType"] || "Issued", 'dateInformation' => date["dateInformation"] }.compact
+    #       xml.date(date["date"], attributes)
+    #     end
+    #   end
+    # end
+
+    # def insert_funding_references(xml)
+    #   return xml unless Array.wrap(funding_references).present?
+
+    #   xml.fundingReferences do
+    #     Array.wrap(funding_references).each do |funding_reference|
+    #       xml.fundingReference do
+    #         xml.funderName(funding_reference["funderName"])
+    #         xml.funderIdentifier(funding_reference["funderIdentifier"], { "funderIdentifierType" => funding_reference["funderIdentifierType"] }.compact) if funding_reference["funderIdentifier"].present?
+    #         xml.awardNumber(funding_reference["awardNumber"], { "awardURI" => funding_reference["awardUri"] }.compact) if funding_reference["awardNumber"].present? || funding_reference["awardUri"].present?
+    #         xml.awardTitle(funding_reference["awardTitle"]) if funding_reference["awardTitle"].present?
+    #       end
+    #     end
+    #   end
+    # end
+
+    def insert_crossref_subjects(xml)
+      return xml unless subjects.present?
+
+      xml.subjects do
+        subjects.each do |subject|
+          if subject.is_a?(Hash)
+            xml.subject(subject['subject'])
+          else
+            xml.subject(subject)
+          end
+        end
+      end
+    end
+
+    # def insert_version(xml)
+    #   return xml unless version_info.present?
+
+    #   xml.version(version_info)
+    # end
+
+    def insert_crossref_language(xml)
+      return xml unless language.present?
+
+      xml.language(language)
+    end
+
+    def insert_crossref_publication_date(xml)
+      return xml if date['registered'].blank?
+
+      date_ = get_datetime_from_iso8601(date['registered'])
+
+      xml.publication_date('media_type' => 'online') do
+        xml.month(date_.month) if date_.month.present?
+        xml.day(date_.day) if date_.day.present?
+        xml.year(date_.year) if date_.year.present?
+      end
+    end
+
+    def insert_posted_date(xml)
+      return xml if date['published'].blank?
+
+      date_ = get_datetime_from_iso8601(date['published'])
+
+      xml.posted_date do
+        xml.month(date_.month) if date_.month.present?
+        xml.day(date_.day) if date_.day.present?
+        xml.year(date_.year) if date_.year.present?
+      end
+    end
+
+    def insert_institution(xml)
+      return xml if publisher.blank?
+
+      xml.institution do
+        xml.institution_name(publisher['name'])
+      end
+    end
+
+    def insert_doi_data(xml)
+      return xml if doi_from_url(id).blank? || url.blank?
+
+      xml.doi_data do
+        xml.doi(doi_from_url(id).downcase)
+        xml.resource(url)
+        xml.collection('property' => 'text-mining') do
+          xml.item do
+            xml.resource(url, 'mime_type' => 'text/html')
+          end
+        end
+      end
+    end
+
+    def insert_crossref_license(xml)
+      return xml unless license.present?
+
+      xml.license do
+        rights = license
+        if rights.is_a?(Hash)
+          r = rights
+        else
+          r = {}
+          r['rights'] = rights
+          r['rightsUri'] = normalize_id(rights)
+        end
+
+        attributes = {
+          'rightsURI' => r['rightsUri'],
+          'rightsIdentifier' => r['rightsIdentifier'],
+          'rightsIdentifierScheme' => r['rightsIdentifierScheme'],
+          'schemeURI' => r['schemeUri'],
+          'xml:lang' => r['lang']
+        }.compact
+
+        xml.rights(r['rights'], attributes)
+      end
+    end
+
+    def insert_crossref_issn(xml)
+      issn = if container.to_h.fetch('identifierType', nil) == 'ISSN'
+               container.to_h.fetch('identifier', nil)
+             end
+
+      return xml if issn.blank?
+
+      xml.issn(issn)
+    end
+
+    def insert_crossref_abstract(xml)
+      return xml if descriptions.blank?
+
+      if descriptions.first.is_a?(Hash)
+        d = descriptions.first
+      else
+        d = {}
+        d['description'] = descriptions.first
+      end
+
+      xml.abstract('xmlns' => 'http://www.ncbi.nlm.nih.gov/JATS1') do
+        xml.p(d['description'])
+      end
+    end
+
+    def crossref_root_attributes
+      { 'xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+        'xsi:schemaLocation': 'http://www.crossref.org/schema/5.3.1 https://www.crossref.org/schemas/crossref5.3.1.xsd',
+        xmlns: 'http://www.crossref.org/schema/5.3.1',
+        'xmlns:jats': 'http://www.ncbi.nlm.nih.gov/JATS1',
+        'xmlns:fr': 'http://www.crossref.org/fundref.xsd',
+        'xmlns:mml': 'http://www.w3.org/1998/Math/MathML',
+        version: '5.3.1' }
+    end
+  end
+end