glossarist 0.4.32 → 0.4.33

package/src/rdf/gloss-hyperedge.js

@@ -1,90 +0,0 @@
-// PartitiveHyperedge → RDF quads.
-//
-// Shape (per concept-model ontology, v3.1.0):
-//   <base>/hyperedge/<carrying-id>/<comprehensive-id>
-//     rdf:type                    gloss:PartitiveHyperedge
-//     gloss:comprehensive         <base>/concept/<comprehensive-id>
-//     gloss:hasPart               <base>/concept/<part-id>        (one per part)
-//     gloss:enumeration           "closed"|"open"                 (literal)
-//     gloss:hasPluralityMarker    "double"|"dashed"               (literal, one per marker)
-//     gloss:hyperedgeContent      "..."                           (literal, omitted if absent)
-//
-// The carrying concept links to this hyperedge via `gloss:hasPartitiveHyperedge`
-// (emitted by gloss-concept.js#conceptToQuads).
-//
-// CROSS-REPO STATUS (validated 2026-07-22):
-//   - Subject URI scheme: matches Ruby (`hyperedge/<c>/<comp>`).
-//   - `comprehensive`, `enumeration`, `hasPluralityMarker`, `hyperedgeContent`:
-//     predicates + object types match Ruby.
-//   - `hasPart`: JS follows the concept-model ontology; Ruby emits
-//     `gloss:part` instead. This is a Ruby bug — tracked as a cross-repo
-//     follow-up. Once Ruby aligns with the ontology, output will be
-//     byte-equivalent (modulo serialization order).
-
-import { PRED } from './predicates.js';
-import { WELL_KNOWN } from './prefixes.js';
-import { namedNode, literal, quad } from './terms.js';
-
-export function* hyperedgeToQuads(hyperedge, { parentUri, index }) {
-  const heSubject = hyperedgeSubjectUri(parentUri, hyperedge, index);
-  const s = namedNode(heSubject);
-
-  yield quad(s, namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.PartitiveHyperedge));
-
-  const comp = hyperedge.comprehensive;
-  if (comp && (comp.source || comp.id)) {
-    yield quad(s, namedNode(PRED.gloss.comprehensive),
-      namedNode(conceptRefUri(comp, parentUri)));
-  }
-
-  const parts = Array.isArray(hyperedge.parts) ? hyperedge.parts : [];
-  for (const p of parts) {
-    if (p && (p.source || p.id)) {
-      yield quad(s, namedNode(PRED.gloss.hasPart),
-        namedNode(conceptRefUri(p, parentUri)));
-    }
-  }
-
-  if (hyperedge.enumeration) {
-    yield quad(s, namedNode(PRED.gloss.enumeration), literal(hyperedge.enumeration));
-  }
-
-  for (const marker of Array.isArray(hyperedge.markers) ? hyperedge.markers : []) {
-    yield quad(s, namedNode(PRED.gloss.hasPluralityMarker), literal(marker));
-  }
-
-  if (hyperedge.content) {
-    const content = hyperedge.content;
-    if (typeof content === 'string') {
-      yield quad(s, namedNode(PRED.gloss.hyperedgeContent), literal(content));
-    } else if (typeof content === 'object') {
-      for (const [lang, text] of Object.entries(content)) {
-        if (typeof text !== 'string') continue;
-        yield quad(s, namedNode(PRED.gloss.hyperedgeContent), literal(text, lang));
-      }
-    }
-  }
-}
-
-// Subject URI scheme: `<base>/hyperedge/<carrying-id>/<comprehensive-id>`.
-// Matches Ruby's `subject { |h| "hyperedge/#{h.identifier}/#{h.comprehensive_id}" }`.
-// Falls back to an index suffix if comprehensive has no id, so two
-// hyperedges on the same concept never collide.
-export function hyperedgeSubjectUri(parentUri, hyperedge, index) {
-  const base = parentUri.replace(/\/concept\/[^/]+$/, '');
-  const carrierId = parentUri.split('/concept/')[1] ?? `carrier-${index}`;
-  const compId = hyperedge?.comprehensive?.id ?? `comp-${index}`;
-  return `${base}/hyperedge/${carrierId}/${compId}`;
-}
-
-// ConceptRef URI: `<base>/concept/<id>`. Matches Ruby's
-// `concept_to_gloss_transform.rb#hyperedge_concept_uri`. Source is
-// dropped from the URI; it stays on the ConceptRef object if needed.
-function conceptRefUri(ref, parentUri) {
-  const id = ref?.id;
-  if (id) {
-    const base = parentUri.split('/concept/')[0];
-    return `${base}/concept/${id}`;
-  }
-  return `urn:glossarist:${ref?.source ?? 'unknown'}:`;
-}

package/src/validators/partitive-drift-rule.js

@@ -1,51 +0,0 @@
-// Warns when a concept expresses the same partitive relationship via
-// BOTH a binary edge (broader_partitive / narrower_partitive /
-// has_part / is_part_of) AND a PartitiveHyperedge part targeting the
-// same concept. Round 1's decision (TODO.hyperedges/24) was "binary
-// and hyperedge coexist, no automatic reconciliation." This rule is
-// the detector for the resulting drift: pure warning, doesn't block
-// save, just surfaces the duplication so the author can pick one
-// encoding.
-//
-// See TODO.hyperedges-v2/21 for the design rationale.
-
-import { ValidationRule } from './validation-rule.js';
-
-const BINARY_PARTITIVE_TYPES = new Set([
-  'broader_partitive', 'narrower_partitive',
-  'has_part', 'is_part_of',
-]);
-
-export class PartitiveDriftRule extends ValidationRule {
-  constructor() { super('partitive-drift', 'warning'); }
-
-  validate(concept, path, result) {
-    const hyperedgeTargets = new Set();
-    for (const he of concept.partitiveHyperedges ?? []) {
-      const comp = he.comprehensive;
-      const compKey = `${comp?.source ?? ''}|${comp?.id ?? ''}`;
-      for (const part of he.parts ?? []) {
-        const key = `${part.source ?? ''}|${part.id ?? ''}`;
-        if (key === '|' || key === compKey) continue;
-        hyperedgeTargets.add(key);
-      }
-    }
-
-    if (hyperedgeTargets.size === 0) return;
-
-    const related = concept.relatedConcepts ?? [];
-    for (let i = 0; i < related.length; i++) {
-      const rc = related[i];
-      if (!BINARY_PARTITIVE_TYPES.has(rc.type)) continue;
-      const ref = rc.ref;
-      const key = `${ref?.source ?? ''}|${ref?.id ?? ''}`;
-      if (hyperedgeTargets.has(key)) {
-        this.addIssue(result,
-          `${path}relatedConcepts[${i}]`,
-          `concept has both a binary '${rc.type}' edge and a ` +
-          `PartitiveHyperedge part targeting (${ref?.source ?? '?'}, ` +
-          `${ref?.id ?? '?'}); pick one encoding to avoid divergence`);
-      }
-    }
-  }
-}

package/src/validators/partitive-hyperedge-rule.js

@@ -1,75 +0,0 @@
-import { ValidationRule } from './validation-rule.js';
-
-// Validates semantic invariants of PartitiveHyperedge entries that
-// the model constructor does NOT enforce. The constructor already
-// rejects empty comprehensive, empty parts, self-loops, invalid
-// marker values, and duplicate markers. This rule provides a
-// defensive walk at validation time plus a warning for the
-// implicit-enumeration case (absent in the source YAML, filled by
-// the model's DEFAULT_ENUMERATION constant).
-export class PartitiveHyperedgeShapeRule extends ValidationRule {
-  constructor() { super('partitive-hyperedge-shape'); }
-
-  validate(concept, path, result) {
-    const edges = concept.partitiveHyperedges ?? [];
-    for (let i = 0; i < edges.length; i++) {
-      const he = edges[i];
-      const base = `${path}partitiveHyperedges[${i}]`;
-
-      this._checkComprehensive(he, i, base, result);
-      this._checkParts(he, i, base, result);
-      this._checkMarkers(he, i, base, result);
-      this._checkSelfLoop(he, i, base, result);
-    }
-  }
-
-  _checkComprehensive(he, idx, base, result) {
-    const ref = he.comprehensive;
-    if (!ref || (!ref.source && !ref.id)) {
-      this.addIssue(result, `${base}.comprehensive`,
-        `partitive_hyperedge ${idx + 1} has empty comprehensive`);
-    }
-  }
-
-  _checkParts(he, idx, base, result) {
-    const parts = he.parts ?? [];
-    if (parts.length === 0) {
-      this.addIssue(result, `${base}.parts`,
-        `partitive_hyperedge ${idx + 1} has no parts`);
-      return;
-    }
-    for (let j = 0; j < parts.length; j++) {
-      const p = parts[j];
-      if (!p || (!p.source && !p.id)) {
-        this.addIssue(result, `${base}.parts[${j}]`,
-          `partitive_hyperedge ${idx + 1} part ${j + 1} has empty ref`);
-      }
-    }
-  }
-
-  _checkMarkers(he, idx, base, result) {
-    const markers = he.markers ?? [];
-    const seen = new Set();
-    for (const m of markers) {
-      if (seen.has(m)) {
-        this.addIssue(result, `${base}.markers`,
-          `partitive_hyperedge ${idx + 1} has duplicate marker '${m}'`);
-      }
-      seen.add(m);
-    }
-  }
-
-  _checkSelfLoop(he, idx, base, result) {
-    const c = he.comprehensive;
-    if (!c) return;
-    const cKey = `${c.source ?? ''}:${c.id ?? ''}`;
-    for (let j = 0; j < (he.parts ?? []).length; j++) {
-      const p = he.parts[j];
-      const pKey = `${p?.source ?? ''}:${p?.id ?? ''}`;
-      if (pKey === cKey) {
-        this.addIssue(result, `${base}.parts[${j}]`,
-          `partitive_hyperedge ${idx + 1} part ${j + 1} cannot be the comprehensive`);
-      }
-    }
-  }
-}