@oml/language 0.18.1 → 0.19.1

package/src/oml/oml-validator.ts

@@ -11,7 +11,40 @@ import {
     getMemberName,
     getNamedElementName,
 } from './oml-utils.js';
-import type { EntityEquivalenceAxiom, ForwardRelation, Import, Member, OmlAstType, Ontology, PropertyEquivalenceAxiom, QuotedLiteral, RelationEntity, RelationInstance, ReverseRelation, Rule, Scalar, ScalarEquivalenceAxiom, TypeAssertion } from './generated/ast.js';
+import type { EntityEquivalenceAxiom, ForwardRelation, Import, Member, OmlAstType, Ontology, PropertyEquivalenceAxiom, PropertyRangeRestrictionAxiom, PropertyValueAssertion, Quantity, QuantityProperty, QuotedLiteral, RelationEntity, RelationInstance, ReverseRelation, Rule, Scalar, ScalarEquivalenceAxiom, TypeAssertion, Unit } from './generated/ast.js';
+
+type DimensionVector = { L: number; M: number; T: number; I: number; H: number; N: number; J: number };
+
+function emptyDimension(): DimensionVector {
+    return { L: 0, M: 0, T: 0, I: 0, H: 0, N: 0, J: 0 };
+}
+
+function parseDimension(input: string): { vector?: DimensionVector; error?: string } {
+    const trimmed = (input ?? '').trim();
+    if (!trimmed) {
+        return { vector: emptyDimension() };
+    }
+    const tokens = trimmed.split(/\s+/);
+    const result = emptyDimension();
+    const seen = new Set<string>();
+    for (const tok of tokens) {
+        const m = /^([LMTIHNJ])(-?\d+)$/.exec(tok);
+        if (!m) {
+            return { error: `Invalid dimension token '${tok}'. Expected axis (L|M|T|I|H|N|J) followed by a signed integer.` };
+        }
+        const axis = m[1];
+        if (seen.has(axis)) {
+            return { error: `Dimension axis '${axis}' appears more than once.` };
+        }
+        seen.add(axis);
+        (result as any)[axis] = parseInt(m[2], 10);
+    }
+    return { vector: result };
+}
+
+function dimensionsEqual(a: DimensionVector, b: DimensionVector): boolean {
+    return a.L === b.L && a.M === b.M && a.T === b.T && a.I === b.I && a.H === b.H && a.N === b.N && a.J === b.J;
+}
 
 interface OntologyValidationContext {
     version: number;
@@ -60,7 +93,7 @@ export function registerValidationChecks(services: OmlServices) {
         InstanceEnumerationAxiom: [],
         LiteralEnumerationAxiom: [],
         PropertyRestrictionAxiom: [],
-        PropertyRangeRestrictionAxiom: [],
+        PropertyRangeRestrictionAxiom: [validator.checkInvalidQuantityPropertyRangeRestriction],
         PropertyCardinalityRestrictionAxiom: [],
         PropertyValueRestrictionAxiom: [],
         PropertySelfRestrictionAxiom: [],
@@ -75,7 +108,7 @@ export function registerValidationChecks(services: OmlServices) {
         // Assertion types
         Assertion: [],
         TypeAssertion: [validator.checkInvalidInstanceType],
-        PropertyValueAssertion: [],
+        PropertyValueAssertion: [validator.checkInvalidPropertyValueAssertion],
         // Literal types
         Literal: [],
         IntegerLiteral: [],
@@ -122,6 +155,10 @@ export function registerValidationChecks(services: OmlServices) {
         Aspect: [],
         Concept: [],
         RelationEntity: [validator.checkInvalidRelationEntity],
+        // Quantity types
+        Quantity: [validator.checkQuantityDimensionFormat],
+        Unit: [validator.checkUnitKindsDimensionalConsistency, validator.checkUnitSymbolUniqueness],
+        QuantityProperty: [validator.checkQuantityPropertyCardinality],
     };
     registry.register(checks, validator);
 }
@@ -200,7 +237,7 @@ export class OmlValidator {
 
         const context = this.getOntologyValidationContext(ontology);
         if (!context?.usedPrefixes.has(prefix)) {
-            accept('warning', `Could not find a reference to prefix '${ownedImport.prefix}'`, {
+            accept('warning', `Prefix '${ownedImport.prefix}' is declared but not used`, {
                 node: ownedImport
             });
         }
@@ -533,7 +570,182 @@ export class OmlValidator {
         }
     }
 
-    private getPropertyKind(property: any): 'annotation property' | 'scalar property' | 'relation' | undefined {
+    checkInvalidPropertyValueAssertion(assertion: PropertyValueAssertion, accept: ValidationAcceptor): void {
+        const property = assertion.property?.ref as any;
+        if (!property) {
+            return;
+        }
+
+        const propertyKind = this.getPropertyKind(property);
+        const literals = assertion.literalValues ?? [];
+
+        if (propertyKind === 'scalar property') {
+            const hasObjectValues = (assertion.referencedValues?.length ?? 0) > 0
+                || (assertion.containedValues?.length ?? 0) > 0;
+            if (hasObjectValues) {
+                accept('error', `Scalar property ${this.getAbbreviatedIri(property)} cannot have instance values`, {
+                    node: assertion,
+                    property: (assertion.referencedValues?.length ?? 0) > 0 ? 'referencedValues' : 'containedValues'
+                });
+            }
+            for (let i = 0; i < literals.length; i++) {
+                if (this.literalUnit(literals[i])) {
+                    accept('error', `Unit suffix is only allowed on quantity property values`, {
+                        node: assertion,
+                        property: 'literalValues',
+                        index: i
+                    });
+                }
+            }
+            return;
+        }
+
+        if (propertyKind === 'relation') {
+            if (literals.length > 0) {
+                accept('error', `Relation ${this.getAbbreviatedIri(property)} cannot have literal values`, {
+                    node: assertion,
+                    property: 'literalValues'
+                });
+            }
+            return;
+        }
+
+        if (propertyKind === 'quantity property') {
+            const hasObjectValues = (assertion.referencedValues?.length ?? 0) > 0
+                || (assertion.containedValues?.length ?? 0) > 0;
+            if (hasObjectValues) {
+                accept('error', `Quantity property ${this.getAbbreviatedIri(property)} cannot have instance values`, {
+                    node: assertion,
+                    property: (assertion.referencedValues?.length ?? 0) > 0 ? 'referencedValues' : 'containedValues'
+                });
+            }
+            const propKinds = new Set<any>((((property as any).kind ?? []) as any[])
+                .map((r: any) => r?.ref)
+                .filter(Boolean));
+            for (let i = 0; i < literals.length; i++) {
+                const lit: any = literals[i];
+                if (!this.isNumericLiteral(lit)) {
+                    accept('error', `Quantity property ${this.getAbbreviatedIri(property)} requires a numeric literal`, {
+                        node: assertion,
+                        property: 'literalValues',
+                        index: i
+                    });
+                    continue;
+                }
+                const unit = lit?.unit?.ref;
+                if (!unit) {
+                    if (lit?.unit?.$refText) {
+                        // Reference present but unresolved; let the linker handle it.
+                        continue;
+                    }
+                    accept('error', `Quantity property ${this.getAbbreviatedIri(property)} requires a unit suffix (e.g., '5^^unit:Metre')`, {
+                        node: assertion,
+                        property: 'literalValues',
+                        index: i
+                    });
+                    continue;
+                }
+                if (propKinds.size === 0) continue;
+                const unitKinds: any[] = ((unit.kinds ?? []) as any[])
+                    .map((r: any) => r?.ref)
+                    .filter(Boolean);
+                if (unitKinds.length === 0) continue;
+                const overlap = unitKinds.some((k: any) => propKinds.has(k));
+                if (!overlap) {
+                    accept('error', `Unit ${this.getAbbreviatedIri(unit)} is not applicable to any quantity kind of property ${this.getAbbreviatedIri(property)}`, {
+                        node: assertion,
+                        property: 'literalValues',
+                        index: i
+                    });
+                }
+            }
+        }
+    }
+
+    checkQuantityDimensionFormat(quantity: Quantity, accept: ValidationAcceptor): void {
+        const dim = quantity.dimension;
+        if (!dim) return;
+        const parsed = parseDimension(dim);
+        if (parsed.error) {
+            accept('error', parsed.error, {
+                node: quantity,
+                property: 'dimension'
+            });
+        }
+    }
+
+    checkUnitKindsDimensionalConsistency(unit: Unit, accept: ValidationAcceptor): void {
+        const kindRefs = ((unit.kinds ?? []) as any[]);
+        const kinds = kindRefs.map((r: any) => r?.ref).filter(Boolean) as any[];
+        if (kinds.length <= 1) return;
+        const vectors: DimensionVector[] = [];
+        for (const k of kinds) {
+            const dim = typeof k?.dimension === 'string' ? k.dimension : '';
+            if (!dim) continue;
+            const parsed = parseDimension(dim);
+            if (parsed.vector) vectors.push(parsed.vector);
+        }
+        if (vectors.length <= 1) return;
+        const ref = vectors[0];
+        for (let i = 1; i < vectors.length; i++) {
+            if (!dimensionsEqual(ref, vectors[i])) {
+                accept('error', `Unit ${this.getAbbreviatedIri(unit)} declares quantity kinds with inconsistent dimensions`, {
+                    node: unit,
+                    property: 'kinds'
+                });
+                return;
+            }
+        }
+    }
+
+    checkUnitSymbolUniqueness(unit: Unit, accept: ValidationAcceptor): void {
+        const ontology: any = findOwningOntologyNode(unit);
+        if (!ontology || ontology.$type !== 'Vocabulary') return;
+        const symbols = ((unit as any).symbol ?? []) as string[];
+        if (symbols.length === 0) return;
+        if (symbols.length > 1) {
+            accept('error', `Unit ${this.getAbbreviatedIri(unit)} declares more than one symbol; only one is allowed`, {
+                node: unit,
+                property: 'symbol' as any,
+                index: 1
+            });
+        }
+        const statements: any[] = ontology.ownedStatements ?? [];
+        const otherUnits = statements.filter((s: any) => s && s !== unit && s.$type === 'Unit');
+        for (let i = 0; i < symbols.length; i++) {
+            const sym = symbols[i];
+            const conflict = otherUnits.find((u: any) => ((u.symbol ?? []) as string[]).includes(sym));
+            if (conflict) {
+                accept('error', `Unit symbol "${sym}" is already used by unit ${this.getAbbreviatedIri(conflict)}`, {
+                    node: unit,
+                    property: 'symbol' as any,
+                    index: i
+                });
+            }
+        }
+    }
+
+    checkQuantityPropertyCardinality(prop: QuantityProperty, accept: ValidationAcceptor): void {
+        const kinds = (((prop as any).kind ?? []) as any[]);
+        if (kinds.length > 1) {
+            accept('error', `Quantity property ${this.getAbbreviatedIri(prop)} declares more than one quantity; only one is allowed`, {
+                node: prop,
+                property: 'kind' as any,
+                index: 1
+            });
+        }
+    }
+
+    checkInvalidQuantityPropertyRangeRestriction(axiom: PropertyRangeRestrictionAxiom, accept: ValidationAcceptor): void {
+        const prop = axiom.property?.ref as any;
+        if (prop?.$type === 'QuantityProperty') {
+            accept('warning', `Range restriction on quantity property ${this.getAbbreviatedIri(prop)} is not meaningful; use a value restriction instead.`, {
+                node: axiom
+            });
+        }
+    }
+
+    private getPropertyKind(property: any): 'annotation property' | 'scalar property' | 'relation' | 'quantity property' | undefined {
         const type = property?.$type;
         if (type === 'AnnotationProperty') {
             return 'annotation property';
@@ -544,9 +756,24 @@ export class OmlValidator {
         if (type === 'UnreifiedRelation' || type === 'ForwardRelation' || type === 'ReverseRelation') {
             return 'relation';
         }
+        if (type === 'QuantityProperty') {
+            return 'quantity property';
+        }
         return undefined;
     }
 
+    private isNumericLiteral(node: any): boolean {
+        const t = node?.$type;
+        return t === 'IntegerLiteral' || t === 'DecimalLiteral' || t === 'DoubleLiteral';
+    }
+
+    private literalUnit(node: any): any {
+        if (!this.isNumericLiteral(node)) return undefined;
+        const ref = node?.unit;
+        if (!ref) return undefined;
+        return ref?.ref ?? (ref?.$refText ? ref : undefined);
+    }
+
     private isStandardScalar(scalar: any): boolean {
         const ontology = findOwningOntologyNode(scalar);
         const namespace = typeof ontology?.namespace === 'string' ? ontology.namespace : '';

package/src/oml/oml.langium

@@ -148,7 +148,9 @@ DescriptionMember:
 VocabularyStatement:
 	Rule |
 	BuiltIn |
-	SpecializableTerm;
+	SpecializableTerm |
+	Quantity |
+	Unit;
 
 DescriptionStatement:
 	NamedInstance;
@@ -160,7 +162,9 @@ DescriptionStatement:
 Term:
 	SpecializableTerm |
 	RelationBase |
-	Property;
+	Property |
+	Quantity |
+	Unit;
 
 Rule:
 	ownedAnnotations+=Annotation*
@@ -200,7 +204,8 @@ RelationBase:
 SpecializableProperty:
 	AnnotationProperty |
     ScalarProperty |
-    UnreifiedRelation;
+    UnreifiedRelation |
+    QuantityProperty;
 
 ////////////////////////////////////////
 //  Types
@@ -283,7 +288,8 @@ AnnotationProperty:
 
 SemanticProperty:
 	ScalarProperty |
-	Relation;
+	Relation |
+	QuantityProperty;
 
 fragment PropertySpecialization:
 	'<' ownedSpecializations+=SpecializationAxiom (',' ownedSpecializations+=SpecializationAxiom)*;
@@ -335,6 +341,32 @@ UnreifiedRelation:
         (transitive?='transitive'))
 	']')? (PropertySpecialization)? (PropertyEquivalence)?;
 
+////////////////////////////////////////
+//  Quantities and Units
+////////////////////////////////////////
+
+Quantity:
+	ownedAnnotations+=Annotation*
+	('quantity' name=ID | 'ref' 'quantity' ref=[Quantity:Ref]) ('['
+		('dimension' dimension=STRING)?
+	']')?;
+
+Unit:
+	ownedAnnotations+=Annotation*
+	('unit' name=ID | 'ref' 'unit' ref=[Unit:Ref]) ('['
+		(('measures' kinds+=[Quantity:Ref] (',' kinds+=[Quantity:Ref])*) |
+		 ('symbol' symbol+=STRING) |
+		 ('multiplier' multiplier+=Decimal))*
+	']')?;
+
+QuantityProperty:
+	ownedAnnotations+=Annotation*
+	('quantity' 'property' name=ID | 'ref' 'quantity' 'property' ref=[QuantityProperty:Ref]) ('['
+		(('domain' domains+=[Entity:Ref] (',' domains+=[Entity:Ref])*) |
+		 ('quantity' kind+=[Quantity:Ref]))*
+		(functional?='functional')?
+	']')? (PropertySpecialization)? (PropertyEquivalence)?;
+
 ////////////////////////////////////////
 //  Description Members and Instances
 ////////////////////////////////////////
@@ -501,13 +533,13 @@ DifferentFromPredicate:
 ////////////////////////////////////////
 
 IntegerLiteral:
-	value=Integer;
+	value=Integer ('^^' unit=[Unit:Ref])?;
 
 DecimalLiteral:
-	value=Decimal;
+	value=Decimal ('^^' unit=[Unit:Ref])?;
 
 DoubleLiteral:
-	value=Double;
+	value=Double ('^^' unit=[Unit:Ref])?;
 
 BooleanLiteral:
 	value=Boolean;