gina 0.6.2 → 0.6.3

package/framework/{v0.6.2 → v0.6.3}/core/plugins/lib/validator/src/form-validator.js

@@ -153,7 +153,11 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
         'isStringMaxLength': 'Should not be more than %s characters',
         'isJsonWebToken': 'Must be a valid JSON Web Token',
         'query': 'Must be a valid response',
-        'isApiError': 'Condition not satisfied',
+        // #B233 rider - dropped: `isApiError` is not a rule, so nothing ever consulted this
+        // label. The API-error path assigns the SERVER's message straight onto the error
+        // object (main.js `errorObject[f].isApiError = result.fields[f]`) and never calls
+        // replace(), so the entry only read as a translatable key that silently did nothing.
+        //'isApiError': 'Condition not satisfied',
         'isInList': 'Must be one of: %s'
     };
     /**
@@ -1167,19 +1171,20 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
             var errors      = self[this['name']]['errors'] || {};
             local.data[this.name] = self[this.name].value;
 
-            if (
-                typeof(errors['isRequired']) == 'undefined'
-                && this.value == ''
-                && !/^false$/i.test(this.value)
-                && this.value != 0
-                ||
-                !errors['isRequired']
-                && this.value == ''
-                && !/^false$/i.test(this.value)
-                && this.value != 0
-            ) {
-                isValid = true;
-            } else if (!errors['isRequired'] && typeof(this.value) == 'string' && this.value == '') {
+            // #B233 - an empty value is adjudicated by isRequired alone: bypass on empty so a
+            // required+empty field records only isRequired, not a second 'Condition not
+            // satisfied'. This REVERSES a twice-declined exclusion (#B78 left `is` untouched,
+            // #B82 re-declined it) on measurement: the old bypass was gated on
+            // !errors['isRequired'] — i.e. disabled exactly when #B78 wants it applied — while
+            // optional+empty already self-passed through it; and on required+empty the condition
+            // is verdict-irrelevant (form validity is getErrors().count() and isRequired has
+            // already recorded its error), so only the message list changes.
+            // #B199 - strict: only the literal empty string is "empty". 0, false and null are
+            // VALUES here and still evaluate the condition.
+            // was: a two-disjunct guard whose arms were both DEAD (`x == '' && x != 0` has no
+            // witness — `x == ''` forces ToNumber(x) === 0 for non-strings and x === '' for
+            // strings), followed by the isRequired-gated string-only bypass described above.
+            if ( this.value === '' ) {
                 isValid = true;
             }
 
@@ -1320,7 +1325,8 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
                 //delete errors['stack'];
             }
 
-            this.valid = isValid;
+            // #B78 - keep .valid consistent with a surviving isRequired error.
+            this.valid = isValid && !errors['isRequired'];
             if ( errors.count() > 0 )
                 this['errors'] = errors;
 
@@ -1358,7 +1364,10 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
 
             // #B78 - an empty value is adjudicated by isRequired alone: bypass on empty so a
             // required+empty field records only isRequired, not a second 'invalid' message.
-            if ( this.value == '' ) {
+            // #B199 - strict: only the literal empty string is "empty". The loose ==
+            // let 0, -0, false and [] coerce equal and ride this bypass, so e.g. a
+            // JSON body's 0 in this field PASSED the rule outright.
+            if ( this.value === '' ) {
                 isValid = true;
             }
 
@@ -1400,7 +1409,10 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
 
             // #B78 - an empty value is adjudicated by isRequired alone: bypass on empty so a
             // required+empty field records only isRequired, not a second 'invalid' message.
-            if ( this.value == '' ) {
+            // #B199 - strict: only the literal empty string is "empty". The loose ==
+            // let 0, -0, false and [] coerce equal and ride this bypass, so e.g. a
+            // JSON body's 0 in this field PASSED the rule outright.
+            if ( this.value === '' ) {
                 isValid = true;
             }
 
@@ -1423,35 +1435,58 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
         }
 
         /**
-         * Check if boolean and convert to `true/false` booloean if value is a string or a number
-         * Will include `false` value if isRequired
+         * Check if boolean and convert to `true/false` boolean if value is a string or a number.
+         * Accepts `true`/`'true'`/`1` and `false`/`'false'`/`0` — the documented set.
+         *
+         * #B78 contract (#B235): an EMPTY value is adjudicated by `isRequired`
+         * alone — the rule self-passes on the literal empty string, and the tail
+         * keeps `this.valid` consistent with a surviving isRequired error
+         * (Shape A). An ACCEPTED answer also clears a prior isRequired error:
+         * `false` and `0` are loose-equal to the empty string so isRequired
+         * flags them, but a recognized boolean false is a present answer (an
+         * unchecked-but-required toggle does not fail). The pre-fix rescue ran
+         * BEFORE the switch on a loose equality that also matched the empty
+         * string, deleting the isRequired error a genuinely-empty field had
+         * earned (#B235).
          * */
         self[el]['isBoolean'] = function() {
             var val     = null
                 , errors = self[this['name']]['errors'] || {}
+                , isValid = false
             ;
 
-            if ( errors['isRequired'] && this.value == false) {
+            // #B235 — was (the loose == also matched ''; `isValid = true` was a
+            // dead write into the binding hoisted from below):
+            // if ( errors['isRequired'] && this.value == false) {
+            //     isValid = true;
+            //     delete errors['isRequired'];
+            //     this['errors'] = errors;
+            // }
+
+            if ( this.value === '' ) { // #B78/#B235 — emptiness is isRequired's verdict alone
                 isValid = true;
-                delete errors['isRequired'];
-                this['errors'] = errors;
-            }
+            } else {
+                switch(this.value) {
+                    case 'true':
+                    case true:
+                    case 1:
+                        val = this.value = local.data[this.name] = true;
+                        break;
+                    case 'false':
+                    case false:
+                    case 0:
+                        val = this.value = local.data[this.name] = false;
+                        break;
+                }
 
-            switch(this.value) {
-                case 'true':
-                case true:
-                case 1:
-                    val = this.value = local.data[this.name] = true;
-                    break;
-                case 'false':
-                case false:
-                case 0:
-                    val = this.value = local.data[this.name] = false;
-                    break;
+                isValid = (val !== null) ? true : false;
+                // an engine-ACCEPTED answer clears the error that isRequired's
+                // loose emptiness test recorded on false/0
+                if ( val !== null && errors['isRequired'] ) {
+                    delete errors['isRequired'];
+                }
             }
 
-            var isValid = (val !== null) ? true : false;
-
             if (!isValid) {
                 errors['isBoolean'] = replace(this.error || local.errorLabels['isBoolean'], this, 'isBoolean')
             }
@@ -1461,7 +1496,8 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
                 //delete errors['stack'];
             }
 
-            this.valid = isValid;
+            // #B78 mirror (Shape A): keep .valid consistent with a surviving isRequired error
+            this.valid = isValid && !errors['isRequired'];
             if ( errors.count() > 0 )
                 this['errors'] = errors;
 
@@ -1506,7 +1542,10 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
 
             if ( +val === +val ) {
                 isValid = true;
-                if ( !errors['isRequired'] && val != '' ) {
+                // #B199 - strict !== : the loose != let the Number 0 (and -0/[] — and
+                // '0', which the entry cast turns into 0) coerce equal to '' and skip
+                // the bounds. Only the literal empty string bypasses.
+                if ( !errors['isRequired'] && val !== '' ) {
                     len = val.toString().length;
                     // if so also test max and min length if defined
                     if (minLength && typeof(minLength) == 'number' && len < minLength) {
@@ -1573,6 +1612,33 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
             return self[this.name]
         }
 
+        /**
+         * Check if value is a whole number.
+         *  - valid if the value is a number with no fractional part
+         *  - a numeric string is accepted; the value is cast to a `Number` on the way
+         *    OUT, after the bounds have been evaluated — whereas `isNumber` casts on
+         *    the way IN, before its own bounds. That ordering difference is why the
+         *    two rules must measure length differently at the bound site (see #B198)
+         *  - if the value is blank, no bound test is done: valid if not required
+         *
+         * Optional bounds constrain the LENGTH of the value's string form — the same
+         * arity contract as `isString`/`isNumber`: `[N]` (or the scalar `N`) supplies
+         * `minLength` only, and an exact length needs `[N, N]` since the exact-length
+         * branch fires only when `minLength === maxLength`.
+         *
+         * #B198 — the bounds measure `val.toString().length`, never `val.length`. This
+         * rule accepts a real `Number` (`+val === +val` passes for one), and
+         * `Number.prototype.length` is `undefined`, so `val.length` made both bounds
+         * silently inert on any numeric value — no error, no warn, `valid` left true.
+         * Numbers reach here from JSON request bodies and from a preceding `toInteger`
+         * (which leaves `Math.round()`'s real Number on `this.value`), so the browser
+         * path was affected too. `isNumber` has always measured `toString().length`.
+         *
+         *  @param {number} [ minLength ]
+         *  @param {number} [ maxLength ]
+         *
+         *  @returns {object} result
+         * */
         self[el]['isInteger'] = function(minLength, maxLength) {
             var val             = this.value
                 , isValid       = false
@@ -1584,13 +1650,18 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
             // test if val is a number
             if ( +val === +val && val % 1 === 0 ) {
                 isValid = true;
-                if ( !errors['isRequired'] && val != '' ) {
+                // #B199 - strict !== : the loose != let the Number 0 (and -0/[]) coerce
+                // equal to '' and skip the bounds. Only the literal empty string bypasses.
+                if ( !errors['isRequired'] && val !== '' ) {
                     // if so also test max and min length if defined
-                    if (minLength && typeof(minLength) == 'number' && val.length < minLength) {
+                    // #B198 - was: `val.length`, which is `undefined` on a real Number
+                    // (this rule accepts one, and never casts), so both bounds were
+                    // silently inert. Measure the string form, as `isNumber` does.
+                    if (minLength && typeof(minLength) == 'number' && val.toString().length < minLength) {
                         isMinLength = false;
                         this['size'] = minLength;
                     }
-                    if (maxLength && typeof(maxLength) == 'number' && val.length > maxLength) {
+                    if (maxLength && typeof(maxLength) == 'number' && val.toString().length > maxLength) {
                         isMaxLength = false;
                         this['size'] = maxLength;
                     }
@@ -1762,7 +1833,10 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
 
             // #B78 - an empty value is adjudicated by isRequired alone: bypass on empty so a
             // required+empty field records only isRequired, not a second 'invalid' message.
-            if ( this.value == '' ) {
+            // #B199 - strict: only the literal empty string is "empty". The loose ==
+            // let 0, -0, false and [] coerce equal and ride this bypass, so e.g. a
+            // JSON body's 0 in this field PASSED the rule outright.
+            if ( this.value === '' ) {
                 isValid = true
             }
 
@@ -1867,7 +1941,9 @@ function FormValidatorUtil(data, $fields, xhrOptions, fieldsSet, culture) {
          *      // OR
          *      "isString": [7, 40] // Means at least 7 chars length and maximum 40 chars length
          *      // OR
-         *      "isString": [7] // Means is strickly equal to 7 chars length, same as [7,7]
+         *      "isString": [7] // Means at least 7 chars length, same as 7 above: a one-element array supplies minLength only
+         *      // OR
+         *      "isString": [7, 7] // Means strictly equal to 7 chars length
          *  }
          * }
          * @param {number|undefined} [ minLength ]