4365136167

Build Type

push

github

Committed by GitHub

Commit Message

feat(tools): add graph and graph search (#614)

Run Details

2778 of 2845 branches covered (97.64%)

Branch coverage included in aggregate %.

93 of 95 new or added lines in 11 files covered. (97.89%)

1 existing line in 1 file now uncovered.

5477 of 5500 relevant lines covered (99.58%)

8224.05 hits per line

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

94.32

/packages/concerto-core/lib/modelutil.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';

const { MetaModelUtil } = require('@accordproject/concerto-metamodel');
const semver = require('semver');
const Globalize = require('./globalize');

const ID_REGEX = /^(\p{Lu}|\p{Ll}|\p{Lt}|\p{Lm}|\p{Lo}|\p{Nl}|\$|_|\\u[0-9A-Fa-f]{4})(?:\p{Lu}|\p{Ll}|\p{Lt}|\p{Lm}|\p{Lo}|\p{Nl}|\$|_|\\u[0-9A-Fa-f]{4}|\p{Mn}|\p{Mc}|\p{Nd}|\p{Pc}|\u200C|\u200D)*$/u;

/**
 * Internal Model Utility Class
 * <p><a href="./diagrams-private/modelutil.svg"><img src="./diagrams-private/modelutil.svg" style="height:100%;"/></a></p>
 * @private
 * @class
 * @memberof module:concerto-core
 */
class ModelUtil {
    /**
     * Returns everything after the last dot, if present, of the source string
     * @param {string} fqn - the source string
     * @return {string} - the string after the last dot
     */
    static getShortName(fqn) {
        let result = fqn;
        let dotIndex = fqn.lastIndexOf('.');
        if (dotIndex > -1) {
            result = fqn.substr(dotIndex + 1);
        }

        return result;
    }

    /**
     * Returns the namespace for the fully qualified name of a type
     * @param {string} fqn - the fully qualified identifier of a type
     * @return {string} - namespace of the type (everything before the last dot)
     * or the empty string if there is no dot
     */
    static getNamespace(fqn) {
        if (!fqn) {
            throw new Error(Globalize.formatMessage('modelutil-getnamespace-nofnq'));
        }

        let result = '';
        let dotIndex = fqn.lastIndexOf('.');
        if (dotIndex > -1) {
            result = fqn.substr(0, dotIndex);
        }

        return result;
    }

    /**
     * @typedef ParseNamespaceResult
     * @property {string} name the name of the namespace
     * @property {string} escapedNamespace the escaped namespace
     * @property {string} version the version of the namespace
     * @property {object} versionParsed the parsed semantic version of the namespace
     */

    /**
     * Parses a potentially versioned namespace into
     * its name and version parts. The version of the namespace
     * (if present) is parsed using semver.parse.
     * @param {string} ns the namespace to parse
     * @returns {ParseNamespaceResult} the result of parsing
     */
    static parseNamespace(ns) {
        if(!ns) {
            throw new Error('Namespace is null or undefined.');
        }

        const parts = ns.split('@');
        if(parts.length > 2) {
            throw new Error(`Invalid namespace ${ns}`);
        }

        if(parts.length === 2) {
            if(!semver.valid(parts[1])) {
                throw new Error(`Invalid namespace ${ns}`);
            }
        }

        return {
            name: parts[0],
            escapedNamespace: ns.replace('@', '_'),
            version: parts.length > 1 ? parts[1] : null,
            versionParsed: parts.length > 1 ? semver.parse(parts[1]) : null
        };
    }

    /**
     * Return the fully qualified name for an import
     * @param {object} imp - the import
     * @return {string[]} - the fully qualified names for that import
     * @private
     */
    static importFullyQualifiedNames(imp) {
        return MetaModelUtil.importFullyQualifiedNames(imp);
    }

    /**
     * Returns true if the type is a primitive type
     * @param {string} typeName - the name of the type
     * @return {boolean} - true if the type is a primitive
     * @private
     */
    static isPrimitiveType(typeName) {
        const primitiveTypes = ['Boolean', 'String', 'DateTime', 'Double', 'Integer', 'Long'];
        return (primitiveTypes.indexOf(typeName) >= 0);
    }

    /**
     * Returns true if the type is assignable to the propertyType.
     *
     * @param {ModelFile} modelFile - the ModelFile that owns the Property
     * @param {string} typeName - the FQN of the type we are trying to assign
     * @param {Property} property - the property that we'd like to store the
     * type in.
     * @return {boolean} - true if the type can be assigned to the property
     * @private
     */
    static isAssignableTo(modelFile, typeName, property) {
        const propertyTypeName = property.getFullyQualifiedTypeName();

        const isDirectMatch = (typeName === propertyTypeName);
        if (isDirectMatch || ModelUtil.isPrimitiveType(typeName) || ModelUtil.isPrimitiveType(propertyTypeName)) {
            return isDirectMatch;
        }

        const typeDeclaration = modelFile.getType(typeName);
        if (!typeDeclaration) {
            throw new Error('Cannot find type ' + typeName);
        }

        return typeDeclaration.getAllSuperTypeDeclarations().
            some(type => type.getFullyQualifiedName() === propertyTypeName);
    }

    /**
     * Returns the passed string with the first character capitalized
     * @param {string} string - the string
     * @return {string} the string with the first letter capitalized
     * @private
     */
    static capitalizeFirstLetter(string) {
        return string.charAt(0).toUpperCase() + string.slice(1);
    }

    /**
     * Returns the true if the given field is an enumerated type
     * @param {Field} field - the string
     * @return {boolean} true if the field is declared as an enumeration
     * @private
     */
    static isEnum(field) {
        const modelFile = field.getParent().getModelFile();
        const typeDeclaration = modelFile.getType(field.getType());
        return (typeDeclaration !== null && typeDeclaration.isEnum());
    }

    /**
     * Returns the true if the given field is a Scalar type
     * @param {Field} field - the Field to test
     * @return {boolean} true if the field is declared as an scalar
     * @private
     */
    static isScalar(field) {
        const modelFile = field.getParent().getModelFile();
        const declaration = modelFile.getType(field.getType());
        return (declaration !== null && declaration.isScalarDeclaration?.());
    }

    /**
     * Return true if the name is a valid Concerto identifier
     * @param {string} name - the name of the identifier to test.
     * @returns {boolean} true if the identifier is valid.
     */
    static isValidIdentifier(name) {
        return ID_REGEX.test(name);
    }

    /**
     * Get the fully qualified name of a type.
     * @param {string} namespace - namespace of the type.
     * @param {string} type - short name of the type.
     * @returns {string} the fully qualified type name.
     */
    static getFullyQualifiedName(namespace, type) {
        if (namespace) {
            return `${namespace}.${type}`;
        } else {
            return type;
        }
    }

    /**
     * Converts a fully qualified type name to a FQN without a namespace version.
     * If the FQN is a primitive type it is returned unchanged.
     * @param {string} fqn fully qualified name of a type
     * @returns {string} the fully qualified name minus the namespace version
     */
    static removeNamespaceVersionFromFullyQualifiedName(fqn) {
        if(ModelUtil.isPrimitiveType(fqn)) {
            return fqn;
        }
        const ns = ModelUtil.getNamespace(fqn);
        const { name: namespace } = ModelUtil.parseNamespace(ns);
        const typeName = ModelUtil.getShortName(fqn);
        return ModelUtil.getFullyQualifiedName(namespace, typeName);
    }
}

module.exports = ModelUtil;

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	const { MetaModelUtil } = require('@accordproject/concerto-metamodel');	3✔
18	const semver = require('semver');	3✔
19	const Globalize = require('./globalize');	3✔
20
21	const ID_REGEX = /^(\p{Lu}\|\p{Ll}\|\p{Lt}\|\p{Lm}\|\p{Lo}\|\p{Nl}\|\$\|_\|\\u[0-9A-Fa-f]{4})(?:\p{Lu}\|\p{Ll}\|\p{Lt}\|\p{Lm}\|\p{Lo}\|\p{Nl}\|\$\|_\|\\u[0-9A-Fa-f]{4}\|\p{Mn}\|\p{Mc}\|\p{Nd}\|\p{Pc}\|\u200C\|\u200D)*$/u;	3✔
22
23	/**
24	* Internal Model Utility Class
25	* <p><a href="./diagrams-private/modelutil.svg"><img src="./diagrams-private/modelutil.svg" style="height:100%;"/></a></p>
26	* @private
27	* @class
28	* @memberof module:concerto-core
29	*/
30	class ModelUtil {
31	/**
32	* Returns everything after the last dot, if present, of the source string
33	* @param {string} fqn - the source string
34	* @return {string} - the string after the last dot
35	*/
36	static getShortName(fqn) {
37	let result = fqn;	19,011✔
38	let dotIndex = fqn.lastIndexOf('.');	19,011✔
39	if (dotIndex > -1) {	19,011✔
40	result = fqn.substr(dotIndex + 1);	19,002✔
41	}
42
43	return result;	19,011✔
44	}
45
46	/**
47	* Returns the namespace for the fully qualified name of a type
48	* @param {string} fqn - the fully qualified identifier of a type
49	* @return {string} - namespace of the type (everything before the last dot)
50	* or the empty string if there is no dot
51	*/
52	static getNamespace(fqn) {
53	if (!fqn) {	209,745✔
54	throw new Error(Globalize.formatMessage('modelutil-getnamespace-nofnq'));	3✔
55	}
56
57	let result = '';	209,742✔
58	let dotIndex = fqn.lastIndexOf('.');	209,742✔
59	if (dotIndex > -1) {	209,742✔
60	result = fqn.substr(0, dotIndex);	209,703✔
61	}
62
63	return result;	209,742✔
64	}
65
66	/**
67	* @typedef ParseNamespaceResult
68	* @property {string} name the name of the namespace
69	* @property {string} escapedNamespace the escaped namespace
70	* @property {string} version the version of the namespace
71	* @property {object} versionParsed the parsed semantic version of the namespace
72	*/
73
74	/**
75	* Parses a potentially versioned namespace into
76	* its name and version parts. The version of the namespace
77	* (if present) is parsed using semver.parse.
78	* @param {string} ns the namespace to parse
79	* @returns {ParseNamespaceResult} the result of parsing
80	*/
81	static parseNamespace(ns) {
82	if(!ns) {	26,583✔
83	throw new Error('Namespace is null or undefined.');	3✔
84	}
85
86	const parts = ns.split('@');	26,580✔
87	if(parts.length > 2) {	26,580✔
88	throw new Error(`Invalid namespace ${ns}`);	3✔
89	}
90
91	if(parts.length === 2) {	26,577✔
92	if(!semver.valid(parts[1])) {	20,010✔
93	throw new Error(`Invalid namespace ${ns}`);	3✔
94	}
95	}
96
97	return {	26,574✔
98	name: parts[0],
99	escapedNamespace: ns.replace('@', '_'),
100	version: parts.length > 1 ? parts[1] : null,	26,574✔
101	versionParsed: parts.length > 1 ? semver.parse(parts[1]) : null	26,574✔
102	};
103	}
104
105	/**
106	* Return the fully qualified name for an import
107	* @param {object} imp - the import
108	* @return {string[]} - the fully qualified names for that import
109	* @private
110	*/
111	static importFullyQualifiedNames(imp) {
112	return MetaModelUtil.importFullyQualifiedNames(imp);	5,469✔
113	}
114
115	/**
116	* Returns true if the type is a primitive type
117	* @param {string} typeName - the name of the type
118	* @return {boolean} - true if the type is a primitive
119	* @private
120	*/
121	static isPrimitiveType(typeName) {
122	const primitiveTypes = ['Boolean', 'String', 'DateTime', 'Double', 'Integer', 'Long'];	996,180✔
123	return (primitiveTypes.indexOf(typeName) >= 0);	996,180✔
124	}
125
126	/**
127	* Returns true if the type is assignable to the propertyType.
128	*
129	* @param {ModelFile} modelFile - the ModelFile that owns the Property
130	* @param {string} typeName - the FQN of the type we are trying to assign
131	* @param {Property} property - the property that we'd like to store the
132	* type in.
133	* @return {boolean} - true if the type can be assigned to the property
134	* @private
135	*/
136	static isAssignableTo(modelFile, typeName, property) {
137	const propertyTypeName = property.getFullyQualifiedTypeName();	2,541✔
138
139	const isDirectMatch = (typeName === propertyTypeName);	2,541✔
140	if (isDirectMatch \|\| ModelUtil.isPrimitiveType(typeName) \|\| ModelUtil.isPrimitiveType(propertyTypeName)) {	2,541✔
141	return isDirectMatch;	1,986✔
142	}
143
144	const typeDeclaration = modelFile.getType(typeName);	555✔
145	if (!typeDeclaration) {	555✔
146	throw new Error('Cannot find type ' + typeName);	3✔
147	}
148
149	return typeDeclaration.getAllSuperTypeDeclarations().	552✔
150	some(type => type.getFullyQualifiedName() === propertyTypeName);	666✔
151	}
152
153	/**
154	* Returns the passed string with the first character capitalized
155	* @param {string} string - the string
156	* @return {string} the string with the first letter capitalized
157	* @private
158	*/
159	static capitalizeFirstLetter(string) {
160	return string.charAt(0).toUpperCase() + string.slice(1);	12✔
161	}
162
163	/**
164	* Returns the true if the given field is an enumerated type
165	* @param {Field} field - the string
166	* @return {boolean} true if the field is declared as an enumeration
167	* @private
168	*/
169	static isEnum(field) {
170	const modelFile = field.getParent().getModelFile();	1,134✔
171	const typeDeclaration = modelFile.getType(field.getType());	1,134✔
172	return (typeDeclaration !== null && typeDeclaration.isEnum());	1,134✔
173	}
174
175	/**
176	* Returns the true if the given field is a Scalar type
177	* @param {Field} field - the Field to test
178	* @return {boolean} true if the field is declared as an scalar
179	* @private
180	*/
181	static isScalar(field) {
NEW 182	const modelFile = field.getParent().getModelFile();	×
NEW 183	const declaration = modelFile.getType(field.getType());	×
UNCOV 184	return (declaration !== null && declaration.isScalarDeclaration?.());	×
185	}
186
187	/**
188	* Return true if the name is a valid Concerto identifier
189	* @param {string} name - the name of the identifier to test.
190	* @returns {boolean} true if the identifier is valid.
191	*/
192	static isValidIdentifier(name) {
193	return ID_REGEX.test(name);	294,552✔
194	}
195
196	/**
197	* Get the fully qualified name of a type.
198	* @param {string} namespace - namespace of the type.
199	* @param {string} type - short name of the type.
200	* @returns {string} the fully qualified type name.
201	*/
202	static getFullyQualifiedName(namespace, type) {
203	if (namespace) {	119,640✔
204	return `${namespace}.${type}`;	119,619✔
205	} else {
206	return type;	21✔
207	}
208	}
209
210	/**
211	* Converts a fully qualified type name to a FQN without a namespace version.
212	* If the FQN is a primitive type it is returned unchanged.
213	* @param {string} fqn fully qualified name of a type
214	* @returns {string} the fully qualified name minus the namespace version
215	*/
216	static removeNamespaceVersionFromFullyQualifiedName(fqn) {
217	if(ModelUtil.isPrimitiveType(fqn)) {	6✔
218	return fqn;	3✔
219	}
220	const ns = ModelUtil.getNamespace(fqn);	3✔
221	const { name: namespace } = ModelUtil.parseNamespace(ns);	3✔
222	const typeName = ModelUtil.getShortName(fqn);	3✔
223	return ModelUtil.getFullyQualifiedName(namespace, typeName);	3✔
224	}
225	}
226
227	module.exports = ModelUtil;	3✔

accordproject / concerto / 4365136167

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