glossarist 2.13.4 → 2.13.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebf6ec1d9cc3f2c1932fff4d389b19e60dff4846e3f82167fa6e13bef8347f7d
-  data.tar.gz: 2aee9b19e15588b9fc74a973d02406de96b1ed01ebefcdd7b87bc472d3b8d53b
+  metadata.gz: f074d0113023ae82f1ae9cc8186cee518bc10ad87faabe3895117dcbbc700524
+  data.tar.gz: 8d89647b60c955419db263514521fcefcaa2efc07b4f6a16510bae2fa0313a82
 SHA512:
-  metadata.gz: '09eeb3261b6e753a4e1690496f13db04053429318108d52a031963087a9c908f842a12802b310014874f78f5d47bfd3a54dd1672e610e0b55684133a82ec2331'
-  data.tar.gz: de663d1b6fe2581a17ae52e2fb69d2ea6accf6ca46f92be084ec603c5b8f0f3d614a5dbeaf5a20178bb8d08511ea046210ed09a183c9c35b0f9d462b0dcb62d6
+  metadata.gz: 539a902946b70e6dac712f088a73b456e0732b29740ff770194a3165624edffcc88b8169221d37d97cf357d2bb0b486acb0f9b042c716634df04fe9ba0c9d1c9
+  data.tar.gz: 3ba5d4428d42ab96861986029fe8ca919cbabefa90c42c5106b888e27e8bc74e02c4dc31413b4cb6915858ef4a261c0c4818edbe46e89e0ae01474e4b589ce85

data/lib/glossarist/rdf/gloss_partitive_member.rb

@@ -1,12 +1,20 @@
 # frozen_string_literal: true
 
+require "digest"
 require "lutaml/model"
 
 module Glossarist
   module Rdf
-    # RDF view for V3::PartitiveMember. Emits a
-    # gloss:PartitiveMember subject with ref, presence, count, and
-    # is_delimiting properties.
+    # RDF view for V3::PartitiveMember. Emits a gloss:PartitiveMember
+    # subject carrying the ConceptRef target plus the ISO 704:2022
+    # orthogonal dimensions (presence, count, is_delimiting).
+    #
+    # Subject identity is content-derived so the same member in the
+    # same relation produces the same URI across runs (and across
+    # processes). Two members with identical ref + dimensions share a
+    # subject — that is intentional: it exposes model-level
+    # inconsistency if the same partitive concept is given different
+    # dimensions inside the same dataset.
     class GlossPartitiveMember < Lutaml::Model::Serializable
       attribute :ref_id, :string
       attribute :ref_source, :string
@@ -18,7 +26,7 @@ module Glossarist
       rdf do
         namespace Namespaces::GlossaristNamespace
 
-        subject { |m| "partitiveMember/#{m.ref_source}:#{m.ref_id}" }
+        subject { |m| "partitiveMember/#{GlossPartitiveMember.deterministic_id(m)}" }
 
         types "gloss:PartitiveMember"
 
@@ -35,6 +43,15 @@ module Glossarist
         predicate :isDelimiting, namespace: Namespaces::GlossaristNamespace,
                                  to: :is_delimiting
       end
+
+      def self.deterministic_id(member)
+        readable = [member.ref_source, member.ref_id].compact.reject(&:empty?)
+        return readable.join(":") unless readable.empty?
+
+        parts = [member.ref_source, member.ref_id, member.ref_text,
+                 member.presence, member.count, member.is_delimiting]
+        Digest::MD5.hexdigest(parts.compact.join("|"))[0..11]
+      end
     end
   end
 end

data/lib/glossarist/rdf/gloss_partitive_relation.rb

@@ -1,23 +1,27 @@
 # frozen_string_literal: true
 
+require "digest"
 require "lutaml/model"
 
 module Glossarist
   module Rdf
     # RDF view for V3::PartitiveRelation. Emits a
-    # gloss:PartitiveRelation subject with comprehensive, hasPartitive,
-    # completeness, criterion properties.
+    # gloss:PartitiveRelation subject with comprehensive, completeness,
+    # criterion properties, plus hasPartitive (concept URIs, for graph
+    # traversal) and hasPartitiveMember (typed subjects carrying the
+    # ISO 704:2022 per-member dimensions).
     class GlossPartitiveRelation < Lutaml::Model::Serializable
       attribute :identifier, :string
       attribute :comprehensive_uri, :string
       attribute :partitive_member_ids, :string, collection: true
+      attribute :partitive_members, GlossPartitiveMember, collection: true
       attribute :completeness, :string
       attribute :criterion, :hash
 
       rdf do
         namespace Namespaces::GlossaristNamespace
 
-        subject { |r| "partitiveRelation/#{r.identifier}/#{r.object_id}" }
+        subject { |r| "partitiveRelation/#{GlossPartitiveRelation.deterministic_id(r)}" }
 
         types "gloss:PartitiveRelation"
 
@@ -29,6 +33,25 @@ module Glossarist
                                  to: :completeness, uri_reference: true
         predicate :criterion, namespace: Namespaces::GlossaristNamespace,
                               to: :criterion
+
+        members :partitive_members, link: "gloss:hasPartitiveMember"
+      end
+
+      def self.deterministic_id(rel)
+        parts = [rel.identifier, rel.comprehensive_uri, rel.completeness]
+        parts << criterion_fingerprint(rel.criterion)
+        Array(rel.partitive_members).each do |m|
+          parts << GlossPartitiveMember.deterministic_id(m)
+        end
+        Digest::MD5.hexdigest(parts.compact.join("|"))[0..11]
+      end
+
+      def self.criterion_fingerprint(criterion)
+        return nil unless criterion.is_a?(Hash) && !criterion.empty?
+
+        criterion.sort_by { |k, _| k.to_s }
+          .map { |k, v| "#{k}=#{v}" }
+          .join(";")
       end
     end
   end

data/lib/glossarist/transforms/concept_to_gloss_transform.rb

@@ -131,7 +131,7 @@ module Glossarist
                                        identifier),
           dates: build_gloss_dates(managed_concept.dates, identifier),
           partitive_relations: build_gloss_partitive_relations(
-            v3_partitive_relations(managed_concept), identifier,
+            v3_partitive_relations(managed_concept), identifier
           ),
           **rel_targets,
         )
@@ -150,33 +150,54 @@ module Glossarist
         return [] unless relations
 
         Array(relations).map do |rel|
+          source_members = Array(rel.partitives)
+          gloss_members = source_members.map { |m| build_gloss_partitive_member(m) }
+          member_uris = source_members
+            .select { |m| m.is_a?(V3::PartitiveMember) && m.ref.is_a?(Glossarist::ConceptRef) }
+            .map { |m| concept_ref_uri(m.ref) }
+
           Rdf::GlossPartitiveRelation.new(
             identifier: identifier.to_s,
-            comprehensive_uri: partitive_concept_uri(rel.comprehensive),
-            partitive_member_ids: Array(rel.partitives).map do |m|
-              partitive_member_uri(m)
-            end,
+            comprehensive_uri: concept_ref_uri(rel.comprehensive),
+            partitive_member_ids: member_uris,
+            partitive_members: gloss_members,
             completeness: rel.completeness,
             criterion: rel.criterion,
           )
         end
       end
 
-      def partitive_concept_uri(ref)
-        return nil unless ref.is_a?(Glossarist::ConceptRef)
+      def build_gloss_partitive_member(member)
+        return Rdf::GlossPartitiveMember.new unless member.is_a?(V3::PartitiveMember)
 
-        Glossarist::Rdf::Namespaces::GlossaristNamespace.uri +
-          "concept/#{ref.id || ref.text}"
+        ref = member.ref
+        ref_attrs = if ref.is_a?(Glossarist::ConceptRef)
+                      { ref_id: ref.id, ref_source: ref.source, ref_text: ref.text }
+                    else
+                      {}
+                    end
+
+        Rdf::GlossPartitiveMember.new(
+          **ref_attrs,
+          presence: member.presence,
+          count: member.count,
+          is_delimiting: member.is_delimiting,
+        )
       end
 
-      def partitive_member_uri(member)
-        return nil unless member.is_a?(V3::PartitiveMember)
-
-        ref = member.ref
+      # Single SSOT for ConceptRef → concept URI. Handles all four
+      # ref shapes (source+id, id-only, source+text, text-only) and
+      # mirrors GlossCitation.slug's `[source, id].compact.join("/")`
+      # convention so external ConceptRefs don't collide with local
+      # ones of the same id.
+      def concept_ref_uri(ref)
         return nil unless ref.is_a?(Glossarist::ConceptRef)
 
+        slug = [ref.source, ref.id || ref.text].compact.reject(&:empty?)
+        return nil if slug.empty?
+
         Glossarist::Rdf::Namespaces::GlossaristNamespace.uri +
-          "concept/#{ref.id || ref.text}"
+          "concept/#{slug.join('/')}"
       end
 
       def build_gloss_localized_concept(l10n, concept_id)

data/lib/glossarist/v3/multiplicity.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    # Multiplicity — ISO 704:2022 partitive multiplicity (derived view).
+    #
+    # ISO 704:2022 multiplicity is the cross product of two orthogonal
+    # dimensions (PartitivePresence × PartitiveCount). The 5 valid
+    # combinations map to the 5 ISO 704 names:
+    #
+    #   required × exactly_one  → compulsory
+    #   optional × exactly_one  → optional
+    #   required × multiple     → compulsory_multiple
+    #   optional × multiple     → optional_multiple
+    #   required × at_least_one → compulsory_at_least_one
+    #
+    # (optional × at_least_one is REDUNDANT with optional × multiple —
+    # "may exist, ≥1 if it does" = "may exist in any number" — and is
+    # explicitly rejected at construction with a clear error message.)
+    #
+    # This module is the SSOT for the (presence, count) → ISO name
+    # mapping. Both MULTIPLICITY constants and MULTIPLICITY_VALUES are
+    # derived from this single table; no duplicate string literals.
+    module Multiplicity
+      NAME_BY_PAIR = {
+        %w[required exactly_one] => "compulsory",
+        %w[optional exactly_one] => "optional",
+        %w[required multiple] => "compulsory_multiple",
+        %w[optional multiple] => "optional_multiple",
+        %w[required at_least_one] => "compulsory_at_least_one",
+      }.freeze
+
+      # Precomputed reverse map: ISO name → (presence, count) pair.
+      # Avoids NAME_BY_PAIR.find for O(1) reverse lookup. Mirrors the
+      # glossarist-js PAIR_BY_NAME so the JS and Ruby MECE derivation
+      # stay in lockstep.
+      PAIR_BY_NAME = NAME_BY_PAIR.each_with_object({}) do |(pair, name), h|
+        h[name] = pair
+      end.freeze
+
+      MULTIPLICITY = NAME_BY_PAIR.values.to_h do |name|
+        [name.upcase.to_sym, name]
+      end.freeze
+
+      MULTIPLICITY_VALUES = NAME_BY_PAIR.values.freeze
+      DEFAULT_MULTIPLICITY = MULTIPLICITY[:COMPULSORY]
+
+      def self.multiplicity_from_pair(presence, count)
+        name = NAME_BY_PAIR[[presence, count]]
+        raise invalid_combination_error(presence, count) if name.nil?
+
+        name
+      end
+
+      def self.pair_from_multiplicity(name)
+        pair = PAIR_BY_NAME[name]
+        raise ArgumentError, "Unknown multiplicity: #{name.inspect}" if pair.nil?
+
+        { presence: pair[0], count: pair[1] }
+      end
+
+      def self.valid_multiplicity?(name)
+        PAIR_BY_NAME.key?(name)
+      end
+
+      def self.invalid_combination_error(presence, count)
+        ArgumentError.new(
+          "Invalid multiplicity combination: " \
+          "presence=#{presence}, count=#{count}. " \
+          "(optional + at_least_one collapses to " \
+          "optional + multiple — use count=multiple.)",
+        )
+      end
+    end
+  end
+end

data/lib/glossarist/v3/partitive_member.rb

@@ -74,20 +74,6 @@ module Glossarist
         is_delimiting == true
       end
 
-      # Derived ISO 704 name for display. Returns the flat-enum
-      # name that corresponds to this (presence, count) pair.
-      def iso704_name
-        case [presence, count]
-        when ["required", "exactly_one"] then "compulsory"
-        when ["optional", "exactly_one"] then "optional"
-        when ["required", "multiple"] then "compulsory_multiple"
-        when ["optional", "multiple"] then "optional_multiple"
-        when ["required", "at_least_one"] then "compulsory_at_least_one"
-        else raise ArgumentError,
-                     "invalid combination presence=#{presence} count=#{count}"
-        end
-      end
-
       private
 
       def validate_ref!

data/lib/glossarist/v3.rb

@@ -11,6 +11,13 @@ module Glossarist
     autoload :RelatedConcept, "glossarist/v3/related_concept"
     autoload :PartitiveRelation, "glossarist/v3/partitive_relation"
     autoload :PartitiveMember, "glossarist/v3/partitive_member"
+    # Multiplicity is a derived-view utility module (SSOT for the
+    # ISO 704:2022 (presence, count) → name mapping), not a Lutaml
+    # model — so it is autoloaded but NOT registered via
+    # Configuration.register_model. Used by renderers/viewers to
+    # display the ISO name; the PartitiveMember model itself only
+    # carries the orthogonal presence + count dimensions.
+    autoload :Multiplicity, "glossarist/v3/multiplicity"
     autoload :ConceptData, "glossarist/v3/concept_data"
     autoload :LocalizedConcept, "glossarist/v3/localized_concept"
     autoload :ManagedConceptData, "glossarist/v3/managed_concept_data"

data/lib/glossarist/validation/rules/partitive_relation_rule.rb

@@ -14,14 +14,19 @@ module Glossarist
       #     ISO 12620 coordinate-concept coherence)
       #   - warning when a relation has no criterion (cannot
       #     distinguish from siblings sharing the comprehensive)
-      #   - warning when multiplicity is not the default compulsory
-      #     (encourages explicit statement of optional/multiple)
+      #   - warning when a member's presence or count deviates from
+      #     the defaults (required / exactly_one) — encourages an
+      #     explicit choice rather than an accidental non-default
       #   - error when ExternalConcept (status: external) lacks
       #     at least one designation
       #
       # The model constructor already rejects empty comprehensive,
-      # empty partitives list, self-loops, invalid enum values.
+      # empty partitives list, self-loops, invalid enum values, and
+      # the optional + at_least_one combination.
       class PartitiveRelationRule < Base
+        DEFAULT_PRESENCE = "required"
+        DEFAULT_COUNT = "exactly_one"
+
         def code = "GLS-221"
         def category = :schema
         def severity = "error"
@@ -46,7 +51,7 @@ module Glossarist
           relations.each_with_index do |rel, idx|
             check_cardinality(rel, idx, fname, issues)
             check_criterion_present(rel, idx, fname, issues)
-            check_member_multiplicity(rel, idx, fname, issues)
+            check_member_dimensions(rel, idx, fname, issues)
           end
 
           check_duplicate_decomposition(relations, fname, issues)
@@ -85,28 +90,28 @@ module Glossarist
           )
         end
 
-        def check_member_multiplicity(rel, idx, fname, issues)
+        # Warns once per member when presence or count deviates from
+        # the model defaults. The warning is intentionally generic —
+        # it fires for required+multiple (non-default count) just as
+        # for optional+exactly_one (non-default presence). Both are
+        # legal; the warning encourages an explicit, reviewed choice
+        # rather than an accidental non-default.
+        def check_member_dimensions(rel, idx, fname, issues)
           rel.partitives.each_with_index do |member, mi|
-            unless member.required? && member.count == "exactly_one"
-              issues << issue(
-                "partitive_relation #{idx + 1}.partitives[#{mi}] has " \
-                "non-default presence='#{member.presence}' count='#{member.count}' " \
-                "(ISO 704 name: #{member.iso704_name}); confirm the " \
-                "optionality is intentional",
-                severity: "warning",
-                location: fname,
-              )
-            end
-
-            next unless member.delimiting?
+            non_default = []
+            non_default << "presence='#{member.presence}'" if member.presence != DEFAULT_PRESENCE
+            non_default << "count='#{member.count}'" if member.count != DEFAULT_COUNT
+            next if non_default.empty?
 
             issues << issue(
-              "partitive_relation #{idx + 1}.partitives[#{mi}] is marked " \
-              "delimiting (ISO 704 bold 3x-width line); behaves like a " \
-              "delimiting characteristic distinguishing the comprehensive " \
-              "from coordinate concepts",
-              severity: "info",
+              "partitive_relation #{idx + 1}.partitives[#{mi}] uses " \
+              "non-default #{non_default.join(' ')} " \
+              "(defaults: presence=#{DEFAULT_PRESENCE}, count=#{DEFAULT_COUNT}) " \
+              "— confirm the dimensions are intentional",
+              severity: "warning",
               location: fname,
+              suggestion: "Non-default dimensions are valid; this warning " \
+                          "exists to catch accidental drift from the model defaults.",
             )
           end
         end

data/lib/glossarist/version.rb

@@ -4,5 +4,5 @@
 #
 
 module Glossarist
-  VERSION = "2.13.4"
+  VERSION = "2.13.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: glossarist
 version: !ruby/object:Gem::Version
-  version: 2.13.4
+  version: 2.13.5
 platform: ruby
 authors:
 - Ribose
@@ -396,6 +396,7 @@ files:
 - lib/glossarist/v3/localized_concept.rb
 - lib/glossarist/v3/managed_concept.rb
 - lib/glossarist/v3/managed_concept_data.rb
+- lib/glossarist/v3/multiplicity.rb
 - lib/glossarist/v3/partitive_member.rb
 - lib/glossarist/v3/partitive_relation.rb
 - lib/glossarist/v3/related_concept.rb