10248251351

Committed 05 Aug 2024 11:51AM UTC coverage: 98.426% (+0.03%) from 98.396%

Build # 10248251351

Build Type

Pull #888

github

Committed by

web-flow

Commit Message

Merge 8a1ab6308 into e6e0771f1

Pull Request Pull Request #888: feat(decorator): added new methods to extract vocab or non-vocab decorators from model

Run Details

2212 of 2280 branches covered (97.02%)

Branch coverage included in aggregate %.

53 of 57 new or added lines in 3 files covered. (92.98%)

5 existing lines in 1 file now uncovered.

4105 of 4138 relevant lines covered (99.2%)

66186.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.31

/packages/concerto-vocabulary/lib/vocabulary.js

/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

'use strict';

// Types needed for TypeScript generation.
/* eslint-disable no-unused-vars */
/* istanbul ignore next */
if (global === undefined) {
    const VocabularyManager = require('./vocabularymanager');
    const { ModelFile } = require('@accordproject/concerto-core');
}
/* eslint-enable no-unused-vars */

/**
* A vocabulary for a concerto model
* @class
* @memberof module:concerto-vocabulary
*/
class Vocabulary {
    /**
     * Create the Vocabulary
     * @constructor
     * @param {VocabularyManager} vocabularyManager - the manager for this vocabulary
     * @param {object} voc - the JSON representation of the vocabulary
     */
    constructor(vocabularyManager, voc) {
        if(!vocabularyManager) {
            throw new Error('VocabularyManager must be specified');
        }
        if(!voc) {
            throw new Error('Vocabulary object must be specified');
        }

        if(!voc.declarations) {
            throw new Error('Vocabulary object must have declarations');
        }

        if(!voc.namespace) {
            throw new Error('A vocabulary must specify a namespace');
        }

        if(!voc.locale) {
            throw new Error('A vocabulary must specify a locale');
        }

        Vocabulary.validateLocale(voc.locale);

        this.vocabularyManager = vocabularyManager;
        this.content = voc;
    }

    /**
     * Returns the namespace for the vocabulary
     * @returns {string} the namespace for this vocabulary
     */
    getNamespace() {
        return this.content.namespace;
    }

    /**
     * Validates a locale
     * @param {string} locale the locale to validate
     * @throws {Error} if the locale is invalid
     */
    static validateLocale(locale) {
        new Intl.Locale(locale);
        if(locale !== locale.toLowerCase()) {
            throw new Error('Locale should be lowercase with dashes');
        }
    }

    /**
     * Returns the locale for the vocabulary
     * @returns {string} the locale for this vocabulary
     */
    getLocale() {
        return this.content.locale;
    }

    /**
     * Returns the identifier for the vocabulary, composed of the namespace plus the locale
     * @returns {string} the identifier for this vocabulary
     */
    getIdentifier() {
        return `${this.getNamespace()}/${this.content.locale}`;
    }

    /**
     * Returns all the declarations for this vocabulary
     * @returns {Array} an array of objects
     */
    getTerms() {
        return this.content.declarations;
    }

    /**
     * Gets the term for a concept, enum or property
     * @param {string} declarationName the name of a concept or enum
     * @param {string} [propertyName] the name of a property (optional)
     * @param {string} [identifier] the identifier of the term (optional)
     * @returns {string} the term or null if it does not exist
     */
    getTerm(declarationName, propertyName, identifier) {
        const decl = this.content.declarations.find(d => Object.keys(d)[0] === declarationName);
        if(!decl) {
            return null;
        }
        if(!propertyName) {
            return identifier ? decl[identifier] : decl[declarationName];
        }
        else {
            const property = decl.properties ? decl.properties.find(d => d[propertyName]) : null;
            return property ? identifier ? property[identifier] : property[propertyName] : null;
        }
    }

    /**
     * Gets the terms for a concept, enum or property
     * @param {string} declarationName the name of a concept or enum
     * @param {string} [propertyName] the name of a property (optional)
     * @returns {string} the term or null if it does not exist
     */
    getElementTerms(declarationName, propertyName) {
        const decl = this.content.declarations.find(d => Object.keys(d)[0] === declarationName);
        if(!decl) {
            return null;
        }
        if(!propertyName) {
            return decl;
        }
        else {
            const property = decl.properties ? decl.properties.find(d => d[propertyName]) : null;
            return property;
        }
    }

    /**
     * Validates a vocabulary against a ModelFile, returning errors for
     * missing and additional terms.
     * @param {ModelFile} modelFile the model file for this vocabulary
     * @returns {*} an object with missingTerms and additionalTerms properties
     */
    validate(modelFile) {
        const getOwnProperties = (declaration) => {
            // ensures we have a valid return, even for scalars and map-declarations
            if(declaration.isMapDeclaration()) {
                return [declaration.getKey(), declaration.getValue()];
            } else {
                return declaration.getOwnProperties?.() ? declaration.getOwnProperties?.() : [];
            }
        };

        const getPropertyName = (property) => {
            if(property.isKey?.()) {
                return 'KEY';
            } else if(property.isValue?.()) {
                return 'VALUE';
            } else {
                return property.getName();
            }
        };

        const checkPropertyExists = (k, p) => {
            const declaration = modelFile.getLocalType(Object.keys(k)[0]);
            const property = Object.keys(p)[0];
            if(declaration.isMapDeclaration()) {
                if (property === 'KEY') {
                    return true;
                } else if(property === 'VALUE') {
                    return true;
                } else {
                    return false;
                }
            } else {
                return declaration.getOwnProperty(Object.keys(p)[0]);
            }
        };

        const result = {
            missingTerms: modelFile.getAllDeclarations().flatMap( d => this.getTerm(d.getName())
                ? getOwnProperties(d).flatMap( p => this.getTerm(d.getName(), getPropertyName(p)) ? null : `${d.getName()}.${getPropertyName(p)}`)
                : d.getName() ).filter( i => i !== null),
            additionalTerms: this.content.declarations.flatMap( k => modelFile.getLocalType(Object.keys(k)[0])
                ? Array.isArray(k.properties) ? k.properties.flatMap( p => checkPropertyExists(k, p) ? null : `${Object.keys(k)[0]}.${Object.keys(p)[0]}`) : null
                : k ).filter( i => i !== null)
        };

        return result;
    }

    /**
     * Converts the object to JSON
     * @returns {*} the contens of this vocabulary
     */
    toJSON() {
        return this.content;
    }
}

module.exports = Vocabulary;

1	/*
2	* Licensed under the Apache License, Version 2.0 (the "License");
3	* you may not use this file except in compliance with the License.
4	* You may obtain a copy of the License at
5	*
6	* http://www.apache.org/licenses/LICENSE-2.0
7	*
8	* Unless required by applicable law or agreed to in writing, software
9	* distributed under the License is distributed on an "AS IS" BASIS,
10	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11	* See the License for the specific language governing permissions and
12	* limitations under the License.
13	*/
14
15	'use strict';
16
17	// Types needed for TypeScript generation.
18	/* eslint-disable no-unused-vars */
19	/* istanbul ignore next */
20	if (global === undefined) {
21	const VocabularyManager = require('./vocabularymanager');
22	const { ModelFile } = require('@accordproject/concerto-core');
23	}
24	/* eslint-enable no-unused-vars */
25
26	/**
27	* A vocabulary for a concerto model
28	* @class
29	* @memberof module:concerto-vocabulary
30	*/
31	class Vocabulary {
32	/**
33	* Create the Vocabulary
34	* @constructor
35	* @param {VocabularyManager} vocabularyManager - the manager for this vocabulary
36	* @param {object} voc - the JSON representation of the vocabulary
37	*/
38	constructor(vocabularyManager, voc) {
39	if(!vocabularyManager) {	1,698✔
40	throw new Error('VocabularyManager must be specified');	6✔
41	}
42	if(!voc) {	1,692✔
43	throw new Error('Vocabulary object must be specified');	6✔
44	}
45
46	if(!voc.declarations) {	1,686✔
47	throw new Error('Vocabulary object must have declarations');	6✔
48	}
49
50	if(!voc.namespace) {	1,680✔
51	throw new Error('A vocabulary must specify a namespace');	12✔
52	}
53
54	if(!voc.locale) {	1,668!
NEW 55	throw new Error('A vocabulary must specify a locale');	×
56	}
57
58	Vocabulary.validateLocale(voc.locale);	1,668✔
59
60	this.vocabularyManager = vocabularyManager;	1,656✔
61	this.content = voc;	1,656✔
62	}
63
64	/**
65	* Returns the namespace for the vocabulary
66	* @returns {string} the namespace for this vocabulary
67	*/
68	getNamespace() {
69	return this.content.namespace;	10,752✔
70	}
71
72	/**
73	* Validates a locale
74	* @param {string} locale the locale to validate
75	* @throws {Error} if the locale is invalid
76	*/
77	static validateLocale(locale) {
78	new Intl.Locale(locale);	1,680✔
79	if(locale !== locale.toLowerCase()) {	1,674✔
80	throw new Error('Locale should be lowercase with dashes');	12✔
81	}
82	}
83
84	/**
85	* Returns the locale for the vocabulary
86	* @returns {string} the locale for this vocabulary
87	*/
88	getLocale() {
89	return this.content.locale;	1,170✔
90	}
91
92	/**
93	* Returns the identifier for the vocabulary, composed of the namespace plus the locale
94	* @returns {string} the identifier for this vocabulary
95	*/
96	getIdentifier() {
97	return `${this.getNamespace()}/${this.content.locale}`;	8,202✔
98	}
99
100	/**
101	* Returns all the declarations for this vocabulary
102	* @returns {Array} an array of objects
103	*/
104	getTerms() {
105	return this.content.declarations;	12✔
106	}
107
108	/**
109	* Gets the term for a concept, enum or property
110	* @param {string} declarationName the name of a concept or enum
111	* @param {string} [propertyName] the name of a property (optional)
112	* @param {string} [identifier] the identifier of the term (optional)
113	* @returns {string} the term or null if it does not exist
114	*/
115	getTerm(declarationName, propertyName, identifier) {
116	const decl = this.content.declarations.find(d => Object.keys(d)[0] === declarationName);	1,128✔
117	if(!decl) {	456✔
118	return null;	108✔
119	}
120	if(!propertyName) {	348✔
121	return identifier ? decl[identifier] : decl[declarationName];	120✔
122	}
123	else {
124	const property = decl.properties ? decl.properties.find(d => d[propertyName]) : null;	234✔
125	return property ? identifier ? property[identifier] : property[propertyName] : null;	228✔
126	}
127	}
128
129	/**
130	* Gets the terms for a concept, enum or property
131	* @param {string} declarationName the name of a concept or enum
132	* @param {string} [propertyName] the name of a property (optional)
133	* @returns {string} the term or null if it does not exist
134	*/
135	getElementTerms(declarationName, propertyName) {
136	const decl = this.content.declarations.find(d => Object.keys(d)[0] === declarationName);	858✔
137	if(!decl) {	294✔
138	return null;	72✔
139	}
140	if(!propertyName) {	222✔
141	return decl;	54✔
142	}
143	else {
144	const property = decl.properties ? decl.properties.find(d => d[propertyName]) : null;	168✔
145	return property;	168✔
146	}
147	}
148
149	/**
150	* Validates a vocabulary against a ModelFile, returning errors for
151	* missing and additional terms.
152	* @param {ModelFile} modelFile the model file for this vocabulary
153	* @returns {*} an object with missingTerms and additionalTerms properties
154	*/
155	validate(modelFile) {
156	const getOwnProperties = (declaration) => {	24✔
157	// ensures we have a valid return, even for scalars and map-declarations
158	if(declaration.isMapDeclaration()) {	72✔
159	return [declaration.getKey(), declaration.getValue()];	18✔
160	} else {
161	return declaration.getOwnProperties?.() ? declaration.getOwnProperties?.() : [];	54✔
162	}
163	};
164
165	const getPropertyName = (property) => {	24✔
166	if(property.isKey?.()) {	210✔
167	return 'KEY';	24✔
168	} else if(property.isValue?.()) {	186✔
169	return 'VALUE';	30✔
170	} else {
171	return property.getName();	156✔
172	}
173	};
174
175	const checkPropertyExists = (k, p) => {	24✔
176	const declaration = modelFile.getLocalType(Object.keys(k)[0]);	84✔
177	const property = Object.keys(p)[0];	84✔
178	if(declaration.isMapDeclaration()) {	84✔
179	if (property === 'KEY') {	24✔
180	return true;	12✔
181	} else if(property === 'VALUE') {	12✔
182	return true;	6✔
183	} else {
184	return false;	6✔
185	}
186	} else {
187	return declaration.getOwnProperty(Object.keys(p)[0]);	60✔
188	}
189	};
190
191	const result = {	24✔
192	missingTerms: modelFile.getAllDeclarations().flatMap( d => this.getTerm(d.getName())	144✔
193	? getOwnProperties(d).flatMap( p => this.getTerm(d.getName(), getPropertyName(p)) ? null : `${d.getName()}.${getPropertyName(p)}`)	138✔
194	: d.getName() ).filter( i => i !== null),	210✔
195	additionalTerms: this.content.declarations.flatMap( k => modelFile.getLocalType(Object.keys(k)[0])	78✔
196	? Array.isArray(k.properties) ? k.properties.flatMap( p => checkPropertyExists(k, p) ? null : `${Object.keys(k)[0]}.${Object.keys(p)[0]}`) : null	84✔
197	: k ).filter( i => i !== null)	114✔
198	};
199
200	return result;	24✔
201	}
202
203	/**
204	* Converts the object to JSON
205	* @returns {*} the contens of this vocabulary
206	*/
207	toJSON() {
208	return this.content;	6✔
209	}
210	}
211
212	module.exports = Vocabulary;	6✔

accordproject / concerto / 10248251351

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous