10176331891

Committed 31 Jul 2024 07:57AM UTC coverage: 98.393% (-0.003%) from 98.396%

Build # 10176331891

Build Type

Pull #888

github

Committed by

web-flow

Commit Message

Merge aaa8c9318 into e6e0771f1

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

Run Details

2205 of 2273 branches covered (97.01%)

Branch coverage included in aggregate %.

48 of 54 new or added lines in 3 files covered. (88.89%)

7 existing lines in 1 file now uncovered.

4101 of 4136 relevant lines covered (99.15%)

66216.3 hits per line

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

98.36

/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');
        }

        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
     * @private
     */
    static validateLocale(locale) {
        if(!locale) {
            throw new Error('A vocabulary must specify a locale');
        }
        new Intl.Locale(locale);
        if(locale !== locale.toLowerCase()) {
            throw new Error('Locale should be lowercase with dashes');
        }
    }

    /**
     * Returns true if the locale is valid
     * @param {string} locale the locale to validate
     * @returns {boolean} true if the locale is valid
     */
    static isValidLocale(locale) {
        try{
            this.validateLocale(locale);
        }
        catch(error){
            return false;
        }
        return true;
    }

    /**
     * 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	Vocabulary.validateLocale(voc.locale);	1,668✔
55
56	this.vocabularyManager = vocabularyManager;	1,656✔
57	this.content = voc;	1,656✔
58	}
59
60	/**
61	* Returns the namespace for the vocabulary
62	* @returns {string} the namespace for this vocabulary
63	*/
64	getNamespace() {
65	return this.content.namespace;	10,752✔
66	}
67
68	/**
69	* Validates a locale
70	* @param {string} locale the locale to validate
71	* @throws {Error} if the locale is invalid
72	* @private
73	*/
74	static validateLocale(locale) {
75	if(!locale) {	1,680!
NEW 76	throw new Error('A vocabulary must specify a locale');	×
77	}
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 true if the locale is valid
86	* @param {string} locale the locale to validate
87	* @returns {boolean} true if the locale is valid
88	*/
89	static isValidLocale(locale) {
90	try{	12✔
91	this.validateLocale(locale);	12✔
92	}
93	catch(error){
94	return false;	6✔
95	}
96	return true;	6✔
97	}
98
99	/**
100	* Returns the locale for the vocabulary
101	* @returns {string} the locale for this vocabulary
102	*/
103	getLocale() {
104	return this.content.locale;	1,170✔
105	}
106
107	/**
108	* Returns the identifier for the vocabulary, composed of the namespace plus the locale
109	* @returns {string} the identifier for this vocabulary
110	*/
111	getIdentifier() {
112	return `${this.getNamespace()}/${this.content.locale}`;	8,202✔
113	}
114
115	/**
116	* Returns all the declarations for this vocabulary
117	* @returns {Array} an array of objects
118	*/
119	getTerms() {
120	return this.content.declarations;	12✔
121	}
122
123	/**
124	* Gets the term for a concept, enum or property
125	* @param {string} declarationName the name of a concept or enum
126	* @param {string} [propertyName] the name of a property (optional)
127	* @param {string} [identifier] the identifier of the term (optional)
128	* @returns {string} the term or null if it does not exist
129	*/
130	getTerm(declarationName, propertyName, identifier) {
131	const decl = this.content.declarations.find(d => Object.keys(d)[0] === declarationName);	1,128✔
132	if(!decl) {	456✔
133	return null;	108✔
134	}
135	if(!propertyName) {	348✔
136	return identifier ? decl[identifier] : decl[declarationName];	120✔
137	}
138	else {
139	const property = decl.properties ? decl.properties.find(d => d[propertyName]) : null;	234✔
140	return property ? identifier ? property[identifier] : property[propertyName] : null;	228✔
141	}
142	}
143
144	/**
145	* Gets the terms for a concept, enum or property
146	* @param {string} declarationName the name of a concept or enum
147	* @param {string} [propertyName] the name of a property (optional)
148	* @returns {string} the term or null if it does not exist
149	*/
150	getElementTerms(declarationName, propertyName) {
151	const decl = this.content.declarations.find(d => Object.keys(d)[0] === declarationName);	858✔
152	if(!decl) {	294✔
153	return null;	72✔
154	}
155	if(!propertyName) {	222✔
156	return decl;	54✔
157	}
158	else {
159	const property = decl.properties ? decl.properties.find(d => d[propertyName]) : null;	168✔
160	return property;	168✔
161	}
162	}
163
164	/**
165	* Validates a vocabulary against a ModelFile, returning errors for
166	* missing and additional terms.
167	* @param {ModelFile} modelFile the model file for this vocabulary
168	* @returns {*} an object with missingTerms and additionalTerms properties
169	*/
170	validate(modelFile) {
171	const getOwnProperties = (declaration) => {	24✔
172	// ensures we have a valid return, even for scalars and map-declarations
173	if(declaration.isMapDeclaration()) {	72✔
174	return [declaration.getKey(), declaration.getValue()];	18✔
175	} else {
176	return declaration.getOwnProperties?.() ? declaration.getOwnProperties?.() : [];	54✔
177	}
178	};
179
180	const getPropertyName = (property) => {	24✔
181	if(property.isKey?.()) {	210✔
182	return 'KEY';	24✔
183	} else if(property.isValue?.()) {	186✔
184	return 'VALUE';	30✔
185	} else {
186	return property.getName();	156✔
187	}
188	};
189
190	const checkPropertyExists = (k, p) => {	24✔
191	const declaration = modelFile.getLocalType(Object.keys(k)[0]);	84✔
192	const property = Object.keys(p)[0];	84✔
193	if(declaration.isMapDeclaration()) {	84✔
194	if (property === 'KEY') {	24✔
195	return true;	12✔
196	} else if(property === 'VALUE') {	12✔
197	return true;	6✔
198	} else {
199	return false;	6✔
200	}
201	} else {
202	return declaration.getOwnProperty(Object.keys(p)[0]);	60✔
203	}
204	};
205
206	const result = {	24✔
207	missingTerms: modelFile.getAllDeclarations().flatMap( d => this.getTerm(d.getName())	144✔
208	? getOwnProperties(d).flatMap( p => this.getTerm(d.getName(), getPropertyName(p)) ? null : `${d.getName()}.${getPropertyName(p)}`)	138✔
209	: d.getName() ).filter( i => i !== null),	210✔
210	additionalTerms: this.content.declarations.flatMap( k => modelFile.getLocalType(Object.keys(k)[0])	78✔
211	? Array.isArray(k.properties) ? k.properties.flatMap( p => checkPropertyExists(k, p) ? null : `${Object.keys(k)[0]}.${Object.keys(p)[0]}`) : null	84✔
212	: k ).filter( i => i !== null)	114✔
213	};
214
215	return result;	24✔
216	}
217
218	/**
219	* Converts the object to JSON
220	* @returns {*} the contens of this vocabulary
221	*/
222	toJSON() {
223	return this.content;	6✔
224	}
225	}
226
227	module.exports = Vocabulary;	6✔

accordproject / concerto / 10176331891

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