valibot 0.2.5

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Kenichi Nakamura
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,250 @@
+Valibot!
+========
+
+Automatic field validation for forms backed by DataMapper models through Sinatra.
+
+What it requires:
+-----------------
+
+* [Datamapper](http://datamapper.org/)
+* [Sinatra](http://sinatrarb.com/)
+* [Rack](http://rack.rubyforge.org/)
+* [jQuery](http://jquery.com/)
+
+What it provides:
+-----------------
+
+* full automatic field validation on default bind events
+* field value matching confirmation
+* extensible through callbacks used to build, place, remove, or transform error tags
+* Valibot#all method to do the whole thing at once.
+* automatic 'onsubmit' binding
+
+To use (brief):
+-------
+
+* add this gem to your Gemfile, bundle install
+* add the javascript to your site
+* add the app to your config.ru (defaults to '/_valibot')
+* create Valibots for the models on forms where you need them
+
+To use (details):
+-----------------
+
+####to add the javascript to your site, there are two methods:
+
+Valibot has a route at '/valibot.js' that will deliver the source. This is the *preferred* method:
+
+    <script src="/_valibot/valibot.js"></script>
+
+Valibot *can* add a helper to Sinatra::Base called 'valibot_js'. call this in a script template like so:
+
+    <%= valibot_js %>
+
+They deliver the exact same content, but the route adds Cache-Control headers so layers like Varnish or Rack::Cache can do their work. In order to use the helper, you need to register it in your app:
+
+    class App < Sinatra::Base
+      register Valibot::Helpers
+      get('/'){ erb "<script><%= valibot_js %></script>" }
+    end
+
+####the sinatra app needs a place to run at in your Rack config. something like the following should suffice:
+
+    map '/_valibot' do
+      run Valibot::App
+    end
+
+note that you can change the path it runs at, but you must pass that path as a value to the Valibot javascript constructor using the key `pathPrefix` (see below).
+
+####to create the Valibots, call the constructor inside $(document).ready():
+
+    $(document).ready(function(){ new Valibot({ modelName: 'user' }); });
+
+Constructor options:
+--------------------
+
+####modelName : string *required if no `modelNames`*
+name of the model to validate against, in snake_case. in modern Rack-based webapps, the convention for form field names is to follow a `model_name[field_name]` pattern. Rack translates these names into the params hash and it is very common for the controller to pass this hash to a model constructor like `ModelName.new params['model_name']`.  your form should follow this convention for Valibot to work, as it will use jQuery to select all `input`, `textarea`, and `select` tags from the DOM that have names that start with this value. ex:
+
+    <input type="text" name="user[first_name]"/>
+    <input type="text" name="user[email]"/>
+    ...
+    new Valibot({ modelName: 'user' });
+
+---
+
+####modelNames : array of strings *required if no `modelName`*
+names of the models to validate against, in snake_case. this behaves exactly like `modelName` but allows multiple models to be validated in the same form.  ex:
+
+    <input type="text" name="user[first_name]"/>
+    <input type="text" name="profile[bio]"/>
+    ...
+    new Valibot({ modelNames: ['user', 'profile'] });
+
+note that the first invalid field of the _first model specified_ will be `focus()`ed if the form fails validation on submit.
+
+---
+
+####pathPrefix : string
+path you have Valibot racked up at. ex:
+
+    new Valibot({ modelName: 'user', pathPrefix: 'dogs_and_cats' });
+
+---
+
+####errorTagBuilder : function(text, self, minion)
+a callback for building the tag you want to put in the DOM and show the user with the error message from DataMapper in it. the default builder will create an `<em>` element, set its class to 'error', innerHTML `text` in, and return it.
+######parameters:
+* `text` - error message from DataMapper
+* `self` - reference to the Valibot object
+* `minion` - reference to the Valitron or Confirm-o-mat object
+######returns:
+* an element with the `text` in it suitable for placing in to the DOM.
+
+---
+
+####errorTagPlacer : function(tag, errorTag, self, minion)
+a callback for placing the element returned from the builder into the DOM.
+######parameters:
+* `tag` - the field element whose value is being validated
+* `errorTag` - the element built and returned by the `errorTagBuilder` function of this Valibot
+* `self` - reference to the Valibot object
+* `minion` - reference to the Valitron or Confirm-o-mat object
+
+---
+
+####errorTagRemover : function(errorTag, self, minion)
+a callback for removing the element from the DOM in the event of no error found.
+######parameters:
+* `errorTag` - the element in the DOM that holds the error message for this field
+* `self` - reference to the Valibot object
+* `minion` - reference to the Valitron or Confirm-o-mat object
+
+---
+
+####errorTagTransformer : function(text, errorTag, self, minion)
+a callback for transforming the element in the DOM in the event of a new error message replacing an old one.
+######parameters:
+* `text` - error message from DataMapper
+* `errorTag` - the element in the DOM that holds the error message for this field
+* `self` - reference to the Valibot object
+* `minion` - reference to the Valitron or Confirm-o-mat object
+
+---
+
+####include : array or map { modelName : array }
+by default, Valibot will attach Valitrons to elements whose name attribute matches a specific regular expression, after jQuery selection. you can force fields whose name attributes don't match the regex to be checked by Valibot by putting the field name in this array. i'm not actually sure when this would be needed. :)
+
+---
+
+####exclude : array or map { modelName : array }
+you can keep Valibot from attaching Valitrons to certain elements by putting their field names in this
+array. ex:
+
+    new Valibot({ modelName: 'user', exclude: ['middle_name'] });
+    
+    new Valibot({ modelNames: ['user', 'profile'], exclude: {'user': ['middle_name'], 'profile': ['icon']});
+
+---
+
+####bindEvents : map { fieldName : event }
+Valibot has a fairly intuitive default bind event for each input type: `change` for checkboxes, radio buttons, and select drop-downs; `blur` for everything else. you can override these defaults on a per-field basis by passing them in this hash. ex:
+
+    new Valibot({ modelName: 'user', bindEvents: {'middle_name':'keyup'} });
+
+---
+
+####context : string
+DataMapper has contextual validations built-in. if you need to validate against a certain context, pass it in here.  ex:
+
+    new Valibot({ modelName: 'user', context: 'signup' });
+
+---
+
+####confirm : array of maps { id : things }
+often on a form, one will have an 'extra' field that is not part of the data model, but needs to match another field in value. usually, these are passwords or email addresses. in this case, if you have given the actual model field element an id of 'password', the confirmation field id should be 'confirm_password'. then you can tell Valibot about this by passing this array of hashes and it will attach a Confirm-o-mat to each. `things` is the word that the Confirm-o-mat will use in its error message about the things not matching. ex:
+
+    new Valibot({ modelName: 'user', confirm: [{'password', 'Passwords'}] });
+
+this would attach a Confirm-o-mat to `$('#confirm_password')` that checks its value against `$('#password').val()` and will build an errorTag with the text, "Passwords do not match."
+
+---
+
+####agreements : array of maps { id : things }
+often on a form, one will have a checkbox that is not part of the data model, but needs to checked as a legally binding agreement. usually, these are rules or term and conditions, etc. in this case, simply give the input a unique id. then you can tell Valibot about it by passing this array of hashes and it will attach an Agree-Pee-Oh to each. `things` is the word that the Agree-Pee-Oh will use in its error message about the things not being agreed to. ex:
+
+    new Valibot({ modelName: 'user', agreements: [{'rules', 'Rules'}] });
+
+this would attach an Agree-Pee-Oh to `$('#rules')` that verified it's checked and will build an errorTag with the text, "You must agree to the Rules." if it is not.
+
+---
+
+####fancy : boolean
+Valibot has two built-in types of errorTag(Placer|Remover|Transformer) functions. the default is very bland and simply inserts, replaces, or removes the errorTag element. the fancy option uses jQuery animation to fadeIn and fadeOut the errorTag element. if this is `true`, and you also feed it your own errorTag callbacks, those will be used instead. ex:
+
+    new Valibot({ modelName: 'user', fancy: true, errorTagPlacer: myETPlacer });
+
+this would utilize the "fancy" Remover and Transformer built-in functions, but call `myETPlacer()` for placement.  note that the `_fancyErrorTagTransformer` function actually calls whatever Placer function is set in the containing Valibot; in this case, `myETPlacer`.
+
+---
+
+####bindOnSubmit : boolean
+Valibot automatically binds it's own `onSubmit()` function to the first form that it finds model fields in. this function will run through any unchecked or invalid 'trons or 'mats and call their `checkValue()` functions. once that is complete, if all of them are valid, it submits the form; otherwise, error messages are built/placed like normal, and the first invalid field is focus()ed. this flag allows you to turn off this functionality, for cases where you need to do your own onsubmit dance. note that the Valibot's onsubmit can be called in this situation anyway; but, be careful because it will submit the form if everything is valid. ex:
+
+    var valibot = new Valibot({ modelName: 'user', bindOnSubmit: false });
+    $(valibot.form).bind('submit', function(event) {
+      event.preventDefault();
+
+      // do something clever
+
+      valibot.onSubmit();
+    });
+
+---
+
+####submitForm : boolean
+sometimes, you just want to submit the form yourself.  most of the time, you want to do it all AJAX fancypants.  fine, just pass this in as `false` and Valibot won't try to submit the form.  it will still call `onSubmitCallback` so you probably want to put your XHRs in there.
+
+---
+
+####onSubmitCallback : function(valibot)
+set this to a function you want to run when the form would be submitted.  if you set `submitForm` to false, this function will be called, but the form WILL NOT be submitted.  use these two together to get Valibot validation on forms you want to submit XHR-style. ex:
+
+    var valibot = new Valibot({ modelName: 'foo', submitForm: false, onSubmitCallback: function(valibot) {
+      $.post(valibot.form.action, $(valibot.form).serialize(), function(response){ /* ... /* });
+    }});
+
+---
+
+####appUrl : string
+perhaps you want to run Valibot at a different URL completely from the one that the form your validating loaded from.  fine, just tell Valibot about it with this.  note that this puts Valibot into JSONP mode and all validation requests turn from POSTs into GETs. ex:
+
+    new Valibot({ modelName: 'user', appUrl: 'http://some.other.domain/'});
+
+this would cause all validation requests to go to 'http://some.other.domain/_valibot/:model/...'
+
+---
+
+####dependents : map of arrays { field : [ otherField, ... ] }
+sometimes you need to validate a field based off of the value of another field.  you can tell Valibot about this with this option, and it will automatically include the value(s) of the other field(s) in the validation. ex:
+
+    new Valibot({ modelName: 'user', dependents: {'last_name': ['first_name']} });
+
+this would cause Valibot to POST the value of the field named 'user[first_name]' with the check request for 'last_name'. your model should be configured to validate `last_name` based off of the value of `first_name`:
+
+    validates_with_block :last_name do
+      if self.first_name == 'a' and self.last_name == 'b'
+        [false, "can't have b with a."]
+      else
+        true
+      end
+    end
+
+note that in the above example, `first_name` would still be validated on it's own.
+
+Next Steps (TODOS):
+-------------------
+
+* automated testing (!!)
+* array parameters
+* profit!

data/js/valibot.js

@@ -0,0 +1,503 @@
+/* valibot.js (c) 2011 kenichi nakamura (kenichi.nakamura@gmail.com)
+ *
+ * javascript class for easy automatic form field validation against datamapper
+ * models behind a sinatra app.
+ *
+ * see ____ for details.  TODO
+ */
+
+//  regex to make sure we only grab fields whose 'name' attrs match
+var _valibotFieldRegExp = new RegExp('^\\w+\\[[^\\]]+\\]$');
+
+if (Array.prototype.indexOf == null) {
+  Array.prototype.indexOf = function(obj) {
+    for (var i = 0; i < this.length; i++) {
+      if (this[i] == obj) {
+        return i;
+      }
+    }
+    return -1;
+  };
+}
+Array.prototype.contains = function(obj){ return this.indexOf(obj) != -1; };
+
+/* the Valibot class. create an object of this class and feed it a model name. oh,
+ * and options too if you want. the object, during construction, will attach
+ * Valitrons (see below) to each field it finds that matches the modelName specified.
+ * it will also attach Confirmomats (see below) to any field specified as a
+ * confirmation field.
+ */
+function Valibot(opts) {
+
+  this.pathPrefix =          '_valibot';
+  this.modelNames =          [];
+  this.errorTagPlacer =      this._defaultErrorTagPlacer;
+  this.errorTagBuilder =     this._defaultErrorTagBuilder;
+  this.errorTagRemover =     this._defaultErrorTagRemover;
+  this.errorTagTransformer = this._defaultErrorTagTransformer;
+  this.include =             {};
+  this.exclude =             {};
+  this.bindEvents =          {};
+  this.context =             null;
+  this.confirm =             [];
+  this.confirmomats =        [];
+  this.valitrons =           [];
+  this.valids =              [];
+  this.invalids =            [];
+  this.bindOnSubmit =        true;
+  this.submitForm =          true;
+  this.onSubmitCallback =    null;
+  this.agreements =          [];
+  this.agreepeeohs =         [];
+  this.formId =              '';
+  this.appUrl =              null;
+  this.dependents =          {};
+
+  if (opts != null) {
+    if (opts.fancy != null && opts.fancy) {
+      this.errorTagPlacer =      this._fancyErrorTagPlacer;
+      this.errorTagRemover =     this._fancyErrorTagRemover;
+      this.errorTagTransformer = this._fancyErrorTagTransformer;
+    }
+    if (opts.modelName != null)             this.modelNames =          [opts.modelName];
+    if (opts.modelNames != null)            this.modelNames =          opts.modelNames;
+    if (opts.pathPrefix != null)            this.pathPrefix =          opts.pathPrefix;
+    if (opts.errorTagPlacer != null)        this.errorTagPlacer =      opts.errorTagPlacer;
+    if (opts.errorTagBuilder != null)       this.errorTagBuilder =     opts.errorTagBuilder;
+    if (opts.errorTagRemover != null)       this.errorTagRemover =     opts.errorTagRemover;
+    if (opts.errorTagTransformer != null)   this.errorTagTransformer = opts.errorTagTransformer;
+    if (opts.bindEvents != null)            this.bindEvents =          opts.bindEvents;
+    if (opts.context != null)               this.context =             opts.context;
+    if (opts.confirm != null)               this.confirm =             opts.confirm;
+    if (opts.bindOnSubmit != null)          this.bindOnSubmit =        opts.bindOnSubmit;
+    if (opts.submitForm != null)            this.submitForm =          opts.submitForm;
+    if (opts.onSubmitCallback != null)      this.onSubmitCallback =    opts.onSubmitCallback;
+    if (opts.agreements != null)            this.agreements =          opts.agreements;
+    if (opts.formId != null)                this.formId =              '#' + opts.formId + ' ';
+    if (opts.appUrl != null)                this.appUrl =              opts.appUrl;
+    if (opts.dependents != null)            this.dependents =          opts.dependents;
+
+    if (opts.include != null) {
+      if (opts.include instanceof Array) {
+        this.include[this.modelNames[0]] = opts.include;
+      } else {
+        this.include = opts.include;
+      }
+    }
+    if (opts.exclude != null) {
+      if (opts.exclude instanceof Array) {
+        this.exclude[this.modelNames[0]] = opts.exclude;
+      } else {
+        this.exclude = opts.exclude;
+      }
+    }
+     
+  }
+
+  var _this = this;
+  $(this.modelNames).each(function(i, modelName) {
+    $(_this.formId + 'input[name^=' +    modelName + '], ' +
+      _this.formId + 'select[name^=' +   modelName + '], ' +
+      _this.formId + 'textarea[name^=' + modelName + ']').each(function(i,f) {
+
+      var _name = $(f).attr('name');
+      var field = _name.substring(_name.indexOf('[') + 1, _name.length - 1);
+
+      var _type = f.type.toLowerCase();
+      var _defaultBindEvent = 'blur';
+      if (_type == 'checkbox' || _type == 'radio' || _type == 'select-one' || _type == 'select-multiple')
+        _defaultBindEvent = 'change';
+
+      var bindEvent = (_this.bindEvents[field] != null) ? _this.bindEvents[field] : _defaultBindEvent;
+
+      if (_this.include[modelName] instanceof Array && _this.include[modelName].indexOf(field) != -1) {
+        _this.valitrons.push(new Valitron(f, modelName, field, bindEvent, _this));
+      } else if (_this.exclude[modelName] instanceof Array && _this.exclude[modelName].indexOf(field) != -1) {
+        // NOOP
+      } else {
+        if (_valibotFieldRegExp.test(f.name))
+          _this.valitrons.push(new Valitron(f, modelName, field, bindEvent, _this));
+      }
+
+    });
+  });
+
+  if (this.confirm != null && this.confirm.length > 0) {
+    $(this.confirm).each(function(i,c) {
+      $.each(c, function(id, things) { _this.confirmomats.push(new Confirmomat(id, things, _this)); });
+    });
+  }
+
+  if (this.agreements != null && this.agreements.length > 0) {
+    $(this.agreements).each(function(i,c) {
+      $.each(c, function(id, things) { _this.agreepeeohs.push(new AgreePeeOh(id, things, _this)); });
+    });
+  }
+
+  this.form = this.valitrons.concat(this.confirmomats).concat(this.agreepeeohs)[0].tag.form;
+  if (this.bindOnSubmit)
+    $(this.form).submit(function(e){ e.preventDefault(); _this.onSubmit(); });
+
+}
+
+Valibot.prototype = {
+
+  addValid:
+    function(good) {
+      if (!this.valids.contains(good))  this.valids.push(good);
+      if (this.invalids.contains(good)) this.invalids.splice(this.invalids.indexOf(good), 1);
+    },
+
+  removeValid:
+    function(remove) {
+      if (this.valids.contains(remove)) this.valids.splice(this.valids.indexOf(remove), 1);
+    },
+
+  addInvalid:
+    function(bad) {
+      if (!this.invalids.contains(bad)) this.invalids.push(bad);
+      this.removeValid(bad);
+    },
+
+  unchecked:
+    function() {
+      var uc = [];
+      var _this = this;
+      $(this.valitrons).each(function(i,tron){ if (!_this.valids.contains(tron) && !_this.invalids.contains(tron)) uc.push(tron); });
+      $(this.confirmomats).each(function(i,mat){ if (!_this.valids.contains(mat) && !_this.invalids.contains(mat)) uc.push(mat); });
+      $(this.agreepeeohs).each(function(i,oh){ if (!_this.valids.contains(oh) && !_this.invalids.contains(oh)) uc.push(oh); });
+      return uc;
+    },
+
+  allValid:
+    function() {
+      return this.invalids.length == 0 &&
+        this.valids.length == this.valitrons.length + this.confirmomats.length + this.agreepeeohs.length;
+    },
+
+  onSubmit:
+    function() {
+      if (!this.allValid()) {
+        this.checking = this.invalids.concat(this.unchecked());
+        var _this = this;
+        $(this.invalids).each(function(i, bad){ bad.checkValue(null, function(valid) { _this.onSubmitCheckCallback(bad); }); });
+        $(this.unchecked()).each(function(i, uc){ uc.checkValue(null, function(valid) { _this.onSubmitCheckCallback(uc); }); });
+      } else {
+        if (this.submitForm) {
+          this.form.submit();
+        } else if (typeof this.onSubmitCallback === 'function') {
+          this.onSubmitCallback(this);
+        }
+      }
+    },
+
+  onSubmitCheckCallback:
+    function(tronOrMat, valid) {
+      this.checking.splice(this.checking.indexOf(tronOrMat), 1);
+      if (this.checking.length == 0) {
+        if (!this.allValid()) {
+          this.invalids[0].tag.focus();
+        } else {
+          if (this.submitForm) {
+            this.form.submit();
+          } else if (typeof this.onSubmitCallback === 'function') {
+            this.onSubmitCallback(this);
+          }
+        }
+      }
+    },
+
+  // never called by Valibot or its minions, but left here for utility.
+  all:
+    function(callback) {
+      var params = {};
+      $(this.valitrons).each(function(i, tron){ params[tron.tag.name] = tron.tag.value; });
+      var path = (this.appUrl != null ? this.appUrl : '') +
+                 '/' + this.pathPrefix +
+                 '/' + this.modelName +
+                 (this.context != null ? ('/in/' + this.context) : '');
+      if (this.context != null)
+        path = path + '/in/' + this.context;
+      $.post(path, params, function(res){ callback(res) },
+             this.valibot.appUrl != null ? 'jsonp' : 'json');
+    },
+
+  _defaultErrorTagPlacer:
+    function(tag, errorTag, self, minion) {
+      $(errorTag).insertAfter($(tag));
+    },
+
+  _defaultErrorTagBuilder:
+    function(text, self, minion) {
+      var em = document.createElement('em');
+      em.className = 'error';
+      em.innerHTML = text;
+      return em;
+    },
+
+  _defaultErrorTagRemover:
+    function(errorTag, self, callback, minion) {
+      var ret = $(errorTag).remove();
+      if (callback != null) callback(ret);
+    },
+
+  _defaultErrorTagTransformer:
+    function(text, errorTag, self, minion) {
+      var em = this.errorTagBuilder(text, self, minion);
+      $(errorTag).replaceWith(em);
+      return em;
+    },
+
+  _fancyErrorTagPlacer:
+    function(tag, errorTag, self, minion) {
+      $(errorTag).css('display', 'none');
+      $(errorTag).insertAfter($(tag));
+      $(errorTag).fadeIn();
+    },
+
+  _fancyErrorTagRemover:
+    function(errorTag, self, minion) {
+      $(errorTag).fadeOut(null, null, function(){ $(errorTag).remove(); });
+    },
+
+  _fancyErrorTagTransformer:
+    function(text, errorTag, self, minion) {
+      if (text == errorTag.innerHTML) {
+        return errorTag;
+      } else {
+        var newErrorTag = self.errorTagBuilder(text, self, minion);
+        $(errorTag).fadeOut(null, null, function() {
+          var tag = $(errorTag).prev();
+          $(errorTag).remove();
+          self.errorTagPlacer(tag, newErrorTag);
+        });
+        return newErrorTag;
+      }
+    }
+
+};
+
+// ---
+
+/* the Valitron class. instantiated on each model form field by an overseeing
+ * Valibot. handles the actual XHR between the JS and the valibot sinatra app.
+ */
+function Valitron(tag, model, field, bindEvent, valibot) {
+  this.valid = false;
+  this.tag = tag;
+  this.model = model;
+  this.field = field;
+  this.valibot = valibot;
+  this.errorTag = null;
+  var _this = this;
+  $(this.tag).bind(bindEvent, function(event){ _this.checkValue(event); });
+  $(this.tag).bind('keyup', function(event){ _this.reset(); });
+}
+
+Valitron.prototype = {
+
+  checkValue:
+    function(event, callback) {
+      var _this = this;
+      var path = (this.valibot.appUrl != null ? this.valibot.appUrl : '') +
+                 '/' + this.valibot.pathPrefix +
+                 '/' + this.model +
+                 '/' + this.field +
+                 (this.valibot.context != null ? ('/in/' + this.valibot.context) : '');
+      var val = this.tag.value;
+      if (this.tag.type.toLowerCase() == 'checkbox') val = this.tag.checked;
+      var params = {value: val};
+      if (this.valibot.dependents[this.field]) {
+        $(this.valibot.dependents[this.field]).each(function(i,dep) {
+          params[_this.model + '[' + dep + ']'] =
+            $('input[name="' + _this.model + '[' + dep + ']"], ' +
+              'select[name="' + _this.model + '[' + dep + ']"], ' +
+              'textarea[name="' + _this.model + '[' + dep + ']"]').val();
+        });
+      }
+      $.post(path, params, function(res){ _this.handleResponse(res, callback); },
+             this.valibot.appUrl != null ? 'jsonp' : 'json');
+    },
+
+  handleResponse:
+    function(res, callback) {
+
+      // bad state -> good state
+      if (res == null && this.errorTag != null) {
+        var _this = this;
+        this.valibot.errorTagRemover(this.errorTag, this.valibot, function(ret){ _this.errorTag = null; }, this);
+        this.valibot.addValid(this);
+        if (callback != null) callback(true);
+        this.valid = true;
+
+      // null state -> good state
+      } else if (res == null && this.errorTag == null) {
+        this.valibot.addValid(this);
+        if (callback != null) callback(true);
+        this.valid = true;
+
+      // bad state -> bad state
+      } else if (res != null && res.error != null && this.errorTag != null) {
+        this.errorTag = this.valibot.errorTagTransformer(this.parseErrorStrings(res.error), this.errorTag, this.valibot, this);
+        this.valibot.addInvalid(this);
+        if (callback != null) callback(false);
+        this.valid = false;
+
+      // null state -> bad state
+      } else if (res != null && res.error != null && this.errorTag == null) {
+        this.errorTag = this.valibot.errorTagBuilder(this.parseErrorStrings(res.error), this.valibot, this);
+        this.valibot.errorTagPlacer(this.tag, this.errorTag, this.valibot, this);
+        this.valibot.addInvalid(this);
+        if (callback != null) callback(false);
+        this.valid = false;
+      }
+    },
+
+  parseErrorStrings:
+    function(error) {
+      var es = '';
+      $(error).each(function(i, e) { es += e + '<br/>' });
+      return es.substring(0, es.length - 5); // remove last <br/>
+    },
+
+  reset:
+    function() {
+      this.valibot.removeValid(this);
+      this.valid = false;
+    }
+
+};
+
+// ---
+
+/* the Confirm-o-mat class. instantiated on form fields that are specified as
+ * needing to match another field by an overseeing Valibot. handles the test
+ * for equal values between fields.
+ */
+function Confirmomat(id, things, valibot) {
+  if ($('#' + id).length == 1 && $('#confirm_' + id).length == 1) {
+    this.valid = false;
+    this.tag = $('#confirm_' + id)[0];
+    this.id = id;
+    this.things = things;
+    this.valibot = valibot;
+    this.errorTag = null;
+    var _this = this;
+    $(this.tag).bind('blur', function(event){ _this.checkValue(event); });
+    $(this.tag).bind('keyup', function(event){ _this.reset(); });
+    $('#' + this.id).bind('keyup', function(event){ _this.reset(); });
+  } else {
+    // console.log('ERROR: matching fields not found or too many found.');
+    return null;
+  }
+}
+
+Confirmomat.prototype = {
+
+  checkValue:
+    function(event, callback) {
+      if ($('#' + this.id).val() == $(this.tag).val()) {
+
+        // bad state -> good state
+        if (this.errorTag != null) {
+          var _this = this;
+          this.valibot.errorTagRemover(this.errorTag, this.valibot, function(ret){ _this.errorTag = null; }, this);
+        }
+
+        // * state -> good state
+        this.valibot.addValid(this);
+        if (callback != null) callback(true);
+        this.valid = true;
+
+      } else {
+
+        // bad state -> bad state
+        if (this.errorTag != null) {
+          this.valibot.errorTagTransformer(this.things + " do not match.", this.errorTag, this.valibot, this);
+
+        // null state -> bad state
+        } else {
+          this.errorTag = this.valibot.errorTagBuilder(this.things + " do not match.", this.valibot, this);
+          this.valibot.errorTagPlacer(this.tag, this.errorTag, this.valibot, this);
+        }
+
+        // * state -> bad state
+        this.valibot.addInvalid(this);
+        if (callback != null) callback(false);
+        this.valid = false;
+
+      }
+    },
+
+  reset:
+    function() {
+      // console.log('confirmomat resetting.');
+      this.valibot.removeValid(this);
+      this.valid = false;
+    }
+
+};
+
+// ---
+
+/* the AgreePeeOh class. instantiated on checkboxes that are specified as
+ * needing to be checked for form submission to be allowed.
+ */
+function AgreePeeOh(id, things, valibot) {
+  if ($('#' + id).length == 1) {
+    this.valid = false;
+    this.id = id;
+    this.tag = $('#' + id)[0];
+    this.things = things;
+    this.valibot = valibot;
+    this.errorTag = null;
+    var _this = this;
+    $(this.tag).bind('change', function(event){ _this.checkValue(event); });
+  } else {
+    return null;
+  }
+}
+
+AgreePeeOh.prototype = {
+
+  checkValue:
+    function(event, callback) {
+      if ($('#' + this.id).attr('checked')) {
+
+        // bad state -> good state
+        if (this.errorTag != null) {
+          var _this = this;
+          this.valibot.errorTagRemover(this.errorTag, this.valibot, function(ret){ _this.errorTag = null; }, this);
+        }
+
+        // * state -> good state
+        this.valibot.addValid(this);
+        if (callback != null) callback(true);
+        this.valid = true;
+
+      } else {
+
+        // bad state -> bad state
+        if (this.errorTag != null) {
+          this.valibot.errorTagTransformer("You must agree to the " + this.things + ".", this.errorTag, this.valibot, this);
+
+        // null state -> bad state
+        } else {
+          this.errorTag = this.valibot.errorTagBuilder("You must agree to the " + this.things + ".", this.valibot, this);
+          this.valibot.errorTagPlacer(this.tag, this.errorTag, this.valibot, this);
+        }
+
+        // * state -> bad state
+        this.valibot.addInvalid(this);
+        if (callback != null) callback(false);
+        this.valid = false;
+
+      }
+    },
+
+  reset:
+    function() {
+      this.valibot.removeValid(this);
+      this.valid = false;
+    }
+};

data/lib/valibot.rb

@@ -0,0 +1,117 @@
+# valibot.rb (c) 2011 kenichi nakamura (kenichi.nakamura@gmail.com)
+# 
+# easy automatic form field validation against datamapper models behind a sinatra app.
+# this is the helper module and Sinatra app class.
+# 
+# see ____ for details.  TODO
+ 
+module Valibot
+
+  JAVASCRIPT = File.join File.dirname(__FILE__), '..', 'js', 'valibot.js'
+
+  module Helpers
+
+    def self.registered app; app.helpers Valibot::Helpers; end
+    def valibot_js; File.read Valibot::JAVASCRIPT; end
+
+  end
+
+  class App < Sinatra::Base
+
+    before do
+      set_content_type
+    end
+
+    get '/valibot.js' do
+      content_type :js
+      cache_control :public, :max_age => 10 * 60
+      File.read Valibot::JAVASCRIPT
+    end
+
+    post '/:model/:field/in/:context' do
+      validate_field_value *parse(params)
+    end
+
+    post '/:model/in/:context' do
+      validate_model *parse(params)
+    end
+
+    post '/:model/:field' do
+      validate_field_value *parse(params)
+    end
+
+    post '/:model' do
+      validate_model *parse(params)
+    end
+
+    get '/:model/:field/in/:context' do
+      jsonp validate_field_value *parse(params)
+    end
+
+    get '/:model/in/:context' do
+      jsonp validate_model *parse(params)
+    end
+
+    get '/:model/:field' do
+      jsonp validate_field_value *parse(params)
+    end
+
+    get '/:model' do
+      jsonp validate_model *parse(params)
+    end
+
+    private
+
+    def parse params = {}
+      model_class_name = params[:model].camel_case
+      model_class = begin
+                      Kernel.const_get(model_class_name)
+                    rescue NameError => e
+                      halt(Yajl.dump :error => e.message)
+                    end
+      field_sym = params[:field] ? params[:field].to_sym : nil
+      context = params[:context] ? params[:context].to_sym : :default
+      dependents = params[params[:model]]
+      [model_class, field_sym, context, dependents].compact
+    end
+    
+    def validate_field_value model = nil, field = nil, context = :default, dependents = {}
+      if model && model.included_modules.include?(DataMapper::Resource)
+        begin
+          if model.properties.map(&:name).include?(field) or model.new.__send__(field).kind_of?(DataMapper::Collection)
+            obj = model.new dependents.merge field => params['value']
+            Yajl.dump :error => obj.errors[field] if !obj.valid?(context) && obj.errors.keys.include?(field)
+          else
+            Yajl.dump :error => "Invalid field: #{params[:field]}"
+          end
+        rescue NoMethodError => e
+          Yajl.dump :error => "Invalid field: #{params[:field]}"
+        end
+      else
+        Yajl.dump :error => "Invalid model: #{params[:model].camel_case}"
+      end
+    end
+
+    def validate_model model = nil, context = :default
+      if model && model.included_modules.include?(DataMapper::Resource)
+        obj = model.new params[params[:model]]
+        unless obj.valid?(context)
+          Yajl.dump :error => obj.errors.to_hash
+        end
+      else
+        Yajl.dump :error => "Invalid model: #{params[:model].camel_case}"
+      end
+    end
+
+    def set_content_type
+      content_type (params['callback'] ? :js : :json)
+    end
+
+    def jsonp json = ''
+      return json unless params['callback']
+      params['callback'] + "(#{json})"
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: valibot
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.2.5
+platform: ruby
+authors: 
+- Kenichi Nakamura
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-02 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: dm-validations
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+  type: :runtime
+  version_requirements: *id003
+description: 
+email: 
+- kenichi.nakamura@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/valibot.rb
+- js/valibot.js
+- LICENSE
+- README.md
+homepage: https://github.com/kenichi/valibot
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.4
+requirements: []
+
+rubyforge_project: valibot
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Automatic field validation for forms backed by  DataMapper models through Sinatra.
+test_files: []
+