judge 1.4.0 → 1.5.0

data/judge.gemspec

@@ -18,6 +18,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "jasmine",            "~> 1.1.2"
   s.add_development_dependency "rails",              "~> 3.2"
   s.add_development_dependency "rspec",              "~> 2.8"
-  s.add_development_dependency "sqlite3-ruby",       "~> 1.3.3"
+  s.add_development_dependency "sqlite3",            "~> 1.3.5"
   s.add_development_dependency "factory_girl",       "~> 2.6"
 end

data/lib/generators/judge/templates/judge.js

@@ -1,4 +1,4 @@
-// Judge 1.4.0
+// Judge 1.5.0
 // (c) 2011–2012 Joe Corcoran
 // http://raw.github.com/joecorcoran/judge/master/LICENSE.txt
 // This is the JavaScript part of Judge, a client-side validation gem for Rails 3.
@@ -13,7 +13,7 @@
   // The judge namespace.
   var judge = {};
 
-  judge.VERSION = '1.4.0';
+  judge.VERSION = '1.5.0';
 
   // A judge.Watcher is a DOM element wrapper that judge uses to store validation info and instance methods.
   judge.Watcher = function (element) {

data/lib/generators/judge/templates/underscore.js

@@ -1,4 +1,5 @@
-//     Underscore.js 1.3.1
+
+//     Underscore.js 1.3.2
 //     (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
 //     Underscore is freely distributable under the MIT license.
 //     Portions of Underscore are inspired or borrowed from Prototype,
@@ -62,7 +63,7 @@
   }
 
   // Current version.
-  _.VERSION = '1.3.1';
+  _.VERSION = '1.3.2';
 
   // Collection Functions
   // --------------------
@@ -180,7 +181,7 @@
     each(obj, function(value, index, list) {
       if (!(result = result && iterator.call(context, value, index, list))) return breaker;
     });
-    return result;
+    return !!result;
   };
 
   // Determine if at least one element in the object matches a truth test.
@@ -224,7 +225,7 @@
 
   // Return the maximum element or (element-based computation).
   _.max = function(obj, iterator, context) {
-    if (!iterator && _.isArray(obj)) return Math.max.apply(Math, obj);
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0]) return Math.max.apply(Math, obj);
     if (!iterator && _.isEmpty(obj)) return -Infinity;
     var result = {computed : -Infinity};
     each(obj, function(value, index, list) {
@@ -236,7 +237,7 @@
 
   // Return the minimum element (or element-based computation).
   _.min = function(obj, iterator, context) {
-    if (!iterator && _.isArray(obj)) return Math.min.apply(Math, obj);
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0]) return Math.min.apply(Math, obj);
     if (!iterator && _.isEmpty(obj)) return Infinity;
     var result = {computed : Infinity};
     each(obj, function(value, index, list) {
@@ -250,19 +251,16 @@
   _.shuffle = function(obj) {
     var shuffled = [], rand;
     each(obj, function(value, index, list) {
-      if (index == 0) {
-        shuffled[0] = value;
-      } else {
-        rand = Math.floor(Math.random() * (index + 1));
-        shuffled[index] = shuffled[rand];
-        shuffled[rand] = value;
-      }
+      rand = Math.floor(Math.random() * (index + 1));
+      shuffled[index] = shuffled[rand];
+      shuffled[rand] = value;
     });
     return shuffled;
   };
 
   // Sort the object's values by a criterion produced by an iterator.
-  _.sortBy = function(obj, iterator, context) {
+  _.sortBy = function(obj, val, context) {
+    var iterator = _.isFunction(val) ? val : function(obj) { return obj[val]; };
     return _.pluck(_.map(obj, function(value, index, list) {
       return {
         value : value,
@@ -270,6 +268,8 @@
       };
     }).sort(function(left, right) {
       var a = left.criteria, b = right.criteria;
+      if (a === void 0) return 1;
+      if (b === void 0) return -1;
       return a < b ? -1 : a > b ? 1 : 0;
     }), 'value');
   };
@@ -299,26 +299,26 @@
   };
 
   // Safely convert anything iterable into a real, live array.
-  _.toArray = function(iterable) {
-    if (!iterable)                return [];
-    if (iterable.toArray)         return iterable.toArray();
-    if (_.isArray(iterable))      return slice.call(iterable);
-    if (_.isArguments(iterable))  return slice.call(iterable);
-    return _.values(iterable);
+  _.toArray = function(obj) {
+    if (!obj)                                     return [];
+    if (_.isArray(obj))                           return slice.call(obj);
+    if (_.isArguments(obj))                       return slice.call(obj);
+    if (obj.toArray && _.isFunction(obj.toArray)) return obj.toArray();
+    return _.values(obj);
   };
 
   // Return the number of elements in an object.
   _.size = function(obj) {
-    return _.toArray(obj).length;
+    return _.isArray(obj) ? obj.length : _.keys(obj).length;
   };
 
   // Array Functions
   // ---------------
 
   // Get the first element of an array. Passing **n** will return the first N
-  // values in the array. Aliased as `head`. The **guard** check allows it to work
-  // with `_.map`.
-  _.first = _.head = function(array, n, guard) {
+  // values in the array. Aliased as `head` and `take`. The **guard** check
+  // allows it to work with `_.map`.
+  _.first = _.head = _.take = function(array, n, guard) {
     return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
   };
 
@@ -372,15 +372,17 @@
   // Aliased as `unique`.
   _.uniq = _.unique = function(array, isSorted, iterator) {
     var initial = iterator ? _.map(array, iterator) : array;
-    var result = [];
-    _.reduce(initial, function(memo, el, i) {
-      if (0 == i || (isSorted === true ? _.last(memo) != el : !_.include(memo, el))) {
-        memo[memo.length] = el;
-        result[result.length] = array[i];
+    var results = [];
+    // The `isSorted` flag is irrelevant if the array only contains two elements.
+    if (array.length < 3) isSorted = true;
+    _.reduce(initial, function (memo, value, index) {
+      if (isSorted ? _.last(memo) !== value || !memo.length : !_.include(memo, value)) {
+        memo.push(value);
+        results.push(array[index]);
       }
       return memo;
     }, []);
-    return result;
+    return results;
   };
 
   // Produce an array that contains the union: each distinct element from all of
@@ -403,7 +405,7 @@
   // Take the difference between one array and a number of other arrays.
   // Only the elements present in just the first array will remain.
   _.difference = function(array) {
-    var rest = _.flatten(slice.call(arguments, 1));
+    var rest = _.flatten(slice.call(arguments, 1), true);
     return _.filter(array, function(value){ return !_.include(rest, value); });
   };
 
@@ -514,7 +516,7 @@
   // it with the arguments supplied.
   _.delay = function(func, wait) {
     var args = slice.call(arguments, 2);
-    return setTimeout(function(){ return func.apply(func, args); }, wait);
+    return setTimeout(function(){ return func.apply(null, args); }, wait);
   };
 
   // Defers a function, scheduling it to run after the current call stack has
@@ -526,7 +528,7 @@
   // Returns a function, that, when invoked, will only be triggered at most once
   // during a given window of time.
   _.throttle = function(func, wait) {
-    var context, args, timeout, throttling, more;
+    var context, args, timeout, throttling, more, result;
     var whenDone = _.debounce(function(){ more = throttling = false; }, wait);
     return function() {
       context = this; args = arguments;
@@ -539,24 +541,27 @@
       if (throttling) {
         more = true;
       } else {
-        func.apply(context, args);
+        result = func.apply(context, args);
       }
       whenDone();
       throttling = true;
+      return result;
     };
   };
 
   // Returns a function, that, as long as it continues to be invoked, will not
   // be triggered. The function will be called after it stops being called for
-  // N milliseconds.
-  _.debounce = function(func, wait) {
+  // N milliseconds. If `immediate` is passed, trigger the function on the
+  // leading edge, instead of the trailing.
+  _.debounce = function(func, wait, immediate) {
     var timeout;
     return function() {
       var context = this, args = arguments;
       var later = function() {
         timeout = null;
-        func.apply(context, args);
+        if (!immediate) func.apply(context, args);
       };
+      if (immediate && !timeout) func.apply(context, args);
       clearTimeout(timeout);
       timeout = setTimeout(later, wait);
     };
@@ -641,6 +646,15 @@
     return obj;
   };
 
+  // Return a copy of the object only containing the whitelisted properties.
+  _.pick = function(obj) {
+    var result = {};
+    each(_.flatten(slice.call(arguments, 1)), function(key) {
+      if (key in obj) result[key] = obj[key];
+    });
+    return result;
+  };
+
   // Fill in a given object with default properties.
   _.defaults = function(obj) {
     each(slice.call(arguments, 1), function(source) {
@@ -761,6 +775,7 @@
   // Is a given array, string, or object empty?
   // An "empty" object has no enumerable own-properties.
   _.isEmpty = function(obj) {
+    if (obj == null) return true;
     if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
     for (var key in obj) if (_.has(obj, key)) return false;
     return true;
@@ -807,6 +822,11 @@
     return toString.call(obj) == '[object Number]';
   };
 
+  // Is a given object a finite number?
+  _.isFinite = function(obj) {
+    return _.isNumber(obj) && isFinite(obj);
+  };
+
   // Is the given value `NaN`?
   _.isNaN = function(obj) {
     // `NaN` is the only value for which `===` is not reflexive.
@@ -868,6 +888,14 @@
     return (''+string).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#x27;').replace(/\//g,'&#x2F;');
   };
 
+  // If the value of the named property is a function then invoke it;
+  // otherwise, return it.
+  _.result = function(object, property) {
+    if (object == null) return null;
+    var value = object[property];
+    return _.isFunction(value) ? value.call(object) : value;
+  };
+
   // Add your own custom functions to the Underscore object, ensuring that
   // they're correctly added to the OOP wrapper as well.
   _.mixin = function(obj) {
@@ -897,39 +925,72 @@
   // guaranteed not to match.
   var noMatch = /.^/;
 
+  // Certain characters need to be escaped so that they can be put into a
+  // string literal.
+  var escapes = {
+    '\\': '\\',
+    "'": "'",
+    'r': '\r',
+    'n': '\n',
+    't': '\t',
+    'u2028': '\u2028',
+    'u2029': '\u2029'
+  };
+
+  for (var p in escapes) escapes[escapes[p]] = p;
+  var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
+  var unescaper = /\\(\\|'|r|n|t|u2028|u2029)/g;
+
   // Within an interpolation, evaluation, or escaping, remove HTML escaping
   // that had been previously added.
   var unescape = function(code) {
-    return code.replace(/\\\\/g, '\\').replace(/\\'/g, "'");
+    return code.replace(unescaper, function(match, escape) {
+      return escapes[escape];
+    });
   };
 
   // JavaScript micro-templating, similar to John Resig's implementation.
   // Underscore templating handles arbitrary delimiters, preserves whitespace,
   // and correctly escapes quotes within interpolated code.
-  _.template = function(str, data) {
-    var c  = _.templateSettings;
-    var tmpl = 'var __p=[],print=function(){__p.push.apply(__p,arguments);};' +
-      'with(obj||{}){__p.push(\'' +
-      str.replace(/\\/g, '\\\\')
-         .replace(/'/g, "\\'")
-         .replace(c.escape || noMatch, function(match, code) {
-           return "',_.escape(" + unescape(code) + "),'";
-         })
-         .replace(c.interpolate || noMatch, function(match, code) {
-           return "'," + unescape(code) + ",'";
-         })
-         .replace(c.evaluate || noMatch, function(match, code) {
-           return "');" + unescape(code).replace(/[\r\n\t]/g, ' ') + ";__p.push('";
-         })
-         .replace(/\r/g, '\\r')
-         .replace(/\n/g, '\\n')
-         .replace(/\t/g, '\\t')
-         + "');}return __p.join('');";
-    var func = new Function('obj', '_', tmpl);
-    if (data) return func(data, _);
-    return function(data) {
-      return func.call(this, data, _);
+  _.template = function(text, data, settings) {
+    settings = _.extend(_.templateSettings, settings);
+
+    // Compile the template source, taking care to escape characters that
+    // cannot be included in a string literal and then unescape them in code
+    // blocks.
+    var source = "__p+='" + text
+      .replace(escaper, function(match) {
+        return '\\' + escapes[match];
+      })
+      .replace(settings.escape || noMatch, function(match, code) {
+        return "'+\n_.escape(" + unescape(code) + ")+\n'";
+      })
+      .replace(settings.interpolate || noMatch, function(match, code) {
+        return "'+\n(" + unescape(code) + ")+\n'";
+      })
+      .replace(settings.evaluate || noMatch, function(match, code) {
+        return "';\n" + unescape(code) + "\n;__p+='";
+      }) + "';\n";
+
+    // If a variable is not specified, place data values in local scope.
+    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
+
+    source = "var __p='';" +
+      "var print=function(){__p+=Array.prototype.join.call(arguments, '')};\n" +
+      source + "return __p;\n";
+
+    var render = new Function(settings.variable || 'obj', '_', source);
+    if (data) return render(data, _);
+    var template = function(data) {
+      return render.call(this, data, _);
     };
+
+    // Provide the compiled function source as a convenience for build time
+    // precompilation.
+    template.source = 'function(' + (settings.variable || 'obj') + '){\n' +
+      source + '}';
+
+    return template;
   };
 
   // Add a "chain" function, which will delegate to the wrapper.

data/lib/judge.rb

@@ -4,4 +4,5 @@ require "validator"
 require "validator_collection"
 require "message_collection"
 require "form_builder"
-require "html"
+require "html"
+require "each_validator"

data/lib/judge/each_validator.rb

@@ -0,0 +1,21 @@
+module Judge
+  module EachValidator
+
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+
+      def declare_messages(*keys)
+        send :define_method, :messages_to_lookup do
+          keys
+        end
+      end
+
+    end
+
+  end
+end
+
+::ActiveModel::EachValidator.send(:include, Judge::EachValidator) if defined?(::ActiveModel::EachValidator)

data/lib/judge/message_collection.rb

@@ -1,95 +1,86 @@
+require 'message_config'
+
 module Judge
 
   class MessageCollection
 
-    MESSAGE_MAP = {
-      :confirmation => { :base => :confirmation },
-      :acceptance   => { :base => :accepted },
-      :presence     => { :base => :blank },
-      :length       => { :base => nil,
-                         :options => {
-                           :minimum => :too_short,
-                           :maximum => :too_long,
-                           :is      => :wrong_length    
-                         }
-                       },
-      :format       => { :base => :invalid },
-      :inclusion    => { :base => :inclusion },
-      :exclusion    => { :base => :exclusion },
-      :numericality => { :base => :not_a_number,
-                         :options => {
-                           :greater_than             => :greater_than, 
-                           :greater_than_or_equal_to => :greater_than_or_equal_to, 
-                           :equal_to                 => :equal_to, 
-                           :less_than                => :less_than, 
-                           :less_than_or_equal_to    => :less_than_or_equal_to,
-                           :odd                      => :odd,
-                           :even                     => :even
-                         }
-                       }
-    }
-
-    ALLOW_BLANK = [:format, :exclusion, :inclusion, :length]
-
-    DEFAULT_OPTS = { :generate => true }
-
-    attr_reader   :object, :method, :kind, :options, :mm
-    attr_accessor :messages
-
-    def initialize(object, method, amv, opts = {})
-      opts = DEFAULT_OPTS.merge(opts)
+    include MessageConfig
+
+    attr_reader   :object, :method, :amv, :kind, :options
+
+    def initialize(object, method, amv)
       @object   = object
       @method   = method
+      @amv      = amv
       @kind     = amv.kind
       @options  = amv.options.dup
-      @mm       = MESSAGE_MAP
       @messages = {}
-      generate_messages! unless opts[:generate] == false
+      generate_messages!
     end
 
     def generate_messages!
-      if messages.blank?
-        %w{base options blank integer}.each do |type|
-          self.send(:"generate_#{type}!")
-        end
+      %w{base options integer custom blank}.each do |type|
+        @messages = @messages.merge(self.send(:"#{type}_messages"))
       end
     end
 
     def to_hash
-      messages
+      @messages
+    end
+
+    def custom_messages?
+      amv.respond_to?(:messages_to_lookup) && amv.messages_to_lookup.present?
     end
 
     private
 
-    def generate_base!
-      if mm.has_key?(kind) && mm[kind][:base].present?
-        base_message = mm[kind][:base]
-        messages[base_message] = object.errors.generate_message(method, base_message, options)
+    def base_messages
+      msgs = {}
+      if MESSAGE_MAP.has_key?(kind) && MESSAGE_MAP[kind][:base].present?
+        base_message = MESSAGE_MAP[kind][:base]
+        msgs[base_message] = object.errors.generate_message(method, base_message, options)
       end
+      msgs
     end
 
-    def generate_options!
-      if mm.has_key?(kind) && mm[kind][:options].present?
-        opt_messages = mm[kind][:options]
+    def options_messages
+      msgs = {}
+      if MESSAGE_MAP.has_key?(kind) && MESSAGE_MAP[kind][:options].present?
+        opt_messages = MESSAGE_MAP[kind][:options]
         opt_messages.each do |opt, opt_message|
           if options.has_key?(opt)
             options_for_interpolation = { :count => options[opt] }.merge(options)
-            messages[opt_message] = object.errors.generate_message(method, opt_message, options_for_interpolation)
+            msgs[opt_message] = object.errors.generate_message(method, opt_message, options_for_interpolation)
           end
         end
       end
+      msgs
     end
 
-    def generate_blank!
-      if ALLOW_BLANK.include?(kind) && options[:allow_blank].blank? && messages[:blank].blank?
-        messages[:blank] = object.errors.generate_message(method, :blank)
+    def blank_messages
+      msgs = {}
+      if ALLOW_BLANK.include?(kind) && options[:allow_blank].blank? && @messages[:blank].blank?
+        msgs[:blank] = object.errors.generate_message(method, :blank)
       end
+      msgs
     end
 
-    def generate_integer!
+    def integer_messages
+      msgs = {}
       if kind == :numericality && options[:only_integer].present?
-        messages[:not_an_integer] = object.errors.generate_message(method, :not_an_integer)
+        msgs[:not_an_integer] = object.errors.generate_message(method, :not_an_integer)
+      end
+      msgs
+    end
+
+    def custom_messages
+      msgs = {}
+      if custom_messages?
+        amv.messages_to_lookup.each do |key|
+          msgs[key.to_sym] = object.errors.generate_message(method, key)
+        end
       end
+      msgs
     end
 
   end