Changeset 487 for Dev/trunk/src/node_modules/tv4/tv4.js

Timestamp:

03/05/14 22:44:48 (11 years ago)

Author:

hendrikvanantwerpen

Message:

Completed migration to API, without CouchDB proxy.

Move to API is now completed. The full API is password protected, a very
limited API is exposed for respondents, which works with secrets that
are passed in URLs.

Serverside the HTTPResult class was introduced, which is similar to
Promises, but specifically for HTTP. It carries a status code and
response and makes it easier to extract parts of async handling in
separate functions.

Fixed a bug in our schema (it seems optional attributes don't exist but
a required list does). Verification of our schema by grunt-tv4 didn't
work yet. Our schema is organized the wrong way (this is fixable),
but the json-schema schema has problems with simple types and $refs.

File:

• Dev/trunk/src/node_modules/tv4/tv4.js (modified) (12 diffs)

Dev/trunk/src/node_modules/tv4/tv4.js

@@ -133 +133 @@
                 this.scannedFrozen = [];
                 this.scannedFrozenSchemas = [];
-                this.key = 'tv4_validation_id';
+                this.scannedFrozenValidationErrors = [];
+                this.validatedSchemasKey = 'tv4_validation_id';
+                this.validationErrorsKey = 'tv4_validation_errors_id';
         }
         if (trackUnknownProperties) {
@@ -240 +242 @@
 };
 ValidatorContext.prototype.searchSchemas = function (schema, url) {
-        if (typeof schema.id === "string") {
-                if (isTrustedUrl(url, schema.id)) {
-                        if (this.schemas[schema.id] === undefined) {
-                                this.schemas[schema.id] = schema;
-                        }
-                }
-        }
-        if (typeof schema === "object") {
+        if (schema && typeof schema === "object") {
+                if (typeof schema.id === "string") {
+                        if (isTrustedUrl(url, schema.id)) {
+                                if (this.schemas[schema.id] === undefined) {
+                                        this.schemas[schema.id] = schema;
+                                }
+                        }
+                }
                 for (var key in schema) {
                         if (key !== "enum") {
@@ -264 +266 @@
 ValidatorContext.prototype.addSchema = function (url, schema) {
         //overload
-        if (typeof schema === 'undefined') {
+        if (typeof url !== 'string' || typeof schema === 'undefined') {
                 if (typeof url === 'object' && typeof url.id === 'string') {
                         schema = url;
@@ -331 +333 @@
         }
 
-        if (this.checkRecursive && (typeof data) === 'object') {
+        var startErrorCount = this.errors.length;
+        var frozenIndex, scannedFrozenSchemaIndex = null, scannedSchemasIndex = null;
+        if (this.checkRecursive && data && typeof data === 'object') {
                 topLevel = !this.scanned.length;
-                if (data[this.key] && data[this.key].indexOf(schema) !== -1) { return null; }
-                var frozenIndex;
+                if (data[this.validatedSchemasKey]) {
+                        var schemaIndex = data[this.validatedSchemasKey].indexOf(schema);
+                        if (schemaIndex !== -1) {
+                                this.errors = this.errors.concat(data[this.validationErrorsKey][schemaIndex]);
+                                return null;
+                        }
+                }
                 if (Object.isFrozen(data)) {
                         frozenIndex = this.scannedFrozen.indexOf(data);
-                        if (frozenIndex !== -1 && this.scannedFrozenSchemas[frozenIndex].indexOf(schema) !== -1) { return null; }
+                        if (frozenIndex !== -1) {
+                                var frozenSchemaIndex = this.scannedFrozenSchemas[frozenIndex].indexOf(schema);
+                                if (frozenSchemaIndex !== -1) {
+                                        this.errors = this.errors.concat(this.scannedFrozenValidationErrors[frozenIndex][frozenSchemaIndex]);
+                                        return null;
+                                }
+                        }
                 }
                 this.scanned.push(data);
@@ -346 +361 @@
                                 this.scannedFrozenSchemas.push([]);
                         }
-                        this.scannedFrozenSchemas[frozenIndex].push(schema);
+                        scannedFrozenSchemaIndex = this.scannedFrozenSchemas[frozenIndex].length;
+                        this.scannedFrozenSchemas[frozenIndex][scannedFrozenSchemaIndex] = schema;
+                        this.scannedFrozenValidationErrors[frozenIndex][scannedFrozenSchemaIndex] = [];
                 } else {
-                        if (!data[this.key]) {
+                        if (!data[this.validatedSchemasKey]) {
                                 try {
-                                        Object.defineProperty(data, this.key, {
+                                        Object.defineProperty(data, this.validatedSchemasKey, {
+                                                value: [],
+                                                configurable: true
+                                        });
+                                        Object.defineProperty(data, this.validationErrorsKey, {
                                                 value: [],
                                                 configurable: true
@@ -356 +377 @@
                                 } catch (e) {
                                         //IE 7/8 workaround
-                                        data[this.key] = [];
-                                }
-                        }
-                        data[this.key].push(schema);
+                                        data[this.validatedSchemasKey] = [];
+                                        data[this.validationErrorsKey] = [];
+                                }
+                        }
+                        scannedSchemasIndex = data[this.validatedSchemasKey].length;
+                        data[this.validatedSchemasKey][scannedSchemasIndex] = schema;
+                        data[this.validationErrorsKey][scannedSchemasIndex] = [];
                 }
         }
@@ -376 +400 @@
                 while (this.scanned.length) {
                         var item = this.scanned.pop();
-                        delete item[this.key];
+                        delete item[this.validatedSchemasKey];
                 }
                 this.scannedFrozen = [];
@@ -391 +415 @@
                         this.prefixErrors(errorCount, dataPart, schemaPart);
                 }
+        }
+        
+        if (scannedFrozenSchemaIndex !== null) {
+                this.scannedFrozenValidationErrors[frozenIndex][scannedFrozenSchemaIndex] = this.errors.slice(startErrorCount);
+        } else if (scannedSchemasIndex !== null) {
+                data[this.validationErrorsKey][scannedSchemasIndex] = this.errors.slice(startErrorCount);
         }
 
@@ -996 +1026 @@
 }
 function normSchema(schema, baseUri) {
-        if (baseUri === undefined) {
-                baseUri = schema.id;
-        } else if (typeof schema.id === "string") {
-                baseUri = resolveUrl(baseUri, schema.id);
-                schema.id = baseUri;
-        }
-        if (typeof schema === "object") {
+        if (schema && typeof schema === "object") {
+                if (baseUri === undefined) {
+                        baseUri = schema.id;
+                } else if (typeof schema.id === "string") {
+                        baseUri = resolveUrl(baseUri, schema.id);
+                        schema.id = baseUri;
+                }
                 if (Array.isArray(schema)) {
                         for (var i = 0; i < schema.length; i++) {
@@ -1050 +1080 @@
         FORMAT_CUSTOM: 500,
         // Schema structure
-        CIRCULAR_REFERENCE: 500,
+        CIRCULAR_REFERENCE: 600,
         // Non-standard validation options
         UNKNOWN_PROPERTY: 1000
@@ -1091 +1121 @@
 
 function ValidationError(code, message, dataPath, schemaPath, subErrors) {
+        Error.call(this);
         if (code === undefined) {
                 throw new Error ("No code supplied for error: "+ message);
         }
+        this.message = message;
         this.code = code;
-        this.message = message;
         this.dataPath = dataPath || "";
         this.schemaPath = schemaPath || "";
         this.subErrors = subErrors || null;
-}
-ValidationError.prototype = new Error();
+
+        var err = new Error(this.message);
+        this.stack = err.stack || err.stacktrace;
+        if (!this.stack) {
+                try {
+                        throw err;
+                }
+                catch(err) {
+                        this.stack = err.stack || err.stacktrace;
+                }
+        }
+}
+ValidationError.prototype = Object.create(Error.prototype);
+ValidationError.prototype.constructor = ValidationError;
+ValidationError.prototype.name = 'ValidationError';
+
 ValidationError.prototype.prefixWith = function (dataPrefix, schemaPrefix) {
         if (dataPrefix !== null) {
@@ -1265 +1310 @@
 
 })(this);
-
-//@ sourceMappingURL=tv4.js.map