glossarist 2.13.3 → 2.13.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ffd41dbfe184c1b47711cb7b38b10c136fca8fcdac813baf2f070f99b5f5212
-  data.tar.gz: caaa34a425e82a8e79f20870ca4c49fcbe8b8bcb391ad1a5597f5c2904d3c242
+  metadata.gz: f074d0113023ae82f1ae9cc8186cee518bc10ad87faabe3895117dcbbc700524
+  data.tar.gz: 8d89647b60c955419db263514521fcefcaa2efc07b4f6a16510bae2fa0313a82
 SHA512:
-  metadata.gz: ef5b2c5cd5f4055b725399445d58246463c432b7d0a69ba2f81610b53dd9a5b5701963a5a7461add48da294d904f0faba5709c8bacfd79ac13415cecb61baa34
-  data.tar.gz: 16eb1b43dd51bcc39c6da768a2edddbe33d01fd59af0ec972494c9a2f629f17a2b45ab120a218abd423605c7afa6ed54b405ec3088bd682804e9bc1bbad0c13d
+  metadata.gz: 539a902946b70e6dac712f088a73b456e0732b29740ff770194a3165624edffcc88b8169221d37d97cf357d2bb0b486acb0f9b042c716634df04fe9ba0c9d1c9
+  data.tar.gz: 3ba5d4428d42ab96861986029fe8ca919cbabefa90c42c5106b888e27e8bc74e02c4dc31413b4cb6915858ef4a261c0c4818edbe46e89e0ae01474e4b589ce85

data/config.yml

@@ -212,17 +212,25 @@ completeness:
     - partial
 
 multiplicity:
-  # ISO 704:2022 partitive member multiplicity. Encodes the diagram
-  # line notation as structured data:
-  #   compulsory          — 1 solid line (must exist in every instance)
-  #   optional            — 1 dashed line (exists in some instances only)
-  #   compulsory_multiple — 2 solid lines (multiple must exist)
-  #   optional_multiple   — 2 dashed lines (multiple may exist)
-  #   compulsory_at_least_one        — 1 solid + 1 dashed line (at least one must exist)
-  # Default: compulsory.
-  value:
-    - compulsory
+  # MECE decomposition of ISO 704:2022 partitive member multiplicity.
+  # Two orthogonal dimensions replace the prior flat 5-value enum.
+  #
+  # presence (line style):
+  #   required — solid line (must exist)
+  #   optional — dashed line (may exist)
+  #
+  # count (line count):
+  #   exactly_one  — 1 line (exactly one instance)
+  #   at_least_one — 1 solid + 1 dashed (at least one instance)
+  #   multiple     — 2 lines (multiple instances)
+  #
+  # Valid combinations (5): required+exactly_one, optional+exactly_one,
+  # required+multiple, optional+multiple, required+at_least_one.
+  # Invalid: optional+at_least_one (collapses to optional+multiple).
+  presence:
+    - required
     - optional
-    - compulsory_multiple
-    - optional_multiple
-    - compulsory_at_least_one
+  count:
+    - exactly_one
+    - at_least_one
+    - multiple

data/lib/glossarist/glossary_definition.rb

@@ -37,6 +37,10 @@ module Glossarist
     # PartitiveRelation redesign (TODO.partitive-relation-v2).
     COMPLETENESS_VALUES = config.dig("completeness", "value").freeze
 
-    MULTIPLICITY_VALUES = config.dig("multiplicity", "value").freeze
+    PARTITIVE_PRESENCE_VALUES =
+      config.dig("multiplicity", "presence").freeze
+
+    PARTITIVE_COUNT_VALUES =
+      config.dig("multiplicity", "count").freeze
   end
 end

data/lib/glossarist/rdf/gloss_partitive_member.rb

@@ -1,23 +1,32 @@
 # 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, multiplicity, 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
       attribute :ref_text, :string
-      attribute :multiplicity, :string
+      attribute :presence, :string
+      attribute :count, :string
       attribute :is_delimiting, :boolean
 
       rdf do
         namespace Namespaces::GlossaristNamespace
 
-        subject { |m| "partitiveMember/#{m.ref_source}:#{m.ref_id}" }
+        subject { |m| "partitiveMember/#{GlossPartitiveMember.deterministic_id(m)}" }
 
         types "gloss:PartitiveMember"
 
@@ -27,11 +36,22 @@ module Glossarist
                           to: :ref_id
         predicate :refText, namespace: Namespaces::GlossaristNamespace,
                             to: :ref_text
-        predicate :multiplicity, namespace: Namespaces::GlossaristNamespace,
-                                 to: :multiplicity
+        predicate :presence, namespace: Namespaces::GlossaristNamespace,
+                             to: :presence
+        predicate :count, namespace: Namespaces::GlossaristNamespace,
+                          to: :count
         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

@@ -6,50 +6,68 @@ module Glossarist
     # a ConceptRef to the partitive concept plus ISO 704:2022
     # multiplicity and delimiting metadata.
     #
-    # ISO 704:2022 partitive member notation:
+    # ISO 704:2022 partitive member notation uses two orthogonal
+    # dimensions (MECE decomposition):
     #
-    #   multiplicity (diagram line notation):
-    #     compulsory          — 1 solid line (must exist in every instance)
-    #     optional            — 1 dashed line (exists in some instances only)
-    #     compulsory_multiple — 2 solid lines (multiple must exist)
-    #     optional_multiple   — 2 dashed lines (multiple may exist)
-    #     compulsory_at_least_one        — 1 solid + 1 dashed line (≥1 must exist)
+    #   presence (line style — solid vs dashed):
+    #     required   — solid line (must exist in every instance)
+    #     optional   — dashed line (may exist; exists in some instances)
     #
-    #   is_delimiting (orthogonal, bold 3x-width line in diagram):
-    #     A delimiting part behaves like a delimiting characteristic:
-    #     it distinguishes the comprehensive from coordinate concepts.
-    #     Example (ISO 704 §5.5.4.2.2): for "optomechanical mouse",
-    #     the delimiting parts are mouse ball, x/y-axis rollers,
-    #     infrared emitter/sensor — they distinguish it from
-    #     "mechanical mouse" and "optical mouse". Mouse button is
-    #     NOT delimiting (all computer mice have buttons).
+    #   count (line count — how many):
+    #     exactly_one  — 1 line
+    #     at_least_one — 1 solid + 1 dashed
+    #     multiple     — 2 lines
+    #
+    # Valid combinations (5):
+    #   required + exactly_one    = compulsory (1 solid)
+    #   optional + exactly_one    = optional (1 dashed)
+    #   required + multiple       = compulsory_multiple (2 solid)
+    #   optional + multiple       = optional_multiple (2 dashed)
+    #   required + at_least_one   = compulsory_at_least_one (1 solid + 1 dashed)
+    #
+    # Invalid: optional + at_least_one (collapses to optional + multiple
+    # because "at least one, if present" = "zero or more" = optional_multiple).
+    #
+    # is_delimiting (orthogonal, bold 3x-width line in diagram):
+    #   A delimiting part behaves like a delimiting characteristic:
+    #   it distinguishes the comprehensive from coordinate concepts.
+    #   Example (ISO 704 §5.5.4.2.2): for "optomechanical mouse",
+    #   the delimiting parts are mouse ball, x/y-axis rollers,
+    #   infrared emitter/sensor — they distinguish it from
+    #   "mechanical mouse" and "optical mouse". Mouse button is
+    #   NOT delimiting (all computer mice have buttons).
     class PartitiveMember < Lutaml::Model::Serializable
-      DEFAULT_MULTIPLICITY = "compulsory"
+      DEFAULT_PRESENCE = "required"
+      DEFAULT_COUNT = "exactly_one"
 
       attribute :ref, ConceptRef
-      attribute :multiplicity, :string,
-                values: Glossarist::GlossaryDefinition::MULTIPLICITY_VALUES,
-                default: -> { DEFAULT_MULTIPLICITY }
+      attribute :presence, :string,
+                values: Glossarist::GlossaryDefinition::PARTITIVE_PRESENCE_VALUES,
+                default: -> { DEFAULT_PRESENCE }
+      attribute :count, :string,
+                values: Glossarist::GlossaryDefinition::PARTITIVE_COUNT_VALUES,
+                default: -> { DEFAULT_COUNT }
       attribute :is_delimiting, :boolean, default: -> { false }
 
       key_value do
         map :ref, to: :ref
-        map :multiplicity, to: :multiplicity
+        map :presence, to: :presence
+        map :count, to: :count
         map :is_delimiting, to: :is_delimiting
       end
 
       def validate!
         validate_ref!
-        validate_multiplicity!
+        validate_presence_count!
         self
       end
 
-      def compulsory?
-        multiplicity == "compulsory"
+      def required?
+        presence == "required"
       end
 
       def optional?
-        multiplicity == "optional"
+        presence == "optional"
       end
 
       def delimiting?
@@ -66,15 +84,28 @@ module Glossarist
               "(source, id, or text required)"
       end
 
-      def validate_multiplicity!
-        return if multiplicity.nil?
+      def validate_presence_count!
+        unless Glossarist::GlossaryDefinition::PARTITIVE_PRESENCE_VALUES
+                 .include?(presence)
+          raise ArgumentError,
+                "PartitiveMember#presence has invalid value " \
+                "#{presence.inspect}; must be one of " \
+                "#{GlossaryDefinition::PARTITIVE_PRESENCE_VALUES.join(', ')}"
+        end
+
+        unless Glossarist::GlossaryDefinition::PARTITIVE_COUNT_VALUES
+                 .include?(count)
+          raise ArgumentError,
+                "PartitiveMember#count has invalid value " \
+                "#{count.inspect}; must be one of " \
+                "#{GlossaryDefinition::PARTITIVE_COUNT_VALUES.join(', ')}"
+        end
 
-        unless Glossarist::GlossaryDefinition::MULTIPLICITY_VALUES
-                 .include?(multiplicity)
+        if presence == "optional" && count == "at_least_one"
           raise ArgumentError,
-                "PartitiveMember#multiplicity has invalid value " \
-                "#{multiplicity.inspect}; must be one of " \
-                "#{GlossaryDefinition::MULTIPLICITY_VALUES.join(', ')}"
+                "PartitiveMember presence=optional + count=at_least_one is " \
+                "invalid — it collapses to optional + multiple (zero or more). " \
+                "Use presence: optional, count: multiple instead."
         end
       end
     end

data/lib/glossarist/v3/partitive_relation.rb

@@ -12,10 +12,9 @@ module Glossarist
     # within one relation are coordinate concepts: they share the
     # comprehensive AND share the criterion of subdivision.
     #
-    # Per-partitive metadata (ISO 704:2022):
-    #   - multiplicity (compulsory, optional, compulsory_multiple,
-    #     optional_multiple, compulsory_at_least_one) — encodes the diagram
-    #     line notation as data
+    # Per-partitive metadata (ISO 704:2022, MECE decomposition):
+    #   - presence (required, optional) — line style: solid vs dashed
+    #   - count (exactly_one, at_least_one, multiple) — line count
     #   - is_delimiting — orthogonal flag; a delimiting part behaves
     #     like a delimiting characteristic (distinguishes the
     #     comprehensive from coordinate concepts)

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.compulsory?
-              issues << issue(
-                "partitive_relation #{idx + 1}.partitives[#{mi}] has " \
-                "non-default multiplicity '#{member.multiplicity}'; " \
-                "ISO 704 diagram uses dashed/multiple-line notation for " \
-                "this — 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.3"
+  VERSION = "2.13.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glossarist
 version: !ruby/object:Gem::Version
-  version: 2.13.3
+  version: 2.13.5
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-27 00:00:00.000000000 Z
+date: 2026-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -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