labimotion 2.2.0.rc21 → 2.2.0.rc22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 006f7a0d5c1bc994e1ed1be862881e579b83a91844e176858571471a4225a6e5
-  data.tar.gz: 9d40a31313cc7717bd0a9cb971e457bc6c2ad93a3818a3ad305dec05ad9bc406
+  metadata.gz: c79a031d59f881b26d04e1acb6863bff76a6164e096068268d7495042d8db0f0
+  data.tar.gz: 3d84dc19e636a8c57734675e41d58ef16bb821e7d7be34be2cbe7b3196a3b804
 SHA512:
-  metadata.gz: 399cb835f06e3cc7e30a8c59f3e64ae7738da938a7bb4a68e3ffd9c331854e36c84743b90a07769407c910d2b49042996734d2572517932a97869a18f0e6174b
-  data.tar.gz: 8ce94d81213aba4205aff04328c3eba89ca095b84301ddf7eee22497e0964635a0998735175f47fa00642f4d47d481e9ef0aa95bb1b04357705a1c1ad21c3c6b
+  metadata.gz: 4ad9ee1d24b63e2ebdc8a6bf6ca338fe3170644c63bc50cafcd89a660250fef0747375617b394a8174644ead7461f2dcc1d81fa4095e7365e11b07517781af00
+  data.tar.gz: 103e68dc679f80f3a214946361dc70ad5c1204336f567d17aaae4a9aa32298e56c23f4af4f545f07e27c9cdc8ccaea7bcc00e4978918af0b9d5f9baba6188785

data/lib/labimotion/apis/labimotion_doi_api.rb

@@ -8,7 +8,9 @@ module Labimotion
     # Grape route and helper DSL blocks are necessarily large.
     KLASS_TYPES = Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE.keys.freeze
     # Publication fields exposed on the public (anonymous) DOI endpoints.
-    PUBLIC_PUBLICATION_KEYS = %w[title description authors contributor license].freeze
+    # `contributor` (singular) is kept for DOIs released before contributors
+    # became a list — their snapshot still carries it.
+    PUBLIC_PUBLICATION_KEYS = %w[title description authors contributors contributor references license].freeze
 
     helpers do
       def resolve_klass!(type, id)

data/lib/labimotion/apis/labimotion_template_browse_api.rb

@@ -10,7 +10,9 @@ module Labimotion
     KLASS_BY_TYPE = Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE
     KLASS_TYPES = KLASS_BY_TYPE.keys.freeze
     # Publication fields exposed alongside a template / its released DOIs.
-    PUBLICATION_KEYS = %w[title description authors contributor license].freeze
+    # `contributor` (singular) is kept for DOIs released before contributors
+    # became a list — their snapshot still carries it.
+    PUBLICATION_KEYS = %w[title description authors contributors contributor references license].freeze
     # type => [revision model, foreign key to the klass]
     REVISION_BY_TYPE = {
       'element' => [::Labimotion::ElementKlassesRevision, :element_klass_id],

data/lib/labimotion/libs/data/datacite/labimotion_template.html.erb

@@ -15,8 +15,8 @@
       <% if creator['orcid'].present? %>
       <nameIdentifier schemeURI="https://orcid.org/" nameIdentifierScheme="ORCID"><%= creator['orcid'] %></nameIdentifier>
       <% end %>
-      <% if creator['affiliation'].present? %>
-      <affiliation><%= creator['affiliation'] %></affiliation>
+      <% if creator['affiliation'].present? || creator['ror'].present? %>
+      <affiliation<% if creator['ror'].present? %> affiliationIdentifier="<%= creator['ror'] %>" affiliationIdentifierScheme="ROR" schemeURI="https://ror.org"<% end %>><%= creator['affiliation'] %></affiliation>
       <% end %>
     </creator>
     <% end %>
@@ -29,18 +29,30 @@
   <subjects>
     <subject>Chemistry</subject>
   </subjects>
-  <% if contributor %>
+  <% if contributors.any? %>
   <contributors>
-    <contributor contributorType="Researcher">
+    <% contributors.each do |contributor| %>
+    <contributor contributorType="<%= contributor['contributorType'] %>">
       <contributorName nameType="Personal"><%= contributor['familyName'] %>, <%= contributor['givenName'] %></contributorName>
       <givenName><%= contributor['givenName'] %></givenName>
       <familyName><%= contributor['familyName'] %></familyName>
       <% if contributor['orcid'].present? %>
       <nameIdentifier schemeURI="https://orcid.org/" nameIdentifierScheme="ORCID"><%= contributor['orcid'] %></nameIdentifier>
       <% end %>
+      <% if contributor['affiliation'].present? || contributor['ror'].present? %>
+      <affiliation<% if contributor['ror'].present? %> affiliationIdentifier="<%= contributor['ror'] %>" affiliationIdentifierScheme="ROR" schemeURI="https://ror.org"<% end %>><%= contributor['affiliation'] %></affiliation>
+      <% end %>
     </contributor>
+    <% end %>
   </contributors>
   <% end %>
+  <% if references.any? %>
+  <relatedIdentifiers>
+    <% references.each do |reference| %>
+    <relatedIdentifier relatedIdentifierType="DOI" relationType="References">https://dx.doi.org/<%= reference['doi'] %></relatedIdentifier>
+    <% end %>
+  </relatedIdentifiers>
+  <% end %>
   <language>en</language>
   <resourceType resourceTypeGeneral="Model"><%= resource_label %></resourceType>
   <version><%= version %></version>

data/lib/labimotion/usecases/build_template_doi_xml.rb

@@ -76,30 +76,57 @@ module Labimotion
     end
 
     def creators
-      Array(publication['authors']).filter_map do |author|
-        next unless author.is_a?(Hash)
-
-        given = author['givenName'].to_s.strip
-        family = author['familyName'].to_s.strip
-        next if given.empty? && family.empty?
+      Array(publication['authors']).filter_map { |author| person(author) }
+    end
 
-        { 'givenName' => h(given), 'familyName' => h(family),
-          'orcid' => h(author['orcid'].to_s.strip), 'affiliation' => h(author['affiliation'].to_s.strip) }
+    # The people credited as DataCite contributors, each in their own role.
+    # Held apart from the creators — a contributor need not be one of the
+    # authors — and empty (no contributors block) until one is named; they are
+    # never inferred from whoever happens to be publishing. DOIs released
+    # before contributors became a list carry a single `contributor`.
+    def contributors
+      list = publication['contributors']
+      list = [publication['contributor']].compact unless list.is_a?(Array)
+      list.filter_map do |entry|
+        person(entry)&.merge('contributorType' => h(contributor_type(entry)))
       end
     end
 
-    # The author picked from the author list, rendered as a DataCite
-    # "Researcher" contributor. Nil (no contributors block) when none has been
-    # picked — it is never inferred from whoever happens to be publishing.
-    def contributor
-      picked = publication['contributor']
-      return nil unless picked.is_a?(Hash)
+    def contributor_type(entry)
+      type = entry['contributorType'].to_s.strip
+      types = TemplateDoiHelpers::CONTRIBUTOR_TYPES
+      types.include?(type) ? type : TemplateDoiHelpers::DEFAULT_CONTRIBUTOR_TYPE
+    end
 
-      given = picked['givenName'].to_s.strip
-      family = picked['familyName'].to_s.strip
+    # A creator or contributor, escaped for the template. Nameless entries are
+    # dropped: DataCite has nowhere to put an ORCID or affiliation on its own.
+    # `ror` is the resolver URI DataCite expects in affiliationIdentifier,
+    # rebuilt from the bare id that is stored.
+    def person(entry)
+      return nil unless entry.is_a?(Hash)
+
+      given = entry['givenName'].to_s.strip
+      family = entry['familyName'].to_s.strip
       return nil if given.empty? && family.empty?
 
-      { 'givenName' => h(given), 'familyName' => h(family), 'orcid' => h(picked['orcid'].to_s.strip) }
+      ror = entry['ror_id'].to_s.strip
+      { 'givenName' => h(given), 'familyName' => h(family), 'orcid' => h(entry['orcid'].to_s.strip),
+        'affiliation' => h(entry['affiliation'].to_s.strip),
+        'ror' => ror.empty? ? '' : h("https://ror.org/#{ror}") }
+    end
+
+    # Works this template cites, published as DataCite relatedIdentifiers of
+    # relationType "References". Only the DOI travels — a relatedIdentifier
+    # carries no title — so entries without one are skipped.
+    def references
+      Array(publication['references']).filter_map do |reference|
+        next unless reference.is_a?(Hash)
+
+        doi = reference['doi'].to_s.strip
+        next if doi.empty?
+
+        { 'doi' => h(doi) }
+      end
     end
 
     # What this DOI renders: the snapshot taken when it was released, so every

data/lib/labimotion/usecases/release_template_doi.rb

@@ -86,13 +86,12 @@ module Labimotion
     end
 
     # Everything the publication form owns that DataCite needs, named so the
-    # modal can say what is still missing. The contributor is one of the
-    # authors and has to be picked in the form — a DOI is never released
-    # crediting whoever happened to press the button.
+    # modal can say what is still missing. Contributors and references are
+    # optional: not every template credits a role beyond its authors, and not
+    # every template cites a work.
     def missing_metadata
       missing = %w[title description].reject { |key| publication[key].to_s.strip.present? }
       missing << 'authors' unless Array(publication['authors']).any? { |author| named?(author) }
-      missing << 'contributor' unless named?(publication['contributor'])
       missing
     end
 

data/lib/labimotion/usecases/template_doi_helpers.rb

@@ -20,6 +20,24 @@ module Labimotion
       ::Labimotion::DatasetKlass => 'datasets'
     }.freeze
 
+    # Where the hub lives, most specific first. PUBLIC_URL is the instance's own
+    # public address (the host app's config/application.rb insists on it), so the
+    # link follows whichever instance is serving it rather than a hardcoded
+    # chemotion-repository.net. The DataCite-facing domains stay as fallbacks for
+    # deployments that only set those.
+    HOST_ENV_KEYS = %w[PUBLIC_URL REPO_HOST DOI_DOMAIN_TEST DOI_DOMAIN].freeze
+
+    # The DataCite kernel-4 contributorType vocabulary. A template DOI may name
+    # any number of contributors — including none — each credited in one of
+    # these roles. The list is closed: DataCite rejects anything else.
+    CONTRIBUTOR_TYPES = %w[
+      ContactPerson DataCollector DataCurator DataManager Distributor Editor
+      HostingInstitution Producer ProjectLeader ProjectManager ProjectMember
+      RegistrationAgency RegistrationAuthority RelatedPerson Researcher
+      ResearchGroup RightsHolder Sponsor Supervisor WorkPackageLeader Other
+    ].freeze
+    DEFAULT_CONTRIBUTOR_TYPE = 'Researcher'
+
     module_function
 
     # True once the template's latest DOI has been released (minted) and the
@@ -49,13 +67,17 @@ module Labimotion
     # Used as the DOI's DataCite landing page and surfaced in the UI.
     def template_url(record)
       type = klass_type_for(record)
-      host = ENV['REPO_HOST'].presence || ENV['DOI_DOMAIN_TEST'].presence ||
-             ENV['DOI_DOMAIN'].presence || 'https://www.chemotion-repository.net'
       record_id = record.try(:identifier).presence || record.try(:uuid).presence || record.id
       query = "type=finder&kind=#{type}&id=#{record_id}"
       version = record.try(:version)
       query += "&version=#{version}" if version.present?
-      "#{host.chomp('/')}/home/genericHub?#{query}"
+      "#{public_host}/home/genericHub?#{query}"
+    end
+
+    # The instance serving the hub, without its trailing slash.
+    def public_host
+      host = HOST_ENV_KEYS.lazy.filter_map { |key| ENV[key].presence }.first
+      (host || 'http://localhost:3000').chomp('/')
     end
 
     # A user may manage a template's DOI iff they hold the LabIMotion

data/lib/labimotion/usecases/update_template_publication_metadata.rb

@@ -7,7 +7,12 @@ module Labimotion
   class UpdateTemplatePublicationMetadata
     include TemplateDoiHelpers
 
-    ALLOWED_KEYS = %w[title description authors contributor license].freeze
+    ALLOWED_KEYS = %w[title description authors contributors references license].freeze
+    REFERENCE_KEYS = %w[doi title url].freeze
+    # Authors and contributors are the same shape: a DataCite personal name plus
+    # the identifiers that make it resolvable — ORCID for the person, ROR for
+    # their organisation. Contributors carry a contributorType on top.
+    PERSON_KEYS = %w[givenName familyName orcid affiliation affiliation_id ror_id].freeze
 
     attr_reader :record, :current_user, :publication, :error
 
@@ -39,42 +44,82 @@ module Labimotion
     def normalized_publication
       slice = publication.stringify_keys.slice(*ALLOWED_KEYS)
       slice['authors'] = Array(slice['authors']).filter_map { |a| normalize_author(a) }
-      picked = picked_contributor(slice['authors'], slice['contributor'])
-      picked ? slice['contributor'] = picked : slice.delete('contributor')
+      # Contributors are people in their own right — none of them need be one of
+      # the authors — so they are stored as given rather than matched back
+      # against the author list. There may be any number, including none.
+      slice['contributors'] = submitted_contributors.filter_map { |c| normalize_contributor(c) }
+      slice['references'] = Array(slice['references']).filter_map { |r| normalize_reference(r) }
       slice
     end
 
-    # The contributor is one of the authors, so it is matched back against the
-    # saved author list and stored as that author. Anything that matches none
-    # of them — a stale pick whose author has since been removed, or a name
-    # that was never on the list — is dropped.
-    def picked_contributor(authors, contributor)
-      picked = normalize_author(contributor)
-      return nil if picked.nil?
+    # A single `contributor` is what the first version of the form sent; a
+    # template saved by it is read back into the list rather than dropped.
+    def submitted_contributors
+      given = publication.stringify_keys
+      given['contributors'].is_a?(Array) ? given['contributors'] : [given['contributor']].compact
+    end
+
+    # A person plus the DataCite role they are credited in. An unknown or
+    # missing role falls back to "Researcher" rather than failing the save —
+    # the vocabulary is closed, so anything else would be rejected at minting.
+    def normalize_contributor(contributor)
+      h = normalize_author(contributor)
+      return nil unless h
 
-      authors.find { |author| same_person?(author, picked) }
+      type = contributor.stringify_keys['contributorType'].to_s.strip
+      known = TemplateDoiHelpers::CONTRIBUTOR_TYPES.include?(type)
+      h.merge('contributorType' => known ? type : TemplateDoiHelpers::DEFAULT_CONTRIBUTOR_TYPE)
     end
 
-    # ORCID identifies a person when both sides carry one; otherwise fall back
-    # to the name pair, which is what the editor matches on too.
-    def same_person?(one, other)
-      orcids = [one, other].map { |a| a['orcid'].to_s.strip }
-      return orcids[0].casecmp?(orcids[1]) if orcids.all?(&:present?)
+    # A cited work, identified by its DOI. Anything without one is dropped: the
+    # DOI is what goes to DataCite as a relatedIdentifier, and a reference
+    # without it would be published as an empty relation.
+    def normalize_reference(reference)
+      return nil unless reference.is_a?(Hash)
+
+      h = reference.stringify_keys.slice(*REFERENCE_KEYS)
+      h['doi'] = sanitize_doi(h['doi'])
+      return nil if h['doi'].nil?
+
+      h.transform_values { |v| v.to_s.strip }
+    end
 
-      %w[givenName familyName].all? do |key|
-        one[key].to_s.strip.casecmp?(other[key].to_s.strip)
-      end
+    # Accepts a bare DOI, a doi: prefix or a resolver URL, and keeps the bare
+    # "10.x/y" form. Nil for anything that is not a DOI.
+    def sanitize_doi(value)
+      match = value.to_s.strip.match(%r{(10\.\d{4,9}/\S+)\z})
+      match && match[1]
     end
 
     def normalize_author(author)
       return nil unless author.is_a?(Hash)
 
-      h = author.stringify_keys.slice('givenName', 'familyName', 'orcid', 'affiliation', 'affiliation_id')
+      h = author.stringify_keys.slice(*PERSON_KEYS)
       return nil if h.values_at('givenName', 'familyName').all? { |v| v.to_s.strip.empty? }
 
+      ror = normalize_ror(h['ror_id']) || ror_for(h['affiliation_id'])
+      ror ? h['ror_id'] = ror : h.delete('ror_id')
       h
     end
 
+    # ROR IDs travel either bare ("05f950310") or as a resolver URL; DataCite
+    # wants the URI, so the bare form is what gets stored and the URI is built
+    # when the XML is rendered.
+    def normalize_ror(value)
+      value.to_s.strip.sub(%r{\Ahttps?://ror\.org/}i, '').presence
+    end
+
+    # The authoritative ROR for a picked affiliation. Whoever the editor picked
+    # came from an Affiliation record, so its id is the better source than
+    # anything retyped — and the current-user payload carries no ROR at all.
+    def ror_for(affiliation_id)
+      return nil if affiliation_id.blank? || !defined?(::Affiliation)
+
+      normalize_ror(::Affiliation.where(id: affiliation_id).pick(:ror_id))
+    rescue StandardError
+      nil
+    end
+
     def failure(message)
       @error = message
       self

data/lib/labimotion/version.rb

@@ -2,5 +2,5 @@
 
 ## Labimotion Version
 module Labimotion
-  VERSION = '2.2.0.rc21'
+  VERSION = '2.2.0.rc22'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.2.0.rc21
+  version: 2.2.0.rc22
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-07-28 00:00:00.000000000 Z
+date: 2026-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: caxlsx