glossarist 2.11.3 → 2.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3342996cc6138d6314fc904cc38790e593dfc6336943b421357406f78c62df9
-  data.tar.gz: f385a95f0ee4cf4b9c1a927f9e63bb3dd6ba9bbbc468c5881011d49041b79a8c
+  metadata.gz: 4fafa61aa5261ca29216b423006cd0764470a9f8bf59733449ba3b501a63413b
+  data.tar.gz: b7c5f6148a76feca5dcbe8321e1a49bed99772a415168ddb977786d214c50110
 SHA512:
-  metadata.gz: 39a3a8436356b5280bde95caff163f18d1e2654f4c00603d124dff135f242f27ca15e50664cf6a649b9be8718678723218b37ec9548ba9b5acae029bbe132b9d
-  data.tar.gz: f01d59ac8056b432faeeb9addc329c080d2b4dcd6a8ab74941016d5325d0814c3dab77381682d5c6b570c61d38f70990af9c8d742c5538faa9e53d157643b087
+  metadata.gz: 163a2b94ff599127f8997de745f05ebec13ab19095790bf91ca832e7ea2c79525c65ca93a4e1cbd45ba4fcd9c4f1d4db9cb564bf370497d1e22fd5aa3e28ec73
+  data.tar.gz: 43be5caab946b3202614ec38db165f6ce72b56137ca1daa87fa0e9c12a853b3c878541c8b8a9b23589719d4239a566ddb621ddee2552e7c284ab435232c03cd1

data/CLAUDE.md

@@ -35,6 +35,36 @@ All model classes use `Lutaml::Model::Serializable` for serialization.
 - **`ConceptReference`** (`concept_reference.rb`) — a typed reference to another concept. Local refs use `concept_id` alone; external refs use `source` (URN prefix) + `concept_id` or a direct `urn` field. Has `local?`/`external?` predicates. No `to_gcr_hash` or `from_urn` — model-driven architecture uses lutaml-model for serialization; URN construction/parsing belongs in `UrnResolver`.
 - **`RelatedConcept`** (`related_concept.rb`) — a concept with a typed relationship. Relationship types cover ISO 10241-1 (deprecates/supersedes/superseded_by/compare/contrast/see), ISO 25964/SKOS (broader/narrower/broader_generic/narrower_generic/broader_partitive/narrower_partitive/broader_instantial/narrower_instantial/equivalent/close_match/broad_match/narrow_match/related_match), ISO 12620/TBX (homograph/false_friend/related_concept/related_concept_broader/related_concept_narrower/sequentially_related_concept/spatially_related_concept/temporally_related_concept), and designation-level (abbreviated_form_for/short_form_for). Types are defined in `config.yml` under `related_concept.type`.
 
+#### V3 `related` placement (MECE)
+
+In V3, `related` lives **only** on `V3::ManagedConcept#related`.
+`V3::ManagedConceptData` does NOT declare or serialize `related`.
+V2 placed `related` inside data; the `SchemaMigration::V2ToV3#step_v2_to_v3`
+migration moves any data-level entries up to the concept level. The
+V3 output never carries `related` at the data level.
+
+This consolidation closes the legacy trap where writing to
+`data.related` bypassed `ManagedConcept.detect_schema_version` (which
+keys off `concept.related`).
+
+### PartitiveHyperedge (V3 only)
+
+`PartitiveHyperedge` (`v3/partitive_hyperedge.rb`) — a one-to-many partitive decomposition. One comprehensive concept is related to one or more parts as a SINGLE relationship. Captures invariants that binary `RelatedConcept` edges cannot:
+
+- which comprehensive owns which parts (set membership)
+- diagram notation flags (`PluralityMarker`: `double`, `dashed`)
+- enumeration completeness (`PartitiveEnumeration`: `closed`, `open`)
+
+Wired into `V3::ManagedConcept#partitive_hyperedges`. NOT on `ManagedConceptData` (relationships live at the concept level for MECE consistency with `related`).
+
+Enum values are SSOT-loaded from `config.yml` via `GlossaryDefinition::PARTITIVE_ENUMERATION_VALUES` and `PLURALITY_MARKER_VALUES`. The `values:` option on each attribute documents the enum; the model's `initialize` override enforces them at construction (lutaml-model 0.8.17 does not enforce `values:` on assignment). Construction also rejects empty comprehensive, empty parts, self-loops, and duplicate marker values.
+
+Semantic checks (defaulted-enumeration warning, defensive walk) live in `Validation::Rules::PartitiveHyperedgeRule` (auto-registered by `Validation::Rules`).
+
+RDF emission: `Rdf::GlossHyperedge` view class (per-hyperedge `gloss:PartitiveHyperedge` subject with `gloss:comprehensive`, `gloss:part+`, `gloss:enumeration`, `gloss:hasPluralityMarker*`, `gloss:hyperedgeContent?`), wired into `Transforms::ConceptToGlossTransform` and emitted as `gloss:hasHyperedge` link from `GlossConcept`.
+
+Binary `broader_partitive`/`narrower_partitive` `RelatedConcept` edges and `PartitiveHyperedge` coexist — no automatic consolidation. See `concept-model/TODO.hyperedge/00-design-overview.md`.
+
 ### Reference Resolution
 
 - **`ReferenceExtractor`** (`reference_extractor.rb`) — extracts `ConceptReference` and `AssetReference` objects from `{{...}}` mentions and `image::...[]` references in concept text fields.

data/config.yml

@@ -186,3 +186,18 @@ concept_date:
     - retired
     - review
     - review_decision
+
+partitive_enumeration:
+  # Whether a PartitiveHyperedge's parts array constitutes the complete
+  # decomposition of the comprehensive (closed) or only a partial one
+  # (open). Default: closed.
+  value:
+    - closed
+    - open
+
+plurality_marker:
+  # Diagram notation flags from VIM concept-relationship diagrams.
+  # Orthogonal to enumeration — both may be set on the same hyperedge.
+  value:
+    - double   # close-set double line at receiver; several parts involved
+    - dashed   # broken/dashed line; plurality is uncertain

data/lib/glossarist/concept_source.rb

@@ -7,6 +7,7 @@ module Glossarist
               values: Glossarist::GlossaryDefinition::CONCEPT_SOURCE_TYPES
     attribute :origin, Citation
     attribute :modification, :string
+    attribute :sourced_from, Citation, collection: true
 
     key_value do
       map :id, to: :id
@@ -14,6 +15,7 @@ module Glossarist
       map :status, to: :status
       map :type, to: :type
       map :modification, to: :modification
+      map :sourced_from, to: :sourced_from
     end
   end
 end

data/lib/glossarist/designation/designation_relationship.rb

@@ -3,7 +3,7 @@
 module Glossarist
   module Designation
     class DesignationRelationship < Lutaml::Model::Serializable
-      attribute :content, :string
+      attribute :content, :hash
       attribute :type, :string,
                 values: Glossarist::GlossaryDefinition::DESIGNATION_RELATIONSHIP_TYPES
       attribute :target, :string

data/lib/glossarist/glossary_definition.rb

@@ -33,5 +33,11 @@ module Glossarist
                                                 "relationship_type")&.freeze
 
     ISO12620_TERM_TYPES = config.dig("iso12620", "term_type").freeze
+
+    PARTITIVE_ENUMERATION_VALUES =
+      config.dig("partitive_enumeration", "value").freeze
+
+    PLURALITY_MARKER_VALUES =
+      config.dig("plurality_marker", "value").freeze
   end
 end

data/lib/glossarist/managed_concept.rb

@@ -174,6 +174,8 @@ module Glossarist
       return "3" if concept.related&.any?
       return "3" if concept.sources&.any?
       return "3" if concept.data&.domains&.any?
+      return "3" if concept.is_a?(V3::ManagedConcept) &&
+                     concept.partitive_hyperedges&.any?
       return "3" if localization_has_references?(concept)
 
       "2"

data/lib/glossarist/rdf/gloss_concept.rb

@@ -11,6 +11,7 @@ module Glossarist
       attribute :sources, GlossConceptSource, collection: true
       attribute :domains, GlossConceptReference, collection: true
       attribute :dates, GlossConceptDate, collection: true
+      attribute :hyperedges, GlossHyperedge, collection: true
 
       RelationshipPredicates::CONCEPT_REL_PREDICATES.each_key do |type|
         attribute :"#{type}_targets", :string, collection: true
@@ -41,6 +42,8 @@ module Glossarist
                 link: "gloss:hasDomain"
         members :dates,
                 link: "gloss:hasDate"
+        members :hyperedges,
+                link: "gloss:hasPartitiveHyperedge"
 
         RelationshipPredicates::CONCEPT_REL_PREDICATES.each do |type, (ns, name)|
           predicate name, namespace: ns, to: :"#{type}_targets",

data/lib/glossarist/rdf/gloss_concept_source.rb

@@ -9,6 +9,7 @@ module Glossarist
       attribute :type, :string
       attribute :modification, :string
       attribute :origin, GlossCitation
+      attribute :sourced_from, GlossCitation, collection: true
 
       rdf do
         namespace Namespaces::GlossaristNamespace
@@ -25,6 +26,7 @@ module Glossarist
                                  to: :modification
 
         members :origin, link: "gloss:sourceOrigin"
+        members :sourced_from, link: "gloss:sourcedFrom"
       end
 
       def self.deterministic_id(source)
@@ -33,6 +35,9 @@ module Glossarist
         if origin
           parts << origin.source << origin.id << origin.version << origin.link
         end
+        Array(source.sourced_from).each do |sf|
+          parts << sf&.source << sf&.id << sf&.version << sf&.link
+        end
         Digest::MD5.hexdigest(parts.compact.join("|"))[0..11]
       end
     end

data/lib/glossarist/rdf/gloss_hyperedge.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    # RDF view for a PartitiveHyperedge (concept-model v3.1.0).
+    #
+    # Emits one `gloss:PartitiveHyperedge` subject per hyperedge with:
+    #
+    #   - gloss:comprehensive — IRI of the comprehensive concept
+    #   - gloss:part          — IRI of each part concept (zero or more)
+    #   - gloss:enumeration   — xsd:string ("closed" | "open")
+    #   - gloss:hasPluralityMarker — xsd:string per marker ("double" |
+    #                                "dashed"). One triple per marker.
+    #   - gloss:hyperedgeContent   — xsd:string (omitted if absent)
+    #
+    # The hyperedge is anchored to the concept that carries it via
+    # `gloss:hasHyperedge` (an inverse of `gloss:comprehensive`). The
+    # subject URI is derived from the carrying concept's identifier
+    # and the comprehensive's id, so it is stable across builds.
+    class GlossHyperedge < Lutaml::Model::Serializable
+      attribute :identifier, :string
+      attribute :comprehensive_id, :string
+      attribute :comprehensive_uri, :string
+      attribute :part_uris, :string, collection: true
+      attribute :enumeration, :string
+      attribute :markers, :string, collection: true
+      attribute :content, :hash
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |h| "hyperedge/#{h.identifier}/#{h.comprehensive_id}" }
+
+        types "gloss:PartitiveHyperedge"
+
+        predicate :comprehensive, namespace: Namespaces::GlossaristNamespace,
+                                   to: :comprehensive_uri
+        predicate :part, namespace: Namespaces::GlossaristNamespace,
+                          to: :part_uris
+        predicate :enumeration, namespace: Namespaces::GlossaristNamespace,
+                                to: :enumeration
+        predicate :hasPluralityMarker,
+                  namespace: Namespaces::GlossaristNamespace,
+                  to: :markers
+        predicate :hyperedgeContent,
+                  namespace: Namespaces::GlossaristNamespace,
+                  to: :content
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/v3.rb

@@ -29,6 +29,7 @@ module Glossarist
         GlossFigureImage
         GlossTable
         GlossFormula
+        GlossHyperedge
       ].freeze
 
       VIEW_CLASS_NAMES.each do |name|

data/lib/glossarist/rdf.rb

@@ -42,6 +42,7 @@ module Glossarist
     autoload :GlossFigureImage,       "#{__dir__}/rdf/gloss_figure_image"
     autoload :GlossTable,             "#{__dir__}/rdf/gloss_table"
     autoload :GlossFormula,           "#{__dir__}/rdf/gloss_formula"
+    autoload :GlossHyperedge,         "#{__dir__}/rdf/gloss_hyperedge"
     autoload :V3,                     "#{__dir__}/rdf/v3"
   end
 end

data/lib/glossarist/related_concept.rb

@@ -2,7 +2,7 @@
 
 module Glossarist
   class RelatedConcept < Lutaml::Model::Serializable
-    attribute :content, :string
+    attribute :content, :hash
     attribute :type, :string,
               values: Glossarist::GlossaryDefinition::RELATED_CONCEPT_TYPES
     attribute :ref, ConceptRef

data/lib/glossarist/schema_migration/v2_to_v3.rb

@@ -38,11 +38,25 @@ module Glossarist
       end
 
       def self.step_v2_to_v3(concept)
-        if concept.data&.related&.any?
-          concept.related ||= []
-          concept.related = (concept.related + concept.data.related).uniq
-          concept.data.related = []
-        end
+        # V2 placed `related` inside ManagedConceptData; V3 places it
+        # on ManagedConcept itself. Move any data-level related entries
+        # up to the concept level. V3::ManagedConceptData no longer
+        # serializes `related`, so we don't need to clear the moved-from
+        # slot — the V3 output naturally omits it.
+        data_related = concept.data&.related
+        return step_v2_to_v3_hyperedge_note if data_related.nil? || data_related.empty?
+
+        concept.related ||= []
+        concept.related = (concept.related + data_related).uniq
+        "3"
+      end
+
+      # Hyperedges: V2 has no hyperedge concept. V2's binary
+      # `broader_partitive` / `narrower_partitive` edges migrate as
+      # `related` entries (see step_v2_to_v3). Hyperedges are a V3-only
+      # construct and require no migration logic — concepts upgraded
+      # from V2 to V3 simply have no hyperedges.
+      def self.step_v2_to_v3_hyperedge_note
         "3"
       end
     end

data/lib/glossarist/transforms/concept_to_gloss_transform.rb

@@ -130,10 +130,44 @@ module Glossarist
           domains: build_gloss_domains(managed_concept.data&.domains,
                                        identifier),
           dates: build_gloss_dates(managed_concept.dates, identifier),
+          hyperedges: build_gloss_hyperedges(v3_hyperedges(managed_concept),
+                                             identifier),
           **rel_targets,
         )
       end
 
+      # Hyperedges are a V3-only attribute. The transform accepts both
+      # V1/V2 and V3 concepts; for V1/V2 concepts the hyperedge list
+      # is always empty.
+      def v3_hyperedges(managed_concept)
+        return [] unless managed_concept.is_a?(V3::ManagedConcept)
+
+        managed_concept.partitive_hyperedges
+      end
+
+      def build_gloss_hyperedges(hyperedges, identifier)
+        return [] unless hyperedges
+
+        Array(hyperedges).map do |he|
+          Rdf::GlossHyperedge.new(
+            identifier: identifier.to_s,
+            comprehensive_id: he.comprehensive.id.to_s,
+            comprehensive_uri: hyperedge_concept_uri(he.comprehensive),
+            part_uris: Array(he.parts).map { |p| hyperedge_concept_uri(p) },
+            enumeration: he.enumeration,
+            markers: Array(he.markers),
+            content: he.content,
+          )
+        end
+      end
+
+      def hyperedge_concept_uri(ref)
+        return nil unless ref.is_a?(Glossarist::ConceptRef)
+
+        Glossarist::Rdf::Namespaces::GlossaristNamespace.uri +
+          "concept/#{ref.id}"
+      end
+
       def build_gloss_localized_concept(l10n, concept_id)
         lang = l10n.language_code
         data = l10n.data

data/lib/glossarist/v2/concept_source.rb

@@ -4,12 +4,14 @@ module Glossarist
   module V2
     class ConceptSource < Glossarist::ConceptSource
       attribute :origin, V2::Citation
+      attribute :sourced_from, V2::Citation, collection: true
 
       key_value do
         map :origin, to: :origin
         map :status, to: :status
         map :type, to: :type
         map :modification, to: :modification
+        map :sourced_from, to: :sourced_from
       end
     end
   end

data/lib/glossarist/v3/concept_source.rb

@@ -4,12 +4,14 @@ module Glossarist
   module V3
     class ConceptSource < Glossarist::ConceptSource
       attribute :origin, V3::Citation
+      attribute :sourced_from, V3::Citation, collection: true
 
       key_value do
         map :origin, to: :origin
         map :status, to: :status
         map :type, to: :type
         map :modification, to: :modification
+        map :sourced_from, to: :sourced_from
       end
     end
   end

data/lib/glossarist/v3/managed_concept.rb

@@ -5,6 +5,7 @@ module Glossarist
     class ManagedConcept < Glossarist::ManagedConcept
       attribute :data, V3::ManagedConceptData, default: -> { V3::ManagedConceptData.new }
       attribute :related, V3::RelatedConcept, collection: true
+      attribute :partitive_hyperedges, V3::PartitiveHyperedge, collection: true
       attribute :dates, V3::ConceptDate, collection: true
       attribute :date_accepted, V3::ConceptDate
       attribute :sources, V3::ConceptSource, collection: true
@@ -12,6 +13,7 @@ module Glossarist
       key_value do
         map :data, to: :data
         map :related, to: :related
+        map :partitive_hyperedges, to: :partitive_hyperedges
         map :dates, to: :dates
         map %i[date_accepted dateAccepted],
             with: { from: :date_accepted_from_yaml, to: :date_accepted_to_yaml }

data/lib/glossarist/v3/managed_concept_data.rb

@@ -2,6 +2,20 @@
 
 module Glossarist
   module V3
+    # V3 ManagedConceptData — the data payload inside a V3::ManagedConcept.
+    #
+    # V3 placement rule (MECE): `related` lives ONLY on V3::ManagedConcept,
+    # not on its data payload. V2 placed `related` inside data; the
+    # V2→V3 migration (SchemaMigration::V2ToV3) moves it to the concept
+    # level. Keeping `related` writable on V3 data would re-open the
+    # trap where writing to `data.related` bypasses
+    # `ManagedConcept.detect_schema_version` (which keys off
+    # `concept.related`).
+    #
+    # The base class Glossarist::ManagedConceptData still declares
+    # `related` for V1/V2 compatibility; V3 overrides that with an
+    # empty attribute via `attribute :related, nil` so the slot is
+    # inert and serializes nothing.
     class ManagedConceptData < Glossarist::ManagedConceptData
       attribute :sources, V3::ConceptSource, collection: true
       attribute :localizations, V3::LocalizedConcept,
@@ -17,7 +31,6 @@ module Glossarist
                                 with: { from: :domains_from_yaml, to: :domains_to_yaml }
         map :tags, to: :tags
         map :sources, to: :sources
-        map :related, to: :related
         map :localizations, to: :localizations,
                             with: { from: :localizations_from_yaml, to: :localizations_to_yaml }
       end
@@ -34,3 +47,4 @@ module Glossarist
     end
   end
 end
+

data/lib/glossarist/v3/partitive_hyperedge.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    # PartitiveHyperedge — a one-to-many partitive decomposition.
+    #
+    # One comprehensive concept (the whole) is related to one or more
+    # parts as a SINGLE relationship. Captures invariants that binary
+    # RelatedConcept edges cannot:
+    #
+    #   - which comprehensive owns which parts (set membership)
+    #   - plurality markers from the source diagram (double / dashed)
+    #   - enumeration completeness (closed: all parts listed; open:
+    #     other parts may exist)
+    #
+    # Enum values are SSOT-loaded from `config.yml` via
+    # `GlossaryDefinition`. The `values:` option on each attribute
+    # documents the enum for schema generation. lutaml-model 0.8.x
+    # does NOT enforce `values:` on assignment — semantic checks live
+    # in `Validation::Rules::PartitiveHyperedgeRule` (auto-registered
+    # via `Validation::Rules`). The model's `validate!` method covers
+    # type-shape invariants that fail loudly at construction (empty
+    # comprehensive, empty parts, self-loop, invalid enum values).
+    #
+    # Note on duplicates: lutaml-model's enum-collection setter
+    # dedupes silently via the getter, so duplicate markers at
+    # construction time are silently coerced to a unique set. We do
+    # not attempt to override this; the framework's Set semantics are
+    # the data contract.
+    #
+    # `content` is a localized string hash `{ "eng" => "...", "fra" => "..." }`
+    # keyed by ISO 639 language code. All free-form text fields in
+    # Glossarist MUST be localized — the project is multi-language by
+    # domain. Read values via the `LocalizedString` helper module:
+    #
+    #   Glossarist::LocalizedString.fetch(he.content, "eng")
+    #
+    # Matches the pattern used by `Section#names`, `DatasetRegister#description`,
+    # `Formula#expression`, `Table#content`. The concept-model schema and
+    # `RelatedConcept#content` still declare `type: string` today — those
+    # are bugs to fix, not patterns to copy.
+    class PartitiveHyperedge < Lutaml::Model::Serializable
+      DEFAULT_ENUMERATION = "closed"
+
+      attribute :comprehensive, ConceptRef
+      attribute :parts, ConceptRef, collection: true
+      attribute :enumeration, :string,
+                values: Glossarist::GlossaryDefinition::PARTITIVE_ENUMERATION_VALUES,
+                default: -> { DEFAULT_ENUMERATION }
+      attribute :markers, :string,
+                values: Glossarist::GlossaryDefinition::PLURALITY_MARKER_VALUES,
+                collection: true
+      attribute :content, :hash
+
+      key_value do
+        map :comprehensive, to: :comprehensive
+        map :parts, to: :parts
+        map :enumeration, to: :enumeration
+        map :markers, to: :markers
+        map :content, to: :content
+      end
+
+      # Type-shape validators — invoke via `validate!` after
+      # construction. We do NOT call these from `initialize` because
+      # lutaml-model deserializes attributes AFTER `new` returns (see
+      # `Lutaml::KeyValue::Transform#data_to_model`); validating in
+      # `initialize` sees a half-built instance and raises spuriously.
+
+      def validate!
+        validate_comprehensive!
+        validate_parts!
+        validate_self_loop!
+        validate_markers!
+        validate_enumeration!
+        self
+      end
+
+      private
+
+      def validate_comprehensive!
+        return if comprehensive.is_a?(ConceptRef) &&
+                  (comprehensive.source || comprehensive.id)
+
+        raise ArgumentError,
+              "PartitiveHyperedge#comprehensive must be a non-empty " \
+              "ConceptRef (source or id required)"
+      end
+
+      def validate_parts!
+        return if Array(parts).any?
+
+        raise ArgumentError, "PartitiveHyperedge requires at least one part"
+      end
+
+      def validate_self_loop!
+        return unless comprehensive.is_a?(ConceptRef)
+
+        comp_key = [comprehensive.source, comprehensive.id]
+        parts.each do |p|
+          next unless p.is_a?(ConceptRef)
+          next unless [p.source, p.id] == comp_key
+
+          raise ArgumentError,
+                "PartitiveHyperedge#parts cannot include the comprehensive"
+        end
+      end
+
+      def validate_markers!
+        Array(markers).each do |m|
+          unless Glossarist::GlossaryDefinition::PLURALITY_MARKER_VALUES.include?(m)
+            raise ArgumentError,
+                  "PartitiveHyperedge#markers contains invalid value #{m.inspect}; " \
+                  "must be one of " \
+                  "#{GlossaryDefinition::PLURALITY_MARKER_VALUES.join(', ')}"
+          end
+        end
+      end
+
+      def validate_enumeration!
+        return if enumeration.nil?
+
+        unless Glossarist::GlossaryDefinition::PARTITIVE_ENUMERATION_VALUES
+                 .include?(enumeration)
+          raise ArgumentError,
+                "PartitiveHyperedge#enumeration has invalid value " \
+                "#{enumeration.inspect}; must be one of " \
+                "#{GlossaryDefinition::PARTITIVE_ENUMERATION_VALUES.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/v3.rb

@@ -9,6 +9,7 @@ module Glossarist
     autoload :DetailedDefinition, "glossarist/v3/detailed_definition"
     autoload :ConceptRef, "glossarist/v3/concept_ref"
     autoload :RelatedConcept, "glossarist/v3/related_concept"
+    autoload :PartitiveHyperedge, "glossarist/v3/partitive_hyperedge"
     autoload :ConceptData, "glossarist/v3/concept_data"
     autoload :LocalizedConcept, "glossarist/v3/localized_concept"
     autoload :ManagedConceptData, "glossarist/v3/managed_concept_data"
@@ -23,6 +24,7 @@ module Glossarist
     Configuration.register_model(LocalizedConcept, id: :localized_concept)
     Configuration.register_model(ConceptRef, id: :concept_ref)
     Configuration.register_model(RelatedConcept, id: :related_concept)
+    Configuration.register_model(PartitiveHyperedge, id: :partitive_hyperedge)
     Configuration.register_model(ManagedConceptData, id: :managed_concept_data)
     Configuration.register_model(ManagedConcept, id: :managed_concept)
     Configuration.register_model(ConceptDocument, id: :concept_document)

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      # Validates semantic invariants of PartitiveHyperedge entries that
+      # the model constructor does NOT enforce. Specifically:
+      #
+      #   - warning when `enumeration` was filled by lutaml-model's
+      #     default proc (i.e. the source YAML omitted it) — author is
+      #     *encouraged* to set explicitly per the design doc
+      #   - error when markers contain values not in
+      #     PLURALITY_MARKER_VALUES
+      #
+      # The model constructor already rejects empty comprehensive,
+      # empty parts, self-loops, and (lutaml-model auto-dedupes
+      # duplicate markers on enum-collection assignment, so no
+      # explicit check is needed).
+      class PartitiveHyperedgeRule < Base
+        def code = "GLS-220"
+        def category = :schema
+        def severity = "error"
+        def scope = :concept
+
+        def applicable?(context)
+          concept = context.concept
+          return false unless concept.is_a?(V3::ManagedConcept)
+
+          concept.partitive_hyperedges&.any?
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          return issues unless concept.is_a?(V3::ManagedConcept)
+
+          concept.partitive_hyperedges.each_with_index do |he, idx|
+            check_comprehensive(he, idx, fname, issues)
+            check_parts(he, idx, fname, issues)
+            check_markers(he, idx, fname, issues)
+            check_enumeration_explicit(he, idx, fname, issues)
+          end
+
+          issues
+        end
+
+        private
+
+        def check_comprehensive(he, idx, fname, issues)
+          ref = he.comprehensive
+          return if ref.is_a?(Glossarist::ConceptRef) && (ref.source || ref.id)
+
+          issues << issue(
+            "partitive_hyperedge #{idx + 1} has empty comprehensive",
+            location: fname,
+          )
+        end
+
+        def check_parts(he, idx, fname, issues)
+          parts = Array(he.parts)
+          if parts.empty?
+            issues << issue(
+              "partitive_hyperedge #{idx + 1} has no parts",
+              location: fname,
+            )
+            return
+          end
+
+          parts.each_with_index do |part, pi|
+            next if part.is_a?(Glossarist::ConceptRef) && (part.source || part.id)
+
+            issues << issue(
+              "partitive_hyperedge #{idx + 1} part #{pi + 1} has empty ref",
+              location: fname,
+            )
+          end
+        end
+
+        def check_markers(he, idx, fname, issues)
+          # `using_default?` reports whether an attribute was set by
+          # the user (false) or filled by the default proc (true).
+          # `markers` has no default, so absence yields nil/[] and
+          # `using_default?(:markers)` is true. We still walk for
+          # invalid values because `values:` is informational.
+          Array(he.markers).each_with_index do |m, mi|
+            unless Glossarist::GlossaryDefinition::PLURALITY_MARKER_VALUES.include?(m)
+              issues << issue(
+                "partitive_hyperedge #{idx + 1} marker #{mi + 1} has invalid value #{m.inspect}",
+                location: fname,
+              )
+            end
+          end
+        end
+
+        def check_enumeration_explicit(he, idx, fname, issues)
+          # `using_default?(:enumeration)` is true iff the value was
+          # NOT explicitly set by the caller (filled by default proc).
+          return unless he.using_default?(:enumeration)
+
+          issues << issue(
+            "partitive_hyperedge #{idx + 1} has implicit enumeration (default '#{Glossarist::V3::PartitiveHyperedge::DEFAULT_ENUMERATION}')",
+            severity: "warning",
+            location: fname,
+            suggestion: "Set 'enumeration: closed' or 'enumeration: open' explicitly",
+          )
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/version.rb

@@ -4,5 +4,5 @@
 #
 
 module Glossarist
-  VERSION = "2.11.3"
+  VERSION = "2.12.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glossarist
 version: !ruby/object:Gem::Version
-  version: 2.11.3
+  version: 2.12.1
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-08 00:00:00.000000000 Z
+date: 2026-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -307,6 +307,7 @@ files:
 - lib/glossarist/rdf/gloss_figure_image.rb
 - lib/glossarist/rdf/gloss_formula.rb
 - lib/glossarist/rdf/gloss_grammar_info.rb
+- lib/glossarist/rdf/gloss_hyperedge.rb
 - lib/glossarist/rdf/gloss_locality.rb
 - lib/glossarist/rdf/gloss_localized_concept.rb
 - lib/glossarist/rdf/gloss_non_verbal_rep.rb
@@ -394,6 +395,7 @@ files:
 - lib/glossarist/v3/localized_concept.rb
 - lib/glossarist/v3/managed_concept.rb
 - lib/glossarist/v3/managed_concept_data.rb
+- lib/glossarist/v3/partitive_hyperedge.rb
 - lib/glossarist/v3/related_concept.rb
 - lib/glossarist/validation.rb
 - lib/glossarist/validation/asset_index.rb
@@ -436,6 +438,7 @@ files:
 - lib/glossarist/validation/rules/orphaned_bibliography_rule.rb
 - lib/glossarist/validation/rules/orphaned_images_rule.rb
 - lib/glossarist/validation/rules/orphaned_l10n_files_rule.rb
+- lib/glossarist/validation/rules/partitive_hyperedge_rule.rb
 - lib/glossarist/validation/rules/preferred_term_rule.rb
 - lib/glossarist/validation/rules/ref_shape_rule.rb
 - lib/glossarist/validation/rules/registry.rb