judge 1.2.0 → 1.3.0

data/lib/judge/version.rb

@@ -1,3 +1,3 @@
 module Judge
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 end

data/spec/javascripts/JudgeSpec.js

@@ -11,61 +11,69 @@ describe('judge', function() {
     });
     
     it('validates a single element', function() {
-      var e = document.getElementById('foo_one'),
-          v = judge.validate(e);
-      expect(v.length).toEqual(1);
+      var elements = document.getElementById('foo_one'),
+          results = judge.validate(elements);
+      expect(results.length).toEqual(1);
     });
 
     it('validates a collection of elements', function() {
-      var e = document.querySelectorAll('input[type=radio]'),
-          v = judge.validate(e);
-      expect(v.length).toEqual(1);
+      var elements = document.querySelectorAll('input[type=radio]'),
+          results = judge.validate(elements);
+      expect(results.length).toEqual(1);
+    });
+
+    describe('callbacks', function() {
+      it('calls callback correct number of times', function() {
+        var elements = document.getElementsByTagName('textarea');
+            callback = jasmine.createSpy(),
+            length = elements.length;
+        judge.validate(elements, callback);
+        expect(callback.callCount).toBe(length);
+      });
     });
 
   });
 
   describe('judge.Watcher', function() {
   
-    var j;
+    var watcher;
     
     beforeEach(function() {
       loadFixtures('spec/javascripts/fixtures/form.html');
-      j = new judge.Watcher(document.getElementById('foo_one'));
+      watcher = new judge.Watcher(document.getElementById('foo_one'));
     });
 
     it('returns new instance of judge', function() {
-      expect(typeof j).toEqual('object');
-      expect(j.constructor).toEqual(judge.Watcher);
+      expect(watcher.constructor).toEqual(judge.Watcher);
     });
 
     it('associates with element', function() {
-      expect(j.element).toEqual(document.getElementById('foo_one'));
+      expect(watcher.element).toEqual(document.getElementById('foo_one'));
     });
 
     it('holds validators', function() {
-      expect(_(j.validators).isArray()).toEqual(true);
-      expect(_(j.validators).isEmpty()).toEqual(false);
+      expect(_(watcher.validators).isArray()).toEqual(true);
+      expect(_(watcher.validators).isEmpty()).toEqual(false);
     });
 
     it('holds messages inside validators', function() {
-      expect(_(j.validators).first().hasOwnProperty('messages')).toBe(true);
-      expect(_(j.validators).first().messages).toBeInstanceOf(Object);
+      expect(_(watcher.validators).first().messages).toBeInstanceOf(Object);
     });
 
     it('has validation methods in prototype', function() {
-      expect(j.validates()).not.toBeEmpty();
-      expect(_(j.validates()).keys()).toContain('presence');
+      expect(watcher.validates()).not.toBeEmpty();
+      expect(_(watcher.validates()).keys()).toContain('presence');
     });
 
     it('has custom validation methods when defined by user', function() {
       judge.customValidators.phatness = function() {};
-      expect(_(j.validates()).keys()).toContain('phatness');
+      expect(_(watcher.validates()).keys()).toContain('phatness');
     });
 
     it('throws error if element has no data-validate attribute', function() {
-      var e = document.createElement('input');
-      e.type = 'text';
-      expect(function() { new judge.Watcher(e); }).toThrow();
+      var input = document.createElement('input');
+      input.type = 'text';
+      expect(function() { new judge.Watcher(input); }).toThrow();
     });
 
     it('throws error if no element is passed', function() {
@@ -73,125 +81,6 @@ describe('judge', function() {
     });
 
   });
-    
-  describe('judge.store', function() {
-
-    var e;
-
-    beforeEach(function() {
-      loadFixtures('spec/javascripts/fixtures/form.html');
-      judge.store.clear();
-      e = document.getElementById('foo_one');
-    });
-
-    describe('save / get', function() {
-
-      it('saves Watcher against key', function() {
-        judge.store.save('mykey', e);
-        expect(_(judge.store.get('mykey')).first().constructor).toEqual(judge.Watcher);
-        expect(_(judge.store.get('mykey')).first().element).toBe(e);
-      });
-
-      it('does not save Watcher if element has already been stored against same key', function() {
-        judge.store.save('mykey', e);
-        judge.store.save('mykey', e);
-        expect(judge.store.get('mykey').length).toEqual(1);
-      });
-
-      it('does save Watcher again if key is different', function() {
-        judge.store.save('mykey', e);
-        judge.store.save('mykey2', e);
-        expect(judge.store.get('mykey').length).toEqual(1);
-        expect(judge.store.get('mykey2').length).toEqual(1);
-      });
-
-    });
-
-    describe('getDOM', function() {
-      
-      it('returns DOM elements from stored Watchers', function() {
-        judge.store.save('mykey', e);
-        judge.store.save('mykey', document.getElementById('foo_two_foobar'));
-        var d = judge.store.getDOM('mykey');
-        expect(d.length).toEqual(2);
-        expect(Object.prototype.toString.call(d[0])).toEqual('[object HTMLSelectElement]');
-      });
-
-      it('returns store object with watchers converted to elements if no key given', function() {
-        judge.store.save('mykey', e);
-        judge.store.save('mykey2', document.getElementById('foo_two_foobar'));
-        judge.store.save('mykey2', document.getElementById('foo_three'));
-        var d = judge.store.getDOM();
-        expect(d.mykey.length).toEqual(1);
-        expect(d.mykey2.length).toEqual(2);
-        expect(Object.prototype.toString.call(d.mykey[0])).toEqual('[object HTMLSelectElement]');
-      });
-
-      it('returns null if key not found', function() {
-        expect(judge.store.getDOM('notakey')).toEqual(null);
-      });
-
-    });
-
-    describe('validate', function() {
-      
-      it('validates all elements stored against key', function() {
-        judge.store.save('mykey', e);
-        var results = judge.store.validate('mykey');
-        expect(_(results).first()).toBeInstanceOf(Object);
-        expect(_(results).first().element).toEqual(e);
-      });
-
-      it('returns null if no elements found', function() {
-        var results = judge.store.validate('mykey');
-        expect(results).toBe(null);
-      });
-
-      it('returns null if key is not passed', function() {
-        var results = judge.store.validate();
-        expect(results).toBe(null);
-      });
-
-    });
-
-    describe('remove', function() {
-      
-      it('removes Watcher from store', function() {
-        judge.store.save('mykey', e);
-        expect(_(judge.store.remove('mykey', e)).isUndefined()).toEqual(true);
-        expect(judge.store.get('mykey')).toBe(null);
-      });
-
-      it('returns null if key not found', function() {
-        judge.store.save('mykey', e);
-        expect(judge.store.remove('notakey', e)).toEqual(null);
-      });
-
-    });
-
-    describe('clear', function() {
-      
-      it('clears entire store if no key is passed', function() {
-        judge.store.save('mykey', e);
-        judge.store.clear();
-        expect(judge.store.get()).toEqual({});
-      });
-
-      it('clears all Watchers against key', function() {
-        judge.store.save('mykey', e);
-        judge.store.save('mykey2', e);
-        judge.store.clear('mykey');
-        expect(judge.store.get('mykey')).toBe(null);
-        expect(judge.store.get('mykey2').length).toEqual(1);
-      });
-
-      it('returns null if key not found', function() {
-        expect(judge.store.clear('notakey')).toBe(null);
-      });
-
-    });
-
-  });
 
   describe('judge.Watcher instance methods', function() {
 
@@ -201,179 +90,174 @@ describe('judge', function() {
 
     describe('validate method', function() {
       
-      var j, r;
+      var watcher, result;
 
       beforeEach(function() {
-        j = new judge.Watcher(document.getElementById('foo_one'));
-        r = j.validate();
+        watcher = new judge.Watcher(document.getElementById('foo_one'));
+        result = watcher.validate();
       });
 
       it('returns element', function() {
-        expect(r.element).toBeInstanceOf(Object);
+        expect(result.element).toBeInstanceOf(Object);
       });
 
       it('returns validity', function() {
-        expect(typeof r.valid).toEqual('boolean');
+        expect(_.isBoolean(result.valid)).toBe(true);
       });
 
       it('returns messages', function() {
-        expect(r.messages).toBeInstanceOf(Array);
+        expect(result.messages).toBeInstanceOf(Array);
+      });
+
+      describe('callback', function() {
+
+        var callback, args;
+
+        beforeEach(function() {
+          callback = jasmine.createSpy();
+          watcher.validate(callback);
+          args = callback.argsForCall[0];
+        });
+
+        it('is called when given', function() {
+          expect(callback).toHaveBeenCalled();
+        });
+        it('receives correct args', function() {
+          expect(_.isBoolean(args[0])).toBe(true);
+          expect(_.isArray(args[1])).toBe(true);
+          expect(_.isElement(args[2])).toBe(true);
+        });
+        
       });
 
     });
     
     describe('presence', function() {
       
-      var j;
+      var watcher;
 
       beforeEach(function() {
-        j = new judge.Watcher(document.getElementById('foo_one'));
+        watcher = new judge.Watcher(document.getElementById('foo_one'));
       });
       
       it('invalidates empty input', function() {
-        expect(j.validate().valid).toEqual(false);
-      });
-
-      it('returns message', function() {
-        expect(j.validate().messages).not.toBeEmpty();
+        expect(watcher.validate().valid).toEqual(false);
       });
 
       it('validates non-empty input', function() {
-        j.element.children[1].selected = true;
-        expect(j.validate().valid).toEqual(true);
+        watcher.element.children[1].selected = true;
+        expect(watcher.validate().valid).toEqual(true);
       });
 
     });
 
     describe('length', function() {
 
-      var j;
+      var watcher;
 
       beforeEach(function() {
-        j = new judge.Watcher(document.getElementById('foo_two_foobar'));
+        watcher = new judge.Watcher(document.getElementById('foo_two_foobar'));
       });
 
       it('validates valid input', function() {
-        j.element.value = 'abcdef';
-        expect(j.validate().valid).toEqual(true);
+        watcher.element.value = 'abcdef';
+        expect(watcher.validate().valid).toEqual(true);
       });
 
       it('validates allow_blank', function() {
-        j.element.value = '';
-        expect(j.validate().valid).toEqual(true);
-      });
-
-      it('returns message', function() {
-        j.element.value = 'abc';
-        expect(j.validate().messages).not.toBeEmpty();
+        watcher.element.value = '';
+        expect(watcher.validate().valid).toEqual(true);
       });
 
       it('invalidates when value is under minimum', function() {
-        j.element.value = 'abc';
-        expect(j.validate().valid).toEqual(false);
+        watcher.element.value = 'abc';
+        expect(watcher.validate().valid).toEqual(false);
       });
 
       it('invalidates when value is over maximum', function() {
-        j.element.value = 'abcdefghijkl';
-        expect(j.validate().valid).toEqual(false);
+        watcher.element.value = 'abcdefghijkl';
+        expect(watcher.validate().valid).toEqual(false);
       });
-
-      //it('invalidates when value is not equal to is', function() {
-      //  jIs.element.value = 'abc';
-      //  expect(jIs.validate().valid).toEqual(false);
-      //});
     });
 
     describe('exclusion', function() {
 
-      var j;
+      var watcher;
 
       beforeEach(function() {
-        j = new judge.Watcher(document.getElementById('foo_three'));
+        watcher = new judge.Watcher(document.getElementById('foo_three'));
       });
       
       it('validates when value is not in array', function() {
-        expect(j.validate().valid).toEqual(true);
+        expect(watcher.validate().valid).toEqual(true);
       });
 
       it('invalidates when value is in array', function() {
-        j.element.children[1].selected = true;
-        expect(j.validate().valid).toEqual(false);
-      }); 
-
-      it('returns message', function() {
-        expect(j.validate().messages).not.toBeEmpty();
+        watcher.element.children[1].selected = true;
+        expect(watcher.validate().valid).toEqual(false);
       });
 
     });
 
     describe('inclusion', function() {
 
-      var j;
+      var watcher;
 
       beforeEach(function() {
-        j = new judge.Watcher(document.getElementById('foo_three_inc'));
+        watcher = new judge.Watcher(document.getElementById('foo_three_inc'));
       });
       
       it('validates when value is in array', function() {
-        j.element.children[1].selected = true;
-        expect(j.validate().valid).toEqual(true);
+        watcher.element.children[1].selected = true;
+        expect(watcher.validate().valid).toEqual(true);
       });
 
       it('invalidates when value is not in array', function() {
-        expect(j.validate().valid).toEqual(false);
-      });
-
-      it('returns message', function() {
-        expect(j.validate().messages).not.toBeEmpty();
+        expect(watcher.validate().valid).toEqual(false);
       });
 
     });
 
     describe('numericality', function() {
 
-      var j, jEven, jGt, jLt;
+      var watcher, watcherEven, watcherGt, watcherLt;
 
       beforeEach(function() {
-        j     = new judge.Watcher(document.getElementById('foo_four'));
-        jEven = new judge.Watcher(document.getElementById('foo_four_even'));
-        jGt   = new judge.Watcher(document.getElementById('foo_four_gt'));
-        jLt   = new judge.Watcher(document.getElementById('foo_four_lt'));
+        watcher     = new judge.Watcher(document.getElementById('foo_four'));
+        watcherEven = new judge.Watcher(document.getElementById('foo_four_even'));
+        watcherGt   = new judge.Watcher(document.getElementById('foo_four_gt'));
+        watcherLt   = new judge.Watcher(document.getElementById('foo_four_lt'));
       });
 
       it('invalidates when value is not a number', function() {
-        j.element.value = 'foo bar';
-        expect(j.validate().valid).toEqual(false);
-        expect(j.validate().messages).not.toBeEmpty();
+        watcher.element.value = 'foo bar';
+        expect(watcher.validate().valid).toEqual(false);
       });
 
       it('validates odd / invalidates not odd', function() {
-        j.element.value = '2';
-        expect(j.validate().valid).toEqual(false);
-        expect(j.validate().messages).not.toBeEmpty();
-        j.element.value = '1';
-        expect(j.validate().valid).toEqual(true);
+        watcher.element.value = '2';
+        expect(watcher.validate().valid).toEqual(false);
+        watcher.element.value = '1';
+        expect(watcher.validate().valid).toEqual(true);
       });
 
       it('validates even / invalidates not even', function() {
-        jEven.element.value = '1';
-        expect(jEven.validate().valid).toEqual(false);
-        expect(jEven.validate().messages).not.toBeEmpty();
-        jEven.element.value = '2';
-        expect(jEven.validate().valid).toEqual(true);
+        watcherEven.element.value = '1';
+        expect(watcherEven.validate().valid).toEqual(false);
+        watcherEven.element.value = '2';
+        expect(watcherEven.validate().valid).toEqual(true);
       });
 
       describe('integer', function() {
 
         it('validates int', function() {
-          j.element.value = '1';
-          expect(j.validate().valid).toEqual(true);
+          watcher.element.value = '1';
+          expect(watcher.validate().valid).toEqual(true);
         });
 
         it('invalidates float', function() {
-          j.element.value = '1.1';
-          expect(j.validate().valid).toEqual(false);
-          expect(j.validate().messages).not.toBeEmpty();
+          watcher.element.value = '1.1';
+          expect(watcher.validate().valid).toEqual(false);
         });
 
       });
@@ -381,17 +265,15 @@ describe('judge', function() {
       describe('greater than', function() {
         
         it('invalidates not greater than', function() {
-          jGt.element.value = '6';
-          expect(jGt.validate().valid).toEqual(false);
-          expect(jGt.validate().messages).not.toBeEmpty();
-          jGt.element.value = '7';
-          expect(jGt.validate().valid).toEqual(false);
-          expect(jGt.validate().messages).not.toBeEmpty();
+          watcherGt.element.value = '6';
+          expect(watcherGt.validate().valid).toEqual(false);
+          watcherGt.element.value = '7';
+          expect(watcherGt.validate().valid).toEqual(false);
         });
 
         it('validates greater than', function() {
-          jGt.element.value = '8';
-          expect(jGt.validate().valid).toEqual(true);
+          watcherGt.element.value = '8';
+          expect(watcherGt.validate().valid).toEqual(true);
         });
 
       });
@@ -399,84 +281,55 @@ describe('judge', function() {
       describe('less than', function() {
         
         it('invalidates not less than', function() {
-          jLt.element.value = '8';
-          expect(jLt.validate().valid).toEqual(false);
-          jLt.element.value = '7';
-          expect(jLt.validate().valid).toEqual(false);
+          watcherLt.element.value = '8';
+          expect(watcherLt.validate().valid).toEqual(false);
+          watcherLt.element.value = '7';
+          expect(watcherLt.validate().valid).toEqual(false);
         });
 
         it('validates less than', function() {
-          jLt.element.value = '6';
-          expect(jLt.validate().valid).toEqual(true);
+          watcherLt.element.value = '6';
+          expect(watcherLt.validate().valid).toEqual(true);
         });
-
       });
-
-      //it('validates equal to', function() {
-      //  jLt.element.value = '5';
-      //  expect(jLt.validate().valid).toEqual(false);
-      //  jLt.element.value = '6';
-      //  expect(jLt.validate().valid).toEqual(true);
-      //});
-
-      //it('validates less than or equal to', function() {
-      //  j.element.value = '5';
-      //  expect(j.validate().valid).toEqual(true);
-      //  j.element.value = '7';
-      //  expect(j.validate().valid).toEqual(true);
-      //  j.element.value = '9';
-      //  expect(j.validate().valid).toEqual(false);
-      //});
-
-      //it('validates greater than or equal to', function() {
-      //  jEven.element.value = '20';
-      //  expect(jEven.validate().valid).toEqual(true);
-      //  jEven.element.value = '2';
-      //  expect(jEven.validate().valid).toEqual(true);
-      //  jEven.element.value = '1';
-      //  expect(jEven.validate().valid).toEqual(false);
-      //});
-
     });
 
     describe('format', function() {
 
       describe('with', function() {
         
-        var j;
+        var watcher;
 
         beforeEach(function() {
-          j = new judge.Watcher(document.getElementById('foo_five_wi'));
+          watcher = new judge.Watcher(document.getElementById('foo_five_wi'));
         });
 
         it('invalidates value matching with', function() {
-          expect(j.validate().valid).toEqual(false);
-          expect(j.validate().messages).not.toBeEmpty();
+          expect(watcher.validate().valid).toEqual(false);
         });
 
         it('invalidates value not matching with', function() {
-          j.element.children[1].selected = true;
-          expect(j.validate().valid).toEqual(true);
+          watcher.element.children[1].selected = true;
+          expect(watcher.validate().valid).toEqual(true);
         });
 
       });
 
       describe('without', function() {
 
-        var j;
+        var watcher;
 
         beforeEach(function() {
-          j = new judge.Watcher(document.getElementById('foo_five_wo'));
+          watcher = new judge.Watcher(document.getElementById('foo_five_wo'));
         });
 
         it('validates value not matching with', function() {
-          expect(j.validate().valid).toEqual(true);
+          expect(watcher.validate().valid).toEqual(true);
         });
 
         it('invalidates value matching with', function() {
-          j.element.children[1].selected = true;
-          expect(j.validate().valid).toEqual(false);
-          expect(j.validate().messages).not.toBeEmpty();
+          watcher.element.children[1].selected = true;
+          expect(watcher.validate().valid).toEqual(false);
         });
 
       });
@@ -485,178 +338,161 @@ describe('judge', function() {
 
     describe('acceptance', function() {
 
-      var j;
+      var watcher;
 
       beforeEach(function() {
-        j = new judge.Watcher(document.getElementById('foo_six'));
+        watcher = new judge.Watcher(document.getElementById('foo_six'));
       });
 
       it('validates when element is checked', function() {
-        j.element.checked = true;
-        expect(j.validate().valid).toEqual(true);        
+        watcher.element.checked = true;
+        expect(watcher.validate().valid).toEqual(true);        
       });
 
       it('invalidates when element is not checked', function() {
-        expect(j.validate().valid).toEqual(false);
+        expect(watcher.validate().valid).toEqual(false);
       });
 
     });
 
     describe('confirmation', function() {
       
-      var j, c;
+      var watcher, conf;
 
       beforeEach(function() {
-        j = new judge.Watcher(document.getElementById('foo_seven'));
-        c = document.getElementById('foo_seven_confirmation');
+        watcher = new judge.Watcher(document.getElementById('foo_seven'));
+        conf = document.getElementById('foo_seven_confirmation');
       });
 
       it('validates when confirmed', function() {
-        j.element.value = 'password';
-        c.value = 'password';
-        expect(j.validate().valid).toEqual(true);
+        watcher.element.value = 'password';
+        conf.value = 'password';
+        expect(watcher.validate().valid).toEqual(true);
       });
 
       it('invalidates when not confirmed', function() {
-        j.element.value = 'password';
-        c.value = 'wrongpassword';
-        expect(j.validate().valid).toEqual(false);
+        watcher.element.value = 'password';
+        conf.value = 'wrongpassword';
+        expect(watcher.validate().valid).toEqual(false);
       });
 
     });
 
   });
 
-  describe('utils', function() {
+  describe('judge.store', function() {
 
-    describe('isCollection', function() {
-      
-      beforeEach(function() {
-        loadFixtures('spec/javascripts/fixtures/form.html');
+    var element;
+
+    beforeEach(function() {
+      loadFixtures('spec/javascripts/fixtures/form.html');
+      judge.store.clear();
+      element = document.getElementById('foo_one');
+    });
+
+    describe('save / get', function() {
+
+      it('saves Watcher against key', function() {
+        judge.store.save('mykey', element);
+        expect(_(judge.store.get('mykey')).first().constructor).toEqual(judge.Watcher);
+        expect(_(judge.store.get('mykey')).first().element).toBe(element);
       });
 
-      it('returns true if judge can treat object as collection', function() {
-        var a = [],
-            n = document.getElementsByTagName('input');
-        expect(judge.utils.isCollection(a)).toEqual(true);
-        expect(judge.utils.isCollection(n)).toEqual(true);
+      it('does not save Watcher if element has already been stored against same key', function() {
+        judge.store.save('mykey', element);
+        judge.store.save('mykey', element);
+        expect(judge.store.get('mykey').length).toEqual(1);
       });
 
-      it('returns false otherwise', function() {
-        var o = { a:1, b:2 };
-        expect(judge.utils.isCollection(o)).toEqual(false);
+      it('does save Watcher again if key is different', function() {
+        judge.store.save('mykey', element);
+        judge.store.save('mykey2', element);
+        expect(judge.store.get('mykey').length).toEqual(1);
+        expect(judge.store.get('mykey2').length).toEqual(1);
       });
 
     });
 
-    describe('getObjectString', function() {
+    describe('getDOM', function() {
       
-      it('returns type as represented in Object.prototype.toString', function() {
-        var i = document.createElement('input'),
-            s = document.createElement('select');
-        expect(judge.utils.getObjectString(i)).toEqual('HTMLInputElement');
-        expect(judge.utils.getObjectString(s)).toEqual('HTMLSelectElement');
+      it('returns DOM elements from stored Watchers', function() {
+        judge.store.save('mykey', element);
+        judge.store.save('mykey', document.getElementById('foo_two_foobar'));
+        var storedElements = judge.store.getDOM('mykey');
+        expect(storedElements.length).toEqual(2);
+        expect(Object.prototype.toString.call(storedElements[0])).toEqual('[object HTMLSelectElement]');
       });
 
-    });
-    
-    describe('isInt', function() {
-      
-      it('returns true when int', function() {
-        expect(judge.utils.isInt(1)).toEqual(true);
-        expect(judge.utils.isInt(1.)).toEqual(true);
-        expect(judge.utils.isInt(1.0)).toEqual(true);
-        expect(judge.utils.isInt(0)).toEqual(true);
-        expect(judge.utils.isInt(-1)).toEqual(true);
+      it('returns store object with watchers converted to elements if no key given', function() {
+        judge.store.save('mykey', element);
+        judge.store.save('mykey2', document.getElementById('foo_two_foobar'));
+        judge.store.save('mykey2', document.getElementById('foo_three'));
+        var storedElements = judge.store.getDOM();
+        expect(storedElements.mykey.length).toEqual(1);
+        expect(storedElements.mykey2.length).toEqual(2);
+        expect(Object.prototype.toString.call(storedElements.mykey[0])).toEqual('[object HTMLSelectElement]');
       });
 
-      it('returns false when not int', function() {
-        expect(judge.utils.isInt(1.1)).toEqual(false);
-        expect(judge.utils.isInt(-1.1)).toEqual(false);
+      it('returns null if key not found', function() {
+        expect(judge.store.getDOM('notakey')).toEqual(null);
       });
 
     });
 
-    describe('isFloat', function() {
-      
-      it('returns true when float', function() {
-        expect(judge.utils.isFloat(1.1)).toEqual(true);
-        expect(judge.utils.isFloat(-1.1)).toEqual(true);
-      });
+    describe('validate', function() {
       
-      it('returns false when not float', function() {
-         expect(judge.utils.isFloat(1)).toEqual(false);
-         expect(judge.utils.isFloat(1.)).toEqual(false);
-         expect(judge.utils.isFloat(1.0)).toEqual(false);
-         expect(judge.utils.isFloat(0)).toEqual(false);
-         expect(judge.utils.isFloat(-1)).toEqual(false);
+      it('validates all elements stored against key', function() {
+        judge.store.save('mykey', element);
+        var results = judge.store.validate('mykey');
+        expect(_(results).first()).toBeInstanceOf(Object);
+        expect(_(results).first().element).toEqual(element);
       });
 
-    });
-
-    describe('isEven', function() {
-      
-      it('returns true when even', function() {
-        expect(judge.utils.isEven(2)).toEqual(true);
-        expect(judge.utils.isEven(0)).toEqual(true);
-        expect(judge.utils.isEven(-2)).toEqual(true);
+      it('returns null if no elements found', function() {
+        var results = judge.store.validate('mykey');
+        expect(results).toBe(null);
       });
-      
-      it('returns false when odd', function() {
-        expect(judge.utils.isEven(1)).toEqual(false);
-        expect(judge.utils.isEven(-1)).toEqual(false);
+
+      it('returns null if key is not passed', function() {
+        var results = judge.store.validate();
+        expect(results).toBe(null);
       });
 
     });
 
-    describe('isOdd', function() {
-      
-      it('returns true when odd', function() {
-        expect(judge.utils.isOdd(1)).toEqual(true);
-        expect(judge.utils.isOdd(-1)).toEqual(true);
-      });
+    describe('remove', function() {
       
-      it('returns false when even', function() {
-        expect(judge.utils.isOdd(2)).toEqual(false);
-        expect(judge.utils.isOdd(0)).toEqual(false);
-        expect(judge.utils.isOdd(-2)).toEqual(false);
+      it('removes Watcher from store', function() {
+        judge.store.save('mykey', element);
+        expect(_(judge.store.remove('mykey', element)).isUndefined()).toEqual(true);
+        expect(judge.store.get('mykey')).toBe(null);
       });
 
-    });
-
-    describe('operate', function() {
-      
-      it('evaluates and returns true or false', function() {
-        expect(judge.utils.operate(1, '<', 4)).toEqual(true);
-        expect(judge.utils.operate(1, '==', 1)).toEqual(true);
-        expect(judge.utils.operate(1, '>=', 4)).toEqual(false);
+      it('returns null if key not found', function() {
+        judge.store.save('mykey', element);
+        expect(judge.store.remove('notakey', element)).toEqual(null);
       });
 
     });
 
-    describe('convertRegExp', function() {
+    describe('clear', function() {
       
-      it('converts string format options-first ruby regexp into RegExp object', function() {
-        var re = judge.utils.convertRegExp('(?mix:[A-Z0-9]\.)');
-        expect(re).toBeInstanceOf(RegExp);
-        expect(re.source).toEqual('[A-Z0-9]\.');
-        expect(re.multiline).toEqual(true);
-        expect(re.global).toEqual(false);
+      it('clears entire store if no key is passed', function() {
+        judge.store.save('mykey', element);
+        judge.store.clear();
+        expect(judge.store.get()).toEqual({});
       });
 
-    });
-
-    describe('convertFlags', function() {
-
-      it('returns m if present in options string without negation', function() {
-        expect(judge.utils.convertFlags('mix')).toEqual('m');
-        expect(judge.utils.convertFlags('m-ix')).toEqual('m');
-        expect(judge.utils.convertFlags('mx-i')).toEqual('m');
+      it('clears all Watchers against key', function() {
+        judge.store.save('mykey', element);
+        judge.store.save('mykey2', element);
+        judge.store.clear('mykey');
+        expect(judge.store.get('mykey')).toBe(null);
+        expect(judge.store.get('mykey2').length).toEqual(1);
       });
 
-      it('returns empty string otherwise', function() {
-        expect(judge.utils.convertFlags('ix-m')).toEqual('');
-        expect(judge.utils.convertFlags('x-mi')).toEqual('');
+      it('returns null if key not found', function() {
+        expect(judge.store.clear('notakey')).toBe(null);
       });
 
     });