honkster-jelly 0.13.0 → 0.13.1

data/generators/jelly/templates/javascripts/jelly.js

@@ -1,7 +1,7 @@
 /**
  *  Jelly. a sweet unobtrusive javascript framework for Rails
  *
- *  version 0.13.0
+ *  version 0.13.1
  *
  * Copyright (c) 2009 Pivotal Labs
  * Licensed under the MIT license.
@@ -62,7 +62,7 @@
           throw "op " + JSON.stringify(op) + " is not an attach op"
         }
         var args = [op[1]];
-        args.concat.apply(args, op.slice(2));
+        args.push.apply(args, op.slice(2));
         Jelly.Observers.attach.apply(this, args);
       },
 

data/spec/javascript/jelly_spec.js

@@ -1,28 +1,28 @@
-describe("Jelly", function() {
+describe("Jelly", function () {
   var our_token;
 
-  beforeEach(function() {
+  beforeEach(function () {
     spyOn($, 'ajax');
     our_token = "authenticity token";
     window._token = our_token;
     Jelly.init();
   });
 
-  describe(".add", function() {
-    afterEach(function() {
+  describe(".add", function () {
+    afterEach(function () {
       delete Jelly.Pages.all["test-name"];
     });
 
-    it("instantiates a Page with the passed-in name and attaches the set of passed-in functions to the Page object", function() {
+    it("instantiates a Page with the passed-in name and attaches the set of passed-in functions to the Page object", function () {
       expect(Jelly.Pages.all["test-name"]).toEqual(undefined);
 
-      var showFn = function() {
+      var showFn = function () {
       };
-      var newFn = function() {
+      var newFn = function () {
       };
-      var indexFn = function() {
+      var indexFn = function () {
       };
-      var newPage = Jelly.Pages.add("test-name", {show: showFn}, {'new': newFn}, {index: indexFn});
+      var newPage = Jelly.Pages.add("test-name", {show:showFn}, {'new':newFn}, {index:indexFn});
       expect(Jelly.Pages.all["test-name"]).toNotEqual(undefined);
       expect(newPage).toEqual(Jelly.Pages.all["test-name"]);
       expect(newPage.show).toEqual(showFn);
@@ -30,57 +30,333 @@ describe("Jelly", function() {
       expect(newPage.index).toEqual(indexFn);
     });
   });
-  
-  describe(".run", function() {
-    describe("attach", function() {
-      describe("when the component does not respond to init", function() {
-        describe("when the component is referenced as a String", function() {
-          beforeEach(function() {
+
+  describe(".run", function () {
+    describe("attach", function () {
+      describe("when the component does not respond to init", function () {
+        describe("when the component is referenced as a String", function () {
+          beforeEach(function () {
             window.MyComponent = {
             };
           });
-  
-          afterEach(function() {
+
+          afterEach(function () {
             delete window.MyComponent;
           });
-  
-          it("attaches the component to Jelly.observers", function() {
+
+          it("attaches the component to Jelly.observers", function () {
             Jelly.run(["attach", "MyComponent"]);
             expect(Jelly.observers).toContain(MyComponent);
           });
         });
-  
-        describe("when the component is referenced as itself", function() {
-          it("attaches the component to Jelly.observers", function() {
+
+        describe("when the component is referenced as itself", function () {
+          it("attaches the component to Jelly.observers", function () {
             var component = {};
             Jelly.run(["attach", component]);
             expect(Jelly.observers).toContain(component);
           });
         });
       })
+
+      describe("when component responds to init", function () {
+        describe("when the component's init method returns undefined", function () {
+          describe("when the component is referenced as a String", function () {
+            beforeEach(function () {
+              window.MyComponent = {
+                init:function () {
+                }
+              };
+            });
+
+            afterEach(function () {
+              delete window.MyComponent;
+            });
+
+            it("calls the init method on the component and attaches the component to Jelly.observers", function () {
+              spyOn(MyComponent, 'init');
+              Jelly.run(["attach", MyComponent, 1, 2]);
+              expect(MyComponent.init).wasCalledWith(1, 2);
+              expect(Jelly.observers).toContain(MyComponent);
+            });
+          });
+
+          describe("when the component is referenced as itself", function () {
+            var component;
+            beforeEach(function () {
+              component = {
+                init:function () {
+                }
+              };
+            });
+
+            it("calls the init method on the component and attaches the component to Jelly.observers", function () {
+              spyOn(component, 'init');
+              Jelly.run(["attach", component, 1, 2]);
+              expect(component.init).wasCalledWith(1, 2);
+              expect(Jelly.observers).toContain(component);
+            });
+          });
+        });
+
+        describe("when the component's init method returns false", function () {
+          var component;
+          beforeEach(function () {
+            component = {
+              init:function () {
+                component.initCalled = true;
+                return false;
+              }
+            };
+          });
+
+          it("calls the init method on the component and does not attaches an observer to Jelly.observers", function () {
+            var originalObserversLength = Jelly.observers.length;
+            Jelly.run(["attach", component, 1, 2]);
+            expect(component.initCalled).toBeTruthy();
+            expect(Jelly.observers.length).toEqual(originalObserversLength);
+            expect(Jelly.observers).toNotContain(component);
+          });
+        });
+
+        describe("when the component's init method returns null", function () {
+          var component;
+          beforeEach(function () {
+            component = {
+              init:function () {
+                component.initCalled = true;
+                return null;
+              }
+            };
+          });
+
+          it("calls the init method on the component and does not attaches an observer to Jelly.observers", function () {
+            var originalObserversLength = Jelly.observers.length;
+            Jelly.run(["attach", component, 1, 2]);
+            expect(component.initCalled).toBeTruthy();
+            expect(Jelly.observers.length).toEqual(originalObserversLength);
+            expect(Jelly.observers).toNotContain(component);
+          });
+        });
+
+        describe("when the component's init method returns an object", function () {
+          it("attaches the returned object (instead of the component) to Jelly.observers", function () {
+            var observer = new Object();
+            var component = {
+              init:function () {
+                return observer;
+              }
+            };
+            Jelly.run(["attach", component, 1, 2]);
+            expect(Jelly.observers).toContain(observer);
+            expect(Jelly.observers).toNotContain(component);
+          });
+        });
+      });
+    });
+
+    describe("notify", function () {
+      beforeEach(function () {
+        Jelly.Pages.add("MyPage", {
+          on_my_method:function () {
+          }
+        });
+        Jelly.run(["attach", "Jelly.Page", "MyPage", "index"]);
+      });
+
+      describe("when bound to the default Jelly.observers collection", function () {
+        describe("the active page object", function () {
+          describe("when the notify method is defined on the page", function () {
+            it("should call the notify method on the page", function () {
+              spyOn(page, 'on_my_method');
+              Jelly.run(["notify", "on_my_method", "arg1", "arg2"]);
+              expect(page.on_my_method).wasCalled();
+              expect(page.on_my_method).wasCalledWith('arg1', 'arg2');
+            });
+
+            describe("when there are attached components", function () {
+              it("calls the notify methods in the order of the attached components", function () {
+                var component = {
+                  on_my_method:function () {
+                  }
+                };
+                Jelly.attach(component);
+
+                var functionsCalledInOrder = [];
+                spyOn(page, 'on_my_method').andCallFake(function () {
+                  functionsCalledInOrder.push("page");
+                });
+                spyOn(component, 'on_my_method').andCallFake(function () {
+                  functionsCalledInOrder.push("component");
+                });
+                Jelly.run(["notify", "on_my_method", "arg1", "arg2"]);
+                expect(page.on_my_method).wasCalled();
+                expect(page.on_my_method).wasCalledWith('arg1', 'arg2');
+                expect(component.on_my_method).wasCalled();
+                expect(component.on_my_method).wasCalledWith('arg1', 'arg2');
+                expect(functionsCalledInOrder).toEqual(["page", "component"]);
+              });
+            });
+          });
+
+          describe("when the page object does not define the notify method", function () {
+            it("does not blow up", function () {
+              expect(page.on_my_undefined_method).toBe(undefined);
+              Jelly.run(["notify", "on_my_undefined_method", "arg1", "arg2"]);
+            });
+          });
+        });
+
+        describe("when the 'on' parameter is present", function () {
+          beforeEach(function () {
+            GlobalObject = {on_my_method:function () {
+            }};
+            GlobalObject.secondObject = {on_my_method:function () {
+            }};
+          });
+
+          afterEach(function () {
+            delete GlobalObject;
+          });
+        });
+      });
+
+      describe("when bound to an array of custom observers", function () {
+        it("notifies the given observers and not the existing Jelly.observers, unless in the list of observers", function () {
+          var component = {
+            on_my_method:function () {
+            }
+          };
+          Jelly.attach("Jelly.Page", "MyPage", "index");
+          Jelly.attach(component);
+
+          spyOn(page, 'on_my_method');
+          spyOn(component, 'on_my_method');
+
+          var customObserver1 = {on_my_method:function () {
+          }};
+          spyOn(customObserver1, 'on_my_method');
+          var customObserver2 = {on_my_method:function () {
+          }};
+          spyOn(customObserver2, 'on_my_method');
+
+          Jelly.run.call([customObserver1, customObserver2], ["notify", "on_my_method", "arg1", "arg2"]);
+
+          expect(page.on_my_method).wasNotCalled();
+          expect(component.on_my_method).wasNotCalled();
+
+          expect(customObserver1.on_my_method).wasCalled();
+          expect(customObserver1.on_my_method).wasCalledWith('arg1', 'arg2');
+          expect(customObserver2.on_my_method).wasCalled();
+          expect(customObserver2.on_my_method).wasCalledWith('arg1', 'arg2');
+        });
+      });
+
+      describe("an observer listening to on_notify", function () {
+        it("receives a notify instruction", function () {
+          var observer = {
+            on_notify:function () {
+            }
+          };
+          spyOn(observer, 'on_notify');
+
+          Jelly.run.call([observer], ["notify", "on_my_method", "arg1", "arg2"]);
+
+          expect(observer.on_notify).wasCalledWith("on_my_method", "arg1", "arg2");
+        });
+      });
+
+      describe("an observer listening to the notify method", function () {
+        var observer;
+        beforeEach(function () {
+          observer = {
+            on_my_method:function () {
+            }
+          };
+          Jelly.attach(observer);
+          expect(Jelly.observers).toContain(observer);
+        });
+
+        describe("when the observer does not have a detach method defined", function () {
+          beforeEach(function () {
+            expect(observer.detach).toBe(undefined);
+          });
+
+          it("leaves the observer in Jelly.observers and calls the notify method on the observer", function () {
+            spyOn(observer, "on_my_method");
+
+            Jelly.run(["notify", "on_my_method"]);
+            expect(Jelly.observers).toContain(observer);
+            expect(observer.on_my_method).wasCalled();
+          });
+        });
+
+        describe("when the observer a detach method defined", function () {
+          describe("when the detach method is truthy", function () {
+            var anotherObserver;
+            beforeEach(function () {
+              observer.detach = function () {
+                return true;
+              };
+              anotherObserver = {
+                on_my_method:function () {
+                }
+              };
+              Jelly.attach(anotherObserver);
+            });
+
+            it("removes observer in Jelly.observers, does not call the notify method on the observer, and calls the other observers", function () {
+              spyOn(observer, "on_my_method");
+              spyOn(anotherObserver, "on_my_method");
+
+              Jelly.run(["notify", "on_my_method"]);
+              expect(Jelly.observers).toNotContain(observer);
+              expect(observer.on_my_method).wasNotCalled();
+              expect(anotherObserver.on_my_method).wasCalled();
+            });
+          });
+
+          describe("when the detach method is falsy", function () {
+            beforeEach(function () {
+              observer.detach = function () {
+                return undefined;
+              }
+            });
+
+            it("leaves the observer in Jelly.observers and calls the notify method on the observer", function () {
+              spyOn(observer, "on_my_method");
+
+              Jelly.run(["notify", "on_my_method"]);
+              expect(Jelly.observers).toContain(observer);
+              expect(observer.on_my_method).wasCalled();
+            });
+          });
+        });
+      });
+
     });
   });
 
-  describe(".attach", function() {
-    describe("when the component does not respond to init", function() {
-      describe("when the component is referenced as a String", function() {
-        beforeEach(function() {
+  describe(".attach", function () {
+    describe("when the component does not respond to init", function () {
+      describe("when the component is referenced as a String", function () {
+        beforeEach(function () {
           window.MyComponent = {
           };
         });
 
-        afterEach(function() {
+        afterEach(function () {
           delete window.MyComponent;
         });
 
-        it("attaches the component to Jelly.observers", function() {
+        it("attaches the component to Jelly.observers", function () {
           Jelly.attach("MyComponent");
           expect(Jelly.observers).toContain(MyComponent);
         });
       });
 
-      describe("when the component is referenced as itself", function() {
-        it("attaches the component to Jelly.observers", function() {
+      describe("when the component is referenced as itself", function () {
+        it("attaches the component to Jelly.observers", function () {
           var component = {};
           Jelly.attach(component);
           expect(Jelly.observers).toContain(component);
@@ -88,21 +364,21 @@ describe("Jelly", function() {
       });
     });
 
-    describe("when component responds to init", function() {
-      describe("when the component's init method returns undefined", function() {
-        describe("when the component is referenced as a String", function() {
-          beforeEach(function() {
+    describe("when component responds to init", function () {
+      describe("when the component's init method returns undefined", function () {
+        describe("when the component is referenced as a String", function () {
+          beforeEach(function () {
             window.MyComponent = {
-              init: function() {
+              init:function () {
               }
             };
           });
 
-          afterEach(function() {
+          afterEach(function () {
             delete window.MyComponent;
           });
 
-          it("calls the init method on the component and attaches the component to Jelly.observers", function() {
+          it("calls the init method on the component and attaches the component to Jelly.observers", function () {
             spyOn(MyComponent, 'init');
             Jelly.attach(MyComponent, 1, 2);
             expect(MyComponent.init).wasCalledWith(1, 2);
@@ -110,16 +386,16 @@ describe("Jelly", function() {
           });
         });
 
-        describe("when the component is referenced as itself", function() {
+        describe("when the component is referenced as itself", function () {
           var component;
-          beforeEach(function() {
+          beforeEach(function () {
             component = {
-              init: function() {
+              init:function () {
               }
             };
           });
 
-          it("calls the init method on the component and attaches the component to Jelly.observers", function() {
+          it("calls the init method on the component and attaches the component to Jelly.observers", function () {
             spyOn(component, 'init');
             Jelly.attach(component, 1, 2);
             expect(component.init).wasCalledWith(1, 2);
@@ -128,18 +404,18 @@ describe("Jelly", function() {
         });
       });
 
-      describe("when the component's init method returns false", function() {
+      describe("when the component's init method returns false", function () {
         var component;
-        beforeEach(function() {
+        beforeEach(function () {
           component = {
-            init: function() {
+            init:function () {
               component.initCalled = true;
               return false;
             }
           };
         });
 
-        it("calls the init method on the component and does not attaches an observer to Jelly.observers", function() {
+        it("calls the init method on the component and does not attaches an observer to Jelly.observers", function () {
           var originalObserversLength = Jelly.observers.length;
           Jelly.attach(component, 1, 2);
           expect(component.initCalled).toBeTruthy();
@@ -148,18 +424,18 @@ describe("Jelly", function() {
         });
       });
 
-      describe("when the component's init method returns null", function() {
+      describe("when the component's init method returns null", function () {
         var component;
-        beforeEach(function() {
+        beforeEach(function () {
           component = {
-            init: function() {
+            init:function () {
               component.initCalled = true;
               return null;
             }
           };
         });
 
-        it("calls the init method on the component and does not attaches an observer to Jelly.observers", function() {
+        it("calls the init method on the component and does not attaches an observer to Jelly.observers", function () {
           var originalObserversLength = Jelly.observers.length;
           Jelly.attach(component, 1, 2);
           expect(component.initCalled).toBeTruthy();
@@ -168,11 +444,11 @@ describe("Jelly", function() {
         });
       });
 
-      describe("when the component's init method returns an object", function() {
-        it("attaches the returned object (instead of the component) to Jelly.observers", function() {
+      describe("when the component's init method returns an object", function () {
+        it("attaches the returned object (instead of the component) to Jelly.observers", function () {
           var observer = new Object();
           var component = {
-            init: function() {
+            init:function () {
               return observer;
             }
           };
@@ -184,38 +460,38 @@ describe("Jelly", function() {
     });
   });
 
-  describe(".Observers.notify", function() {
-    beforeEach(function() {
+  describe(".Observers.notify", function () {
+    beforeEach(function () {
       Jelly.Pages.add("MyPage", {
-        on_my_method : function() {
+        on_my_method:function () {
         }
       });
       Jelly.attach("Jelly.Page", "MyPage", "index");
     });
 
-    describe("when bound to the default Jelly.observers collection", function() {
-      describe("the active page object", function() {
-        describe("when the notify method is defined on the page", function() {
-          it("should call the notify method on the page", function() {
+    describe("when bound to the default Jelly.observers collection", function () {
+      describe("the active page object", function () {
+        describe("when the notify method is defined on the page", function () {
+          it("should call the notify method on the page", function () {
             spyOn(page, 'on_my_method');
             Jelly.notifyObservers("on_my_method", "arg1", "arg2");
             expect(page.on_my_method).wasCalled();
             expect(page.on_my_method).wasCalledWith('arg1', 'arg2');
           });
 
-          describe("when there are attached components", function() {
-            it("calls the notify methods in the order of the attached components", function() {
+          describe("when there are attached components", function () {
+            it("calls the notify methods in the order of the attached components", function () {
               var component = {
-                on_my_method: function() {
+                on_my_method:function () {
                 }
               };
               Jelly.attach(component);
 
               var functionsCalledInOrder = [];
-              spyOn(page, 'on_my_method').andCallFake(function() {
+              spyOn(page, 'on_my_method').andCallFake(function () {
                 functionsCalledInOrder.push("page");
               });
-              spyOn(component, 'on_my_method').andCallFake(function() {
+              spyOn(component, 'on_my_method').andCallFake(function () {
                 functionsCalledInOrder.push("component");
               });
               Jelly.notifyObservers("on_my_method", "arg1", "arg2");
@@ -228,32 +504,32 @@ describe("Jelly", function() {
           });
         });
 
-        describe("when the page object does not define the notify method", function() {
-          it("does not blow up", function() {
+        describe("when the page object does not define the notify method", function () {
+          it("does not blow up", function () {
             expect(page.on_my_undefined_method).toBe(undefined);
             Jelly.notifyObservers("on_my_undefined_method", "arg1", "arg2");
           });
         });
       });
 
-      describe("when the 'on' parameter is present", function() {
-        beforeEach(function() {
-          GlobalObject = {on_my_method: function() {
+      describe("when the 'on' parameter is present", function () {
+        beforeEach(function () {
+          GlobalObject = {on_my_method:function () {
           }};
-          GlobalObject.secondObject = {on_my_method: function() {
+          GlobalObject.secondObject = {on_my_method:function () {
           }};
         });
 
-        afterEach(function() {
+        afterEach(function () {
           delete GlobalObject;
         });
       });
     });
 
-    describe("when bound to an array of custom observers", function() {
-      it("notifies the given observers and not the existing Jelly.observers, unless in the list of observers", function() {
+    describe("when bound to an array of custom observers", function () {
+      it("notifies the given observers and not the existing Jelly.observers, unless in the list of observers", function () {
         var component = {
-          on_my_method: function() {
+          on_my_method:function () {
           }
         };
         Jelly.attach("Jelly.Page", "MyPage", "index");
@@ -262,10 +538,10 @@ describe("Jelly", function() {
         spyOn(page, 'on_my_method');
         spyOn(component, 'on_my_method');
 
-        var customObserver1 = {on_my_method: function() {
+        var customObserver1 = {on_my_method:function () {
         }};
         spyOn(customObserver1, 'on_my_method');
-        var customObserver2 = {on_my_method: function() {
+        var customObserver2 = {on_my_method:function () {
         }};
         spyOn(customObserver2, 'on_my_method');
 
@@ -281,10 +557,10 @@ describe("Jelly", function() {
       });
     });
 
-    describe("an observer listening to on_notify", function() {
-      it("receives a notify instruction", function() {
+    describe("an observer listening to on_notify", function () {
+      it("receives a notify instruction", function () {
         var observer = {
-          on_notify: function() {
+          on_notify:function () {
           }
         };
         spyOn(observer, 'on_notify');
@@ -295,23 +571,23 @@ describe("Jelly", function() {
       });
     });
 
-    describe("an observer listening to the notify method", function() {
+    describe("an observer listening to the notify method", function () {
       var observer;
-      beforeEach(function() {
+      beforeEach(function () {
         observer = {
-          on_my_method: function() {
+          on_my_method:function () {
           }
         };
         Jelly.attach(observer);
         expect(Jelly.observers).toContain(observer);
       });
 
-      describe("when the observer does not have a detach method defined", function() {
-        beforeEach(function() {
+      describe("when the observer does not have a detach method defined", function () {
+        beforeEach(function () {
           expect(observer.detach).toBe(undefined);
         });
 
-        it("leaves the observer in Jelly.observers and calls the notify method on the observer", function() {
+        it("leaves the observer in Jelly.observers and calls the notify method on the observer", function () {
           spyOn(observer, "on_my_method");
 
           Jelly.notifyObservers("on_my_method");
@@ -320,21 +596,21 @@ describe("Jelly", function() {
         });
       });
 
-      describe("when the observer a detach method defined", function() {
-        describe("when the detach method is truthy", function() {
+      describe("when the observer a detach method defined", function () {
+        describe("when the detach method is truthy", function () {
           var anotherObserver;
-          beforeEach(function() {
-            observer.detach = function() {
+          beforeEach(function () {
+            observer.detach = function () {
               return true;
             };
             anotherObserver = {
-              on_my_method: function() {
+              on_my_method:function () {
               }
             };
             Jelly.attach(anotherObserver);
           });
 
-          it("removes observer in Jelly.observers, does not call the notify method on the observer, and calls the other observers", function() {
+          it("removes observer in Jelly.observers, does not call the notify method on the observer, and calls the other observers", function () {
             spyOn(observer, "on_my_method");
             spyOn(anotherObserver, "on_my_method");
 
@@ -345,14 +621,14 @@ describe("Jelly", function() {
           });
         });
 
-        describe("when the detach method is falsy", function() {
-          beforeEach(function() {
-            observer.detach = function() {
+        describe("when the detach method is falsy", function () {
+          beforeEach(function () {
+            observer.detach = function () {
               return undefined;
             }
           });
 
-          it("leaves the observer in Jelly.observers and calls the notify method on the observer", function() {
+          it("leaves the observer in Jelly.observers and calls the notify method on the observer", function () {
             spyOn(observer, "on_my_method");
 
             Jelly.notifyObservers("on_my_method");
@@ -365,55 +641,55 @@ describe("Jelly", function() {
   });
 });
 
-describe("Jelly.Page", function() {
+describe("Jelly.Page", function () {
   var our_token;
 
-  beforeEach(function() {
+  beforeEach(function () {
     spyOn($, 'ajax');
     our_token = "authenticity token";
     window._token = our_token;
     Jelly.init();
   });
 
-  describe(".init", function() {
-    beforeEach(function() {
+  describe(".init", function () {
+    beforeEach(function () {
       Jelly.Pages.add("DefinedComponent", {
-        baz : function() {
+        baz:function () {
         },
-        all : function() {
+        all:function () {
         },
-        show: function() {
+        show:function () {
         }
       });
       spyOn(Jelly.Pages.all["DefinedComponent"], "show");
     });
 
-    afterEach(function() {
+    afterEach(function () {
       delete Jelly.Pages.all["DefinedComponent"];
     });
 
-    describe("when the passed-in controllerName is defined", function() {
-      describe("when the actionName is defined", function() {
-        it("invokes the page-specific method", function() {
+    describe("when the passed-in controllerName is defined", function () {
+      describe("when the actionName is defined", function () {
+        it("invokes the page-specific method", function () {
           var foobar = Jelly.Pages.all["DefinedComponent"];
           expect(foobar.show).wasNotCalled();
           Jelly.Page.init("DefinedComponent", "show");
           expect(foobar.show).wasCalled();
         });
 
-        describe("when the 'all' method is defined", function() {
+        describe("when the 'all' method is defined", function () {
           var invokedMethods;
-          beforeEach(function() {
+          beforeEach(function () {
             invokedMethods = [];
-            spyOn(Jelly.Pages.all["DefinedComponent"], "all").andCallFake(function() {
+            spyOn(Jelly.Pages.all["DefinedComponent"], "all").andCallFake(function () {
               invokedMethods.push("all");
             });
-            spyOn(Jelly.Pages.all["DefinedComponent"], "baz").andCallFake(function() {
+            spyOn(Jelly.Pages.all["DefinedComponent"], "baz").andCallFake(function () {
               invokedMethods.push("baz");
             });
           });
 
-          it("invokes the all method before invoking the page-specific method", function() {
+          it("invokes the all method before invoking the page-specific method", function () {
             expect(invokedMethods).toEqual([]);
             Jelly.Page.init("DefinedComponent", "baz");
             expect(invokedMethods).toEqual(['all', 'baz']);
@@ -421,22 +697,22 @@ describe("Jelly.Page", function() {
         });
       });
 
-      describe("when the actionName is not defined", function() {
-        it("does not blow up", function() {
+      describe("when the actionName is not defined", function () {
+        it("does not blow up", function () {
           expect(Jelly.Pages.all["DefinedComponent"].easterBunny).toEqual(undefined);
           Jelly.Page.init("DefinedComponent", "easterBunny");
         });
 
-        describe("when the 'all' method is defined", function() {
+        describe("when the 'all' method is defined", function () {
           var invokedMethods;
-          beforeEach(function() {
+          beforeEach(function () {
             invokedMethods = [];
-            Jelly.Pages.all["DefinedComponent"].all = function() {
+            Jelly.Pages.all["DefinedComponent"].all = function () {
               invokedMethods.push("all");
             };
           });
 
-          it("invokes the all method", function() {
+          it("invokes the all method", function () {
             expect(Jelly.Pages.all["DefinedComponent"].easterBunny).toEqual(undefined);
             expect(invokedMethods).toEqual([]);
             Jelly.Page.init("DefinedComponent", "easterBunny");
@@ -446,8 +722,8 @@ describe("Jelly.Page", function() {
       });
     });
 
-    describe("when the passed-in controllerName is not defined", function() {
-      it("does nothing and does not cause an error", function() {
+    describe("when the passed-in controllerName is not defined", function () {
+      it("does nothing and does not cause an error", function () {
         expect(Jelly.Pages.all["UndefinedComponent"]).toEqual(undefined);
         Jelly.Page.init("UndefinedComponent", "easterBunny");
       });
@@ -455,10 +731,10 @@ describe("Jelly.Page", function() {
   });
 });
 
-describe("Jelly.Location", function() {
+describe("Jelly.Location", function () {
   var our_token, originalTop;
 
-  beforeEach(function() {
+  beforeEach(function () {
     spyOn($, 'ajax');
     our_token = "authenticity token";
     window._token = our_token;
@@ -466,13 +742,13 @@ describe("Jelly.Location", function() {
     originalTop = window.top;
   });
 
-  afterEach(function() {
+  afterEach(function () {
     window.top = originalTop;
   });
 
-  describe(".on_redirect", function() {
-    it("sets top.location.href to the given location", function() {
-      var window = {top: {location: {}}};
+  describe(".on_redirect", function () {
+    it("sets top.location.href to the given location", function () {
+      var window = {top:{location:{}}};
       spyOn(Jelly.Location, "window").andReturn(window);
       Jelly.Location.on_redirect("http://mars.com");
       expect(window.top.location.href).toEqual("http://mars.com");

metadata

@@ -2,7 +2,7 @@
 name: honkster-jelly
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.13.0
+  version: 0.13.1
 platform: ruby
 authors: 
 - Pivotal Labs, Inc