blob: 135b0ee74d2144614639f14c18f8a13d374940c2 [file] [log] [blame]
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// -----------------------------------------------------------------------------
// NOTE: If you change this file you need to touch
// extension_renderer_resources.grd to have your change take effect.
// -----------------------------------------------------------------------------
//==============================================================================
// This file contains a class that implements a subset of JSON Schema.
// See: http://www.json.com/json-schema-proposal/ for more details.
//
// The following features of JSON Schema are not implemented:
// - requires
// - unique
// - disallow
// - union types (but replaced with 'choices')
//
// The following properties are not applicable to the interface exposed by
// this class:
// - options
// - readonly
// - title
// - description
// - format
// - default
// - transient
// - hidden
//
// There are also these departures from the JSON Schema proposal:
// - function and undefined types are supported
// - null counts as 'unspecified' for optional values
// - added the 'choices' property, to allow specifying a list of possible types
// for a value
// - by default an "object" typed schema does not allow additional properties.
// if present, "additionalProperties" is to be a schema against which all
// additional properties will be validated.
//==============================================================================
var loadTypeSchema = require('utils').loadTypeSchema;
var CHECK = requireNative('logging').CHECK;
function isInstanceOfClass(instance, className) {
while ((instance = instance.__proto__)) {
if (instance.constructor.name == className)
return true;
}
return false;
}
function isOptionalValue(value) {
return typeof(value) === 'undefined' || value === null;
}
function enumToString(enumValue) {
if (enumValue.name === undefined)
return enumValue;
return enumValue.name;
}
/**
* Validates an instance against a schema and accumulates errors. Usage:
*
* var validator = new JSONSchemaValidator();
* validator.validate(inst, schema);
* if (validator.errors.length == 0)
* console.log("Valid!");
* else
* console.log(validator.errors);
*
* The errors property contains a list of objects. Each object has two
* properties: "path" and "message". The "path" property contains the path to
* the key that had the problem, and the "message" property contains a sentence
* describing the error.
*/
function JSONSchemaValidator() {
this.errors = [];
this.types = [];
}
JSONSchemaValidator.messages = {
invalidEnum: "Value must be one of: [*].",
propertyRequired: "Property is required.",
unexpectedProperty: "Unexpected property.",
arrayMinItems: "Array must have at least * items.",
arrayMaxItems: "Array must not have more than * items.",
itemRequired: "Item is required.",
stringMinLength: "String must be at least * characters long.",
stringMaxLength: "String must not be more than * characters long.",
stringPattern: "String must match the pattern: *.",
numberFiniteNotNan: "Value must not be *.",
numberMinValue: "Value must not be less than *.",
numberMaxValue: "Value must not be greater than *.",
numberIntValue: "Value must fit in a 32-bit signed integer.",
numberMaxDecimal: "Value must not have more than * decimal places.",
invalidType: "Expected '*' but got '*'.",
invalidTypeIntegerNumber:
"Expected 'integer' but got 'number', consider using Math.round().",
invalidChoice: "Value does not match any valid type choices.",
invalidPropertyType: "Missing property type.",
schemaRequired: "Schema value required.",
unknownSchemaReference: "Unknown schema reference: *.",
notInstance: "Object must be an instance of *."
};
/**
* Builds an error message. Key is the property in the |errors| object, and
* |opt_replacements| is an array of values to replace "*" characters with.
*/
JSONSchemaValidator.formatError = function(key, opt_replacements) {
var message = this.messages[key];
if (opt_replacements) {
for (var i = 0; i < opt_replacements.length; i++) {
message = message.replace("*", opt_replacements[i]);
}
}
return message;
};
/**
* Classifies a value as one of the JSON schema primitive types. Note that we
* don't explicitly disallow 'function', because we want to allow functions in
* the input values.
*/
JSONSchemaValidator.getType = function(value) {
var s = typeof value;
if (s == "object") {
if (value === null) {
return "null";
} else if (Object.prototype.toString.call(value) == "[object Array]") {
return "array";
} else if (Object.prototype.toString.call(value) ==
"[object ArrayBuffer]") {
return "binary";
}
} else if (s == "number") {
if (value % 1 == 0) {
return "integer";
}
}
return s;
};
/**
* Add types that may be referenced by validated schemas that reference them
* with "$ref": <typeId>. Each type must be a valid schema and define an
* "id" property.
*/
JSONSchemaValidator.prototype.addTypes = function(typeOrTypeList) {
function addType(validator, type) {
if (!type.id)
throw new Error("Attempt to addType with missing 'id' property");
validator.types[type.id] = type;
}
if (typeOrTypeList instanceof Array) {
for (var i = 0; i < typeOrTypeList.length; i++) {
addType(this, typeOrTypeList[i]);
}
} else {
addType(this, typeOrTypeList);
}
}
/**
* Returns a list of strings of the types that this schema accepts.
*/
JSONSchemaValidator.prototype.getAllTypesForSchema = function(schema) {
var schemaTypes = [];
if (schema.type)
$Array.push(schemaTypes, schema.type);
if (schema.choices) {
for (var i = 0; i < schema.choices.length; i++) {
var choiceTypes = this.getAllTypesForSchema(schema.choices[i]);
schemaTypes = $Array.concat(schemaTypes, choiceTypes);
}
}
var ref = schema['$ref'];
if (ref) {
var type = this.getOrAddType(ref);
CHECK(type, 'Could not find type ' + ref);
schemaTypes = $Array.concat(schemaTypes, this.getAllTypesForSchema(type));
}
return schemaTypes;
};
JSONSchemaValidator.prototype.getOrAddType = function(typeName) {
if (!this.types[typeName])
this.types[typeName] = loadTypeSchema(typeName);
return this.types[typeName];
};
/**
* Returns true if |schema| would accept an argument of type |type|.
*/
JSONSchemaValidator.prototype.isValidSchemaType = function(type, schema) {
if (type == 'any')
return true;
// TODO(kalman): I don't understand this code. How can type be "null"?
if (schema.optional && (type == "null" || type == "undefined"))
return true;
var schemaTypes = this.getAllTypesForSchema(schema);
for (var i = 0; i < schemaTypes.length; i++) {
if (schemaTypes[i] == "any" || type == schemaTypes[i] ||
(type == "integer" && schemaTypes[i] == "number"))
return true;
}
return false;
};
/**
* Returns true if there is a non-null argument that both |schema1| and
* |schema2| would accept.
*/
JSONSchemaValidator.prototype.checkSchemaOverlap = function(schema1, schema2) {
var schema1Types = this.getAllTypesForSchema(schema1);
for (var i = 0; i < schema1Types.length; i++) {
if (this.isValidSchemaType(schema1Types[i], schema2))
return true;
}
return false;
};
/**
* Validates an instance against a schema. The instance can be any JavaScript
* value and will be validated recursively. When this method returns, the
* |errors| property will contain a list of errors, if any.
*/
JSONSchemaValidator.prototype.validate = function(instance, schema, opt_path) {
var path = opt_path || "";
if (!schema) {
this.addError(path, "schemaRequired");
return;
}
// If this schema defines itself as reference type, save it in this.types.
if (schema.id)
this.types[schema.id] = schema;
// If the schema has an extends property, the instance must validate against
// that schema too.
if (schema.extends)
this.validate(instance, schema.extends, path);
// If the schema has a $ref property, the instance must validate against
// that schema too. It must be present in this.types to be referenced.
var ref = schema["$ref"];
if (ref) {
if (!this.getOrAddType(ref))
this.addError(path, "unknownSchemaReference", [ ref ]);
else
this.validate(instance, this.getOrAddType(ref), path)
}
// If the schema has a choices property, the instance must validate against at
// least one of the items in that array.
if (schema.choices) {
this.validateChoices(instance, schema, path);
return;
}
// If the schema has an enum property, the instance must be one of those
// values.
if (schema.enum) {
if (!this.validateEnum(instance, schema, path))
return;
}
if (schema.type && schema.type != "any") {
if (!this.validateType(instance, schema, path))
return;
// Type-specific validation.
switch (schema.type) {
case "object":
this.validateObject(instance, schema, path);
break;
case "array":
this.validateArray(instance, schema, path);
break;
case "string":
this.validateString(instance, schema, path);
break;
case "number":
case "integer":
this.validateNumber(instance, schema, path);
break;
}
}
};
/**
* Validates an instance against a choices schema. The instance must match at
* least one of the provided choices.
*/
JSONSchemaValidator.prototype.validateChoices =
function(instance, schema, path) {
var originalErrors = this.errors;
for (var i = 0; i < schema.choices.length; i++) {
this.errors = [];
this.validate(instance, schema.choices[i], path);
if (this.errors.length == 0) {
this.errors = originalErrors;
return;
}
}
this.errors = originalErrors;
this.addError(path, "invalidChoice");
};
/**
* Validates an instance against a schema with an enum type. Populates the
* |errors| property, and returns a boolean indicating whether the instance
* validates.
*/
JSONSchemaValidator.prototype.validateEnum = function(instance, schema, path) {
for (var i = 0; i < schema.enum.length; i++) {
if (instance === enumToString(schema.enum[i]))
return true;
}
this.addError(path, "invalidEnum",
[schema.enum.map(enumToString).join(", ")]);
return false;
};
/**
* Validates an instance against an object schema and populates the errors
* property.
*/
JSONSchemaValidator.prototype.validateObject =
function(instance, schema, path) {
if (schema.properties) {
for (var prop in schema.properties) {
// It is common in JavaScript to add properties to Object.prototype. This
// check prevents such additions from being interpreted as required
// schema properties.
// TODO(aa): If it ever turns out that we actually want this to work,
// there are other checks we could put here, like requiring that schema
// properties be objects that have a 'type' property.
if (!$Object.hasOwnProperty(schema.properties, prop))
continue;
var propPath = path ? path + "." + prop : prop;
if (schema.properties[prop] == undefined) {
this.addError(propPath, "invalidPropertyType");
} else if (prop in instance && !isOptionalValue(instance[prop])) {
this.validate(instance[prop], schema.properties[prop], propPath);
} else if (!schema.properties[prop].optional) {
this.addError(propPath, "propertyRequired");
}
}
}
// If "instanceof" property is set, check that this object inherits from
// the specified constructor (function).
if (schema.isInstanceOf) {
if (!isInstanceOfClass(instance, schema.isInstanceOf))
this.addError(propPath, "notInstance", [schema.isInstanceOf]);
}
// Exit early from additional property check if "type":"any" is defined.
if (schema.additionalProperties &&
schema.additionalProperties.type &&
schema.additionalProperties.type == "any") {
return;
}
// By default, additional properties are not allowed on instance objects. This
// can be overridden by setting the additionalProperties property to a schema
// which any additional properties must validate against.
for (var prop in instance) {
if (schema.properties && prop in schema.properties)
continue;
// Any properties inherited through the prototype are ignored.
if (!$Object.hasOwnProperty(instance, prop))
continue;
var propPath = path ? path + "." + prop : prop;
if (schema.additionalProperties)
this.validate(instance[prop], schema.additionalProperties, propPath);
else
this.addError(propPath, "unexpectedProperty");
}
};
/**
* Validates an instance against an array schema and populates the errors
* property.
*/
JSONSchemaValidator.prototype.validateArray = function(instance, schema, path) {
var typeOfItems = JSONSchemaValidator.getType(schema.items);
if (typeOfItems == 'object') {
if (schema.minItems && instance.length < schema.minItems) {
this.addError(path, "arrayMinItems", [schema.minItems]);
}
if (typeof schema.maxItems != "undefined" &&
instance.length > schema.maxItems) {
this.addError(path, "arrayMaxItems", [schema.maxItems]);
}
// If the items property is a single schema, each item in the array must
// have that schema.
for (var i = 0; i < instance.length; i++) {
this.validate(instance[i], schema.items, path + "." + i);
}
} else if (typeOfItems == 'array') {
// If the items property is an array of schemas, each item in the array must
// validate against the corresponding schema.
for (var i = 0; i < schema.items.length; i++) {
var itemPath = path ? path + "." + i : String(i);
if (i in instance && !isOptionalValue(instance[i])) {
this.validate(instance[i], schema.items[i], itemPath);
} else if (!schema.items[i].optional) {
this.addError(itemPath, "itemRequired");
}
}
if (schema.additionalProperties) {
for (var i = schema.items.length; i < instance.length; i++) {
var itemPath = path ? path + "." + i : String(i);
this.validate(instance[i], schema.additionalProperties, itemPath);
}
} else {
if (instance.length > schema.items.length) {
this.addError(path, "arrayMaxItems", [schema.items.length]);
}
}
}
};
/**
* Validates a string and populates the errors property.
*/
JSONSchemaValidator.prototype.validateString =
function(instance, schema, path) {
if (schema.minLength && instance.length < schema.minLength)
this.addError(path, "stringMinLength", [schema.minLength]);
if (schema.maxLength && instance.length > schema.maxLength)
this.addError(path, "stringMaxLength", [schema.maxLength]);
if (schema.pattern && !schema.pattern.test(instance))
this.addError(path, "stringPattern", [schema.pattern]);
};
/**
* Validates a number and populates the errors property. The instance is
* assumed to be a number.
*/
JSONSchemaValidator.prototype.validateNumber =
function(instance, schema, path) {
// Forbid NaN, +Infinity, and -Infinity. Our APIs don't use them, and
// JSON serialization encodes them as 'null'. Re-evaluate supporting
// them if we add an API that could reasonably take them as a parameter.
if (isNaN(instance) ||
instance == Number.POSITIVE_INFINITY ||
instance == Number.NEGATIVE_INFINITY )
this.addError(path, "numberFiniteNotNan", [instance]);
if (schema.minimum !== undefined && instance < schema.minimum)
this.addError(path, "numberMinValue", [schema.minimum]);
if (schema.maximum !== undefined && instance > schema.maximum)
this.addError(path, "numberMaxValue", [schema.maximum]);
// Check for integer values outside of -2^31..2^31-1.
if (schema.type === "integer" && (instance | 0) !== instance)
this.addError(path, "numberIntValue", []);
if (schema.maxDecimal && instance * Math.pow(10, schema.maxDecimal) % 1)
this.addError(path, "numberMaxDecimal", [schema.maxDecimal]);
};
/**
* Validates the primitive type of an instance and populates the errors
* property. Returns true if the instance validates, false otherwise.
*/
JSONSchemaValidator.prototype.validateType = function(instance, schema, path) {
var actualType = JSONSchemaValidator.getType(instance);
if (schema.type == actualType ||
(schema.type == "number" && actualType == "integer")) {
return true;
} else if (schema.type == "integer" && actualType == "number") {
this.addError(path, "invalidTypeIntegerNumber");
return false;
} else {
this.addError(path, "invalidType", [schema.type, actualType]);
return false;
}
};
/**
* Adds an error message. |key| is an index into the |messages| object.
* |replacements| is an array of values to replace '*' characters in the
* message.
*/
JSONSchemaValidator.prototype.addError = function(path, key, replacements) {
$Array.push(this.errors, {
path: path,
message: JSONSchemaValidator.formatError(key, replacements)
});
};
/**
* Resets errors to an empty list so you can call 'validate' again.
*/
JSONSchemaValidator.prototype.resetErrors = function() {
this.errors = [];
};
exports.$set('JSONSchemaValidator', JSONSchemaValidator);