Source: string.js

  1. 'use strict';
  3. var assert = require('assert');
  4. var util = require('util');
  6. var ut = require('utjs');
  8. var Type = require('./Type');
  10. /**
  11.  * Generates a schema object that matches a string data type.
  12.  *
  13.  * @constructor
  14.  * @extends Type
  15.  */
  16. function StringType() {
  17.   StringType.super_.call(this);
  18. }
  20. util.inherits(StringType, Type);
  22. /**
  23.  * Specifies the minimum number string characters.
  24.  * @param  {Number} limit The minimum number of string characters required.
  25.  * @return {StringType} The class reference so multiple calls can be chained.
  26.  */
  27. StringType.prototype.min = function (limit) {
  28.   assert(ut.isInteger(limit) && limit >= 0, 'limit must be a positive integer');
  30.   this._rules.min = limit;
  31.   return this;
  32. };
  34. /**
  35.  * Specifies the maximum number string characters.
  36.  * @param  {Number} limit The maximum number of string characters required.
  37.  * @return {StringType} The class reference so multiple calls can be chained.
  38.  */
  39. StringType.prototype.max = function (limit) {
  40.   assert(ut.isInteger(limit) && limit >= 0, 'limit must be a positive integer');
  42.   this._rules.max = limit;
  43.   return this;
  44. };
  46. /**
  47.  * Specifies the exact string length required.
  48.  * @param  {Number} limit the required string length.
  49.  * @return {StringType} The class reference so multiple calls can be chained.
  50.  */
  51. StringType.prototype.length = function (limit) {
  52.   assert(ut.isInteger(limit) && limit >= 0, 'limit must be a positive integer');
  54.   this._rules.length = limit;
  55.   return this;
  56. };
  58. /**
  59.  * Defines a regular expression rule.
  60.  * @param  {RegExp} pattern a regular expression object the string value must match against.
  61.  * @return {StringType} The class reference so multiple calls can be chained.
  62.  */
  63. StringType.prototype.regex = function (pattern) {
  64.   assert(ut.isRegExp(pattern), 'pattern must be a RegExp instance');
  66.   this._rules.regex = pattern;
  67.   return this;
  68. };
  70. /**
  71.  * Requires the string value to be in valid ISO 8601 date format.
  72.  * @return {StringType} The class reference so multiple calls can be chained.
  73.  */
  74. StringType.prototype.isoDate = function () {
  75.   this._rules.isoDate = true;
  76.   return this;
  77. };
  79. StringType.prototype._validate = function (value) {
  80.   var rules = this._rules;
  82.   if (typeof value !== 'string') {
  83.     return !rules.required && value === undefined;
  84.   }
  86.   var min = rules.min;
  87.   var max = rules.max;
  88.   var length = rules.length;
  89.   var regex = rules.regex;
  90.   var isoDate = rules.isoDate;
  92.   var valueLength = value.length;
  94.   if (min !== undefined && valueLength < min ||
  95.       max !== undefined && valueLength > max) {
  96.     return false;
  97.   }
  99.   if (length !== undefined && valueLength !== length) {
  100.     return false;
  101.   }
  103.   if (regex !== undefined && !regex.test(value)) {
  104.     return false;
  105.   }
  107.   if (isoDate && !ut.isDateString(value)) {
  108.     return false;
  109.   }
  111.   return rules.forbidden ? false : true;
  112. };
  114. /**
  115.  * Creates and returns a StringType object.
  116.  * @return {StringType} The StringType object.
  117.  * @global
  118.  * @alias string
  119.  */
  120. module.exports = function string() {
  121.   return new StringType();
  122. };