labimotion 2.2.0.rc20 → 2.2.0.rc22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9df5db25f00061785cdfbc01efc3bcf1331ce6e028f4059e766a20adbda0c93
-  data.tar.gz: b3a45b638d8d2cf2e44cdd97ec0b4306af12f3abc25e44c414b1f49783b38f5e
+  metadata.gz: c79a031d59f881b26d04e1acb6863bff76a6164e096068268d7495042d8db0f0
+  data.tar.gz: 3d84dc19e636a8c57734675e41d58ef16bb821e7d7be34be2cbe7b3196a3b804
 SHA512:
-  metadata.gz: 7ffd28b485709f2bc8f795e1ecd4dee5fb1a0ebbe412f9fee0dd8635ad5807757f3d88609bb6ca8e5a80c5c8fc2709dc9d2ce70545db4ee53be0ddee84d4bad8
-  data.tar.gz: 8e06a2b44be3cbc288838b1aede00a788e740df1f1eacb62467772c8addf610d3644807f13de409a1fee3da362651d01ce92508d5a24c2c89480ff1647e18a4d
+  metadata.gz: 4ad9ee1d24b63e2ebdc8a6bf6ca338fe3170644c63bc50cafcd89a660250fef0747375617b394a8174644ead7461f2dcc1d81fa4095e7365e11b07517781af00
+  data.tar.gz: 103e68dc679f80f3a214946361dc70ad5c1204336f567d17aaae4a9aa32298e56c23f4af4f545f07e27c9cdc8ccaea7bcc00e4978918af0b9d5f9baba6188785

data/lib/labimotion/apis/labimotion_doi_api.rb

@@ -7,6 +7,10 @@ module Labimotion
     # rubocop:disable Metrics/BlockLength
     # 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.
+    # `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)
@@ -41,25 +45,36 @@ module Labimotion
         )
       end
 
-      # Public, read-only view of one released DOI version.
-      def released_doi_version(doi)
+      # Public, read-only view of one released DOI version, carrying the
+      # publication metadata that version was released with.
+      def released_doi_version(record, doi)
         full = doi.full_doi
         {
           doi: full,
           doi_url: "https://dx.doi.org/#{full}",
           version: ::Doi.labimotion_doi_version(doi),
-          minted_at: doi.minted_at
+          minted_at: doi.minted_at,
+          publication: released_publication(record, doi)
         }
       end
 
+      # The snapshot taken when this version was released. DOIs released before
+      # snapshots were kept have none, and fall back to the template's current
+      # publication — the best available answer for them.
+      def released_publication(record, doi)
+        publication = ::Doi.labimotion_doi_publication(doi).presence ||
+                      (record.properties_template || {})['publication']
+        publication.is_a?(Hash) ? publication.slice(*PUBLIC_PUBLICATION_KEYS) : {}
+      end
+
       # Public payload for a template that has at least one released DOI: the
       # latest released DOI promoted to the top level, plus its publication
-      # metadata, hub deep-link and every released version. `record_id` matches
-      # the hub grid's row id (identifier || uuid) so the frontend can merge it.
+      # metadata, hub deep-link and every released version. Each version brings
+      # its own publication, so the top-level one is the latest release's rather
+      # than the template's work-in-progress. `record_id` matches the hub grid's
+      # row id (identifier || uuid) so the frontend can merge it.
       def released_template_doi(record, dois)
-        versions = dois.sort_by(&:id).map { |doi| released_doi_version(doi) }
-        publication = (record.properties_template || {})['publication']
-        publication = publication.is_a?(Hash) ? publication.slice('title', 'description', 'authors', 'license') : {}
+        versions = dois.sort_by(&:id).map { |doi| released_doi_version(record, doi) }
         versions.last.merge(
           record_id: record.try(:identifier).presence || record.try(:uuid).presence || record.id,
           identifier: record.try(:identifier),
@@ -68,7 +83,6 @@ module Labimotion
           template_version: record.try(:version),
           next_doi_version: ::Doi.labimotion_version_segment(record),
           template_url: Labimotion::TemplateDoiHelpers.template_url(record),
-          publication: publication,
           versions: versions
         )
       end
@@ -125,7 +139,7 @@ module Labimotion
                 version: ::Doi.labimotion_doi_version(doi),
                 full_doi: doi.full_doi,
                 minted: doi.minted == true,
-                xml: Labimotion::BuildTemplateDoiXml.new(record, doi, current_user).call
+                xml: Labimotion::BuildTemplateDoiXml.new(record, doi).call
               }
             end
             { versions: versions }

data/lib/labimotion/apis/labimotion_template_browse_api.rb

@@ -9,6 +9,10 @@ module Labimotion
   class LabimotionTemplateBrowseAPI < Grape::API
     KLASS_BY_TYPE = Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE
     KLASS_TYPES = KLASS_BY_TYPE.keys.freeze
+    # Publication fields exposed alongside a template / its released DOIs.
+    # `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],
@@ -76,7 +80,14 @@ module Labimotion
       # The template's DOI publication metadata (shown alongside the DOI).
       def template_publication(record)
         pub = (record.properties_template || {})['publication']
-        pub.is_a?(Hash) ? pub.slice('title', 'description', 'authors', 'license') : {}
+        pub.is_a?(Hash) ? pub.slice(*PUBLICATION_KEYS) : {}
+      end
+
+      # The publication a released DOI was published with. Falls back to the
+      # template's current metadata for DOIs released before snapshots were kept.
+      def released_publication(record, doi)
+        pub = ::Doi.labimotion_doi_publication(doi)
+        pub.is_a?(Hash) && pub.any? ? pub.slice(*PUBLICATION_KEYS) : template_publication(record)
       end
 
       # Released (minted) DOIs of the template, each tagged with its DOI version
@@ -88,6 +99,7 @@ module Labimotion
           full = doi.full_doi
           { version: ::Doi.labimotion_doi_version(doi), doi: full,
             doi_url: "https://dx.doi.org/#{full}", minted_at: doi.minted_at,
+            publication: released_publication(record, doi),
             xml: Labimotion::BuildTemplateDoiXml.new(record, doi).call }
         end
       end

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/models/concerns/template_doi.rb

@@ -82,6 +82,26 @@ module Labimotion
         { 'labimotion' => { 'doi_version' => labimotion_version_segment(record, version) } }
       end
 
+      # The publication metadata a released template DOI was published with.
+      # Nil while the DOI is still reserved, and for DOIs released before
+      # snapshots were kept — callers fall back to the template's current
+      # publication in both cases.
+      def labimotion_doi_publication(doi)
+        doi.metadata.to_h.dig('labimotion', 'publication')
+      end
+
+      # The DOI's metadata with the publication snapshotted into it, keeping
+      # the DOI version already stamped there. Taken at release: the template's
+      # publication keeps being edited for the next version, and this version
+      # must stop tracking those edits.
+      def labimotion_metadata_with_publication(doi, publication)
+        metadata = doi.metadata.to_h
+        # Deep-duped: the snapshot must not alias the template's publication,
+        # which goes on being edited for the next version.
+        labimotion = (metadata['labimotion'] || {}).merge('publication' => publication.deep_dup)
+        metadata.merge('labimotion' => labimotion)
+      end
+
       def labimotion_suffix_parts(record)
         # identifier/uuid may both be blank for a draft, which would collapse the
         # scope (colliding across templates). Fall back to the stable record id so

data/lib/labimotion/usecases/build_template_doi_xml.rb

@@ -23,10 +23,9 @@ module Labimotion
       'dataset' => 'LabIMotion Dataset Template'
     }.freeze
 
-    def initialize(record, doi = nil, current_user = nil)
+    def initialize(record, doi = nil)
       @record = record
       @doi = doi || ::Doi.labimotion_latest_doi(record)
-      @current_user = current_user
     end
 
     # Returns the XML string, or nil when no DOI has been reserved yet.
@@ -77,35 +76,70 @@ 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 acting user, rendered as a DataCite "Researcher" contributor. Nil
-    # (no contributors block) when there is no user or they have no name.
-    def contributor
-      user = @current_user
-      return nil unless user
+    def contributor_type(entry)
+      type = entry['contributorType'].to_s.strip
+      types = TemplateDoiHelpers::CONTRIBUTOR_TYPES
+      types.include?(type) ? type : TemplateDoiHelpers::DEFAULT_CONTRIBUTOR_TYPE
+    end
+
+    # 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 = user.try(:first_name).to_s.strip
-      family = user.try(:last_name).to_s.strip
+      given = entry['givenName'].to_s.strip
+      family = entry['familyName'].to_s.strip
       return nil if given.empty? && family.empty?
 
-      orcid = user.respond_to?(:orcid) ? user.orcid.to_s.strip : ''
-      { 'givenName' => h(given), 'familyName' => h(family), 'orcid' => h(orcid) }
+      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
+    # released version keeps showing the metadata it was published with rather
+    # than the template's latest. A DOI that is still reserved has no snapshot
+    # and renders the template's current publication, which is what is still
+    # being edited for it.
     def publication
-      @publication ||=
-        (@record.properties_template.is_a?(Hash) ? @record.properties_template['publication'] : nil) || {}
+      @publication ||= ::Doi.labimotion_doi_publication(@doi).presence || record_publication
+    end
+
+    def record_publication
+      (@record.properties_template.is_a?(Hash) ? @record.properties_template['publication'] : nil) || {}
     end
 
     def h(value)

data/lib/labimotion/usecases/release_template_doi.rb

@@ -24,7 +24,8 @@ module Labimotion
       return failure('doi not reserved') if @doi.nil?
       return self if @doi.minted
 
-      return failure('publication metadata is incomplete') unless metadata_ready?
+      missing = missing_metadata
+      return failure("publication metadata is incomplete: #{missing.join(', ')}") if missing.any?
 
       publish_at_datacite
       self
@@ -37,22 +38,33 @@ module Labimotion
     private
 
     def publish_at_datacite
-      if send_to_datacite?
-        mds = ::Repo::Datacite::Mds.new
-        # DataCite requires the metadata to exist before the DOI can be minted.
-        metadata = mds.upload_metadata(BuildTemplateDoiXml.new(record, doi, current_user).call)
-        return failure(datacite_error('metadata upload', metadata)) unless metadata.is_a?(Net::HTTPSuccess)
-
-        response = mds.mint(doi.full_doi, TemplateDoiHelpers.template_url(record))
-        return failure(datacite_error('mint', response)) unless response.is_a?(Net::HTTPSuccess)
-      end
+      datacite_failure = send_to_datacite? ? mint_at_datacite : nil
+      return failure(datacite_failure) if datacite_failure
 
       ActiveRecord::Base.transaction do
-        doi.update!(minted: true, minted_at: Time.current)
+        # The publication is snapshotted onto the DOI as it is minted, so this
+        # version keeps rendering what it was published with once the template's
+        # metadata moves on to the next version.
+        doi.update!(minted: true, minted_at: Time.current,
+                    metadata: ::Doi.labimotion_metadata_with_publication(doi, publication))
         stamp_release_on_record
       end
     end
 
+    # Uploads the metadata and mints the DOI at DataCite. Returns an error
+    # message, or nil when both calls succeeded.
+    def mint_at_datacite
+      mds = ::Repo::Datacite::Mds.new
+      # DataCite requires the metadata to exist before the DOI can be minted.
+      metadata = mds.upload_metadata(BuildTemplateDoiXml.new(record, doi).call)
+      return datacite_error('metadata upload', metadata) unless metadata.is_a?(Net::HTTPSuccess)
+
+      response = mds.mint(doi.full_doi, TemplateDoiHelpers.template_url(record))
+      return datacite_error('mint', response) unless response.is_a?(Net::HTTPSuccess)
+
+      nil
+    end
+
     def datacite_error(step, response)
       status = response.respond_to?(:code) ? response.code : 'unknown'
       "datacite #{step} failed (status #{status})"
@@ -73,13 +85,26 @@ module Labimotion
       record.update!(attrs) if attrs.any?
     end
 
-    def metadata_ready?
-      publication = record.properties_template.is_a?(Hash) ? record.properties_template['publication'] : nil
-      return false unless publication.is_a?(Hash)
+    # Everything the publication form owns that DataCite needs, named so the
+    # 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
+    end
+
+    def named?(person)
+      person.is_a?(Hash) && person['familyName'].to_s.strip.present?
+    end
 
-      publication['title'].to_s.strip.present? &&
-        publication['description'].to_s.strip.present? &&
-        Array(publication['authors']).any? { |a| a.is_a?(Hash) && a['familyName'].to_s.strip.present? }
+    # The template's current publication metadata — what this release publishes.
+    def publication
+      @publication ||= begin
+        pub = record.properties_template.is_a?(Hash) ? record.properties_template['publication'] : nil
+        pub.is_a?(Hash) ? pub : {}
+      end
     end
 
     def failure(message)

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 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,18 +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) }
+      # 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
 
+    # 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
+
+      type = contributor.stringify_keys['contributorType'].to_s.strip
+      known = TemplateDoiHelpers::CONTRIBUTOR_TYPES.include?(type)
+      h.merge('contributorType' => known ? type : TemplateDoiHelpers::DEFAULT_CONTRIBUTOR_TYPE)
+    end
+
+    # 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
+
+    # 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.rc20'
+  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.rc20
+  version: 2.2.0.rc22
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-07-27 00:00:00.000000000 Z
+date: 2026-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: caxlsx