glossarist 2.13.7 → 2.13.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4d7af45a5f0e045d0f3a18cdcca5791a85bfcb6a16a642af0c1e840b68ef6e8
-  data.tar.gz: 8fd502d531f3c862c340b3aa19bb1fc4e4b205e7217ba4c79ee6bc1809db0d35
+  metadata.gz: 439b6f94f23e6018ec771d6032a05f83aac496fb4a03c8d33cebc793886cc8fa
+  data.tar.gz: 8462a0e92e3e0ff0a9b3447fe94ae1ce9d8f3b59ce10955daeb746a4c0b514d7
 SHA512:
-  metadata.gz: aedc22ebce41ec42d6bc93e96abef82078b7834b66f08a0e219b08f4b2e0eded91561bcc82af7498ab50aed4e8da32d0cabc23c37b7eb56390ec7028e8b731ba
-  data.tar.gz: fe063d88bf1297f1c31e72ce545a9a9e32f7deb89f6d24cd6580572f830f605288e57feed04ed3af4ebb9c777320def6c5fc87e9ec82a93ef12c0a070a7f42b7
+  metadata.gz: e6be9e8613779b1e7a791cc40df512e0592e9d3aa8d27d2339f80f04dc832e001024d412a71f20571e366b7be952581834e12e09dede444a8bf604a3b556e865
+  data.tar.gz: 37170de8e503b351d2e609fd91e294e10bd48f4ae53d20c81b3224737a6413cb53e593bab170e2ea9683f5583cc7969447492bd136ba1dcb2c559d707a9fe3eb

data/lib/glossarist/rdf/gloss_generic_member.rb

@@ -8,7 +8,14 @@ module Glossarist
     # deterministic_id from GlossNaryMember. The `rdf do` block
     # re-declares the predicates because lutaml-model's `rdf` DSL
     # replaces the parent mapping (not extends).
+    #
+    # Carries `gloss:characteristic` — the delimiting characteristic
+    # text per ISO 704:2022 §5.5.4.2.1 (e.g., "detecting movement by
+    # means of light sensors"). Each species in a coordinate set has
+    # its own characteristic under the parent hyperedge's criterion.
     class GlossGenericMember < GlossNaryMember
+      attribute :characteristic, :hash
+
       rdf do
         namespace Namespaces::GlossaristNamespace
 
@@ -26,8 +33,8 @@ module Glossarist
                              to: :presence
         predicate :count, namespace: Namespaces::GlossaristNamespace,
                           to: :count
-        predicate :isDelimiting, namespace: Namespaces::GlossaristNamespace,
-                                 to: :is_delimiting
+        predicate :characteristic, namespace: Namespaces::GlossaristNamespace,
+                                   to: :characteristic
       end
     end
   end

data/lib/glossarist/rdf/gloss_nary_member.rb

@@ -4,27 +4,27 @@ require "lutaml/model"
 
 module Glossarist
   module Rdf
-    # Shared base for typed n-ary relation member RDF views
+    # Shared base for typed n-ary hyperedge member RDF views
     # (GlossPartitiveMember, GlossGenericMember, future leaves).
     #
     # Carries the shared attributes and the deterministic_id algorithm.
-    # Concrete leaves declare their own `rdf do` block because
-    # lutaml-model's `rdf` DSL replaces (not extends) the parent's
-    # mapping — predicate declarations stay in each leaf.
+    # Concrete leaves declare their own `rdf do` block AND their own
+    # type-specific attributes — `is_delimiting` on GlossPartitiveMember
+    # (binary role, ISO 704 §5.5.4.2.2); `characteristic` on
+    # GlossGenericMember (delimiting text, ISO 704 §5.5.4.2.1).
     #
     # Subject identity is content-derived so the same member in the
-    # same relation produces the same URI across runs (and across
+    # same hyperedge 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.
+    # inconsistency if the same concept is given different dimensions
+    # inside the same dataset.
     class GlossNaryMember < Lutaml::Model::Serializable
       attribute :ref_id, :string
       attribute :ref_source, :string
       attribute :ref_text, :string
       attribute :presence, :string
       attribute :count, :string
-      attribute :is_delimiting, :boolean
 
       # Human-readable SOURCE:ID when both are present; SHA-256 / 16
       # hex chars fallback otherwise. Same content → same slug across
@@ -33,10 +33,19 @@ module Glossarist
         readable = [member.ref_source, member.ref_id].compact.reject(&:empty?)
         return readable.join(":") unless readable.empty?
 
-        DeterministicSlug.from_parts(
-          member.ref_source, member.ref_id, member.ref_text,
-          member.presence, member.count, member.is_delimiting
-        )
+        parts = [member.ref_source, member.ref_id, member.ref_text,
+                 member.presence, member.count]
+        # Type-specific discriminator: include the delimiting flag for
+        # partitive members (binary role) or the characteristic text
+        # for generic members (so members of different criteria don't
+        # collide on the same hash input).
+        case member
+        when GlossPartitiveMember
+          parts << member.is_delimiting
+        when GlossGenericMember
+          parts << member.characteristic
+        end
+        DeterministicSlug.from_parts(*parts)
       end
     end
   end

data/lib/glossarist/rdf/gloss_partitive_member.rb

@@ -8,7 +8,12 @@ module Glossarist
     # deterministic_id from GlossNaryMember. The `rdf do` block
     # re-declares the predicates because lutaml-model's `rdf` DSL
     # replaces the parent mapping (not extends).
+    #
+    # Carries `gloss:isDelimiting` — the binary role flag per
+    # ISO 704:2022 §5.5.4.2.2 (a part is or is not a delimiting part).
     class GlossPartitiveMember < GlossNaryMember
+      attribute :is_delimiting, :boolean
+
       rdf do
         namespace Namespaces::GlossaristNamespace
 

data/lib/glossarist/transforms/concept_to_gloss_transform.rb

@@ -136,12 +136,12 @@ module Glossarist
           partitive_relations: build_gloss_hyperedges(
             relation_list, V3::PartitiveHyperedge,
             :build_gloss_partitive_member, :partitive_member_ids,
-            :partitive_members, Rdf::GlossPartitiveRelation, identifier,
+            :partitive_members, Rdf::GlossPartitiveRelation, identifier
           ),
           generic_relations: build_gloss_hyperedges(
             relation_list, V3::GenericHyperedge,
             :build_gloss_generic_member, :generic_member_ids,
-            :generic_members, Rdf::GlossGenericRelation, identifier,
+            :generic_members, Rdf::GlossGenericRelation, identifier
           ),
           **rel_targets,
         )
@@ -156,7 +156,7 @@ module Glossarist
                                   member_ids_attr, members_attr,
                                   gloss_relation_class, identifier)
         Array(relations)
-          .select { |rel| rel.is_a?(hyperedge_class) }
+          .grep(hyperedge_class)
           .map { |rel| build_one_gloss_hyperedge(rel, member_builder, member_ids_attr, members_attr, gloss_relation_class, identifier) }
       end
 
@@ -192,6 +192,8 @@ module Glossarist
 
       # Shared member builder. Per-class metadata (the rdf view class
       # is dispatched by the caller) keeps the duplication to one place.
+      # Per-type fields are dispatched by class — PartitiveMember
+      # carries `is_delimiting`; GenericMember carries `characteristic`.
       def build_gloss_nary_member(gloss_member_class, member)
         ref = member.ref
         ref_attrs = if ref.is_a?(Glossarist::ConceptRef)
@@ -200,11 +202,21 @@ module Glossarist
                       {}
                     end
 
+        type_attrs =
+          case member
+          when V3::PartitiveMember
+            { is_delimiting: member.is_delimiting }
+          when V3::GenericMember
+            { characteristic: member.characteristic }
+          else
+            {}
+          end
+
         gloss_member_class.new(
           **ref_attrs,
           presence: member.presence,
           count: member.count,
-          is_delimiting: member.is_delimiting,
+          **type_attrs,
         )
       end
 

data/lib/glossarist/v3/abstract_hyperedge.rb

@@ -114,8 +114,8 @@ module Glossarist
         parts = [comprehensive.source, comprehensive.id].compact.reject(&:empty?)
         return nil if parts.empty?
 
-        parts.join("-").downcase.gsub(/[^a-z0-9\-]/, "-")
-             .gsub(/-{2,}/, "-").gsub(/\A-|-\z/, "")
+        parts.join("-").downcase.gsub(/[^a-z0-9-]/, "-")
+          .gsub(/-{2,}/, "-").gsub(/\A-|-\z/, "")
       end
 
       # Kebab-case slug derived from the English criterion. Falls back

data/lib/glossarist/v3/generic_member.rb

@@ -2,16 +2,51 @@
 
 module Glossarist
   module V3
-    # GenericMember — one member of a GenericHyperedge. Carries the same
-    # MECE dimensions as PartitiveMember; the comprehensive of its
-    # parent GenericHyperedge denotes the genus concept.
+    # GenericMember — one member (species) of a GenericHyperedge. The
+    # `comprehensive` of its parent GenericHyperedge denotes the genus
+    # concept; this member denotes one species.
     #
-    # See docs/design/generic-relation.md and docs/design/abstract-nary-relation.md
-    # (concept-model repo).
+    # Per ISO 704:2022 §5.5.4.2.1, the intension of a species includes
+    # the intension of the genus plus at least one additional
+    # DELIMITING CHARACTERISTIC. Each species in a coordinate set
+    # (siblings sharing the same criterion of subdivision) carries its
+    # own delimiting characteristic value.
+    #
+    # Example (ISO 704 §5.5.4.2.1 Example 3):
+    #   Hyperedge comprehensive: computer mouse
+    #   Hyperedge criterion (of subdivision): means of movement detection
+    #   Members:
+    #     - mechanical mouse
+    #       characteristic: "detecting movement by means of rollers"
+    #     - optomechanical mouse
+    #       characteristic: "detecting movement by means of rollers and light sensors"
+    #     - optical mouse
+    #       characteristic: "detecting movement by means of light sensors"
+    #
+    # Multidimensionality (ISO 704 §5.6.3): the same genus can have
+    # multiple GenericHyperedges, each with a different criterion
+    # (e.g., means of movement detection vs computer connection). The
+    # `characteristic` on each member is meaningful only within its
+    # parent hyperedge's criterion context.
+    #
+    # Distinct from PartitiveMember: partitive members are binary
+    # delimiting (a part is or isn't delimiting); generic members are
+    # textually delimiting (each species has its own characteristic
+    # phrase that distinguishes it from coordinate concepts).
     class GenericMember < HyperedgeMember
-      # Inherits all attributes and validations from HyperedgeMember.
-      # Declared as a distinct class for type safety and to leave room
-      # for future generic-specific extensions.
+      # The delimiting characteristic of this species under the parent
+      # hyperedge's criterion of subdivision. Localized — different
+      # languages may express the same characteristic differently.
+      # Required for semantic completeness per ISO 704 §5.5.4.2.1, but
+      # the model permits nil to allow incremental population.
+      attribute :characteristic, :hash
+
+      key_value do
+        map :ref, to: :ref
+        map :presence, to: :presence
+        map :count, to: :count
+        map :characteristic, to: :characteristic
+      end
     end
   end
 end

data/lib/glossarist/v3/hyperedge_member.rb

@@ -3,14 +3,25 @@
 module Glossarist
   module V3
     # HyperedgeMember — abstract base shape for members of any
-    # n-ary concept-system relation (PartitiveMember, GenericMember,
+    # n-ary concept-system hyperedge (PartitiveMember, GenericMember,
     # future AssociativeMember, SequentialMember).
     #
-    # Carries the shared ISO 704:2022 MECE dimensions: presence × count,
-    # plus the orthogonal is_delimiting flag.
+    # Carries the shared ISO 704:2022 MECE dimensions on every member:
+    #   presence — required (default) | optional
+    #   count    — exactly_one (default) | at_least_one | multiple
     #
-    # Concrete leaf classes inherit and may add type-specific fields.
-    # See docs/design/abstract-nary-relation.md (concept-model repo).
+    # Type-specific extensions live on the leaves:
+    #   PartitiveMember — `is_delimiting` (Boolean): per ISO 704
+    #     §5.5.4.2.2, a part is or is not a delimiting part. Binary role.
+    #   GenericMember — `characteristic` (LocalizedString): per ISO 704
+    #     §5.5.4.2.1, each species carries a delimiting characteristic
+    #     text (e.g., "detecting movement by means of light sensors")
+    #     that distinguishes it from coordinate concepts under the
+    #     hyperedge's criterion of subdivision.
+    #
+    # The combination (optional, at_least_one) is invalid and collapses
+    # to (optional, multiple). Multiplicity is the SSOT for the
+    # validation; this class delegates to it.
     class HyperedgeMember < Lutaml::Model::Serializable
       DEFAULT_PRESENCE = "required"
       DEFAULT_COUNT = "exactly_one"
@@ -22,13 +33,11 @@ module Glossarist
       attribute :count, :string,
                 values: Glossarist::GlossaryDefinition::MEMBER_COUNT_VALUES,
                 default: -> { DEFAULT_COUNT }
-      attribute :is_delimiting, :boolean, default: -> { false }
 
       key_value do
         map :ref, to: :ref
         map :presence, to: :presence
         map :count, to: :count
-        map :is_delimiting, to: :is_delimiting
       end
 
       def initialize(*)
@@ -55,10 +64,6 @@ module Glossarist
         presence == "optional"
       end
 
-      def delimiting?
-        is_delimiting == true
-      end
-
       private
 
       def validate_ref!

data/lib/glossarist/v3/hyperedge_registry.rb

@@ -15,10 +15,12 @@ module Glossarist
     # validator, RDF emitter, RelationLoader) — they all iterate or
     # resolve through this registry.
     module HyperedgeRegistry
-      # Mutable: register adds entries at load time. DO NOT freeze.
+      # rubocop:disable Style/MutableConstant — these MUST stay
+      # mutable; register() adds entries at load time.
       BY_WIRE_KEY = {}
       BY_TYPE_TAG = {}
       BY_RDF_TYPE = {}
+      # rubocop:enable Style/MutableConstant
 
       Mutex = ::Mutex.new
 

data/lib/glossarist/v3/hyperedge_writer.rb

@@ -45,8 +45,10 @@ module Glossarist
           hyperedge.is_a?(AbstractHyperedge)
 
         path = hyperedge.file_path(@relations_dir)
-        raise WriteError,
-              "cannot derive file path — comprehensive must be non-empty" unless path
+        unless path
+          raise WriteError,
+                "cannot derive file path — comprehensive must be non-empty"
+        end
 
         FileUtils.mkdir_p(File.dirname(path))
         File.write(path, serialize(hyperedge))
@@ -72,7 +74,7 @@ module Glossarist
         ordered["type"]        = hash.delete("type")
         ordered["status"]      = hash.delete("status") if hash.key?("status")
         ordered["comprehensive"] = hash.delete("comprehensive")
-        ordered["members"]     = hash.delete("members")
+        ordered["members"] = hash.delete("members")
         ordered["completeness"] = hash.delete("completeness") if hash.key?("completeness")
         ordered["criterion"]   = hash.delete("criterion") if hash.key?("criterion")
         ordered["sources"]     = hash.delete("sources") if hash.key?("sources")

data/lib/glossarist/v3/partitive_member.rb

@@ -2,15 +2,33 @@
 
 module Glossarist
   module V3
-    # PartitiveMember — one member of a PartitiveHyperedge. Inherits
-    # the ISO 704:2022 MECE shape from HyperedgeMember; the
+    # PartitiveMember — one member of a PartitiveHyperedge. The
     # `comprehensive` of its parent PartitiveHyperedge denotes the
-    # whole concept.
+    # whole concept; this member denotes one of its parts.
     #
-    # Distinct leaf class for type safety and to leave room for
-    # partitive-specific extensions if needed.
+    # Per ISO 704:2022 §5.5.4.2.2, a part is either delimiting or not:
+    # a delimiting part behaves like a delimiting characteristic — it
+    # distinguishes the comprehensive (whole) from coordinate concepts.
+    # Example: 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).
+    #
+    # The binary role is sufficient — no per-member delimiting text is
+    # needed because the part itself IS the delimiting marker.
     class PartitiveMember < HyperedgeMember
-      # Inherits all attributes and validations from HyperedgeMember.
+      attribute :is_delimiting, :boolean, default: -> { false }
+
+      key_value do
+        map :ref, to: :ref
+        map :presence, to: :presence
+        map :count, to: :count
+        map :is_delimiting, to: :is_delimiting
+      end
+
+      def delimiting?
+        is_delimiting == true
+      end
     end
   end
 end

data/lib/glossarist/version.rb

@@ -4,5 +4,5 @@
 #
 
 module Glossarist
-  VERSION = "2.13.7"
+  VERSION = "2.13.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glossarist
 version: !ruby/object:Gem::Version
-  version: 2.13.7
+  version: 2.13.8
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-29 00:00:00.000000000 Z
+date: 2026-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model