headless-squirrel 0.5.1

data/test/regression/prototype/unit/tests/element_mixins_test.js

@@ -0,0 +1,32 @@
+new Test.Unit.Runner({
+  testInput: function() {
+    this.assert($("input").present != null);
+    this.assert(typeof $("input").present == 'function');
+    this.assert($("input").select != null);
+    this.assertRespondsTo('present', Form.Element);
+    this.assertRespondsTo('present', Form.Element.Methods);
+    this.assertRespondsTo('coffee', $('input'));
+    this.assertIdentical(Prototype.K, Form.Element.coffee);
+    this.assertIdentical(Prototype.K, Form.Element.Methods.coffee);
+  },
+  
+  testForm: function() {
+    this.assert($("form").reset != null);
+    this.assert($("form").getInputs().length == 2);
+  },
+  
+  testEvent: function() {
+    this.assert($("form").observe != null)
+    // Can't really test this one with TestUnit...
+    $('form').observe("submit", function(e) { 
+      alert("yeah!"); 
+      Event.stop(e); 
+    });
+  },
+  
+  testCollections: function() {
+    this.assert($$("input").all(function(input) {
+      return (input.focus != null);
+    }));
+  }
+});

data/test/regression/prototype/unit/tests/enumerable_test.js

@@ -0,0 +1,271 @@
+function prime(value) {
+  for (var i = 2; i < value; i++)
+    if (value % i == 0) return false;
+  return true;
+}
+
+new Test.Unit.Runner({    
+  testEachBreak: function() {
+    var result = 0;
+    Fixtures.Basic.each(function(value) {
+      if ((result = value) == 2) throw $break;
+    });
+    
+    this.assertEqual(2, result);
+  },
+  
+  testEachReturnActsAsContinue: function() {
+    var results = [];
+    Fixtures.Basic.each(function(value) {
+      if (value == 2) return;
+      results.push(value);
+    });
+    
+    this.assertEqual('1, 3', results.join(', '));
+  },
+  
+  testEachChaining: function() {
+    this.assertEqual(Fixtures.Primes, Fixtures.Primes.each(Prototype.emptyFunction));
+    this.assertEqual(3, Fixtures.Basic.each(Prototype.emptyFunction).length);
+  },
+
+  testEnumContext: function() {
+    var results = [];
+    Fixtures.Basic.each(function(value) {
+      results.push(value * this.i);
+    }, { i: 2 });
+    
+    this.assertEqual('2 4 6', results.join(' '));
+
+    this.assert(Fixtures.Basic.all(function(value){
+      return value >= this.min && value <= this.max;
+    }, { min: 1, max: 3 }));
+    this.assert(!Fixtures.Basic.all(function(value){
+      return value >= this.min && value <= this.max;
+    }));
+    this.assert(Fixtures.Basic.any(function(value){
+      return value == this.target_value;
+    }, { target_value: 2 }));
+  },
+
+  testAny: function() {
+    this.assert(!([].any()));
+    
+    this.assert([true, true, true].any());
+    this.assert([true, false, false].any());
+    this.assert(![false, false, false].any());
+    
+    this.assert(Fixtures.Basic.any(function(value) {
+      return value > 2;
+    }));
+    this.assert(!Fixtures.Basic.any(function(value) {
+      return value > 5;
+    }));
+  },
+  
+  testAll: function() {
+    this.assert([].all());
+    
+    this.assert([true, true, true].all());
+    this.assert(![true, false, false].all());
+    this.assert(![false, false, false].all());
+
+    this.assert(Fixtures.Basic.all(function(value) {
+      return value > 0;
+    }));
+    this.assert(!Fixtures.Basic.all(function(value) {
+      return value > 1;
+    }));
+  },
+  
+  testCollect: function() {
+    this.assertEqual(Fixtures.Nicknames.join(', '), 
+      Fixtures.People.collect(function(person) {
+        return person.nickname;
+      }).join(", "));
+    
+    this.assertEqual(26,  Fixtures.Primes.map().length);
+  },
+  
+  testDetect: function() {
+    this.assertEqual('Marcel Molina Jr.', 
+      Fixtures.People.detect(function(person) {
+        return person.nickname.match(/no/);
+      }).name);
+  },
+  
+  testEachSlice: function() {
+    this.assertEnumEqual([], [].eachSlice(2));
+    this.assertEqual(1, [1].eachSlice(1).length);
+    this.assertEnumEqual([1], [1].eachSlice(1)[0]);
+    this.assertEqual(2, Fixtures.Basic.eachSlice(2).length);
+    this.assertEnumEqual(
+      [3, 2, 1, 11, 7, 5, 19, 17, 13, 31, 29, 23, 43, 41, 37, 59, 53, 47, 71, 67, 61, 83, 79, 73, 97, 89],
+      Fixtures.Primes.eachSlice( 3, function(slice){ return slice.reverse() }).flatten()
+    );
+    this.assertEnumEqual(Fixtures.Basic, Fixtures.Basic.eachSlice(-10));
+    this.assertEnumEqual(Fixtures.Basic, Fixtures.Basic.eachSlice(0));
+    this.assertNotIdentical(Fixtures.Basic, Fixtures.Basic.eachSlice(0));
+  },
+  
+  testEachWithIndex: function() {
+    var nicknames = [], indexes = [];
+    Fixtures.People.each(function(person, index) {
+      nicknames.push(person.nickname);
+      indexes.push(index);
+    });
+    
+    this.assertEqual(Fixtures.Nicknames.join(', '), 
+      nicknames.join(', '));
+    this.assertEqual('0, 1, 2, 3', indexes.join(', '));
+  },
+  
+  testFindAll: function() {
+    this.assertEqual(Fixtures.Primes.join(', '),
+      Fixtures.Z.findAll(prime).join(', '));
+  },
+  
+  testGrep: function() {
+    this.assertEqual('noradio, htonl', 
+      Fixtures.Nicknames.grep(/o/).join(", "));
+      
+    this.assertEqual('NORADIO, HTONL', 
+      Fixtures.Nicknames.grep(/o/, function(nickname) {
+        return nickname.toUpperCase();
+      }).join(", "))
+
+    this.assertEnumEqual($('grepHeader', 'grepCell'),
+      $('grepTable', 'grepTBody', 'grepRow', 'grepHeader', 'grepCell').grep(new Selector('.cell')));
+
+    // troublesome characters
+    this.assertEnumEqual(['?a', 'c?'], ['?a','b','c?'].grep('?'));
+    this.assertEnumEqual(['*a', 'c*'], ['*a','b','c*'].grep('*'));
+    this.assertEnumEqual(['+a', 'c+'], ['+a','b','c+'].grep('+'));
+    this.assertEnumEqual(['{1}a', 'c{1}'], ['{1}a','b','c{1}'].grep('{1}'));
+    this.assertEnumEqual(['(a', 'c('], ['(a','b','c('].grep('('));
+    this.assertEnumEqual(['|a', 'c|'], ['|a','b','c|'].grep('|'));
+  },
+  
+  testInclude: function() {
+    this.assert(Fixtures.Nicknames.include('sam-'));
+    this.assert(Fixtures.Nicknames.include('noradio'));
+    this.assert(!Fixtures.Nicknames.include('gmosx'));
+    this.assert(Fixtures.Basic.include(2));
+    this.assert(Fixtures.Basic.include('2'));
+    this.assert(!Fixtures.Basic.include('4'));
+  },
+  
+  testInGroupsOf: function() {
+    this.assertEnumEqual([], [].inGroupsOf(3));
+    
+    var arr = [1, 2, 3, 4, 5, 6].inGroupsOf(3);
+    this.assertEqual(2, arr.length);
+    this.assertEnumEqual([1, 2, 3], arr[0]);
+    this.assertEnumEqual([4, 5, 6], arr[1]);
+    
+    arr = [1, 2, 3, 4, 5, 6].inGroupsOf(4);
+    this.assertEqual(2, arr.length);
+    this.assertEnumEqual([1, 2, 3, 4], arr[0]);
+    this.assertEnumEqual([5, 6, null, null], arr[1]);
+    
+    var basic = Fixtures.Basic
+    
+    arr = basic.inGroupsOf(4,'x');
+    this.assertEqual(1, arr.length);
+    this.assertEnumEqual([1, 2, 3, 'x'], arr[0]);
+    
+    this.assertEnumEqual([1,2,3,'a'], basic.inGroupsOf(2, 'a').flatten());
+
+    arr = basic.inGroupsOf(5, '');
+    this.assertEqual(1, arr.length);
+    this.assertEnumEqual([1, 2, 3, '', ''], arr[0]);
+
+    this.assertEnumEqual([1,2,3,0], basic.inGroupsOf(2, 0).flatten());
+    this.assertEnumEqual([1,2,3,false], basic.inGroupsOf(2, false).flatten());
+  },
+  
+  testInject: function() {
+    this.assertEqual(1061, 
+      Fixtures.Primes.inject(0, function(sum, value) {
+        return sum + value;
+      }));
+  },
+  
+  testInvoke: function() {
+    var result = [[2, 1, 3], [6, 5, 4]].invoke('sort');
+    this.assertEqual(2, result.length);
+    this.assertEqual('1, 2, 3', result[0].join(', '));
+    this.assertEqual('4, 5, 6', result[1].join(', '));
+    
+    result = result.invoke('invoke', 'toString', 2);
+    this.assertEqual('1, 10, 11', result[0].join(', '));
+    this.assertEqual('100, 101, 110', result[1].join(', '));
+  },
+  
+  testMax: function() {
+    this.assertEqual(100, Fixtures.Z.max());
+    this.assertEqual(97, Fixtures.Primes.max());
+    this.assertEqual(2, [ -9, -8, -7, -6, -4, -3, -2,  0, -1,  2 ].max());
+    this.assertEqual('sam-', Fixtures.Nicknames.max()); // ?s > ?U
+  },
+  
+  testMin: function() {
+    this.assertEqual(1, Fixtures.Z.min());
+    this.assertEqual(0, [  1, 2, 3, 4, 5, 6, 7, 8, 0, 9 ].min());
+    this.assertEqual('Ulysses', Fixtures.Nicknames.min()); // ?U < ?h
+  },
+  
+  testPartition: function() {
+    var result = Fixtures.People.partition(function(person) {
+      return person.name.length < 15;
+    }).invoke('pluck', 'nickname');
+    
+    this.assertEqual(2, result.length);
+    this.assertEqual('sam-, htonl', result[0].join(', '));
+    this.assertEqual('noradio, Ulysses', result[1].join(', '));
+  },
+  
+  testPluck: function() {
+    this.assertEqual(Fixtures.Nicknames.join(', '),
+      Fixtures.People.pluck('nickname').join(', '));
+  },
+  
+  testReject: function() {
+    this.assertEqual(0, 
+      Fixtures.Nicknames.reject(Prototype.K).length);
+      
+    this.assertEqual('sam-, noradio, htonl',
+      Fixtures.Nicknames.reject(function(nickname) {
+        return nickname != nickname.toLowerCase();
+      }).join(', '));
+  },
+  
+  testSortBy: function() {
+    this.assertEqual('htonl, noradio, sam-, Ulysses',
+      Fixtures.People.sortBy(function(value) {
+        return value.nickname.toLowerCase();
+      }).pluck('nickname').join(', '));
+  },
+  
+  testToArray: function() {
+    var result = Fixtures.People.toArray();
+    this.assert(result != Fixtures.People); // they're different objects...
+    this.assertEqual(Fixtures.Nicknames.join(', '),
+      result.pluck('nickname').join(', ')); // but the values are the same
+  },
+  
+  testZip: function() {
+    var result = [1, 2, 3].zip([4, 5, 6], [7, 8, 9]);
+    this.assertEqual('[[1, 4, 7], [2, 5, 8], [3, 6, 9]]', result.inspect());
+    
+    result = [1, 2, 3].zip([4, 5, 6], [7, 8, 9], function(array) { return array.reverse() });
+    this.assertEqual('[[7, 4, 1], [8, 5, 2], [9, 6, 3]]', result.inspect());
+  },
+  
+  testSize: function() {
+    this.assertEqual(4, Fixtures.People.size());
+    this.assertEqual(4, Fixtures.Nicknames.size());
+    this.assertEqual(26, Fixtures.Primes.size());
+    this.assertEqual(0, [].size());
+  }
+});

data/test/regression/prototype/unit/tests/event_test.js

@@ -0,0 +1,235 @@
+var documentLoaded = document.loaded;
+
+new Test.Unit.Runner({
+  
+  // test firing an event and observing it on the element it's fired from
+  testCustomEventFiring: function() {
+    var span = $("span"), fired = false, observer = function(event) {
+      this.assertEqual(span, event.element());
+      this.assertEqual(1, event.memo.index);
+      fired = true;
+    }.bind(this);
+    
+    span.observe("test:somethingHappened", observer);
+    span.fire("test:somethingHappened", { index: 1 });
+    this.assert(fired);
+    
+    fired = false;
+    span.fire("test:somethingElseHappened");
+    this.assert(!fired);
+    
+    span.stopObserving("test:somethingHappened", observer);
+    span.fire("test:somethingHappened");
+    this.assert(!fired);
+  },
+  
+  // test firing an event and observing it on a containing element
+  testCustomEventBubbling: function() {
+    var span = $("span"), outer = $("outer"), fired = false, observer = function(event) {
+      this.assertEqual(span, event.element());
+      fired = true;
+    }.bind(this);
+    
+    outer.observe("test:somethingHappened", observer);
+    span.fire("test:somethingHappened");
+    this.assert(fired);
+    
+    fired = false;
+    span.fire("test:somethingElseHappened");
+    this.assert(!fired);
+    
+    outer.stopObserving("test:somethingHappened", observer);
+    span.fire("test:somethingHappened");
+    this.assert(!fired);
+  },
+  
+  testCustomEventCanceling: function() {
+    var span = $("span"), outer = $("outer"), inner = $("inner");
+    var fired = false, stopped = false;
+
+    function outerObserver(event) {
+      fired = span == event.element();
+    }
+    
+    function innerObserver(event) {
+      event.stop();
+      stopped = true;
+    }
+    
+    inner.observe("test:somethingHappened", innerObserver);
+    outer.observe("test:somethingHappened", outerObserver);
+    span.fire("test:somethingHappened");
+    this.assert(stopped);
+    this.assert(!fired);
+    
+    fired = stopped = false;
+    inner.stopObserving("test:somethingHappened", innerObserver);
+    span.fire("test:somethingHappened");
+    this.assert(!stopped);
+    this.assert(fired);
+    
+    outer.stopObserving("test:somethingHappened", outerObserver);
+  },
+  
+  testEventObjectIsExtended: function() { 
+    var span = $("span"), event, observedEvent, observer = function(e) { observedEvent = e };
+    span.observe("test:somethingHappened", observer);
+    event = span.fire("test:somethingHappened");
+    this.assertEqual(event, observedEvent);
+    this.assertEqual(Event.Methods.stop.methodize(), event.stop);
+    span.stopObserving("test:somethingHappened", observer);
+    
+    event = span.fire("test:somethingHappenedButNoOneIsListening");
+    this.assertEqual(Event.Methods.stop.methodize(), event.stop);
+  },
+  
+  testEventObserversAreBoundToTheObservedElement: function() {
+    var span = $("span"), target, observer = function() { target = this };
+    
+    span.observe("test:somethingHappened", observer);
+    span.fire("test:somethingHappened");
+    span.stopObserving("test:somethingHappened", observer);
+    this.assertEqual(span, target);
+    target = null;
+    
+    var outer = $("outer");
+    outer.observe("test:somethingHappened", observer);
+    span.fire("test:somethingHappened");
+    outer.stopObserving("test:somethingHappened", observer);
+    this.assertEqual(outer, target);
+  },
+  
+  testMultipleCustomEventObserversWithTheSameHandler: function() {
+    var span = $("span"), count = 0, observer = function() { count++ };
+    
+    span.observe("test:somethingHappened", observer);
+    span.observe("test:somethingElseHappened", observer);
+    span.fire("test:somethingHappened");
+    this.assertEqual(1, count);
+    span.fire("test:somethingElseHappened");
+    this.assertEqual(2, count);
+  },
+  
+  testStopObservingWithoutArguments: function() {
+    var span = $("span"), count = 0, observer = function() { count++ };
+    
+    span.observe("test:somethingHappened", observer);
+    span.observe("test:somethingElseHappened", observer);
+    span.stopObserving();
+    span.fire("test:somethingHappened");
+    this.assertEqual(0, count);
+    span.fire("test:somethingElseHappened");
+    this.assertEqual(0, count);
+  },
+  
+  testStopObservingWithoutHandlerArgument: function() {
+    var span = $("span"), count = 0, observer = function() { count++ };
+    
+    span.observe("test:somethingHappened", observer);
+    span.observe("test:somethingElseHappened", observer);
+    span.stopObserving("test:somethingHappened");
+    span.fire("test:somethingHappened");
+    this.assertEqual(0, count);
+    span.fire("test:somethingElseHappened");
+    this.assertEqual(1, count);
+    span.stopObserving("test:somethingElseHappened");
+    span.fire("test:somethingElseHappened");
+    this.assertEqual(1, count);
+  },
+  
+  testStopObservingRemovesHandlerFromCache: function() {
+    var span = $("span"), observer = Prototype.emptyFunction, eventID;
+    
+    span.observe("test:somethingHappened", observer);
+    
+    var registry = span.getStorage().get('prototype_event_registry');
+    
+    this.assert(registry);
+    this.assert(Object.isArray(registry.get('test:somethingHappened')));
+    this.assertEqual(1, registry.get('test:somethingHappened').length);
+    
+    span.stopObserving("test:somethingHappened", observer);
+    
+    registry = span.getStorage().get('prototype_event_registry');
+    
+    this.assert(registry);
+    this.assert(Object.isArray(registry.get('test:somethingHappened')));
+    this.assertEqual(0, registry.get('test:somethingHappened').length);
+  },
+  
+  testObserveAndStopObservingAreChainable: function() {
+    var span = $("span"), observer = Prototype.emptyFunction;
+
+    this.assertEqual(span, span.observe("test:somethingHappened", observer));
+    this.assertEqual(span, span.stopObserving("test:somethingHappened", observer));
+
+    span.observe("test:somethingHappened", observer);
+    this.assertEqual(span, span.stopObserving("test:somethingHappened"));
+
+    span.observe("test:somethingHappened", observer);
+    this.assertEqual(span, span.stopObserving());
+    this.assertEqual(span, span.stopObserving()); // assert it again, after there are no observers
+
+    span.observe("test:somethingHappened", observer);
+    this.assertEqual(span, span.observe("test:somethingHappened", observer)); // try to reuse the same observer
+    span.stopObserving();
+  },
+
+  testDocumentLoaded: function() {
+    this.assert(!documentLoaded);
+    this.assert(document.loaded);
+  },
+  
+  testDocumentContentLoadedEventFiresBeforeWindowLoad: function() {
+    this.assert(eventResults.contentLoaded, "contentLoaded");
+    this.assert(eventResults.contentLoaded.endOfDocument, "contentLoaded.endOfDocument");
+    this.assert(!eventResults.contentLoaded.windowLoad, "!contentLoaded.windowLoad");
+    this.assert(eventResults.windowLoad, "windowLoad");
+    this.assert(eventResults.windowLoad.endOfDocument, "windowLoad.endOfDocument");
+    this.assert(eventResults.windowLoad.contentLoaded, "windowLoad.contentLoaded");
+  },
+  
+  testEventStopped: function() {
+    var span = $("span"), event;
+
+    span.observe("test:somethingHappened", Prototype.emptyFunction);
+    event = span.fire("test:somethingHappened");
+    this.assert(!event.stopped, "event.stopped should be false with an empty observer");
+    span.stopObserving("test:somethingHappened");
+    
+    span.observe("test:somethingHappened", function(e) { e.stop() });
+    event = span.fire("test:somethingHappened");
+    this.assert(event.stopped, "event.stopped should be true for an observer that calls stop");
+    span.stopObserving("test:somethingHappened");
+  },
+
+  testEventFindElement: function() {
+    var span = $("span"), event;
+    event = span.fire("test:somethingHappened");
+    this.assertElementMatches(event.findElement(), 'span#span');
+    this.assertElementMatches(event.findElement('span'), 'span#span');
+    this.assertElementMatches(event.findElement('p'), 'p#inner');
+    this.assertEqual(null, event.findElement('div.does_not_exist'));
+    this.assertElementMatches(event.findElement('.does_not_exist, span'), 'span#span');
+  },
+  
+  testEventIDDuplication: function() {
+    $('container').down().observe("test:somethingHappened", Prototype.emptyFunction);
+    $('container').innerHTML += $('container').innerHTML;
+    this.assertUndefined($('container').down(1)._prototypeEventID);
+  }
+});
+
+document.observe("dom:loaded", function(event) {
+  eventResults.contentLoaded = {
+    endOfDocument: eventResults.endOfDocument,
+    windowLoad:    eventResults.windowLoad
+  };
+});
+
+Event.observe(window, "load", function(event) {
+  eventResults.windowLoad = {
+    endOfDocument: eventResults.endOfDocument,
+    contentLoaded: eventResults.contentLoaded
+  };
+});