honkster-jelly 0.12.0 → 0.13.0

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

@@ -17,8 +17,8 @@ if(!window.Jelly) window.Jelly = {};
     return $.extend({
       dataType: 'json',
       cache: false,
-      success : function(callbacks) {
-        Jelly.Observers.notify.call(otherParams.observers || Jelly.observers, callbacks);
+      success : function(ops) {
+        Jelly.Observers.run.apply(otherParams.observers || Jelly.observers, ops);
       }
     }, otherParams);
   };

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

@@ -1,7 +1,7 @@
 /**
  *  Jelly. a sweet unobtrusive javascript framework for Rails
  *
- *  version 0.12.0
+ *  version 0.13.0
  *
  * Copyright (c) 2009 Pivotal Labs
  * Licensed under the MIT license.
@@ -32,38 +32,46 @@
   extend(Jelly, {
     init:function () {
       this.observers = [];
+      this.run = this.Observers.run;
       this.attach = this.Observers.attach;
       this.notifyObservers = this.Observers.notify;
       this.Pages.init();
     },
 
     Observers:{
-      attach:function () {
+      run:function () {
         if (this === Jelly) {
-          return Jelly.Observers.attach.apply(this.observers, arguments);
+          return Jelly.Observers.run.apply(this.observers, arguments);
         }
-        var self = Jelly.Observers;
-        for (var i = 0; i < arguments.length; i++) {
-          var definitionOrComponent = arguments[i];
-          if (definitionOrComponent.component) {
-            self.attachFromDefinition.call(
-              this,
-              self.evaluateComponent(definitionOrComponent.component),
-              definitionOrComponent.arguments
-            );
-          } else if (Object.prototype.toString.call(definitionOrComponent) === "[object Array]") {
-            self.attachFromDefinition.call(
-              this,
-              self.evaluateComponent(definitionOrComponent[0]),
-              definitionOrComponent.slice(1)
-            );
-          } else {
-            self.pushIfObserver.call(this, Jelly.Observers.evaluateComponent(definitionOrComponent));
+        for (var i=0, len=arguments.length; i < len; i++) {
+          var op = arguments[i];
+          switch (op[0]) {
+            case ("attach"):
+              Jelly.Observers.runAttachOp.call(this, op);
+              break;
+            case ("notify"):
+              Jelly.Observers.runNotifyOp.call(this, op);
+              break;
           }
+
+        }
+      },
+
+      runAttachOp:function (op) {
+        if (op[0] !== "attach") {
+          throw "op " + JSON.stringify(op) + " is not an attach op"
         }
+        var args = [op[1]];
+        args.concat.apply(args, op.slice(2));
+        Jelly.Observers.attach.apply(this, args);
       },
 
-      attachFromDefinition:function (component, args) {
+      attach:function () {
+        if (this === Jelly) {
+          return Jelly.Observers.attach.apply(this.observers, arguments);
+        }
+        var component = Jelly.Observers.evaluateComponent(arguments[0]);
+        var args = Array.prototype.slice.call(arguments, 1);
         if (component.init) {
           var initReturnValue = component.init.apply(component, args);
           if (initReturnValue === false || initReturnValue === null) {
@@ -85,50 +93,38 @@
         }
       },
 
-      notify:function (instructions) {
+      runNotifyOp:function(op) {
+        if (op[0] !== "notify") {
+          throw "op " + JSON.stringify(op) + " is not a notify op"
+        }
+        var args = [op[1]];
+        args.push.apply(args, op.slice(2));
+        Jelly.Observers.notify.apply(this, args);
+      },
+
+      notify:function () {
         if (this === Jelly) {
           return Jelly.Observers.notify.apply(this.observers, arguments);
         }
-        var previousNotifying = Jelly.Observers.notifying;
-        Jelly.Observers.notifying = true;
-        if (Object.prototype.toString.call(instructions) !== "[object Array]") {
-          instructions = [instructions];
-        }
 
-        var pristineObservers = this.slice(0);
-        var observers;
-        for (var i = 0; i < instructions.length; i++) {
-          var instruction = instructions[i];
-
-          // Deprecate 'on' in favor of making each page action a Component.
-          if (instruction.on) {
-            observers = [eval(instruction.on)];
-          } else {
-            observers = pristineObservers;
-          }
-
-          if (instruction.method) {
-            for (var j = 0; j < observers.length; j++) {
-              var observer = observers[j];
-              Jelly.Observers.notifyObserver.call(this, observer, instruction.method, instruction.arguments);
-              Jelly.Observers.notifyObserver.call(this, observer, 'on_notify', [instruction]);
-            }
-          }
-
-          if (instruction.attach) {
-            Jelly.Observers.attach.apply(this, instruction.attach);
-          }
+        var observers = this.slice(0);
+        var message = arguments[0];
+        var args = Array.prototype.slice.call(arguments, 1);
+        var instruction = [message];
+        instruction.push.apply(instruction, args);
+        for (var i = 0, len = observers.length; i < len; i++) {
+          var observer = observers[i];
+          Jelly.Observers.notifyObserver.call(this, observer, message, args);
+          Jelly.Observers.notifyObserver.call(this, observer, 'on_notify', instruction);
         }
-
-        Jelly.Observers.notifying = previousNotifying;
       },
 
-      notifyObserver:function (observer, method, arguments) {
+      notifyObserver:function (observer, method, args) {
         if (observer[method]) {
           if (observer.detach && observer.detach()) {
             Jelly.Observers.garbageCollectObserver.call(this, observer);
           } else {
-            observer[method].apply(observer, arguments);
+            observer[method].apply(observer, args);
           }
         }
       },

data/lib/jelly/common.rb

@@ -1,28 +1,44 @@
 module Jelly
+  class OldMethodError < NotImplementedError
+  end
+
   module Common
+    def jelly_attach_op(component_name, *args)
+      ["attach", component_name, *args]
+    end
+
+    def jelly_notify_op(message_name, *args)
+      ["notify", message_name, *args]
+    end
+
+    def jelly_call_op(object, method, *args)
+      ["call", object, method, *args]
+    end
+
+    ### Old Methods ###
+
     def jelly_notify_hash(method, *arguments)
-      {"method" => method, "arguments" => arguments}
+      raise Jelly::OldMethodError
     end
 
     def jelly_callback_hash(method, *arguments)
-      warn "jelly_callback_hash has been deprecated. Please use jelly_notify_hash instead"
-      jelly_notify_hash(method, *arguments)
+      raise Jelly::OldMethodError
     end
 
     def jelly_method_call_hash(object, method, *arguments)
-      {"on" => object, "method" => method, "arguments" => arguments}
+      raise Jelly::OldMethodError
     end
 
-    def jelly_notify_attach_hash (components=jelly_attachments)
-      {"attach" => components}
+    def jelly_notify_attach_hash (components=jelly_ops)
+      raise Jelly::OldMethodError
     end
 
     def jelly_attachment_hash(component_name, *args)
-      {'component' => component_name, 'arguments' => args}
+      raise Jelly::OldMethodError
     end
 
     def jelly_attachment_array(component_name, *args)
-      [component_name, *args]
+      raise Jelly::OldMethodError
     end
   end
 end

data/lib/jelly/jelly_controller.rb

@@ -2,15 +2,7 @@ module JellyController
   protected
   include Jelly::Common
 
-  def jelly_callback(callback_base_name = @action_name, options = {}, &block)
-    raw_jelly_callback(options) do
-      arguments = block ? instance_eval(&block) : []
-      arguments = [arguments] unless arguments.is_a?(Array)
-      jelly_notify_hash("on_#{callback_base_name}", *arguments).merge(options)
-    end
-  end
-
-  def raw_jelly_callback(options={}, &block)
+  def render_jelly_ops(options={}, &block)
     options.symbolize_keys!
     options[:format] ||= if params[:callback]
       :jsonp
@@ -19,23 +11,52 @@ module JellyController
     else
       :iframe
     end
-    render :inline => jelly_callback_erb(options, &block)
+    render :inline => render_jelly_ops_erb(options, &block)
   end
 
-  def jelly_callback_erb(options={}, &block)
+  def render_jelly_ops_erb(options={}, &block)
     options[:format] ||= :json
     @jelly_block = block
     case options[:format].to_sym
       when :iframe
-        "<textarea>#{jelly_callback_erb_template}</textarea>"
+        <<-ERB
+        <textarea>#{render_jelly_ops_erb_template}</textarea>
+        ERB
       when :jsonp
-        "#{params[:callback]}(#{jelly_callback_erb_template});"
+        <<-ERB
+        #{params[:callback]}(#{render_jelly_ops_erb_template});
+        ERB
       else
-        jelly_callback_erb_template
+        <<-ERB
+        #{render_jelly_ops_erb_template}
+        ERB
     end
   end
 
+  def render_jelly_ops_erb_template
+    <<-ERB
+    <%=begin
+      instance_eval(&controller.instance_variable_get(:@jelly_block))
+      jelly_ops.to_json.html_safe
+    end -%>
+    ERB
+  end
+
+  ### Old Methods ###
+
+  def jelly_callback(callback_base_name = @action_name, options = {}, &block)
+    raise Jelly::OldMethodError
+  end
+
+  def raw_jelly_callback(options={}, &block)
+    raise Jelly::OldMethodError
+  end
+
+  def jelly_callback_erb(options={}, &block)
+    raise Jelly::OldMethodError
+  end
+
   def jelly_callback_erb_template
-    %Q{<%= instance_eval(&controller.instance_variable_get(:@jelly_block)).to_json.html_safe %>}
+    raise Jelly::OldMethodError
   end
 end

data/lib/jelly/jelly_helper.rb

@@ -12,33 +12,61 @@ module JellyHelper
   end
 
   def spread_jelly
-    attach_javascript_component("Jelly.Location")
-    attach_javascript_component("Jelly.Page", controller.controller_path.camelcase, controller.action_name)
-    attach_javascript_component_javascript_tag(jelly_attachments)
+    jelly_attach("Jelly.Location")
+    jelly_attach("Jelly.Page", controller.controller_path.camelcase, controller.action_name)
+    jelly_run_javascript_tag(jelly_ops)
   end
 
+  def jelly_run_javascript_tag(ops)
+    javascript_tag jelly_run_javascript(ops)
+  end
+
+  def jelly_run_javascript(ops)
+    "Jelly.run.apply(Jelly, #{ops.to_json});"
+  end
+
+  def jelly_clear_ops
+    jelly_ops.clear
+  end
+
+  def jelly_attach(component_name, *args)
+    op = jelly_attach_op(component_name, *args)
+    unless jelly_ops.include? op
+      jelly_ops << op
+    end
+  end
+
+  def jelly_notify(message_name, *args)
+    op = jelly_notify_op(message_name, *args)
+    unless jelly_ops.include? op
+      jelly_ops << op
+    end
+  end
+
+  def jelly_ops
+    @jelly_ops ||= []
+  end
+
+  ### Old Methods ###
+
   def attach_javascript_component_javascript_tag(components)
-    javascript_tag "Jelly.attach.apply(Jelly, #{components.to_json});"
+    raise Jelly::OldMethodError
   end
 
   def clear_jelly_attached
-    jelly_attachments.clear
+    raise Jelly::OldMethodError
   end
 
   def attach_javascript_component(component_name, *args)
-    key = jelly_attachment_array(component_name, *args)
-    unless jelly_attachments.include? key
-      jelly_attachments << key
-    end
+    raise Jelly::OldMethodError
   end
 
-  def attach_javascript_component_on_ready(component_name, *args)
-    warn "attach_javascript_component_on_ready is deprecated since attach_javascript_component adds components to be attached in a $(document).ready block\n#{puts caller.join("\n\t")}"
-    attach_javascript_component(component_name, *args)
+  def jelly_attach_on_ready(component_name, *args)
+    raise Jelly::OldMethodError
   end
 
   def jelly_attachments
-    @jelly_attachments ||= []
+    raise Jelly::OldMethodError
   end
 
 end

data/spec/javascript/ajax_with_jelly_spec.js

@@ -1,6 +1,4 @@
 describe("Jelly", function() {
-  var our_token;
-
   beforeEach(function() {
     Jelly.add("MyPage", {
       on_my_method : function() {
@@ -8,8 +6,6 @@ describe("Jelly", function() {
     });
     page = Jelly.all["MyPage"];
     spyOn($, 'ajax');
-    our_token = "authenticity token";
-    window._token = our_token;
   });
 
   afterEach(function() {
@@ -57,14 +53,11 @@ describe("Jelly", function() {
               observerArgs = [arg1, arg2];
             }
           };
-          Jelly.attach({component: observer, arguments: []});
+          Jelly.attach(observer);
           expect(Jelly.observers).toContain(observer);
 
-          var notification = {
-            "arguments":["arg1", "arg2"],
-            "method":"on_my_method"
-          };
-          $.ajaxWithJelly.params().success(notification);
+          var op = ["notify", "on_my_method", "arg1", "arg2"];
+          $.ajaxWithJelly.params().success([op]);
 
           expect(observerArgs).toEqual(["arg1", "arg2"]);
         });
@@ -81,11 +74,8 @@ describe("Jelly", function() {
           var observers = [observer];
           expect(Jelly.observers).toNotContain(observer);
 
-          var notification = {
-            "arguments":["arg1", "arg2"],
-            "method":"on_my_method"
-          };
-          $.ajaxWithJelly.params({observers: observers}).success(notification);
+          var op = ["notify", "on_my_method", "arg1", "arg2"];
+          $.ajaxWithJelly.params({observers: observers}).success([op]);
 
           expect(observerArgs).toEqual(["arg1", "arg2"]);
         });

data/spec/javascript/jelly_spec.js

@@ -30,136 +30,71 @@ describe("Jelly", function() {
       expect(newPage.index).toEqual(indexFn);
     });
   });
-
-  describe(".attach", function() {
-    describe("when the argument contains a 'component' key", 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() {
             delete window.MyComponent;
           });
-
+  
           it("attaches the component to Jelly.observers", function() {
-            Jelly.attach({component: "MyComponent"});
+            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() {
             var component = {};
-            Jelly.attach({component: 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.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(".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 = {
+          };
         });
 
-        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);
-          });
+        afterEach(function() {
+          delete window.MyComponent;
         });
 
-        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);
-          });
+        it("attaches the component to Jelly.observers", function() {
+          Jelly.attach("MyComponent");
+          expect(Jelly.observers).toContain(MyComponent);
         });
+      });
 
-        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 component is referenced as itself", function() {
+        it("attaches the component to Jelly.observers", function() {
+          var component = {};
+          Jelly.attach(component);
+          expect(Jelly.observers).toContain(component);
         });
       });
     });
 
-    describe("when the argument is an array", function() {
-      describe("when the component does not respond to init", 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() {
+              }
             };
           });
 
@@ -167,148 +102,83 @@ describe("Jelly", function() {
             delete window.MyComponent;
           });
 
-          it("attaches the component to Jelly.observers", function() {
-            Jelly.attach(["MyComponent"]);
+          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);
             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]);
-            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([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.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.attach([component, 1, 2]);
-            expect(component.initCalled).toBeTruthy();
-            expect(Jelly.observers.length).toEqual(originalObserversLength);
-            expect(Jelly.observers).toNotContain(component);
+          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);
+            expect(Jelly.observers).toContain(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, 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 false", function() {
+        var component;
+        beforeEach(function() {
+          component = {
+            init: function() {
+              component.initCalled = true;
+              return false;
+            }
+          };
         });
 
-        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, 1, 2]);
-            expect(Jelly.observers).toContain(observer);
-            expect(Jelly.observers).toNotContain(component);
-          });
+        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();
+          expect(Jelly.observers.length).toEqual(originalObserversLength);
+          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() {
+      describe("when the component's init method returns null", function() {
+        var component;
         beforeEach(function() {
-          window.MyComponent = {
+          component = {
             init: function() {
+              component.initCalled = true;
+              return null;
             }
           };
         });
 
-        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);
+        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();
+          expect(Jelly.observers.length).toEqual(originalObserversLength);
+          expect(Jelly.observers).toNotContain(component);
         });
       });
 
-      describe("when the component is referenced as itself", function() {
-        it("does not call init and attaches 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() {
+              return observer;
             }
           };
-          spyOn(component, 'init');
-          Jelly.attach(component);
-          expect(component.init).wasNotCalled();
-          expect(Jelly.observers).toContain(component);
+          Jelly.attach(component, 1, 2);
+          expect(Jelly.observers).toContain(observer);
+          expect(Jelly.observers).toNotContain(component);
         });
       });
     });
@@ -320,31 +190,7 @@ describe("Jelly", function() {
         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);
-      });
+      Jelly.attach("Jelly.Page", "MyPage", "index");
     });
 
     describe("when bound to the default Jelly.observers collection", function() {
@@ -352,10 +198,7 @@ describe("Jelly", 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"
-            });
+            Jelly.notifyObservers("on_my_method", "arg1", "arg2");
             expect(page.on_my_method).wasCalled();
             expect(page.on_my_method).wasCalledWith('arg1', 'arg2');
           });
@@ -366,7 +209,7 @@ describe("Jelly", function() {
                 on_my_method: function() {
                 }
               };
-              Jelly.attach({component: component, arguments: []});
+              Jelly.attach(component);
 
               var functionsCalledInOrder = [];
               spyOn(page, 'on_my_method').andCallFake(function() {
@@ -375,10 +218,7 @@ describe("Jelly", function() {
               spyOn(component, 'on_my_method').andCallFake(function() {
                 functionsCalledInOrder.push("component");
               });
-              Jelly.notifyObservers({
-                "arguments":["arg1", "arg2"],
-                "method":"on_my_method"
-              });
+              Jelly.notifyObservers("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();
@@ -391,10 +231,7 @@ describe("Jelly", 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({
-              "arguments":["arg1", "arg2"],
-              "method":"on_my_undefined_method"
-            });
+            Jelly.notifyObservers("on_my_undefined_method", "arg1", "arg2");
           });
         });
       });
@@ -410,62 +247,6 @@ describe("Jelly", 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
-              });
-            });
-          })
-        });
       });
     });
 
@@ -475,8 +256,8 @@ describe("Jelly", function() {
           on_my_method: function() {
           }
         };
-        Jelly.attach({component: "Jelly.Page", arguments: ["MyPage", "index"]});
-        Jelly.attach({component: component, arguments: []});
+        Jelly.attach("Jelly.Page", "MyPage", "index");
+        Jelly.attach(component);
 
         spyOn(page, 'on_my_method');
         spyOn(component, 'on_my_method');
@@ -488,10 +269,7 @@ describe("Jelly", function() {
         }};
         spyOn(customObserver2, 'on_my_method');
 
-        Jelly.notifyObservers.call([customObserver1, customObserver2], {
-          "arguments":["arg1", "arg2"],
-          "method":"on_my_method"
-        });
+        Jelly.notifyObservers.call([customObserver1, customObserver2], "on_my_method", "arg1", "arg2");
 
         expect(page.on_my_method).wasNotCalled();
         expect(component.on_my_method).wasNotCalled();
@@ -504,19 +282,16 @@ describe("Jelly", function() {
     });
 
     describe("an observer listening to on_notify", function() {
-      it("receives a notify event with the notify hash", function() {
+      it("receives a notify instruction", function() {
         var observer = {
           on_notify: function() {
           }
         };
         spyOn(observer, 'on_notify');
 
-        Jelly.notifyObservers.call([observer], {
-          "arguments":["arg1", "arg2"],
-          "method":"on_my_method"
-        });
+        Jelly.notifyObservers.call([observer], "on_my_method", "arg1", "arg2");
 
-        expect(observer.on_notify).wasCalledWith({method: "on_my_method", arguments: ["arg1", "arg2"]});
+        expect(observer.on_notify).wasCalledWith("on_my_method", "arg1", "arg2");
       });
     });
 
@@ -527,7 +302,7 @@ describe("Jelly", function() {
           on_my_method: function() {
           }
         };
-        Jelly.attach({component: observer, arguments: []});
+        Jelly.attach(observer);
         expect(Jelly.observers).toContain(observer);
       });
 
@@ -539,7 +314,7 @@ describe("Jelly", function() {
         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: []});
+          Jelly.notifyObservers("on_my_method");
           expect(Jelly.observers).toContain(observer);
           expect(observer.on_my_method).wasCalled();
         });
@@ -556,14 +331,14 @@ describe("Jelly", function() {
               on_my_method: function() {
               }
             };
-            Jelly.attach({component: anotherObserver, arguments: []});
+            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.notifyObservers({method: "on_my_method", arguments: []});
+            Jelly.notifyObservers("on_my_method");
             expect(Jelly.observers).toNotContain(observer);
             expect(observer.on_my_method).wasNotCalled();
             expect(anotherObserver.on_my_method).wasCalled();
@@ -580,80 +355,13 @@ describe("Jelly", function() {
           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: []});
+            Jelly.notifyObservers("on_my_method");
             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');
-      });
-    });
   });
 });