RubyGems - honkster-jelly - Versions diffs - 0.9.1 → 0.9.2 - Mend

honkster-jelly 0.9.1 → 0.9.2

Files changed (84) hide show

data/.gitignore +4 -0
data/Gemfile +1 -2
data/Gemfile.lock +1 -1
data/Rakefile +0 -16
data/jelly.gemspec +13 -64
data/lib/jelly/jelly_helper.rb +1 -1
data/spec/fixtures/public/javascripts/components/component1.js +0 -0
data/spec/fixtures/public/javascripts/foo/components/paw.js +0 -0
data/spec/fixtures/public/javascripts/foo/components/teeth.js +0 -0
data/spec/fixtures/public/javascripts/foo/pages/bears.js +0 -0
data/spec/fixtures/public/javascripts/foo/pages/lions.js +0 -0
data/spec/fixtures/public/javascripts/foo/pages/tigers.js +0 -0
data/spec/fixtures/public/javascripts/pages/page1.js +0 -0
data/spec/jasmine/TrivialReporter.js +129 -0
data/spec/jasmine/jasmine-0.10.0.js +2149 -0
data/spec/jasmine/jasmine.css +76 -0
data/spec/jasmine/json2.js +478 -0
data/spec/jasmine_runner.html +30 -0
data/spec/javascript/ajax_with_jelly_spec.js +157 -0
data/spec/javascript/jelly_spec.js +649 -0
data/spec/javascript/spec_helper.js +7 -0
data/spec/jelly/common_spec.rb +56 -0
data/spec/jelly/jelly_controller_spec.rb +331 -0
data/spec/jelly/jelly_helper_spec.rb +88 -0
data/spec/rails_root/Gemfile +31 -0
data/spec/rails_root/Gemfile.lock +73 -0
data/spec/rails_root/README +256 -0
data/spec/rails_root/Rakefile +7 -0
data/spec/rails_root/app/controllers/application_controller.rb +3 -0
data/spec/rails_root/app/helpers/application_helper.rb +2 -0
data/spec/rails_root/app/views/layouts/application.html.erb +14 -0
data/spec/rails_root/config.ru +4 -0
data/spec/rails_root/config/application.rb +42 -0
data/spec/rails_root/config/boot.rb +6 -0
data/spec/rails_root/config/database.yml +22 -0
data/spec/rails_root/config/environment.rb +5 -0
data/spec/rails_root/config/environments/development.rb +26 -0
data/spec/rails_root/config/environments/production.rb +49 -0
data/spec/rails_root/config/environments/test.rb +35 -0
data/spec/rails_root/config/initializers/backtrace_silencers.rb +7 -0
data/spec/rails_root/config/initializers/inflections.rb +10 -0
data/spec/rails_root/config/initializers/mime_types.rb +5 -0
data/spec/rails_root/config/initializers/new_rails_defaults.rb +19 -0
data/spec/rails_root/config/initializers/secret_token.rb +7 -0
data/spec/rails_root/config/initializers/session_store.rb +8 -0
data/spec/rails_root/config/locales/en.yml +5 -0
data/spec/rails_root/config/routes.rb +58 -0
data/spec/rails_root/db/seeds.rb +7 -0
data/spec/rails_root/db/test.sqlite3 +1 -0
data/spec/rails_root/doc/README_FOR_APP +2 -0
data/spec/rails_root/log/development.log +0 -0
data/spec/rails_root/log/production.log +0 -0
data/spec/rails_root/log/server.log +0 -0
data/spec/rails_root/log/test.log +6 -0
data/spec/rails_root/public/404.html +26 -0
data/spec/rails_root/public/422.html +26 -0
data/spec/rails_root/public/500.html +26 -0
data/spec/rails_root/public/favicon.ico +0 -0
data/spec/rails_root/public/images/rails.png +0 -0
data/spec/rails_root/public/index.html +239 -0
data/spec/rails_root/public/javascripts/application.js +2 -0
data/spec/rails_root/public/javascripts/controls.js +965 -0
data/spec/rails_root/public/javascripts/dragdrop.js +974 -0
data/spec/rails_root/public/javascripts/effects.js +1123 -0
data/spec/rails_root/public/javascripts/prototype.js +6001 -0
data/spec/rails_root/public/javascripts/rails.js +191 -0
data/spec/rails_root/public/robots.txt +5 -0
data/spec/rails_root/script/about +4 -0
data/spec/rails_root/script/console +3 -0
data/spec/rails_root/script/dbconsole +3 -0
data/spec/rails_root/script/destroy +3 -0
data/spec/rails_root/script/generate +3 -0
data/spec/rails_root/script/performance/benchmarker +3 -0
data/spec/rails_root/script/performance/profiler +3 -0
data/spec/rails_root/script/plugin +3 -0
data/spec/rails_root/script/rails +6 -0
data/spec/rails_root/script/runner +3 -0
data/spec/rails_root/script/server +3 -0
data/spec/rails_root/test/performance/browsing_test.rb +9 -0
data/spec/rails_root/test/test_helper.rb +13 -0
data/spec/spec_helper.rb +37 -0
data/spec/spec_suite.rb +3 -0
metadata +271 -46
data/VERSION.yml +0 -5

data/spec/jasmine_runner.html ADDED Viewed

@@ -0,0 +1,30 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+  "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+  <title>Jasmine Test Runner</title>
+</head>
+<script type="text/javascript" src="jasmine/jasmine-0.10.0.js"></script>
+<script type="text/javascript" src="jasmine/TrivialReporter.js"></script>
+<link href="jasmine/jasmine.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="../generators/jelly/templates/javascripts/jquery/jquery-1.3.2.js"></script>
+<script type="text/javascript" src="../generators/jelly/templates/javascripts/ajax_with_jelly.js"></script>
+<script type="text/javascript" src="../generators/jelly/templates/javascripts/jelly.js"></script>
+<script type="text/javascript">
+  jasmine.include('javascript/jelly_spec.js', true);
+  jasmine.include('javascript/ajax_with_jelly_spec.js', true);
+</script>
+<script type="text/javascript">
+  $(document).ready(function() {
+    var jasmineEnv = jasmine.getEnv();
+    jasmineEnv.reporter = new jasmine.TrivialReporter();
+    jasmineEnv.execute();
+  });
+</script>
+<body>
+</body>
+</html>

data/spec/javascript/ajax_with_jelly_spec.js ADDED Viewed

@@ -0,0 +1,157 @@
+describe("Jelly", function() {
+  var our_token;
+  beforeEach(function() {
+    Jelly.add("MyPage", {
+      on_my_method : function() {
+      }
+    });
+    page = Jelly.all["MyPage"];
+    spyOn($, 'ajax');
+    our_token = "authenticity token";
+    window._token = our_token;
+  });
+  afterEach(function() {
+    delete Jelly.all["MyPage"];
+  });
+  describe(".ajaxWithJelly", function() {
+    it("should set default params and call ajax", function() {
+      var params = {foo: "bar"};
+      var modifiedParams = "whatever";
+      spyOn($.ajaxWithJelly, 'params').andReturn(modifiedParams);
+      $.ajaxWithJelly(params);
+      expect($.ajaxWithJelly.params).wasCalled();
+      expect($.ajaxWithJelly.params).wasCalledWith(params);
+      expect($.ajax).wasCalled();
+      expect($.ajax).wasCalledWith(modifiedParams);
+    });
+  });
+  describe(".ajaxWithJelly.params", function() {
+    it("should set some base params", function() {
+      var ajaxParams = $.ajaxWithJelly.params();
+      expect(ajaxParams['dataType']).toEqual('json');
+      expect(ajaxParams['cache']).toBeFalsy();
+      expect(ajaxParams['success']).toBeTruthy();
+    });
+    it("should preserve passed data", function() {
+      var ajaxParams = $.ajaxWithJelly.params({foo : 'bar', data: {bar : 'baz'}});
+      expect(ajaxParams['foo']).toEqual('bar');
+      expect(ajaxParams['data']['bar']).toEqual('baz');
+    });
+    it("should allow override of type", function() {
+      var ajaxParams = $.ajaxWithJelly.params({type : 'DELETE'});
+      expect(ajaxParams['type']).toEqual('DELETE');
+    });
+    describe("whether to set authenticity token", function() {
+      it("should set an auth token when type is not a GET", function() {
+        var ajaxParams = $.ajaxWithJelly.params({type: "NON-GET"});
+        expect(ajaxParams['data']['authenticity_token']).toEqual(our_token);
+      });
+      it("should not set an auth token when type is not passed in", function() {
+        var ajaxParams = $.ajaxWithJelly.params();
+        expect(ajaxParams['data']).toEqual(undefined);
+      });
+      it("should not set an auth token when type is GET", function() {
+        var ajaxParams = $.ajaxWithJelly.params({type: "GET"});
+        expect(ajaxParams['data']).toEqual(undefined);
+      });
+    });
+    describe(".ajaxWithJelly.params.success", function() {
+      describe("when no observers are passed into params", function() {
+        it("calls Jelly.notifyObservers on Jelly.observers", function() {
+          var observerArgs;
+          var observer = {
+            on_my_method: function(arg1, arg2) {
+              observerArgs = [arg1, arg2];
+            }
+          };
+          Jelly.attach({component: observer, arguments: []});
+          expect(Jelly.observers).toContain(observer);
+          var notification = {
+            "arguments":["arg1", "arg2"],
+            "method":"on_my_method"
+          };
+          $.ajaxWithJelly.params().success(notification);
+          expect(observerArgs).toEqual(["arg1", "arg2"]);
+        });
+      });
+      describe("when observers are passed into params", function() {
+        it("calls Jelly.notifyObservers on passed-in observers", function() {
+          var observerArgs;
+          var observer = {
+            on_my_method: function(arg1, arg2) {
+              observerArgs = [arg1, arg2];
+            }
+          };
+          var observers = [observer];
+          expect(Jelly.observers).toNotContain(observer);
+          var notification = {
+            "arguments":["arg1", "arg2"],
+            "method":"on_my_method"
+          };
+          $.ajaxWithJelly.params({observers: observers}).success(notification);
+          expect(observerArgs).toEqual(["arg1", "arg2"]);
+        });
+      });
+    });
+  });
+  describe(".ajaxFormWithJelly", function() {
+    describe("without ajaxForm plugin", function() {
+      it("should not be defined", function() {
+        expect($.fn.ajaxForm).toEqual(undefined);
+        expect($.fn.ajaxFormWithJelly).toEqual(undefined);
+      });
+    });
+    describe("with ajaxForm plugin", function() {
+      var $form;
+      beforeEach(function() {
+        $form = $('body').append('<form id="myForm"></form>').find('#myForm');
+        $.fn.ajaxForm = {};
+        spyOn($.fn, 'ajaxForm');
+        Jelly.defineAjaxWithJellyFunctions($);
+      });
+      afterEach(function() {
+        $.fn.ajaxForm = undefined;
+        Jelly.defineAjaxWithJellyFunctions($);
+      });
+      it("should set default params and call ajax", function() {
+        var modifiedParams = "whatever";
+        spyOn($.ajaxWithJelly, 'params').andReturn(modifiedParams);
+        $form.ajaxFormWithJelly();
+        expect($.ajaxWithJelly.params).wasCalled();
+        expect($.ajaxWithJelly.params).wasCalledWith(undefined);
+        expect($.fn.ajaxForm).wasCalled();
+        expect($.fn.ajaxForm).wasCalledWith(modifiedParams);
+        expect($.fn.ajaxForm.mostRecentCall.object.get(0)).toEqual($form.get(0));
+      });
+      it("should merge in params", function() {
+        var params = {foo: "bar"};
+        spyOn($.ajaxWithJelly, 'params');
+        $form.ajaxFormWithJelly(params);
+        expect($.ajaxWithJelly.params).wasCalled();
+        expect($.ajaxWithJelly.params).wasCalledWith(params);
+      });
+    });
+  });
+});

data/spec/javascript/jelly_spec.js ADDED Viewed

@@ -0,0 +1,649 @@
+describe("Jelly", function() {
+  var our_token;
+  beforeEach(function() {
+    spyOn($, 'ajax');
+    our_token = "authenticity token";
+    window._token = our_token;
+    Jelly.init();
+  });
+  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() {
+      expect(Jelly.Pages.all["test-name"]).toEqual(undefined);
+      var showFn = function() {
+      };
+      var newFn = function() {
+      };
+      var indexFn = function() {
+      };
+      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);
+      expect(newPage['new']).toEqual(newFn);
+      expect(newPage.index).toEqual(indexFn);
+    });
+  });
+  describe(".attach", function() {
+    describe("when the argument contains a 'component' key", 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() {
+            delete window.MyComponent;
+          });
+          it("attaches the component to Jelly.observers", function() {
+            Jelly.attach({component: "MyComponent"});
+            expect(Jelly.observers).toContain(MyComponent);
+          });
+        });
+        describe("when the component is referenced as itself", function() {
+          it("attaches the component to Jelly.observers", function() {
+            var component = {};
+            Jelly.attach({component: 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.attach({component: MyComponent, arguments: [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.attach({component: component, arguments: [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.attach({component: component, arguments: [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.attach({component: component, arguments: [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.attach({component: component, arguments: [1, 2]});
+            expect(Jelly.observers).toContain(observer);
+            expect(Jelly.observers).toNotContain(component);
+          });
+        });
+      });
+    });
+    describe("when the argument does not contain a 'component' key", function() {
+      describe("when the component is referenced as a String", function() {
+        beforeEach(function() {
+          window.MyComponent = {
+            init: function() {
+            }
+          };
+        });
+        afterEach(function() {
+          delete window.MyComponent;
+        });
+        it("does not call init and attaches the component to Jelly.observers", function() {
+          spyOn(MyComponent, 'init');
+          Jelly.attach("MyComponent");
+          expect(MyComponent.init).wasNotCalled();
+          expect(Jelly.observers).toContain(MyComponent);
+        });
+      });
+      describe("when the component is referenced as itself", function() {
+        it("does not call init and attaches the component to Jelly.observers", function() {
+          var component = {
+            init: function() {
+            }
+          };
+          spyOn(component, 'init');
+          Jelly.attach(component);
+          expect(component.init).wasNotCalled();
+          expect(Jelly.observers).toContain(component);
+        });
+      });
+    });
+  });
+  describe(".Observers.notify", function() {
+    beforeEach(function() {
+      Jelly.Pages.add("MyPage", {
+        on_my_method : function() {
+        }
+      });
+      Jelly.attach({component: "Jelly.Page", arguments: ["MyPage", "index"]});
+    });
+    describe(".notifying", function() {
+      it("should be set to true only while observers are being notified", function() {
+        expect(Jelly.Observers.notifying).toBe(false);
+        var notifyingWasSet = false;
+        page.on_my_method = function() {
+          notifyingWasSet = Jelly.Observers.notifying;
+        }
+        Jelly.notifyObservers({
+          "method":"on_my_method"
+        });
+        expect(notifyingWasSet).toBe(true);
+      });
+      it("should be reset to its prior value when notification is complete", function() {
+        Jelly.Observers.notifying = true;
+        spyOn(page, 'on_my_method');
+        Jelly.notifyObservers({
+          "method":"on_my_method"
+        });
+        expect(page.on_my_method).wasCalled();
+        expect(Jelly.Observers.notifying).toBe(true);
+      });
+    });
+    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({
+              "arguments":["arg1", "arg2"],
+              "method":"on_my_method"
+            });
+            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: component, arguments: []});
+              var functionsCalledInOrder = [];
+              spyOn(page, 'on_my_method').andCallFake(function() {
+                functionsCalledInOrder.push("page");
+              });
+              spyOn(component, 'on_my_method').andCallFake(function() {
+                functionsCalledInOrder.push("component");
+              });
+              Jelly.notifyObservers({
+                "arguments":["arg1", "arg2"],
+                "method":"on_my_method"
+              });
+              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.notifyObservers({
+              "arguments":["arg1", "arg2"],
+              "method":"on_my_undefined_method"
+            });
+          });
+        });
+      });
+      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 the 'on' parameter is a string", function() {
+          describe("when the 'on' object defines the notify method", function() {
+            it("should call on_my_method on that object and not on the rest of the observers", function() {
+              spyOn(GlobalObject, 'on_my_method');
+              spyOn(GlobalObject.secondObject, 'on_my_method');
+              Jelly.attach(GlobalObject);
+              Jelly.notifyObservers({
+                "arguments":["arg1", "arg2"],
+                "method":"on_my_method",
+                "on":"GlobalObject.secondObject"
+              });
+              expect(GlobalObject.on_my_method).wasNotCalled();
+              expect(GlobalObject.secondObject.on_my_method).wasCalledWith('arg1', 'arg2');
+            });
+          });
+          describe("when the 'on' object does not define the notify method", function() {
+            it("does not blow up", function() {
+              expect(GlobalObject.secondObject.on_my_undefined_method).toBe(undefined);
+              Jelly.notifyObservers({
+                "arguments":["arg1", "arg2"],
+                "method":"on_my_undefined_method",
+                "on":"GlobalObject.secondObject"
+              });
+            });
+          })
+        });
+        describe("when the 'on' parameter is an object", function() {
+          describe("when the 'on' object defines the notify method", function() {
+            it("should call on_my_method on that object and not on the rest of the observers", function() {
+              spyOn(GlobalObject, 'on_my_method');
+              spyOn(GlobalObject.secondObject, 'on_my_method');
+              Jelly.attach(GlobalObject);
+              Jelly.notifyObservers({
+                "arguments":["arg1", "arg2"],
+                "method":"on_my_method",
+                "on": GlobalObject.secondObject
+              });
+              expect(GlobalObject.on_my_method).wasNotCalled();
+              expect(GlobalObject.secondObject.on_my_method).wasCalledWith('arg1', 'arg2');
+            });
+          });
+          describe("when the 'on' object does not define the notify method", function() {
+            it("does not blow up", function() {
+              expect(GlobalObject.secondObject.on_my_undefined_method).toBe(undefined);
+              Jelly.notifyObservers({
+                "arguments":["arg1", "arg2"],
+                "method":"on_my_undefined_method",
+                "on": GlobalObject.secondObject
+              });
+            });
+          })
+        });
+      });
+    });
+    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({component: "Jelly.Page", arguments: ["MyPage", "index"]});
+        Jelly.attach({component: component, arguments: []});
+        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.notifyObservers.call([customObserver1, customObserver2], {
+          "arguments":["arg1", "arg2"],
+          "method":"on_my_method"
+        });
+        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 event with the notify hash", function() {
+        var observer = {
+          on_notify: function() {
+          }
+        };
+        spyOn(observer, 'on_notify');
+        Jelly.notifyObservers.call([observer], {
+          "arguments":["arg1", "arg2"],
+          "method":"on_my_method"
+        });
+        expect(observer.on_notify).wasCalledWith({method: "on_my_method", arguments: ["arg1", "arg2"]});
+      });
+    });
+    describe("an observer listening to the notify method", function() {
+      var observer;
+      beforeEach(function() {
+        observer = {
+          on_my_method: function() {
+          }
+        };
+        Jelly.attach({component: observer, arguments: []});
+        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.notifyObservers({method: "on_my_method", arguments: []});
+          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({component: anotherObserver, arguments: []});
+          });
+          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.notifyObservers({method: "on_my_method", arguments: []});
+            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.notifyObservers({method: "on_my_method", arguments: []});
+            expect(Jelly.observers).toContain(observer);
+            expect(observer.on_my_method).wasCalled();
+          });
+        });
+      });
+    });
+    describe("when the 'attach' parameter is present", function() {
+      var observers;
+      beforeEach(function() {
+        MyComponent = {
+          init: function() {
+          }
+        };
+        spyOn(MyComponent, 'init');
+        observers = [];
+      });
+      describe("when the method is present", function() {
+        it("attaches the given attachments to the observers and calls the notify on the recently attached observer", function() {
+          Jelly.notifyObservers.call(observers, {
+            "arguments":["arg1", "arg2"],
+            "method":"on_my_method",
+            "attach":[
+              {
+                component: "MyComponent",
+                arguments: [1,2]
+              }
+            ]
+          });
+          expect(MyComponent.init).wasCalledWith(1, 2);
+          expect(Jelly.observers).toNotContain(MyComponent);
+          expect(observers).toContain(MyComponent);
+        });
+      });
+      describe("when there are no other paramaters present", function() {
+        it("attaches the given attachments to the observers", function() {
+          Jelly.notifyObservers.call(observers, {
+            "attach":[
+              {
+                component: "MyComponent",
+                arguments: [1,2]
+              }
+            ]
+          });
+          expect(Jelly.observers).toNotContain(MyComponent);
+          expect(observers).toContain(MyComponent);
+        });
+      });
+    });
+    describe("when given an array of notify instructions", function() {
+      it("notifies the observers of all of the notify hashes", function() {
+        page.on_my_method2 = function() {
+        };
+        spyOn(page, 'on_my_method');
+        spyOn(page, 'on_my_method2');
+        Jelly.notifyObservers([
+          {
+            "arguments":["arg1", "arg2"],
+            "method":"on_my_method"
+          },
+          {
+            "arguments": ["arg3"],
+            "method":"on_my_method2"
+          }
+        ]);
+        expect(page.on_my_method).wasCalledWith('arg1', 'arg2');
+        expect(page.on_my_method2).wasCalledWith('arg3');
+      });
+    });
+  });
+});
+describe("Jelly.Page", function() {
+  var our_token;
+  beforeEach(function() {
+    spyOn($, 'ajax');
+    our_token = "authenticity token";
+    window._token = our_token;
+    Jelly.init();
+  });
+  describe(".init", function() {
+    beforeEach(function() {
+      Jelly.Pages.add("DefinedComponent", {
+        baz : function() {
+        },
+        all : function() {
+        },
+        show: function() {
+        }
+      });
+      spyOn(Jelly.Pages.all["DefinedComponent"], "show");
+    });
+    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() {
+          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() {
+          var invokedMethods;
+          beforeEach(function() {
+            invokedMethods = [];
+            spyOn(Jelly.Pages.all["DefinedComponent"], "all").andCallFake(function() {
+              invokedMethods.push("all");
+            });
+            spyOn(Jelly.Pages.all["DefinedComponent"], "baz").andCallFake(function() {
+              invokedMethods.push("baz");
+            });
+          });
+          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']);
+          });
+        });
+      });
+      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() {
+          var invokedMethods;
+          beforeEach(function() {
+            invokedMethods = [];
+            Jelly.Pages.all["DefinedComponent"].all = function() {
+              invokedMethods.push("all");
+            };
+          });
+          it("invokes the all method", function() {
+            expect(Jelly.Pages.all["DefinedComponent"].easterBunny).toEqual(undefined);
+            expect(invokedMethods).toEqual([]);
+            Jelly.Page.init("DefinedComponent", "easterBunny");
+            expect(invokedMethods).toEqual(['all']);
+          });
+        });
+      });
+    });
+    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");
+      });
+    });
+  });
+});
+describe("Jelly.Location", function() {
+  var our_token, originalTop;
+  beforeEach(function() {
+    spyOn($, 'ajax');
+    our_token = "authenticity token";
+    window._token = our_token;
+    Jelly.init();
+    originalTop = window.top;
+  });
+  afterEach(function() {
+    window.top = originalTop;
+  });
+  describe(".on_redirect", function() {
+    it("sets top.location.href to the given location", function() {
+      window.top = {location: {}};
+      Jelly.Location.on_redirect("http://mars.com");
+      expect(window.top.location.href).toEqual("http://mars.com");
+    });
+  });
+});