[Summary view] [Print] [Text view]

   1  /**

   2   * validate.js

   3   *

   4   * Copyright 2009, Moxiecode Systems AB

   5   * Released under LGPL License.

   6   *

   7   * License: http://tinymce.moxiecode.com/license

   8   * Contributing: http://tinymce.moxiecode.com/contributing

   9   */
  10  
  11  /**

  12      // String validation:

  13  

  14      if (!Validator.isEmail('myemail'))

  15          alert('Invalid email.');

  16  

  17      // Form validation:

  18  

  19      var f = document.forms['myform'];

  20  

  21      if (!Validator.isEmail(f.myemail))

  22          alert('Invalid email.');

  23  */
  24  
  25  var Validator = {
  26      isEmail : function(s) {
  27          return this.test(s, '^[-!#$%&\'*+\\./0-9=?A-Z^_`a-z{|}~]+@[-!#$%&\'*+\\/0-9=?A-Z^_`a-z{|}~]+\.[-!#$%&\'*+\\./0-9=?A-Z^_`a-z{|}~]+$');
  28      },
  29  
  30      isAbsUrl : function(s) {
  31          return this.test(s, '^(news|telnet|nttp|file|http|ftp|https)://[-A-Za-z0-9\\.]+\\/?.*$');
  32      },
  33  
  34      isSize : function(s) {
  35          return this.test(s, '^[0-9.]+(%|in|cm|mm|em|ex|pt|pc|px)?$');
  36      },
  37  
  38      isId : function(s) {
  39          return this.test(s, '^[A-Za-z_]([A-Za-z0-9_])*$');
  40      },
  41  
  42      isEmpty : function(s) {
  43          var nl, i;
  44  
  45          if (s.nodeName == 'SELECT' && s.selectedIndex < 1)
  46              return true;
  47  
  48          if (s.type == 'checkbox' && !s.checked)
  49              return true;
  50  
  51          if (s.type == 'radio') {
  52              for (i=0, nl = s.form.elements; i<nl.length; i++) {
  53                  if (nl[i].type == "radio" && nl[i].name == s.name && nl[i].checked)
  54                      return false;
  55              }
  56  
  57              return true;
  58          }
  59  
  60          return new RegExp('^\\s*$').test(s.nodeType == 1 ? s.value : s);
  61      },
  62  
  63      isNumber : function(s, d) {
  64          return !isNaN(s.nodeType == 1 ? s.value : s) && (!d || !this.test(s, '^-?[0-9]*\\.[0-9]*$'));
  65      },
  66  
  67      test : function(s, p) {
  68          s = s.nodeType == 1 ? s.value : s;
  69  
  70          return s == '' || new RegExp(p).test(s);
  71      }
  72  };
  73  
  74  var AutoValidator = {
  75      settings : {
  76          id_cls : 'id',
  77          int_cls : 'int',
  78          url_cls : 'url',
  79          number_cls : 'number',
  80          email_cls : 'email',
  81          size_cls : 'size',
  82          required_cls : 'required',
  83          invalid_cls : 'invalid',
  84          min_cls : 'min',
  85          max_cls : 'max'
  86      },
  87  
  88      init : function(s) {
  89          var n;
  90  
  91          for (n in s)
  92              this.settings[n] = s[n];
  93      },
  94  
  95      validate : function(f) {
  96          var i, nl, s = this.settings, c = 0;
  97  
  98          nl = this.tags(f, 'label');
  99          for (i=0; i<nl.length; i++) {
 100              this.removeClass(nl[i], s.invalid_cls);
 101              nl[i].setAttribute('aria-invalid', false);
 102          }
 103  
 104          c += this.validateElms(f, 'input');
 105          c += this.validateElms(f, 'select');
 106          c += this.validateElms(f, 'textarea');
 107  
 108          return c == 3;
 109      },
 110  
 111      invalidate : function(n) {
 112          this.mark(n.form, n);
 113      },
 114      
 115      getErrorMessages : function(f) {
 116          var nl, i, s = this.settings, field, msg, values, messages = [], ed = tinyMCEPopup.editor;
 117          nl = this.tags(f, "label");
 118          for (i=0; i<nl.length; i++) {
 119              if (this.hasClass(nl[i], s.invalid_cls)) {
 120                  field = document.getElementById(nl[i].getAttribute("for"));
 121                  values = { field: nl[i].textContent };
 122                  if (this.hasClass(field, s.min_cls, true)) {
 123                      message = ed.getLang('invalid_data_min');
 124                      values.min = this.getNum(field, s.min_cls);
 125                  } else if (this.hasClass(field, s.number_cls)) {
 126                      message = ed.getLang('invalid_data_number');
 127                  } else if (this.hasClass(field, s.size_cls)) {
 128                      message = ed.getLang('invalid_data_size');
 129                  } else {
 130                      message = ed.getLang('invalid_data');
 131                  }
 132                  
 133                  message = message.replace(/{\#([^}]+)\}/g, function(a, b) {
 134                      return values[b] || '{#' + b + '}';
 135                  });
 136                  messages.push(message);
 137              }
 138          }
 139          return messages;
 140      },
 141  
 142      reset : function(e) {
 143          var t = ['label', 'input', 'select', 'textarea'];
 144          var i, j, nl, s = this.settings;
 145  
 146          if (e == null)
 147              return;
 148  
 149          for (i=0; i<t.length; i++) {
 150              nl = this.tags(e.form ? e.form : e, t[i]);
 151              for (j=0; j<nl.length; j++) {
 152                  this.removeClass(nl[j], s.invalid_cls);
 153                  nl[j].setAttribute('aria-invalid', false);
 154              }
 155          }
 156      },
 157  
 158      validateElms : function(f, e) {
 159          var nl, i, n, s = this.settings, st = true, va = Validator, v;
 160  
 161          nl = this.tags(f, e);
 162          for (i=0; i<nl.length; i++) {
 163              n = nl[i];
 164  
 165              this.removeClass(n, s.invalid_cls);
 166  
 167              if (this.hasClass(n, s.required_cls) && va.isEmpty(n))
 168                  st = this.mark(f, n);
 169  
 170              if (this.hasClass(n, s.number_cls) && !va.isNumber(n))
 171                  st = this.mark(f, n);
 172  
 173              if (this.hasClass(n, s.int_cls) && !va.isNumber(n, true))
 174                  st = this.mark(f, n);
 175  
 176              if (this.hasClass(n, s.url_cls) && !va.isAbsUrl(n))
 177                  st = this.mark(f, n);
 178  
 179              if (this.hasClass(n, s.email_cls) && !va.isEmail(n))
 180                  st = this.mark(f, n);
 181  
 182              if (this.hasClass(n, s.size_cls) && !va.isSize(n))
 183                  st = this.mark(f, n);
 184  
 185              if (this.hasClass(n, s.id_cls) && !va.isId(n))
 186                  st = this.mark(f, n);
 187  
 188              if (this.hasClass(n, s.min_cls, true)) {
 189                  v = this.getNum(n, s.min_cls);
 190  
 191                  if (isNaN(v) || parseInt(n.value) < parseInt(v))
 192                      st = this.mark(f, n);
 193              }
 194  
 195              if (this.hasClass(n, s.max_cls, true)) {
 196                  v = this.getNum(n, s.max_cls);
 197  
 198                  if (isNaN(v) || parseInt(n.value) > parseInt(v))
 199                      st = this.mark(f, n);
 200              }
 201          }
 202  
 203          return st;
 204      },
 205  
 206      hasClass : function(n, c, d) {
 207          return new RegExp('\\b' + c + (d ? '[0-9]+' : '') + '\\b', 'g').test(n.className);
 208      },
 209  
 210      getNum : function(n, c) {
 211          c = n.className.match(new RegExp('\\b' + c + '([0-9]+)\\b', 'g'))[0];
 212          c = c.replace(/[^0-9]/g, '');
 213  
 214          return c;
 215      },
 216  
 217      addClass : function(n, c, b) {
 218          var o = this.removeClass(n, c);
 219          n.className = b ? c + (o != '' ? (' ' + o) : '') : (o != '' ? (o + ' ') : '') + c;
 220      },
 221  
 222      removeClass : function(n, c) {
 223          c = n.className.replace(new RegExp("(^|\\s+)" + c + "(\\s+|$)"), ' ');
 224          return n.className = c != ' ' ? c : '';
 225      },
 226  
 227      tags : function(f, s) {
 228          return f.getElementsByTagName(s);
 229      },
 230  
 231      mark : function(f, n) {
 232          var s = this.settings;
 233  
 234          this.addClass(n, s.invalid_cls);
 235          n.setAttribute('aria-invalid', 'true');
 236          this.markLabels(f, n, s.invalid_cls);
 237  
 238          return false;
 239      },
 240  
 241      markLabels : function(f, n, ic) {
 242          var nl, i;
 243  
 244          nl = this.tags(f, "label");
 245          for (i=0; i<nl.length; i++) {
 246              if (nl[i].getAttribute("for") == n.id || nl[i].htmlFor == n.id)
 247                  this.addClass(nl[i], ic);
 248          }
 249  
 250          return null;
 251      }
 252  };