arch-unit-ts/dist/arch-unit/lang/conditions/ArchConditions.js

arch-unit-ts

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ArchConditions = void 0;
const TypeScriptClass_1 = require("../../core/domain/TypeScriptClass");
const ArchCondition_1 = require("../ArchCondition");
const SimpleConditionEvent_1 = require("../SimpleConditionEvent");
const ArchPredicates_1 = require("./ArchPredicates");
const InvertingConditionEvents_1 = require("./InvertingConditionEvents");
const ViolatedAndSatisfiedConditionEvents_1 = require("./ViolatedAndSatisfiedConditionEvents");
class ArchConditions {
    static onlyDependOnClassesThat = (predicate) => {
        return new AllDependenciesCondition('only depend on classes that ' + predicate.description, TypeScriptClass_1.Functions.GET_TARGET_CLASS.is(predicate), TypeScriptClass_1.TypeScriptClass.GET_DIRECT_DEPENDENCIES_FROM_SELF);
    };
    static dependOnClassesThat = (predicate) => {
        return new AnyDependencyCondition('depend on classes that ' + predicate.description, TypeScriptClass_1.Functions.GET_TARGET_CLASS.is(predicate), TypeScriptClass_1.TypeScriptClass.GET_DIRECT_DEPENDENCIES_FROM_SELF);
    };
    static onlyHaveDependentClassesThat = (predicate) => {
        return this.onlyHaveDependentsWhere(TypeScriptClass_1.Functions.GET_ORIGIN_CLASS.is(predicate)).as('only have dependent classes that ' + predicate.description);
    };
    static onlyHaveDependentsWhere(predicate) {
        const description = 'only have dependents where ' + predicate.description;
        return new AllDependenciesCondition(description, predicate, TypeScriptClass_1.TypeScriptClass.GET_DIRECT_DEPENDENCIES_TO_SELF);
    }
    static negate(condition) {
        return new NeverCondition(condition);
    }
    static haveSimpleNameStartingWith(prefix) {
        return this.have(TypeScriptClass_1.TypeScriptClass.simpleNameStartingWith(prefix));
    }
    static haveSimpleNameEndingWith(suffix) {
        return this.have(TypeScriptClass_1.TypeScriptClass.simpleNameEndingWith(suffix));
    }
    static have(predicate) {
        return ArchCondition_1.ArchCondition.from(predicate).as(ArchPredicates_1.ArchPredicates.have(predicate).description);
    }
}
exports.ArchConditions = ArchConditions;
class ContainAnyCondition extends ArchCondition_1.ArchCondition {
    condition;
    constructor(condition) {
        super('contain any element that ' + condition.description);
        this.condition = condition;
    }
    check(collection, events) {
        const subEvents = new ViolatedAndSatisfiedConditionEvents_1.ViolatedAndSatisfiedConditionEvents();
        collection.forEach(item => this.condition.check(item, subEvents));
        if (subEvents.getAllowed().length > 0 || subEvents.getViolating().length > 0) {
            events.add(AnyConditionEvent.default(collection, subEvents));
        }
    }
}
class AnyConditionEvent {
    correspondingObjects;
    allowed;
    violating;
    static default(correspondingObjects, events) {
        return new AnyConditionEvent(correspondingObjects, events.getAllowed(), events.getViolating());
    }
    constructor(correspondingObjects, allowed, violating) {
        this.correspondingObjects = correspondingObjects;
        this.allowed = allowed;
        this.violating = violating;
    }
    isViolation() {
        return this.allowed.length === 0;
    }
    invert() {
        return new OnlyConditionEvent(this.correspondingObjects, this.violating, this.allowed);
    }
    getDescriptionLines() {
        return [this.violating.flatMap(input => input.getDescriptionLines()).join('\n')];
    }
}
class ContainsOnlyCondition extends ArchCondition_1.ArchCondition {
    condition;
    constructor(condition) {
        super('contain only elements that ' + condition.description);
        this.condition = condition;
    }
    check(collection, events) {
        const subEvents = new ViolatedAndSatisfiedConditionEvents_1.ViolatedAndSatisfiedConditionEvents();
        collection.forEach(item => this.condition.check(item, subEvents));
        if (subEvents.getAllowed().length > 0 || subEvents.getViolating().length > 0) {
            events.add(OnlyConditionEvent.default(collection, subEvents));
        }
    }
}
class OnlyConditionEvent {
    correspondingObjects;
    allowed;
    violating;
    constructor(correspondingObjects, allowed, violating) {
        this.correspondingObjects = correspondingObjects;
        this.allowed = allowed;
        this.violating = violating;
    }
    static default(correspondingObjects, events) {
        return new OnlyConditionEvent(correspondingObjects, events.getAllowed(), events.getViolating());
    }
    isViolation() {
        return this.violating.length > 0;
    }
    invert() {
        return new AnyConditionEvent(this.correspondingObjects, this.violating, this.allowed);
    }
    getDescriptionLines() {
        return this.violating.flatMap(conditionEvent => conditionEvent.getDescriptionLines());
    }
}
class DependencyCondition extends ArchCondition_1.ArchCondition {
    conditionPredicate;
    constructor(conditionPredicate) {
        super(conditionPredicate.description);
        this.conditionPredicate = conditionPredicate;
    }
    check(item, events) {
        events.add(new SimpleConditionEvent_1.SimpleConditionEvent(`Dependency ${item.getDescription()}`, !this.conditionPredicate.test(item)));
    }
}
class AllDependenciesCondition extends ArchCondition_1.ArchCondition {
    condition;
    conditionPredicate;
    typeScriptClassToRelevantDependencies;
    constructor(description, conditionPredicate, typeScriptClassToRelevantDependencies) {
        super(description);
        this.condition = new DependencyCondition(conditionPredicate);
        this.conditionPredicate = conditionPredicate;
        this.typeScriptClassToRelevantDependencies = typeScriptClassToRelevantDependencies;
    }
    check(typeScriptClass, events) {
        new ContainsOnlyCondition(this.condition).check(this.typeScriptClassToRelevantDependencies.apply(typeScriptClass), events);
    }
}
class AnyDependencyCondition extends ArchCondition_1.ArchCondition {
    condition;
    conditionPredicate;
    typeScriptClassToRelevantDependencies;
    constructor(description, conditionPredicate, typeScriptClassToRelevantDependencies) {
        super(description);
        this.condition = new DependencyCondition(conditionPredicate);
        this.conditionPredicate = conditionPredicate;
        this.typeScriptClassToRelevantDependencies = typeScriptClassToRelevantDependencies;
    }
    check(typeScriptClass, events) {
        new ContainAnyCondition(this.condition).check(this.typeScriptClassToRelevantDependencies.apply(typeScriptClass), events);
    }
}
class NeverCondition extends ArchCondition_1.ArchCondition {
    condition;
    constructor(condition) {
        super('never ' + condition.description);
        this.condition = condition;
    }
    check(item, events) {
        this.condition.check(item, new InvertingConditionEvents_1.InvertingConditionEvents(events));
    }
}
//# sourceMappingURL=ArchConditions.js.map