Plato on Github

src/attributes/check.js

Maintainability

79.72

Lines of code

137

Created with Raphaël 2.1.002550751002019-3-122018-12-3

2019-10-30
Maintainability: 79.72

Created with Raphaël 2.1.00501001502002019-3-122018-12-3

2019-10-30
Lines of Code: 137

Difficulty

13.31

Estimated Errors

0.22

Function weight

By Complexity

Created with Raphaël 2.1.0_gpfAttributesCheckClassOnly2

By SLOC

Created with Raphaël 2.1.0_gpfAttributesCheckGetMemberAttributes7
1
/**
2
 * @file Attributes validation helpers
3
 * @since 0.2.8
4
 */
5
/*#ifndef(UMD)*/
6
"use strict";
7
/*global _GPF_DEFINE_CLASS_ATTRIBUTES_NAME*/ // $attributes
8
/*global _gpfArrayTail*/ // [].slice.call(,1)
9
/*global _gpfErrorDeclare*/ // Declare new gpf.Error names
10
/*exported _gpfAttributesCheckAppliedOnBaseClass*/ // Ensures attribute is applied on a specific base class
11
/*exported _gpfAttributesCheckAppliedOnlyOnce*/ // Ensures attribute is used only once
12
/*exported _gpfAttributesCheckClassOnly*/ // Ensures attribute is used only at class level
13
/*exported _gpfAttributesCheckMemberOnly*/ // Ensures attribute is used only at member level
14
/*#endif*/
15
 
16
_gpfErrorDeclare("attributes/check", {
17
 
18
    /**
19
     * ### Summary
20
     *
21
     * Class attribute only
22
     *
23
     * ### Description
24
     *
25
     * A class attribute can't be assigned to a member
26
     * @since 0.2.8
27
     */
28
    classAttributeOnly: "Class attribute only",
29
 
30
    /**
31
     * ### Summary
32
     *
33
     * Member attribute only
34
     *
35
     * ### Description
36
     *
37
     * A member attribute can't be assigned to a class
38
     * @since 0.2.8
39
     */
40
    memberAttributeOnly: "Member attribute only",
41
 
42
    /**
43
    * ### Summary
44
    *
45
    * Restricted base class attribute
46
    *
47
    * ### Description
48
    *
49
    * The attribute is restricted to a given base class, check the attribute documentation.
50
    * @since 0.2.8
51
    */
52
    restrictedBaseClassAttribute: "Restricted base class attribute",
53
 
54
    /**
55
    * ### Summary
56
    *
57
    * Unique attribute used twice
58
    *
59
    * ### Description
60
    *
61
    * The attribute is restricted to a single use
62
    * @since 0.2.8
63
    */
64
    uniqueAttributeUsedTwice: "Unique attribute used twice"
65
 
66
});
67
 
68
/**
69
 * Ensures attribute is used only at class level
70
 *
71
 * @param {String} member Member name or empty if global to the class
72
 * @throws {gpf.Error.ClassAttributeOnly}
73
 * @since 0.2.8
74
 */
75
function _gpfAttributesCheckClassOnly (member) {
76
    if (member) {
77
        gpf.Error.classAttributeOnly();
78
    }
79
}
80
 
81
/**
82
 * Ensures attribute is used only at member level
83
 *
84
 * @param {String} member Member name or empty if global to the class
85
 * @throws {gpf.Error.MemberAttributeOnly}
86
 * @since 0.2.8
87
 */
88
function _gpfAttributesCheckMemberOnly (member) {
89
    if (!member) {
90
        gpf.Error.memberAttributeOnly();
91
    }
92
}
93
 
94
function _gpfAttributesCheckAppliedOnBaseClassIsInstanceOf (prototype, ExpectedBaseClass) {
95
    if (!(prototype instanceof ExpectedBaseClass)) {
96
        gpf.Error.restrictedBaseClassAttribute();
97
    }
98
}
99
 
100
/**
101
 * Ensures attribute is applied on a specific base class
102
 *
103
 * @param {_GpfClassDefinition} classDefinition Class definition
104
 * @param {Function} ExpectedBaseClass Expected base class
105
 * @throws {gpf.Error.RestrictedBaseClassAttribute}
106
 * @since 0.2.8
107
 */
108
function _gpfAttributesCheckAppliedOnBaseClass (classDefinition, ExpectedBaseClass) {
109
    var Extend = classDefinition._extend;
110
    if (Extend !== ExpectedBaseClass) {
111
        _gpfAttributesCheckAppliedOnBaseClassIsInstanceOf(Extend.prototype, ExpectedBaseClass);
112
    }
113
}
114
 
115
function _gpfAttributesCheckGetMemberAttributes (member, classDefinition, AttributeClass) {
116
    var allAttributes = classDefinition.getAttributes(AttributeClass);
117
    if (member) {
118
        return allAttributes[member];
119
    }
120
    return allAttributes[_GPF_DEFINE_CLASS_ATTRIBUTES_NAME];
121
}
122
 
123
/**
124
 * Ensures attribute is used only once
125
 *
126
 * @param {String} member Member name or empty if global to the class
127
 * @param {_GpfClassDefinition} classDefinition Class definition
128
 * @param {Function} AttributeClass Attribute class
129
 * @throws {gpf.Error.UniqueAttributeUsedTwice}
130
 * @since 0.2.8
131
 */
132
function _gpfAttributesCheckAppliedOnlyOnce (member, classDefinition, AttributeClass) {
133
    var attributes = _gpfAttributesCheckGetMemberAttributes(member, classDefinition, AttributeClass);
134
    if (_gpfArrayTail(attributes).length) {
135
        gpf.Error.uniqueAttributeUsedTwice();
136
    }
137
}