diff --git a/contrail-webui/server-manager/backbone-validation-amd.js b/contrail-webui/server-manager/backbone-validation-amd.js
new file mode 100644
index 0000000..31f041a
--- /dev/null
+++ b/contrail-webui/server-manager/backbone-validation-amd.js
@@ -0,0 +1,643 @@
+// Backbone.Validation v0.9.1
+//
+// Copyright (c) 2011-2014 Thomas Pedersen
+// Distributed under MIT License
+//
+// Documentation and full license available at:
+// http://thedersen.com/projects/backbone-validation
+(function (factory) {
+  if (typeof exports === 'object') {
+    module.exports = factory(require('backbone'), require('underscore'));
+  } else if (typeof define === 'function' && define.amd) {
+    define(['backbone', 'underscore'], factory);
+  }
+}(function (Backbone, _) {
+  Backbone.Validation = (function(_){
+    'use strict';
+  
+    // Default options
+    // ---------------
+  
+    var defaultOptions = {
+      forceUpdate: false,
+      selector: 'name',
+      labelFormatter: 'sentenceCase',
+      valid: Function.prototype,
+      invalid: Function.prototype
+    };
+  
+  
+    // Helper functions
+    // ----------------
+  
+    // Formatting functions used for formatting error messages
+    var formatFunctions = {
+      // Uses the configured label formatter to format the attribute name
+      // to make it more readable for the user
+      formatLabel: function(attrName, model) {
+        return defaultLabelFormatters[defaultOptions.labelFormatter](attrName, model);
+      },
+  
+      // Replaces nummeric placeholders like {0} in a string with arguments
+      // passed to the function
+      format: function() {
+        var args = Array.prototype.slice.call(arguments),
+            text = args.shift();
+        return text.replace(/\{(\d+)\}/g, function(match, number) {
+          return typeof args[number] !== 'undefined' ? args[number] : match;
+        });
+      }
+    };
+  
+    // Flattens an object
+    // eg:
+    //
+    //     var o = {
+    //       address: {
+    //         street: 'Street',
+    //         zip: 1234
+    //       }
+    //     };
+    //
+    // becomes:
+    //
+    //     var o = {
+    //       'address.street': 'Street',
+    //       'address.zip': 1234
+    //     };
+    var flatten = function (obj, into, prefix) {
+      into = into || {};
+      prefix = prefix || '';
+  
+      _.each(obj, function(val, key) {
+        if(obj.hasOwnProperty(key)) {
+          if (val && typeof val === 'object' && !(
+            val instanceof Array ||
+            val instanceof Date ||
+            val instanceof RegExp ||
+            val instanceof Backbone.Model ||
+            val instanceof Backbone.Collection)
+          ) {
+            flatten(val, into, prefix + key + '.');
+          }
+          else {
+            into[prefix + key] = val;
+          }
+        }
+      });
+  
+      return into;
+    };
+  
+    // Validation
+    // ----------
+  
+    var Validation = (function(){
+  
+      // Returns an object with undefined properties for all
+      // attributes on the model that has defined one or more
+      // validation rules.
+      var getValidatedAttrs = function(model) {
+        return _.reduce(_.keys(_.result(model, 'validation') || {}), function(memo, key) {
+          memo[key] = void 0;
+          return memo;
+        }, {});
+      };
+  
+      // Looks on the model for validations for a specified
+      // attribute. Returns an array of any validators defined,
+      // or an empty array if none is defined.
+      var getValidators = function(model, attr) {
+        var attrValidationSet = model.validation ? _.result(model, 'validation')[attr] || {} : {};
+  
+        // If the validator is a function or a string, wrap it in a function validator
+        if (_.isFunction(attrValidationSet) || _.isString(attrValidationSet)) {
+          attrValidationSet = {
+            fn: attrValidationSet
+          };
+        }
+  
+        // Stick the validator object into an array
+        if(!_.isArray(attrValidationSet)) {
+          attrValidationSet = [attrValidationSet];
+        }
+  
+        // Reduces the array of validators into a new array with objects
+        // with a validation method to call, the value to validate against
+        // and the specified error message, if any
+        return _.reduce(attrValidationSet, function(memo, attrValidation) {
+          _.each(_.without(_.keys(attrValidation), 'msg'), function(validator) {
+            memo.push({
+              fn: defaultValidators[validator],
+              val: attrValidation[validator],
+              msg: attrValidation.msg
+            });
+          });
+          return memo;
+        }, []);
+      };
+  
+      // Validates an attribute against all validators defined
+      // for that attribute. If one or more errors are found,
+      // the first error message is returned.
+      // If the attribute is valid, an empty string is returned.
+      var validateAttr = function(model, attr, value, computed) {
+        // Reduces the array of validators to an error message by
+        // applying all the validators and returning the first error
+        // message, if any.
+        return _.reduce(getValidators(model, attr), function(memo, validator){
+          // Pass the format functions plus the default
+          // validators as the context to the validator
+          var ctx = _.extend({}, formatFunctions, defaultValidators),
+              result = validator.fn.call(ctx, value, attr, validator.val, model, computed);
+  
+          if(result === false || memo === false) {
+            return false;
+          }
+          if (result && !memo) {
+            return _.result(validator, 'msg') || result;
+          }
+          return memo;
+        }, '');
+      };
+  
+      // Loops through the model's attributes and validates them all.
+      // Returns and object containing names of invalid attributes
+      // as well as error messages.
+      var validateModel = function(model, attrs) {
+        var error,
+            invalidAttrs = {},
+            isValid = true,
+            computed = _.clone(attrs),
+            flattened = flatten(attrs);
+  
+        _.each(flattened, function(val, attr) {
+          error = validateAttr(model, attr, val, computed);
+          if (error) {
+            invalidAttrs[attr] = error;
+            isValid = false;
+          }
+        });
+  
+        return {
+          invalidAttrs: invalidAttrs,
+          isValid: isValid
+        };
+      };
+  
+      // Contains the methods that are mixed in on the model when binding
+      var mixin = function(view, options) {
+        return {
+  
+          // Check whether or not a value, or a hash of values
+          // passes validation without updating the model
+          preValidate: function(attr, value) {
+            var self = this,
+                result = {},
+                error;
+  
+            if(_.isObject(attr)){
+              _.each(attr, function(value, key) {
+                error = self.preValidate(key, value);
+                if(error){
+                  result[key] = error;
+                }
+              });
+  
+              return _.isEmpty(result) ? undefined : result;
+            }
+            else {
+              return validateAttr(this, attr, value, _.extend({}, this.attributes));
+            }
+          },
+  
+          // Check to see if an attribute, an array of attributes or the
+          // entire model is valid. Passing true will force a validation
+          // of the model.
+          isValid: function(option) {
+            var flattened = flatten(this.attributes);
+  
+            if(_.isString(option)){
+              return !validateAttr(this, option, flattened[option], _.extend({}, this.attributes));
+            }
+            if(_.isArray(option)){
+              return _.reduce(option, function(memo, attr) {
+                return memo && !validateAttr(this, attr, flattened[attr], _.extend({}, this.attributes));
+              }, true, this);
+            }
+            if(option === true) {
+              this.validate();
+            }
+            return this.validation ? this._isValid : true;
+          },
+  
+          // This is called by Backbone when it needs to perform validation.
+          // You can call it manually without any parameters to validate the
+          // entire model.
+          validate: function(attrs, setOptions){
+            var model = this,
+                validateAll = !attrs,
+                opt = _.extend({}, options, setOptions),
+                validatedAttrs = getValidatedAttrs(model),
+                allAttrs = _.extend({}, validatedAttrs, model.attributes, attrs),
+                changedAttrs = flatten(attrs || allAttrs),
+  
+                result = validateModel(model, allAttrs);
+  
+            model._isValid = result.isValid;
+  
+            // After validation is performed, loop through all validated attributes
+            // and call the valid callbacks so the view is updated.
+            _.each(validatedAttrs, function(val, attr){
+              var invalid = result.invalidAttrs.hasOwnProperty(attr);
+              if(!invalid){
+                opt.valid(view, attr, opt.selector);
+              }
+            });
+  
+            // After validation is performed, loop through all validated and changed attributes
+            // and call the invalid callback so the view is updated.
+            _.each(validatedAttrs, function(val, attr){
+              var invalid = result.invalidAttrs.hasOwnProperty(attr),
+                  changed = changedAttrs.hasOwnProperty(attr);
+  
+              if(invalid && (changed || validateAll)){
+                opt.invalid(view, attr, result.invalidAttrs[attr], opt.selector);
+              }
+            });
+  
+            // Trigger validated events.
+            // Need to defer this so the model is actually updated before
+            // the event is triggered.
+            _.defer(function() {
+              model.trigger('validated', model._isValid, model, result.invalidAttrs);
+              model.trigger('validated:' + (model._isValid ? 'valid' : 'invalid'), model, result.invalidAttrs);
+            });
+  
+            // Return any error messages to Backbone, unless the forceUpdate flag is set.
+            // Then we do not return anything and fools Backbone to believe the validation was
+            // a success. That way Backbone will update the model regardless.
+            if (!opt.forceUpdate && _.intersection(_.keys(result.invalidAttrs), _.keys(changedAttrs)).length > 0) {
+              return result.invalidAttrs;
+            }
+          }
+        };
+      };
+  
+      // Helper to mix in validation on a model
+      var bindModel = function(view, model, options) {
+        _.extend(model, mixin(view, options));
+      };
+  
+      // Removes the methods added to a model
+      var unbindModel = function(model) {
+        delete model.validate;
+        delete model.preValidate;
+        delete model.isValid;
+      };
+  
+      // Mix in validation on a model whenever a model is
+      // added to a collection
+      var collectionAdd = function(model) {
+        bindModel(this.view, model, this.options);
+      };
+  
+      // Remove validation from a model whenever a model is
+      // removed from a collection
+      var collectionRemove = function(model) {
+        unbindModel(model);
+      };
+  
+      // Returns the public methods on Backbone.Validation
+      return {
+  
+        // Current version of the library
+        version: '0.9.1',
+  
+        // Called to configure the default options
+        configure: function(options) {
+          _.extend(defaultOptions, options);
+        },
+  
+        // Hooks up validation on a view with a model
+        // or collection
+        bind: function(view, options) {
+          options = _.extend({}, defaultOptions, defaultCallbacks, options);
+  
+          var model = options.model || view.model,
+              collection = options.collection || view.collection;
+  
+          if(typeof model === 'undefined' && typeof collection === 'undefined'){
+            throw 'Before you execute the binding your view must have a model or a collection.\n' +
+                  'See http://thedersen.com/projects/backbone-validation/#using-form-model-validation for more information.';
+          }
+  
+          if(model) {
+            bindModel(view, model, options);
+          }
+          else if(collection) {
+            collection.each(function(model){
+              bindModel(view, model, options);
+            });
+            collection.bind('add', collectionAdd, {view: view, options: options});
+            collection.bind('remove', collectionRemove);
+          }
+        },
+  
+        // Removes validation from a view with a model
+        // or collection
+        unbind: function(view, options) {
+          options = _.extend({}, options);
+          var model = options.model || view.model,
+              collection = options.collection || view.collection;
+  
+          if(model) {
+            unbindModel(model);
+          }
+          else if(collection) {
+            collection.each(function(model){
+              unbindModel(model);
+            });
+            collection.unbind('add', collectionAdd);
+            collection.unbind('remove', collectionRemove);
+          }
+        },
+  
+        // Used to extend the Backbone.Model.prototype
+        // with validation
+        mixin: mixin(null, defaultOptions)
+      };
+    }());
+  
+  
+    // Callbacks
+    // ---------
+  
+    var defaultCallbacks = Validation.callbacks = {
+  
+      // Gets called when a previously invalid field in the
+      // view becomes valid. Removes any error message.
+      // Should be overridden with custom functionality.
+      valid: function(view, attr, selector) {
+        view.$('[' + selector + '~="' + attr + '"]')
+            .removeClass('invalid')
+            .removeAttr('data-error');
+      },
+  
+      // Gets called when a field in the view becomes invalid.
+      // Adds a error message.
+      // Should be overridden with custom functionality.
+      invalid: function(view, attr, error, selector) {
+        view.$('[' + selector + '~="' + attr + '"]')
+            .addClass('invalid')
+            .attr('data-error', error);
+      }
+    };
+  
+  
+    // Patterns
+    // --------
+  
+    var defaultPatterns = Validation.patterns = {
+      // Matches any digit(s) (i.e. 0-9)
+      digits: /^\d+$/,
+  
+      // Matches any number (e.g. 100.000)
+      number: /^-?(?:\d+|\d{1,3}(?:,\d{3})+)(?:\.\d+)?$/,
+  
+      // Matches a valid email address (e.g. mail@example.com)
+      email: /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i,
+  
+      // Mathes any valid url (e.g. http://www.xample.com)
+      url: /^(https?|ftp):\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i
+    };
+  
+  
+    // Error messages
+    // --------------
+  
+    // Error message for the build in validators.
+    // {x} gets swapped out with arguments form the validator.
+    var defaultMessages = Validation.messages = {
+      required: '{0} is required',
+      acceptance: '{0} must be accepted',
+      min: '{0} must be greater than or equal to {1}',
+      max: '{0} must be less than or equal to {1}',
+      range: '{0} must be between {1} and {2}',
+      length: '{0} must be {1} characters',
+      minLength: '{0} must be at least {1} characters',
+      maxLength: '{0} must be at most {1} characters',
+      rangeLength: '{0} must be between {1} and {2} characters',
+      oneOf: '{0} must be one of: {1}',
+      equalTo: '{0} must be the same as {1}',
+      digits: '{0} must only contain digits',
+      number: '{0} must be a number',
+      email: '{0} must be a valid email',
+      url: '{0} must be a valid url',
+      inlinePattern: '{0} is invalid'
+    };
+  
+    // Label formatters
+    // ----------------
+  
+    // Label formatters are used to convert the attribute name
+    // to a more human friendly label when using the built in
+    // error messages.
+    // Configure which one to use with a call to
+    //
+    //     Backbone.Validation.configure({
+    //       labelFormatter: 'label'
+    //     });
+    var defaultLabelFormatters = Validation.labelFormatters = {
+  
+      // Returns the attribute name with applying any formatting
+      none: function(attrName) {
+        return attrName;
+      },
+  
+      // Converts attributeName or attribute_name to Attribute name
+      sentenceCase: function(attrName) {
+        return attrName.replace(/(?:^\w|[A-Z]|\b\w)/g, function(match, index) {
+          return index === 0 ? match.toUpperCase() : ' ' + match.toLowerCase();
+        }).replace(/_/g, ' ');
+      },
+  
+      // Looks for a label configured on the model and returns it
+      //
+      //      var Model = Backbone.Model.extend({
+      //        validation: {
+      //          someAttribute: {
+      //            required: true
+      //          }
+      //        },
+      //
+      //        labels: {
+      //          someAttribute: 'Custom label'
+      //        }
+      //      });
+      label: function(attrName, model) {
+        return (model.labels && model.labels[attrName]) || defaultLabelFormatters.sentenceCase(attrName, model);
+      }
+    };
+  
+  
+    // Built in validators
+    // -------------------
+  
+    var defaultValidators = Validation.validators = (function(){
+      // Use native trim when defined
+      var trim = String.prototype.trim ?
+        function(text) {
+          return text === null ? '' : String.prototype.trim.call(text);
+        } :
+        function(text) {
+          var trimLeft = /^\s+/,
+              trimRight = /\s+$/;
+  
+          return text === null ? '' : text.toString().replace(trimLeft, '').replace(trimRight, '');
+        };
+  
+      // Determines whether or not a value is a number
+      var isNumber = function(value){
+        return _.isNumber(value) || (_.isString(value) && value.match(defaultPatterns.number));
+      };
+  
+      // Determines whether or not a value is empty
+      var hasValue = function(value) {
+        return !(_.isNull(value) || _.isUndefined(value) || (_.isString(value) && trim(value) === '') || (_.isArray(value) && _.isEmpty(value)));
+      };
+  
+      return {
+        // Function validator
+        // Lets you implement a custom function used for validation
+        fn: function(value, attr, fn, model, computed) {
+          if(_.isString(fn)){
+            fn = model[fn];
+          }
+          return fn.call(model, value, attr, computed);
+        },
+  
+        // Required validator
+        // Validates if the attribute is required or not
+        // This can be specified as either a boolean value or a function that returns a boolean value
+        required: function(value, attr, required, model, computed) {
+          var isRequired = _.isFunction(required) ? required.call(model, value, attr, computed) : required;
+          if(!isRequired && !hasValue(value)) {
+            return false; // overrides all other validators
+          }
+          if (isRequired && !hasValue(value)) {
+            return this.format(defaultMessages.required, this.formatLabel(attr, model));
+          }
+        },
+  
+        // Acceptance validator
+        // Validates that something has to be accepted, e.g. terms of use
+        // `true` or 'true' are valid
+        acceptance: function(value, attr, accept, model) {
+          if(value !== 'true' && (!_.isBoolean(value) || value === false)) {
+            return this.format(defaultMessages.acceptance, this.formatLabel(attr, model));
+          }
+        },
+  
+        // Min validator
+        // Validates that the value has to be a number and equal to or greater than
+        // the min value specified
+        min: function(value, attr, minValue, model) {
+          if (!isNumber(value) || value < minValue) {
+            return this.format(defaultMessages.min, this.formatLabel(attr, model), minValue);
+          }
+        },
+  
+        // Max validator
+        // Validates that the value has to be a number and equal to or less than
+        // the max value specified
+        max: function(value, attr, maxValue, model) {
+          if (!isNumber(value) || value > maxValue) {
+            return this.format(defaultMessages.max, this.formatLabel(attr, model), maxValue);
+          }
+        },
+  
+        // Range validator
+        // Validates that the value has to be a number and equal to or between
+        // the two numbers specified
+        range: function(value, attr, range, model) {
+          if(!isNumber(value) || value < range[0] || value > range[1]) {
+            return this.format(defaultMessages.range, this.formatLabel(attr, model), range[0], range[1]);
+          }
+        },
+  
+        // Length validator
+        // Validates that the value has to be a string with length equal to
+        // the length value specified
+        length: function(value, attr, length, model) {
+          if (!_.isString(value) || value.length !== length) {
+            return this.format(defaultMessages.length, this.formatLabel(attr, model), length);
+          }
+        },
+  
+        // Min length validator
+        // Validates that the value has to be a string with length equal to or greater than
+        // the min length value specified
+        minLength: function(value, attr, minLength, model) {
+          if (!_.isString(value) || value.length < minLength) {
+            return this.format(defaultMessages.minLength, this.formatLabel(attr, model), minLength);
+          }
+        },
+  
+        // Max length validator
+        // Validates that the value has to be a string with length equal to or less than
+        // the max length value specified
+        maxLength: function(value, attr, maxLength, model) {
+          if (!_.isString(value) || value.length > maxLength) {
+            return this.format(defaultMessages.maxLength, this.formatLabel(attr, model), maxLength);
+          }
+        },
+  
+        // Range length validator
+        // Validates that the value has to be a string and equal to or between
+        // the two numbers specified
+        rangeLength: function(value, attr, range, model) {
+          if (!_.isString(value) || value.length < range[0] || value.length > range[1]) {
+            return this.format(defaultMessages.rangeLength, this.formatLabel(attr, model), range[0], range[1]);
+          }
+        },
+  
+        // One of validator
+        // Validates that the value has to be equal to one of the elements in
+        // the specified array. Case sensitive matching
+        oneOf: function(value, attr, values, model) {
+          if(!_.include(values, value)){
+            return this.format(defaultMessages.oneOf, this.formatLabel(attr, model), values.join(', '));
+          }
+        },
+  
+        // Equal to validator
+        // Validates that the value has to be equal to the value of the attribute
+        // with the name specified
+        equalTo: function(value, attr, equalTo, model, computed) {
+          if(value !== computed[equalTo]) {
+            return this.format(defaultMessages.equalTo, this.formatLabel(attr, model), this.formatLabel(equalTo, model));
+          }
+        },
+  
+        // Pattern validator
+        // Validates that the value has to match the pattern specified.
+        // Can be a regular expression or the name of one of the built in patterns
+        pattern: function(value, attr, pattern, model) {
+          if (!hasValue(value) || !value.toString().match(defaultPatterns[pattern] || pattern)) {
+            return this.format(defaultMessages[pattern] || defaultMessages.inlinePattern, this.formatLabel(attr, model), pattern);
+          }
+        }
+      };
+    }());
+  
+    // Set the correct context for all validators
+    // when used from within a method validator
+    _.each(defaultValidators, function(validator, key){
+      defaultValidators[key] = _.bind(defaultValidators[key], _.extend({}, formatFunctions, defaultValidators));
+    });
+  
+    return Validation;
+  }(_));
+  return Backbone.Validation;
+}));
\ No newline at end of file