Context Navigation

source: Dev/trunk/node_modules/grunt-tv4/lib/runner.js

Last change on this file was 487, checked in by hendrikvanantwerpen, 11 years ago

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 size: 9.6 KB

Rev	Line
[487]	1	// Bulk validation core: composites with tv4, miniwrite, ministyle and loaders
	2
	3	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	4
	5	function nextTick(call) {
	6	//lame setImmediate shimable
	7	if (typeof setImmediate === 'function') {
	8	setImmediate(call);
	9	}
	10	else if (process && typeof process.nextTick === 'function') {
	11	process.nextTick(call);
	12	}
	13	else {
	14	setTimeout(call, 1);
	15	}
	16	}
	17
	18	// for-each async style
	19	function forAsync(items, iter, callback) {
	20	var keys = Object.keys(items);
	21	var step = function (err, callback) {
	22	nextTick(function () {
	23	if (err) {
	24	return callback(err);
	25	}
	26	if (keys.length === 0) {
	27	return callback();
	28	}
	29	var key = keys.pop();
	30	iter(items[key], key, function (err) {
	31	step(err, callback);
	32	});
	33	});
	34	};
	35	step(null, callback);
	36	}
	37
	38	function copyProps(target, source, recursive) {
	39	if (source) {
	40	Object.keys(source).forEach(function (key) {
	41	if (recursive && typeof source[key] === 'object') {
	42	target[key] = copyProps((Array.isArray(source[key]) ? [] : {}), source[key], recursive);
	43	return;
	44	}
	45	target[key] = source[key];
	46	});
	47	}
	48	return target;
	49	}
	50
	51	function sortLabel(a, b) {
	52	if (a.label < b.label) {
	53	return 1;
	54	}
	55	if (a.label > b.label) {
	56	return -1;
	57	}
	58	// a must be equal to b
	59	return 0;
	60	}
	61
	62	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	63
	64	function isURL(uri) {
	65	return (/^https?:/.test(uri) \|\| /^file:/.test(uri));
	66	}
	67
	68	var headExp = /^(\w+):/;
	69
	70	function getURLProtocol(uri) {
	71	if (isURL(uri)) {
	72	headExp.lastIndex = 0;
	73	var res = headExp.exec(uri);
	74	if ((res && res.length >= 2)) {
	75	return res[1];
	76	}
	77	}
	78	return '<unknown uri protocol>';
	79	}
	80
	81	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	82
	83	function getOptions(merge) {
	84	var options = {
	85	root: null,
	86	schemas: {},
	87	add: [],
	88	formats: {},
	89	fresh: false,
	90	multi: false,
	91	timeout: 5000,
	92	checkRecursive: false,
	93	banUnknown: true,
	94	languages: {},
	95	language: null
	96	};
	97	return copyProps(options, merge);
	98	}
	99
	100	function getRunner(tv4, loader, out, style) {
	101
	102	function getContext(options) {
	103	var context = {};
	104	context.tv4 = (options.fresh ? tv4.freshApi() : tv4);
	105	context.options = {};
	106
	107	//import options
	108	if (options) {
	109	context.options = getOptions(options);
	110	}
	111
	112	if (typeof context.options.root === 'function') {
	113	context.options.root = context.options.root();
	114	}
	115
	116	if (typeof context.options.schemas === 'function') {
	117	context.options.schemas = context.options.schemas();
	118	}
	119
	120	if (typeof context.options.add === 'function') {
	121	context.options.add = context.options.add();
	122	}
	123
	124	// main validation method
	125	context.validate = function (objects, callback) {
	126	// retunr value
	127	var job = {
	128	context: context,
	129	total: objects.length,
	130	objects: objects, //TODO rename objects to values
	131	success: true,
	132	error: null,
	133	passed: [],
	134	failed: []
	135	};
	136
	137	if (job.objects.length === 0) {
	138	job.error = new Error('zero objects selected');
	139	finaliseTask(job.error, job, callback);
	140	return;
	141	}
	142	job.objects.sort(sortLabel);
	143
	144	//start the flow
	145	loadSchemaList(job, job.context.tv4.getMissingUris(), function (err) {
	146	if (err) {
	147	return finaliseTask(err, job, callback);
	148	}
	149	// loop all objects
	150	forAsync(job.objects, function (object, index, callback) {
	151	validateObject(job, object, callback);
	152
	153	}, function (err) {
	154	finaliseTask(err, job, callback);
	155	});
	156	});
	157	};
	158	return context;
	159	}
	160
	161	var repAccent = style.accent('/');
	162	var repProto = style.accent('://');
	163
	164	function tweakURI(str) {
	165	return str.split(/:\/\//).map(function (str) {
	166	return str.replace(/\//g, repAccent);
	167	}).join(repProto);
	168	}
	169
	170	function finaliseTask(err, job, callback) {
	171	job.success = (job.success && !job.error && job.failed.length === 0);
	172	if (job.error) {
	173	out.writeln('');
	174	out.writeln(style.warning('warning: ') + job.error);
	175	out.writeln('');
	176	callback(null, job);
	177	return;
	178	}
	179	if (err) {
	180	out.writeln('');
	181	out.writeln(style.error('error: ') + err);
	182	out.writeln('');
	183	callback(err, job);
	184	return;
	185	}
	186	out.writeln('');
	187	callback(null, job);
	188	}
	189
	190	//load and add batch of schema by uri, repeat until all missing are solved
	191	function loadSchemaList(job, uris, callback) {
	192	uris = uris.filter(function (value) {
	193	return !!value;
	194	});
	195
	196	if (uris.length === 0) {
	197	nextTick(function () {
	198	callback();
	199	});
	200	return;
	201	}
	202
	203	var sweep = function () {
	204	if (uris.length === 0) {
	205	nextTick(callback);
	206	return;
	207	}
	208	forAsync(uris, function (uri, i, callback) {
	209	if (!uri) {
	210	out.writeln('> ' + style.error('cannot load') + ' "' + tweakURI(uri) + '"');
	211	callback();
	212	}
	213	out.writeln('> ' + style.accent('load') + ' + ' + tweakURI(uri));
	214
	215	loader.load(uri, job.context.options, function (err, schema) {
	216	if (err) {
	217	return callback(err);
	218	}
	219	job.context.tv4.addSchema(uri, schema);
	220	uris = job.context.tv4.getMissingUris();
	221	callback();
	222	});
	223	}, function (err) {
	224	if (err) {
	225	job.error = err;
	226	return callback(null);
	227	}
	228	// sweep again
	229	sweep();
	230	});
	231	};
	232	sweep();
	233	}
	234
	235	//supports automatic lazy loading
	236	function recursiveTest(job, object, callback) {
	237	var opts = job.context.options;
	238	if (job.context.options.multi) {
	239	object.result = job.context.tv4.validateMultiple(object.value, object.schema, opts.checkRecursive, opts.banUnknown);
	240	}
	241	else {
	242	object.result = job.context.tv4.validateResult(object.value, object.schema, opts.checkRecursive, opts.banUnknown);
	243	}
	244
	245	//TODO verify reportOnMissing
	246	if (!object.result.valid) {
	247	job.failed.push(object);
	248	out.writeln('> ' + style.error('fail') + ' - ' + tweakURI(object.label));
	249	return callback();
	250	}
	251	if (object.result.missing.length === 0) {
	252	job.passed.push(object);
	253	out.writeln('> ' + style.success('pass') + ' \| ' + tweakURI(object.label));
	254	return callback();
	255	}
	256
	257	// test for bad fragment pointer fall-through
	258	if (!object.result.missing.every(function (value) {
	259	return (value !== '');
	260	})) {
	261	job.failed.push(object);
	262	out.writeln('> ' + style.error('empty missing-schema url detected') + ' (this likely casued by a bad fragment pointer)');
	263	return callback();
	264	}
	265
	266	out.writeln('> ' + style.accent('auto') + ' ! validation missing ' + object.result.missing.length + ' urls:');
	267	out.writeln('> "' + object.result.missing.join('"\n> "') + '"');
	268
	269	// auto load missing (if loading has an error we'll bail way back)
	270	loadSchemaList(job, object.result.missing, function (err) {
	271	if (err) {
	272	return callback(err);
	273	}
	274	//check again
	275	recursiveTest(job, object, callback);
	276	});
	277	}
	278
	279	function startLoading(job, object, callback) {
	280	//pre fetch (saves a validation round)
	281	loadSchemaList(job, job.context.tv4.getMissingUris(), function (err) {
	282	if (err) {
	283	return callback(err);
	284	}
	285	recursiveTest(job, object, callback);
	286	});
	287	}
	288
	289	//validate single object
	290	function validateObject(job, object, callback) {
	291	if (typeof object.value === 'undefined') {
	292	var onLoad = function (err, obj) {
	293	if (err) {
	294	job.error = err;
	295	return callback(err);
	296	}
	297	object.value = obj;
	298	doValidateObject(job, object, callback);
	299	};
	300	var opts = {
	301	timeout: (job.context.options.timeout \|\| 5000)
	302	};
	303	//TODO verify http:, file: and plain paths all load properly
	304	if (object.path) {
	305	loader.loadPath(object.path, opts, onLoad);
	306	}
	307	else if (object.url) {
	308	loader.load(object.url, opts, onLoad);
	309	}
	310	else {
	311	callback(new Error('object missing value, path or url'));
	312	}
	313	}
	314	else {
	315	doValidateObject(job, object, callback);
	316	}
	317	}
	318
	319	function doValidateObject(job, object, callback) {
	320	if (!object.root) {
	321	//out.writeln(style.warn('no explicit root schema'));
	322	//out.writeln('');
	323	//TODO handle this better
	324	job.error = new Error('no explicit root schema');
	325	callback(job);
	326	return;
	327	}
	328	var t = typeof object.root;
	329
	330	switch (t) {
	331	case 'object':
	332	if (!Array.isArray(object.root)) {
	333	object.schema = object.root;
	334	job.context.tv4.addSchema((object.schema.id \|\| ''), object.schema);
	335
	336	startLoading(job, object, callback);
	337	}
	338	return;
	339	case 'string':
	340	//known from previous sessions?
	341	var schema = job.context.tv4.getSchema(object.root);
	342	if (schema) {
	343	out.writeln('> ' + style.plain('have') + ' : ' + tweakURI(object.root));
	344	object.schema = schema;
	345
	346	recursiveTest(job, object, callback);
	347	return;
	348	}
	349	out.writeln('> ' + style.accent('root') + ' > ' + tweakURI(object.root));
	350
	351	loader.load(object.root, job.context.options, function (err, schema) {
	352	if (err) {
	353	job.error = err;
	354	return callback(job.error);
	355	}
	356	if (!schema) {
	357	job.error = new Error('no schema loaded from: ' + object.root);
	358	return callback(job.error);
	359	}
	360
	361	object.schema = schema;
	362	job.context.tv4.addSchema(object.root, schema);
	363
	364	if (object.schema.id) {
	365	job.context.tv4.addSchema(object.schema);
	366	}
	367	startLoading(job, object, callback);
	368	});
	369	return;
	370	default:
	371	callback(new Error('don\'t know how to load: ' + object.root));
	372	return;
	373	}
	374	}
	375
	376	return {
	377	isURL: isURL,
	378	getURLProtocol: getURLProtocol,
	379	getOptions: getOptions,
	380	getContext: getContext
	381	};
	382	}
	383
	384	module.exports = {
	385	getRunner: getRunner
	386	};

Note: See TracBrowser for help on using the repository browser.

Download in other formats: