glossarist 2.13.0 → 2.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85ff1a35136e9b7ff920830b2bf9a2e4b477bffed405c2386e33739ed6560a45
-  data.tar.gz: f7ef8fb96a58eb21a71534fcc8afc1cf7f26053379cfb00e5ec98098620ca6a6
+  metadata.gz: bff178304ceb50c9e4f73bd22a66686ed7ae759786cf0abb4405e6594357dc49
+  data.tar.gz: f972e9d4a1b876577803285142ac3edb13f6b1a1b240ed416199340982db4e51
 SHA512:
-  metadata.gz: beeecf5f816d5ec10741375d357a1b3602e7d415ebedfc71eff52d414f1d623ed119c7995355231c147020f54b814dc8306d37acdc6eecacdf8ca72ec6ddd65f
-  data.tar.gz: 0a7de5bd20f0f7c58c1c08066983b5c490999570249b686f84f60bd87df9b5e436913db66e43b5d1003805bfa33a6613d67bbd8c49373d21a03815dde83a8e42
+  metadata.gz: 0515fbecf5fac714751b7c6ae23168eb2371fdfc3359a26cf91a6a14efeb5c1700a1080dbe4418c254a601a05a2d734343c5f2ecf2c0dede871bb82cdd1d740f
+  data.tar.gz: 8fefaa9978f3ebe78ae5a03414e395dba36fa8c3887e0d40ff91889c3e6e36e7d2d22a627038478bc6491988c3849c4147420c4e0e6e5851231240ea9b82bac0

data/CLAUDE.md

@@ -54,20 +54,21 @@ keys off `concept.related`).
 Each PartitiveRelation carries:
 
 - `comprehensive` — ConceptRef to the superordinate concept partitive (the whole)
-- `partitives` — `PartitiveMember [2..*]` (ISO 704 "two or more"); each member wraps a ConceptRef plus optional `MemberCertainty` (`confirmed` default, `possible`)
+- `partitives` — `PartitiveMember [2..*]` (ISO 704 "two or more"). Each member wraps a ConceptRef plus ISO 704:2022 notation metadata:
+  - `multiplicity` — one of `compulsory` (1 solid line, default), `optional` (1 dashed line), `compulsory_multiple` (2 solid lines), `optional_multiple` (2 dashed lines), `compulsory_at_least_one` (1 solid + 1 dashed line)
+  - `is_delimiting` — boolean (default false). A delimiting part behaves like a delimiting characteristic: it distinguishes the comprehensive from coordinate concepts. Rendered as a bold 3x-width line in the diagram. Orthogonal to multiplicity.
 - `completeness` — `complete` (default; the encoded partitives constitute the whole) or `partial` (others exist beyond those encoded). ISO 704 rake backline notation.
-- `plurality` — optional `TypeSharedPlurality` block (ISO 704 close-set double line promoted to data: `is_shared`, `is_uncertain`, `shared_type`). Replaces the prior opaque `markers` field.
 - `criterion` — optional localized string hash (`{ "eng" => "physical structure" }`). ISO 12620 coordinate-concept coherence: partitives within one relation share the comprehensive AND the criterion.
 
 Wired into `V3::ManagedConcept#partitive_relations`. NOT on `ManagedConceptData` (relationships live at the concept level for MECE consistency with `related`).
 
-Enum values are SSOT-loaded from `config.yml` via `GlossaryDefinition::COMPLETENESS_VALUES` and `MEMBER_CERTAINTY_VALUES`. The `values:` option on each attribute documents the enum; the model's `validate!` method enforces structural invariants after construction (empty comprehensive, <2 partitives, self-loops, incoherent plurality, invalid enum values).
+Enum values are SSOT-loaded from `config.yml` via `GlossaryDefinition::COMPLETENESS_VALUES` and `MULTIPLICITY_VALUES`. The `values:` option on each attribute documents the enum; the model's `validate!` method enforces structural invariants after construction (empty comprehensive, <2 partitives, self-loops, invalid enum values).
 
-Semantic checks (≥2 partitives cardinality, duplicate comprehensive+criterion detection, criterion-absent warning, ExternalConcept shape) live in `Validation::Rules::PartitiveRelationRule` (auto-registered by `Validation::Rules`, code GLS-221).
+Semantic checks (≥2 partitives cardinality, duplicate comprehensive+criterion detection, criterion-absent warning, non-default multiplicity warning, ExternalConcept shape) live in `Validation::Rules::PartitiveRelationRule` (auto-registered by `Validation::Rules`, code GLS-221).
 
-RDF emission: `Rdf::GlossPartitiveRelation` view class with companion `GlossPartitiveMember` and `GlossTypeSharedPlurality`. Wired into `Transforms::ConceptToGlossTransform` and emitted as `gloss:hasPartitiveRelation` link from `GlossConcept`.
+RDF emission: `Rdf::GlossPartitiveRelation` view class with companion `GlossPartitiveMember`. Wired into `Transforms::ConceptToGlossTransform` and emitted as `gloss:hasPartitiveRelation` link from `GlossConcept`.
 
-Binary `broader_partitive`/`narrower_partitive`/`has_part`/`is_part_of` `RelatedConcept` edges and `PartitiveRelation` coexist — no automatic consolidation. Use a binary edge for pairwise relationships; use a PartitiveRelation when membership is jointly significant (≥2 partitives + completeness/plurality/criterion metadata).
+Binary `broader_partitive`/`narrower_partitive`/`has_part`/`is_part_of` `RelatedConcept` edges and `PartitiveRelation` coexist — no automatic consolidation. Use a binary edge for pairwise relationships; use a PartitiveRelation when membership is jointly significant (≥2 partitives + completeness/multiplicity/delimiting/criterion metadata).
 
 #### ExternalConcept
 

data/config.yml

@@ -211,9 +211,18 @@ completeness:
     - complete
     - partial
 
-member_certainty:
-  # Per-partitive certainty. Glossarist extension beyond ISO 704
-  # notation. Defaults to confirmed when omitted.
+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:
-    - confirmed
-    - possible
+    - compulsory
+    - optional
+    - compulsory_multiple
+    - optional_multiple
+    - compulsory_at_least_one

data/lib/glossarist/glossary_definition.rb

@@ -35,9 +35,8 @@ module Glossarist
     ISO12620_TERM_TYPES = config.dig("iso12620", "term_type").freeze
 
     # PartitiveRelation redesign (TODO.partitive-relation-v2).
-    # Replaces PARTITIVE_ENUMERATION_VALUES + PLURALITY_MARKER_VALUES.
     COMPLETENESS_VALUES = config.dig("completeness", "value").freeze
 
-    MEMBER_CERTAINTY_VALUES = config.dig("member_certainty", "value").freeze
+    MULTIPLICITY_VALUES = config.dig("multiplicity", "value").freeze
   end
 end

data/lib/glossarist/rdf/gloss_partitive_member.rb

@@ -5,12 +5,14 @@ require "lutaml/model"
 module Glossarist
   module Rdf
     # RDF view for V3::PartitiveMember. Emits a
-    # gloss:PartitiveMember subject with ref + certainty properties.
+    # gloss:PartitiveMember subject with ref, multiplicity, and
+    # is_delimiting properties.
     class GlossPartitiveMember < Lutaml::Model::Serializable
       attribute :ref_id, :string
       attribute :ref_source, :string
       attribute :ref_text, :string
-      attribute :certainty, :string
+      attribute :multiplicity, :string
+      attribute :is_delimiting, :boolean
 
       rdf do
         namespace Namespaces::GlossaristNamespace
@@ -25,8 +27,10 @@ module Glossarist
                           to: :ref_id
         predicate :refText, namespace: Namespaces::GlossaristNamespace,
                             to: :ref_text
-        predicate :certainty, namespace: Namespaces::GlossaristNamespace,
-                              to: :certainty
+        predicate :multiplicity, namespace: Namespaces::GlossaristNamespace,
+                                 to: :multiplicity
+        predicate :isDelimiting, namespace: Namespaces::GlossaristNamespace,
+                                 to: :is_delimiting
       end
     end
   end

data/lib/glossarist/rdf/gloss_partitive_relation.rb

@@ -6,13 +6,12 @@ module Glossarist
   module Rdf
     # RDF view for V3::PartitiveRelation. Emits a
     # gloss:PartitiveRelation subject with comprehensive, hasPartitive,
-    # completeness, hasPlurality, criterion properties.
+    # completeness, criterion properties.
     class GlossPartitiveRelation < Lutaml::Model::Serializable
       attribute :identifier, :string
       attribute :comprehensive_uri, :string
       attribute :partitive_member_ids, :string, collection: true
       attribute :completeness, :string
-      attribute :has_plurality, GlossTypeSharedPlurality
       attribute :criterion, :hash
 
       rdf do
@@ -28,8 +27,6 @@ module Glossarist
                                  to: :partitive_member_ids, uri_reference: true
         predicate :completeness, namespace: Namespaces::GlossaristNamespace,
                                  to: :completeness, uri_reference: true
-        members :has_plurality,
-                link: "gloss:hasPlurality"
         predicate :criterion, namespace: Namespaces::GlossaristNamespace,
                               to: :criterion
       end

data/lib/glossarist/rdf/v3.rb

@@ -31,7 +31,6 @@ module Glossarist
         GlossFormula
         GlossPartitiveRelation
         GlossPartitiveMember
-        GlossTypeSharedPlurality
       ].freeze
 
       VIEW_CLASS_NAMES.each do |name|

data/lib/glossarist/rdf.rb

@@ -44,8 +44,6 @@ module Glossarist
     autoload :GlossFormula,           "#{__dir__}/rdf/gloss_formula"
     autoload :GlossPartitiveRelation, "#{__dir__}/rdf/gloss_partitive_relation"
     autoload :GlossPartitiveMember,   "#{__dir__}/rdf/gloss_partitive_member"
-    autoload :GlossTypeSharedPlurality,
-             "#{__dir__}/rdf/gloss_type_shared_plurality"
     autoload :V3,                     "#{__dir__}/rdf/v3"
   end
 end

data/lib/glossarist/transforms/concept_to_gloss_transform.rb

@@ -157,22 +157,11 @@ module Glossarist
               partitive_member_uri(m)
             end,
             completeness: rel.completeness,
-            has_plurality: build_gloss_plurality(rel.plurality),
             criterion: rel.criterion,
           )
         end
       end
 
-      def build_gloss_plurality(plurality)
-        return nil unless plurality
-
-        Rdf::GlossTypeSharedPlurality.new(
-          is_shared: plurality.is_shared,
-          is_uncertain: plurality.is_uncertain,
-          shared_type_uri: partitive_concept_uri(plurality.shared_type),
-        )
-      end
-
       def partitive_concept_uri(ref)
         return nil unless ref.is_a?(Glossarist::ConceptRef)
 

data/lib/glossarist/v3/partitive_member.rb

@@ -3,36 +3,57 @@
 module Glossarist
   module V3
     # PartitiveMember — one member of a PartitiveRelation, carrying
-    # a ConceptRef to the partitive concept plus optional certainty
-    # metadata (Glossarist extension beyond ISO 704 notation).
+    # a ConceptRef to the partitive concept plus ISO 704:2022
+    # multiplicity and delimiting metadata.
     #
-    # A PartitiveMember with no certainty field is implicitly
-    # confirmed.
+    # ISO 704:2022 partitive member notation:
+    #
+    #   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)
+    #
+    #   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_CERTAINTY = "confirmed"
+      DEFAULT_MULTIPLICITY = "compulsory"
 
       attribute :ref, ConceptRef
-      attribute :certainty, :string,
-                values: Glossarist::GlossaryDefinition::MEMBER_CERTAINTY_VALUES,
-                default: -> { DEFAULT_CERTAINTY }
+      attribute :multiplicity, :string,
+                values: Glossarist::GlossaryDefinition::MULTIPLICITY_VALUES,
+                default: -> { DEFAULT_MULTIPLICITY }
+      attribute :is_delimiting, :boolean, default: -> { false }
 
       key_value do
         map :ref, to: :ref
-        map :certainty, to: :certainty
+        map :multiplicity, to: :multiplicity
+        map :is_delimiting, to: :is_delimiting
       end
 
       def validate!
         validate_ref!
-        validate_certainty!
+        validate_multiplicity!
         self
       end
 
-      def confirmed?
-        certainty == DEFAULT_CERTAINTY
+      def compulsory?
+        multiplicity == "compulsory"
+      end
+
+      def optional?
+        multiplicity == "optional"
       end
 
-      def possible?
-        certainty == "possible"
+      def delimiting?
+        is_delimiting == true
       end
 
       private
@@ -45,15 +66,15 @@ module Glossarist
               "(source, id, or text required)"
       end
 
-      def validate_certainty!
-        return if certainty.nil?
+      def validate_multiplicity!
+        return if multiplicity.nil?
 
-        unless Glossarist::GlossaryDefinition::MEMBER_CERTAINTY_VALUES
-                 .include?(certainty)
+        unless Glossarist::GlossaryDefinition::MULTIPLICITY_VALUES
+                 .include?(multiplicity)
           raise ArgumentError,
-                "PartitiveMember#certainty has invalid value " \
-                "#{certainty.inspect}; must be one of " \
-                "#{GlossaryDefinition::MEMBER_CERTAINTY_VALUES.join(', ')}"
+                "PartitiveMember#multiplicity has invalid value " \
+                "#{multiplicity.inspect}; must be one of " \
+                "#{GlossaryDefinition::MULTIPLICITY_VALUES.join(', ')}"
         end
       end
     end

data/lib/glossarist/v3/partitive_relation.rb

@@ -12,10 +12,13 @@ module Glossarist
     # within one relation are coordinate concepts: they share the
     # comprehensive AND share the criterion of subdivision.
     #
-    # Glossarist extensions beyond ISO notation:
-    #   - Per-partitive certainty (MemberCertainty)
-    #   - plurality.shared_type (the type the partitives share)
-    #   - criterion as a structured field (not just diagrammatic)
+    # Per-partitive metadata (ISO 704:2022):
+    #   - multiplicity (compulsory, optional, compulsory_multiple,
+    #     optional_multiple, compulsory_at_least_one) — encodes the diagram
+    #     line notation as data
+    #   - is_delimiting — orthogonal flag; a delimiting part behaves
+    #     like a delimiting characteristic (distinguishes the
+    #     comprehensive from coordinate concepts)
     #
     # Replaces the prior PartitiveHyperedge class. The "hyperedge"
     # framing was graph-theoretic; ISO calls this a *relation*.
@@ -27,14 +30,12 @@ module Glossarist
       attribute :completeness, :string,
                 values: Glossarist::GlossaryDefinition::COMPLETENESS_VALUES,
                 default: -> { DEFAULT_COMPLETENESS }
-      attribute :plurality, TypeSharedPlurality
       attribute :criterion, :hash
 
       key_value do
         map :comprehensive, to: :comprehensive
         map :partitives, to: :partitives
         map :completeness, to: :completeness
-        map :plurality, to: :plurality
         map :criterion, to: :criterion
       end
 
@@ -43,7 +44,6 @@ module Glossarist
         validate_partitives!
         validate_self_loop!
         validate_completeness!
-        validate_plurality!
         self
       end
 
@@ -110,10 +110,6 @@ module Glossarist
                 "#{GlossaryDefinition::COMPLETENESS_VALUES.join(', ')}"
         end
       end
-
-      def validate_plurality!
-        plurality&.validate!
-      end
     end
   end
 end

data/lib/glossarist/v3.rb

@@ -11,7 +11,6 @@ module Glossarist
     autoload :RelatedConcept, "glossarist/v3/related_concept"
     autoload :PartitiveRelation, "glossarist/v3/partitive_relation"
     autoload :PartitiveMember, "glossarist/v3/partitive_member"
-    autoload :TypeSharedPlurality, "glossarist/v3/type_shared_plurality"
     autoload :ConceptData, "glossarist/v3/concept_data"
     autoload :LocalizedConcept, "glossarist/v3/localized_concept"
     autoload :ManagedConceptData, "glossarist/v3/managed_concept_data"
@@ -28,7 +27,6 @@ module Glossarist
     Configuration.register_model(RelatedConcept, id: :related_concept)
     Configuration.register_model(PartitiveRelation, id: :partitive_relation)
     Configuration.register_model(PartitiveMember, id: :partitive_member)
-    Configuration.register_model(TypeSharedPlurality, id: :type_shared_plurality)
     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_relation_rule.rb

@@ -14,9 +14,8 @@ module Glossarist
       #     ISO 12620 coordinate-concept coherence)
       #   - warning when a relation has no criterion (cannot
       #     distinguish from siblings sharing the comprehensive)
-      #   - error when plurality.is_uncertain is set without
-      #     plurality.is_shared: true (broken-line qualifies
-      #     close-set double line)
+      #   - warning when multiplicity is not the default compulsory
+      #     (encourages explicit statement of optional/multiple)
       #   - error when ExternalConcept (status: external) lacks
       #     at least one designation
       #
@@ -47,7 +46,7 @@ module Glossarist
           relations.each_with_index do |rel, idx|
             check_cardinality(rel, idx, fname, issues)
             check_criterion_present(rel, idx, fname, issues)
-            check_plurality_coherence(rel, idx, fname, issues)
+            check_member_multiplicity(rel, idx, fname, issues)
           end
 
           check_duplicate_decomposition(relations, fname, issues)
@@ -86,18 +85,30 @@ module Glossarist
           )
         end
 
-        def check_plurality_coherence(rel, idx, fname, issues)
-          plural = rel.plurality
-          return unless plural
-          return unless plural.is_uncertain
-          return if plural.is_shared
+        def check_member_multiplicity(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?
 
-          issues << issue(
-            "partitive_relation #{idx + 1}.plurality: is_uncertain requires " \
-            "is_shared: true (ISO 704 broken line qualifies the close-set " \
-            "double line claim)",
-            location: fname,
-          )
+            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",
+              location: fname,
+            )
+          end
         end
 
         def check_duplicate_decomposition(relations, fname, issues)

data/lib/glossarist/version.rb

@@ -4,5 +4,5 @@
 #
 
 module Glossarist
-  VERSION = "2.13.0"
+  VERSION = "2.13.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glossarist
 version: !ruby/object:Gem::Version
-  version: 2.13.0
+  version: 2.13.2
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-23 00:00:00.000000000 Z
+date: 2026-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -315,7 +315,6 @@ files:
 - lib/glossarist/rdf/gloss_pronunciation.rb
 - lib/glossarist/rdf/gloss_reference.rb
 - lib/glossarist/rdf/gloss_table.rb
-- lib/glossarist/rdf/gloss_type_shared_plurality.rb
 - lib/glossarist/rdf/localized_literal.rb
 - lib/glossarist/rdf/lutaml_ext.rb
 - lib/glossarist/rdf/namespaces.rb
@@ -400,7 +399,6 @@ files:
 - lib/glossarist/v3/partitive_member.rb
 - lib/glossarist/v3/partitive_relation.rb
 - lib/glossarist/v3/related_concept.rb
-- lib/glossarist/v3/type_shared_plurality.rb
 - lib/glossarist/validation.rb
 - lib/glossarist/validation/asset_index.rb
 - lib/glossarist/validation/bibliography_index.rb

data/lib/glossarist/rdf/gloss_type_shared_plurality.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Glossarist
-  module Rdf
-    # RDF view for V3::TypeSharedPlurality. Emits a
-    # gloss:TypeSharedPlurality subject with is_shared, is_uncertain,
-    # shared_type properties.
-    class GlossTypeSharedPlurality < Lutaml::Model::Serializable
-      attribute :is_shared, :boolean
-      attribute :is_uncertain, :boolean
-      attribute :shared_type_uri, :string
-
-      rdf do
-        namespace Namespaces::GlossaristNamespace
-
-        subject { |p| "plurality/#{p.object_id}" }
-
-        types "gloss:TypeSharedPlurality"
-
-        predicate :isShared, namespace: Namespaces::GlossaristNamespace,
-                             to: :is_shared
-        predicate :isUncertain, namespace: Namespaces::GlossaristNamespace,
-                                to: :is_uncertain
-        predicate :sharedType, namespace: Namespaces::GlossaristNamespace,
-                               to: :shared_type_uri, uri_reference: true
-      end
-    end
-  end
-end

data/lib/glossarist/v3/type_shared_plurality.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Glossarist
-  module V3
-    # TypeSharedPlurality — semantic claims encoded by ISO 704's
-    # close-set double line and broken line notation, promoted from
-    # diagram-notation flags to structured data so tools can reason
-    # about plurality directly.
-    #
-    # A PartitiveRelation has at most one TypeSharedPlurality block.
-    # Absent means: no type-shared plurality claim is being made.
-    #
-    # Replaces the prior `markers` field (which encoded the same
-    # information as opaque strings like "double" and "dashed").
-    class TypeSharedPlurality < Lutaml::Model::Serializable
-      attribute :is_shared, :boolean
-      attribute :is_uncertain, :boolean, default: -> { false }
-      attribute :shared_type, ConceptRef
-
-      key_value do
-        map :is_shared, to: :is_shared
-        map :is_uncertain, to: :is_uncertain
-        map :shared_type, to: :shared_type
-      end
-
-      def validate!
-        unless is_shared.is_a?(TrueClass) || is_shared.is_a?(FalseClass)
-          raise ArgumentError,
-                "TypeSharedPlurality#is_shared is required (boolean)"
-        end
-
-        if is_uncertain == true && is_shared == false
-          raise ArgumentError,
-                "TypeSharedPlurality#is_uncertain requires is_shared: true " \
-                "(ISO 704 broken line qualifies the close-set double line claim)"
-        end
-
-        self
-      end
-    end
-  end
-end