af-client_side_validations 3.1.4.af1

data/test/javascript/public/test/validators/numericality.js

@@ -0,0 +1,158 @@
+module('Numericality options');
+
+test('when value is a number', function() {
+  var element = $('<input type="text" />');
+  var options = { messagess: { numericality: "failed validation" } };
+  element.val('123');
+  equal(clientSideValidations.validators.local.numericality(element, options), undefined);
+});
+
+test('when value is a decimal number', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { numericality: "failed validation" } };
+  element.val('123.456');
+  equal(clientSideValidations.validators.local.numericality(element, options), undefined);
+});
+
+test('when value is not a number', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { numericality: "failed validation" } };
+  element.val('abc123');
+  equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
+});
+
+test('when only allowing integers and value is integer', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { only_integer: "failed validation" }, only_integer: true };
+  element.val('123');
+  equal(clientSideValidations.validators.local.numericality(element, options), undefined);
+});
+
+test('when only allowing integers and value has a negative or positive sign', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { only_integer: "failed validation"}, only_integer: true };
+  element.val('-23');
+  equal(clientSideValidations.validators.local.numericality(element, options), undefined);
+  element.val('+23');
+  equal(clientSideValidations.validators.local.numericality(element, options), undefined);
+});
+
+test('when only allowing integers and value is not integer', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { only_integer: "failed validation" }, only_integer: true };
+  element.val('123.456');
+  equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
+});
+
+test('when only allowing values greater than 10 and value is greater than 10', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { greater_than: "failed validation" }, greater_than: 10 };
+  element.val('11');
+  equal(clientSideValidations.validators.local.numericality(element, options), undefined);
+});
+
+test('when only allowing values greater than 10 and value is 10', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { greater_than: "failed validation" }, greater_than: 10 };
+  element.val('10');
+  equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
+});
+
+test('when only allowing values greater than or equal to 10 and value is 10', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { greater_than_or_equal_to: "failed validation" }, greater_than_or_equal_to: 10 };
+  element.val('10');
+  equal(clientSideValidations.validators.local.numericality(element, options), undefined);
+});
+
+test('when only allowing values greater than or equal to 10 and value is 9', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { greater_than_or_equal_to: "failed validation" }, greater_than_or_equal_to: 10 };
+  element.val('9');
+  equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
+});
+
+test('when only allowing values less than 10 and value is less than 10', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { less_than: "failed validation" }, less_than: 10 };
+  element.val('9');
+  equal(clientSideValidations.validators.local.numericality(element, options), undefined);
+});
+
+test('when only allowing values less than 10 and value is 10', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { less_than: "failed validation" }, less_than: 10 };
+  element.val('10');
+  equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
+});
+
+test('when only allowing values less than or equal to 10 and value is 10', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { less_than_or_equal_to: "failed validation" }, less_than_or_equal_to: 10 };
+  element.val('10');
+  equal(clientSideValidations.validators.local.numericality(element, options), undefined);
+});
+
+test('when only allowing values less than or equal to 10 and value is 11', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { less_than_or_equal_to: "failed validation" }, less_than_or_equal_to: 10 };
+  element.val('11');
+  equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
+});
+
+test('when only allowing values equal to 10 and value is 10', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { equal_to: "failed validation" }, equal_to: 10 };
+  element.val('10');
+  equal(clientSideValidations.validators.local.numericality(element, options), undefined);
+});
+
+test('when only allowing values equal to 10 and value is 11', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { equal_to: "failed validation" }, equal_to: 10 };
+  element.val('11');
+  equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
+});
+
+test('when only allowing value equal to 0 and value is 1', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { equal_to: "failed validation" }, equal_to: 0 };
+  element.val('1');
+  equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
+});
+
+test('when only allowing odd values and the value is odd', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { odd: "failed validation" }, odd: true };
+  element.val('11');
+  equal(clientSideValidations.validators.local.numericality(element, options), undefined);
+});
+
+test('when only allowing odd values and the value is even', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { odd: "failed validation" }, odd: true };
+  element.val('10');
+  equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
+});
+
+test('when only allowing even values and the value is even', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { even: "failed validation" }, even: true };
+  element.val('10');
+  equal(clientSideValidations.validators.local.numericality(element, options), undefined);
+});
+
+test('when only allowing even values and the value is odd', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { even: "failed validation" }, even: true };
+  element.val('11');
+  equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
+});
+
+test('blank values should be evaluated as zero', function() {
+  var element = $('<input type="text" />');
+  var options = { messages: { numericality: "failed validation" } };
+  element.val('');
+  equal(clientSideValidations.validators.local.numericality(element, options), undefined);
+});
+

data/test/javascript/public/test/validators/presence.js

@@ -0,0 +1,21 @@
+module('Presence options');
+
+test('when value is not empty', function() {
+  var element = $('<input type="text" />');
+  var options = { message: "failed validation" };
+  element.val('not empty');
+  equal(clientSideValidations.validators.local.presence(element, options), undefined);
+});
+
+test('when value is empty', function() {
+  var element = $('<input type="text" />');
+  var options = { message: "failed validation" };
+  equal(clientSideValidations.validators.local.presence(element, options), "failed validation");
+});
+
+test('when value is null from non-selected multi-select element', function() {
+  var element = $('<select multiple="multiple />');
+  var options = { message: "failed validation" };
+  equal(clientSideValidations.validators.local.presence(element, options), "failed validation");
+});
+

data/test/javascript/public/test/validators/uniqueness.js

@@ -0,0 +1,107 @@
+module('Uniqueness options', {
+  setup: function() {
+    window['new_user'] = {
+      type: 'ActionView::Helpers::FormBuilder',
+      input_tag: '<div class="field_with_errors"><span id="input_tag" /><label class="message"></label></div>',
+      label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
+      validators: {'user[email]':{"uniqueness":{"message": "must be unique", "scope":{name:"pass"}},"presence":{"message": "must be present"}}}
+    }
+
+    $('#qunit-fixture')
+      .append($('<form />', {
+        action: '/users',
+        'data-validate': true,
+        method: 'post',
+        id: 'new_user'
+      }))
+      .find('form')
+        .append($('<input />', {
+          name: 'user[name]',
+          id: 'user_name',
+          type: 'text'
+        }))
+        .append($('<input />', {
+          name: 'user[email]',
+          id: 'user_email',
+          'data-validate': 'true',
+          type: 'text'
+        }))
+
+    $('form#new_user').validate();
+  }
+});
+
+test('when matching uniqueness on a non-nested resource', function() {
+  var element = $('<input type="text" name="user[email]"/>');
+  var options = { 'message': "failed validation" };
+  element.val('nottaken@test.com');
+  equal(clientSideValidations.validators.remote.uniqueness(element, options), undefined);
+});
+
+test('when matching uniqueness on a non-nested resource', function() {
+  var element = $('<input type="text" name="user[email]"/>');
+  var options = { 'message': "failed validation" };
+  element.val('taken@test.com');
+  equal(clientSideValidations.validators.remote.uniqueness(element, options), "failed validation");
+});
+
+test('when matching uniqueness on a nested singular resource', function() {
+  var element = $('<input type="text" name="profile[user_attributes][email]"/>');
+  var options = { 'message': "failed validation" };
+  element.val('nottaken@test.com');
+  equal(clientSideValidations.validators.remote.uniqueness(element, options), undefined);
+});
+
+test('when matching uniqueness on a nested singular resource', function() {
+  var element = $('<input type="text" name="profile[user_attributes][email]"/>');
+  var options = { 'message': "failed validation" };
+  element.val('taken@test.com');
+  equal(clientSideValidations.validators.remote.uniqueness(element, options), "failed validation");
+});
+
+test('when using scopes with no replacement', function() {
+  var element = $('<input type="text" name="person[age]" />');
+  var options = { 'message': "failed validation", 'with': /\d+/, 'scope': { 'name': 'test name' } };
+  element.val('test');
+  equal(clientSideValidations.validators.remote.uniqueness(element, options), "failed validation");
+});
+
+test('when using scopes with replacement', function() {
+  var element = $('<input type="text" name="person[age]" />');
+  var options = { 'message': "failed validation", 'with': /\d+/, 'scope': { 'name': 'test name' } };
+  element.val('test')
+  $('#qunit-fixture').append('<input type="text" name="person[name]" />').find('input[name="person[name]"]').val('other name');
+  equal(clientSideValidations.validators.remote.uniqueness(element, options), undefined);
+});
+
+test('when validating by scope and mixed focus order', function() {
+  var unique_element = $('#user_email'), scope_element = $('#user_name');
+  unique_element.val('free@test.com');
+  unique_element.trigger('change');
+  unique_element.trigger('focusout');
+  equal($('.message[for="user_email"]').text(), '');
+
+  scope_element.val('test name');
+  scope_element.trigger('change');
+  scope_element.trigger('focusout');
+  equal($('.message[for="user_email"]').text(), 'must be unique');
+});
+
+test('when matching uniqueness on a resource with a defined class name', function() {
+  var element = $('<input type="text" name="user2[email]"/>');
+  var options = { 'message': "failed validation", 'class': "active_record_test_module/user2" };
+  element.val('nottaken@test.com');
+  equal(clientSideValidations.validators.remote.uniqueness(element, options), 'failed validation');
+});
+
+test('when allowing blank', function() {
+ var element = $('<input type="text" name="user2[email]" />');
+ var options = { 'message': "failed validation", 'with': /\d+/, 'allow_blank': true };
+ equal(clientSideValidations.validators.remote.uniqueness(element, options), undefined);
+});
+
+test('when not allowing blank', function() {
+ var element = $('<input type="text" name="user2[email]" />');
+ var options = { 'message': "failed validation", 'with': /\d+/ };
+ equal(clientSideValidations.validators.remote.uniqueness(element, options), "failed validation");
+});

data/test/javascript/public/vendor/jquery.metadata.js

@@ -0,0 +1,122 @@
+/*
+ * Metadata - jQuery plugin for parsing metadata from elements
+ *
+ * Copyright (c) 2006 John Resig, Yehuda Katz, J�örn Zaefferer, Paul McLanahan
+ *
+ * Dual licensed under the MIT and GPL licenses:
+ *   http://www.opensource.org/licenses/mit-license.php
+ *   http://www.gnu.org/licenses/gpl.html
+ *
+ * Revision: $Id: jquery.metadata.js 4187 2007-12-16 17:15:27Z joern.zaefferer $
+ *
+ */
+
+/**
+ * Sets the type of metadata to use. Metadata is encoded in JSON, and each property
+ * in the JSON will become a property of the element itself.
+ *
+ * There are three supported types of metadata storage:
+ *
+ *   attr:  Inside an attribute. The name parameter indicates *which* attribute.
+ *
+ *   class: Inside the class attribute, wrapped in curly braces: { }
+ *
+ *   elem:  Inside a child element (e.g. a script tag). The
+ *          name parameter indicates *which* element.
+ *
+ * The metadata for an element is loaded the first time the element is accessed via jQuery.
+ *
+ * As a result, you can define the metadata type, use $(expr) to load the metadata into the elements
+ * matched by expr, then redefine the metadata type and run another $(expr) for other elements.
+ *
+ * @name $.metadata.setType
+ *
+ * @example <p id="one" class="some_class {item_id: 1, item_label: 'Label'}">This is a p</p>
+ * @before $.metadata.setType("class")
+ * @after $("#one").metadata().item_id == 1; $("#one").metadata().item_label == "Label"
+ * @desc Reads metadata from the class attribute
+ *
+ * @example <p id="one" class="some_class" data="{item_id: 1, item_label: 'Label'}">This is a p</p>
+ * @before $.metadata.setType("attr", "data")
+ * @after $("#one").metadata().item_id == 1; $("#one").metadata().item_label == "Label"
+ * @desc Reads metadata from a "data" attribute
+ *
+ * @example <p id="one" class="some_class"><script>{item_id: 1, item_label: 'Label'}</script>This is a p</p>
+ * @before $.metadata.setType("elem", "script")
+ * @after $("#one").metadata().item_id == 1; $("#one").metadata().item_label == "Label"
+ * @desc Reads metadata from a nested script element
+ *
+ * @param String type The encoding type
+ * @param String name The name of the attribute to be used to get metadata (optional)
+ * @cat Plugins/Metadata
+ * @descr Sets the type of encoding to be used when loading metadata for the first time
+ * @type undefined
+ * @see metadata()
+ */
+
+(function($) {
+
+$.extend({
+  metadata : {
+    defaults : {
+      type: 'class',
+      name: 'metadata',
+      cre: /({.*})/,
+      single: 'metadata'
+    },
+    setType: function( type, name ){
+      this.defaults.type = type;
+      this.defaults.name = name;
+    },
+    get: function( elem, opts ){
+      var settings = $.extend({},this.defaults,opts);
+      // check for empty string in single property
+      if ( !settings.single.length ) settings.single = 'metadata';
+
+      var data = $.data(elem, settings.single);
+      // returned cached data if it already exists
+      if ( data ) return data;
+
+      data = "{}";
+
+      if ( settings.type == "class" ) {
+        var m = settings.cre.exec( elem.className );
+        if ( m )
+          data = m[1];
+      } else if ( settings.type == "elem" ) {
+        if( !elem.getElementsByTagName )
+          return undefined;
+        var e = elem.getElementsByTagName(settings.name);
+        if ( e.length )
+          data = $.trim(e[0].innerHTML);
+      } else if ( elem.getAttribute != undefined ) {
+        var attr = elem.getAttribute( settings.name );
+        if ( attr )
+          data = attr;
+      }
+
+      if ( data.indexOf( '{' ) <0 )
+      data = "{" + data + "}";
+
+      data = eval("(" + data + ")");
+
+      $.data( elem, settings.single, data );
+      return data;
+    }
+  }
+});
+
+/**
+ * Returns the metadata object for the first member of the jQuery object.
+ *
+ * @name metadata
+ * @descr Returns element's metadata object
+ * @param Object opts An object contianing settings to override the defaults
+ * @type jQuery
+ * @cat Plugins/Metadata
+ */
+$.fn.metadata = function( opts ){
+  return $.metadata.get( this[0], opts );
+};
+
+})(jQuery);

data/test/javascript/public/vendor/qunit.css

@@ -0,0 +1,196 @@
+/** Font Family and Sizes */
+
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
+  font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial;
+}
+
+#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
+#qunit-tests { font-size: smaller; }
+
+
+/** Resets */
+
+#qunit-tests, #qunit-tests ol, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult {
+  margin: 0;
+  padding: 0;
+}
+
+
+/** Header */
+
+#qunit-header {
+  padding: 0.5em 0 0.5em 1em;
+
+  color: #8699a4;
+  background-color: #0d3349;
+
+  font-size: 1.5em;
+  line-height: 1em;
+  font-weight: normal;
+
+  border-radius: 15px 15px 0 0;
+  -moz-border-radius: 15px 15px 0 0;
+  -webkit-border-top-right-radius: 15px;
+  -webkit-border-top-left-radius: 15px;
+}
+
+#qunit-header a {
+  text-decoration: none;
+  color: #c2ccd1;
+}
+
+#qunit-header a:hover,
+#qunit-header a:focus {
+  color: #fff;
+}
+
+#qunit-banner {
+  height: 5px;
+}
+
+#qunit-testrunner-toolbar {
+  padding: 0em 0 0.5em 2em;
+}
+
+#qunit-userAgent {
+  padding: 0.5em 0 0.5em 2.5em;
+  background-color: #2b81af;
+  color: #fff;
+  text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
+}
+
+
+/** Tests: Pass/Fail */
+
+#qunit-tests {
+  list-style-position: inside;
+}
+
+#qunit-tests li {
+  padding: 0.4em 0.5em 0.4em 2.5em;
+  border-bottom: 1px solid #fff;
+  list-style-position: inside;
+}
+
+#qunit-tests li strong {
+  cursor: pointer;
+}
+
+#qunit-tests ol {
+  margin-top: 0.5em;
+  padding: 0.5em;
+
+  background-color: #fff;
+
+  border-radius: 15px;
+  -moz-border-radius: 15px;
+  -webkit-border-radius: 15px;
+
+  box-shadow: inset 0px 2px 13px #999;
+  -moz-box-shadow: inset 0px 2px 13px #999;
+  -webkit-box-shadow: inset 0px 2px 13px #999;
+}
+
+#qunit-tests table {
+  border-collapse: collapse;
+  margin-top: .2em;
+}
+
+#qunit-tests th {
+  text-align: right;
+  vertical-align: top;
+  padding: 0 .5em 0 0;
+}
+
+#qunit-tests td {
+  vertical-align: top;
+}
+
+#qunit-tests pre {
+  margin: 0;
+  white-space: pre-wrap;
+  word-wrap: break-word;
+}
+
+#qunit-tests del {
+  background-color: #e0f2be;
+  color: #374e0c;
+  text-decoration: none;
+}
+
+#qunit-tests ins {
+  background-color: #ffcaca;
+  color: #500;
+  text-decoration: none;
+}
+
+/*** Test Counts */
+
+#qunit-tests b.counts                       { color: black; }
+#qunit-tests b.passed                       { color: #5E740B; }
+#qunit-tests b.failed                       { color: #710909; }
+
+#qunit-tests li li {
+  margin: 0.5em;
+  padding: 0.4em 0.5em 0.4em 0.5em;
+  background-color: #fff;
+  border-bottom: none;
+  list-style-position: inside;
+}
+
+/*** Passing Styles */
+
+#qunit-tests li li.pass {
+  color: #5E740B;
+  background-color: #fff;
+  border-left: 26px solid #C6E746;
+}
+
+#qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
+#qunit-tests .pass .test-name               { color: #366097; }
+
+#qunit-tests .pass .test-actual,
+#qunit-tests .pass .test-expected           { color: #999999; }
+
+#qunit-banner.qunit-pass                    { background-color: #C6E746; }
+
+/*** Failing Styles */
+
+#qunit-tests li li.fail {
+  color: #710909;
+  background-color: #fff;
+  border-left: 26px solid #EE5757;
+}
+
+#qunit-tests .fail                          { color: #000000; background-color: #EE5757; }
+#qunit-tests .fail .test-name,
+#qunit-tests .fail .module-name             { color: #000000; }
+
+#qunit-tests .fail .test-actual             { color: #EE5757; }
+#qunit-tests .fail .test-expected           { color: green;   }
+
+#qunit-banner.qunit-fail,
+#qunit-testrunner-toolbar                   { background-color: #EE5757; }
+
+
+/** Footer */
+
+#qunit-testresult {
+  padding: 0.5em 0.5em 0.5em 2.5em;
+
+  color: #2b81af;
+  background-color: #D2E0E6;
+
+  border-radius: 0 0 15px 15px;
+  -moz-border-radius: 0 0 15px 15px;
+  -webkit-border-bottom-right-radius: 15px;
+  -webkit-border-bottom-left-radius: 15px;
+}
+
+/** Fixture */
+
+#qunit-fixture {
+  position: absolute;
+  top: -10000px;
+  left: -10000px;
+}