refactor: only create definition when keyword is used

Author: epoberezkin

keywords/instanceof.js

@@ -1,7 +1,5 @@
 'use strict';
 
-module.exports = defFunc;
-
 var CONSTRUCTORS = {
   Object: Object,
   Array: Array,
@@ -12,44 +10,44 @@ var CONSTRUCTORS = {
   RegExp: RegExp
 };
 
-/* istanbul ignore else */
-if (typeof Buffer != 'undefined')
-  CONSTRUCTORS.Buffer = Buffer;
+module.exports = function defFunc(ajv) {
+  /* istanbul ignore else */
+  if (typeof Buffer != 'undefined')
+    CONSTRUCTORS.Buffer = Buffer;
+
+  defFunc.definition = {
+    compile: function (schema) {
+      if (typeof schema == 'string') {
+        var Constructor = getConstructor(schema);
+        return function (data) {
+          return data instanceof Constructor;
+        };
+      }
 
-var definition = defFunc.definition = {
-  compile: function (schema) {
-    if (typeof schema == 'string') {
-      var Constructor = getConstructor(schema);
+      var constructors = schema.map(getConstructor);
       return function (data) {
-        return data instanceof Constructor;
+        for (var i=0; i<constructors.length; i++)
+          if (data instanceof constructors[i]) return true;
+        return false;
       };
+    },
+    CONSTRUCTORS: CONSTRUCTORS,
+    metaSchema: {
+      anyOf: [
+        { type: 'string' },
+        {
+          type: 'array',
+          items: { type: 'string' }
+        }
+      ]
     }
+  };
 
-    var constructors = schema.map(getConstructor);
-    return function (data) {
-      for (var i=0; i<constructors.length; i++)
-        if (data instanceof constructors[i]) return true;
-      return false;
-    };
-  },
-  CONSTRUCTORS: CONSTRUCTORS,
-  metaSchema: {
-    anyOf: [
-      { type: 'string' },
-      {
-        type: 'array',
-        items: { type: 'string' }
-      }
-    ]
+  ajv.addKeyword('instanceof', defFunc.definition);
+
+  function getConstructor(c) {
+    var Constructor = CONSTRUCTORS[c];
+    if (Constructor) return Constructor;
+    throw new Error('invalid "instanceof" keyword value ' + c);
   }
 };
-
-function defFunc(ajv) {
-  ajv.addKeyword('instanceof', definition);
-}
-
-function getConstructor(c) {
-  var Constructor = CONSTRUCTORS[c];
-  if (Constructor) return Constructor;
-  throw new Error('invalid "instanceof" keyword value');
-}

keywords/propertyNames.js

@@ -1,7 +1,7 @@
 'use strict';
 
-module.exports = function (ajv) {
-  ajv.addKeyword('propertyNames', {
+module.exports = function defFunc(ajv) {
+  defFunc.definition = {
     type: 'object',
     compile: function(schema) {
       var validate = ajv.compile(schema);
@@ -44,5 +44,7 @@ module.exports = function (ajv) {
             : 'http://json-schema.org/draft-04/schema#'
     },
     errors: true
-  });
+  };
+
+  ajv.addKeyword('propertyNames', defFunc.definition);
 };

keywords/range.js

@@ -1,40 +1,38 @@
 'use strict';
 
-module.exports = defFunc;
+module.exports = function defFunc(ajv) {
+  defFunc.definition = {
+    type: 'number',
+    macro: function (schema, parentSchema) {
+      var min = schema[0]
+        , max = schema[1]
+        , exclusive = parentSchema.exclusiveRange;
 
-var definition = defFunc.definition = {
-  type: 'number',
-  macro: function (schema, parentSchema) {
-    var min = schema[0]
-      , max = schema[1]
-      , exclusive = parentSchema.exclusiveRange;
+      validateRangeSchema(min, max, exclusive);
 
-    validateRangeSchema(min, max, exclusive);
+      return {
+        minimum: min,
+        exclusiveMinimum: exclusive,
+        maximum: max,
+        exclusiveMaximum: exclusive
+      };
+    },
+    metaSchema: {
+      type: 'array',
+      minItems: 2,
+      maxItems: 2,
+      items: { type: 'number' }
+    }
+  };
 
-    return {
-      minimum: min,
-      exclusiveMinimum: exclusive,
-      maximum: max,
-      exclusiveMaximum: exclusive
-    };
-  },
-  metaSchema: {
-    type: 'array',
-    minItems: 2,
-    maxItems: 2,
-    items: { type: 'number' }
-  }
-};
-
-function defFunc(ajv) {
-  ajv.addKeyword('range', definition);
+  ajv.addKeyword('range', defFunc.definition);
   ajv.addKeyword('exclusiveRange');
-}
 
-function validateRangeSchema(min, max, exclusive) {
-  if (exclusive !== undefined && typeof exclusive != 'boolean')
-    throw new Error('Invalid schema for exclusiveRange keyword, should be boolean');
+  function validateRangeSchema(min, max, exclusive) {
+    if (exclusive !== undefined && typeof exclusive != 'boolean')
+      throw new Error('Invalid schema for exclusiveRange keyword, should be boolean');
 
-  if (min > max || (exclusive && min == max))
-    throw new Error('There are no numbers in range');
-}
+    if (min > max || (exclusive && min == max))
+      throw new Error('There are no numbers in range');
+  }
+};

keywords/regexp.js

@@ -1,7 +1,7 @@
 'use strict';
 
-module.exports = function (ajv) {
-  ajv.addKeyword('regexp', {
+module.exports = function defFunc(ajv) {
+  defFunc.definition = {
     type: 'string',
     inline: function (it, keyword, schema) {
       return getRegExp() + '.test(data' + (it.dataLevel || '') + ')';
@@ -29,5 +29,7 @@ module.exports = function (ajv) {
       required: ['pattern'],
       additionalProperties: false
     }
-  });
+  };
+
+  ajv.addKeyword('regexp', defFunc.definition);
 };

keywords/typeof.js

@@ -1,33 +1,31 @@
 'use strict';
 
-module.exports = defFunc;
-
 var KNOWN_TYPES = ['undefined', 'string', 'number', 'object', 'function', 'boolean', 'symbol'];
 
-var definition = defFunc.definition = {
-  inline: function (it, keyword, schema) {
-    var data = 'data' + (it.dataLevel || '');
-    if (typeof schema == 'string') return 'typeof ' + data + ' == "' + schema + '"';
-    schema = 'validate.schema' + it.schemaPath + '.' + keyword;
-    return schema + '.indexOf(typeof ' + data + ') >= 0';
-  },
-  metaSchema: {
-    anyOf: [
-      {
-        type: 'string',
-        enum: KNOWN_TYPES
-      },
-      {
-        type: 'array',
-        items: {
+module.exports = function defFunc(ajv) {
+  defFunc.definition = {
+    inline: function (it, keyword, schema) {
+      var data = 'data' + (it.dataLevel || '');
+      if (typeof schema == 'string') return 'typeof ' + data + ' == "' + schema + '"';
+      schema = 'validate.schema' + it.schemaPath + '.' + keyword;
+      return schema + '.indexOf(typeof ' + data + ') >= 0';
+    },
+    metaSchema: {
+      anyOf: [
+        {
           type: 'string',
           enum: KNOWN_TYPES
+        },
+        {
+          type: 'array',
+          items: {
+            type: 'string',
+            enum: KNOWN_TYPES
+          }
         }
-      }
-    ]
-  }
-};
+      ]
+    }
+  };
 
-function defFunc(ajv) {
-  ajv.addKeyword('typeof', definition);
-}
+  ajv.addKeyword('typeof', defFunc.definition);
+};