refactor: MissingRefError class, closes #348

lib/ajv.js

@@ -30,7 +30,9 @@ Ajv.prototype._addSchema = _addSchema;
 Ajv.prototype._compile = _compile;
 
 
-Ajv.ValidationError = require('./compile/validation_error');
+var errorClasses = require('./compile/error_classes');
+Ajv.ValidationError = errorClasses.Validation;
+Ajv.MissingRefError = errorClasses.MissingRef;
 
 var META_SCHEMA_ID = 'http://json-schema.org/draft-04/schema';
 var SCHEMA_URI_FORMAT = /^(?:(?:[a-z][a-z0-9+-.]*:)?\/\/)?[^\s]*$/i;

lib/compile/async.js

@@ -1,5 +1,7 @@
 'use strict';
 
+var MissingRefError = require('./error_classes').MissingRef;
+
 module.exports = compileAsync;
 
 
@@ -51,8 +53,8 @@ function compileAsync(schema, meta, callback) {
   function _compileAsync(schemaObj) {
     try { return self._compile(schemaObj); }
     catch(e) {
-      if (!e.missingSchema) throw e;
-      return loadMissingSchema(e);
+      if (e instanceof MissingRefError) return loadMissingSchema(e);
+      throw e;
     }
 
 

lib/compile/error_classes.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var resolve = require('./resolve');
+
+module.exports = {
+  Validation: errorSubclass(ValidationError),
+  MissingRef: errorSubclass(MissingRefError)
+};
+
+
+function ValidationError(errors) {
+  this.message = 'validation failed';
+  this.errors = errors;
+  this.ajv = this.validation = true;
+}
+
+
+MissingRefError.message = function (baseId, ref) {
+  return 'can\'t resolve reference ' + ref + ' from id ' + baseId;
+};
+
+
+function MissingRefError(baseId, ref, message) {
+  this.message = message || MissingRefError.message(baseId, ref);
+  this.missingRef = resolve.url(baseId, ref);
+  this.missingSchema = resolve.normalizeId(resolve.fullPath(this.missingRef));
+}
+
+
+function errorSubclass(Subclass) {
+  Subclass.prototype = Object.create(Error.prototype);
+  Subclass.prototype.constructor = Subclass;
+  return Subclass;
+}

lib/compile/index.js

@@ -2,6 +2,7 @@
 
 var resolve = require('./resolve')
   , util = require('./util')
+  , errorClasses = require('./error_classes')
   , stableStringify = require('json-stable-stringify')
   , async = require('../async');
 
@@ -25,7 +26,7 @@ var ucs2length = util.ucs2length;
 var equal = require('./equal');
 
 // this error is thrown by async schemas to return validation errors via exception
-var ValidationError = require('./validation_error');
+var ValidationError = errorClasses.Validation;
 
 module.exports = compile;
 
@@ -103,6 +104,7 @@ function compile(schema, root, localRefs, baseId) {
       schemaPath: '',
       errSchemaPath: '#',
       errorPath: '""',
+      MissingRefError: errorClasses.MissingRef,
       RULES: RULES,
       validate: validateGenerator,
       util: util,

lib/compile/validation_error.js

@@ -1,14 +0,0 @@
-'use strict';
-
-module.exports = ValidationError;
-
-
-function ValidationError(errors) {
-  this.message = 'validation failed';
-  this.errors = errors;
-  this.ajv = this.validation = true;
-}
-
-
-ValidationError.prototype = Object.create(Error.prototype);
-ValidationError.prototype.constructor = ValidationError;

lib/dot/ref.jst

@@ -25,7 +25,7 @@
 {{??}}
   {{ var $refVal = it.resolveRef(it.baseId, $schema, it.isRoot); }}
   {{? $refVal === undefined }}
-    {{ var $message = 'can\'t resolve reference ' + $schema + ' from id ' + it.baseId; }}
+    {{ var $message = it.MissingRefError.message(it.baseId, $schema); }}
     {{? it.opts.missingRefs == 'fail' }}
       {{ console.error($message); }}
       {{# def.error:'$ref' }}
@@ -34,12 +34,7 @@
       {{ console.warn($message); }}
       {{? $breakOnError }} if (true) { {{?}}
     {{??}}
-      {{
-        var $error = new Error($message);
-        $error.missingRef = it.resolve.url(it.baseId, $schema);
-        $error.missingSchema = it.resolve.normalizeId(it.resolve.fullPath($error.missingRef));
-        throw $error;
-      }}
+      {{ throw new it.MissingRefError(it.baseId, $schema, $message); }}
     {{?}}
   {{?? $refVal.inline }}
     {{# def.setupNextLevel }}