honkster-jelly 0.7.7 → 0.8.1

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:minor: 7
-:patch: 7
+:minor: 8
+:patch: 1
 :major: 0

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

@@ -19,12 +19,13 @@ if(!window.Jelly) Jelly = new Object();
         authenticity_token: window._token
       });
     }
+    var observers = otherParams.observers || Jelly.observers;
     return $.extend({
       dataType: 'json',
       cache: false,
-      success : $.ajaxWithJelly.onSuccess
+      success : function(callbacks) {
+        Jelly.notifyObservers.call(observers, callbacks);
+      }
     }, otherParams);
   };
-
-  $.ajaxWithJelly.onSuccess = Jelly.notifyObservers.bind(Jelly);
 })(jQuery);

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

@@ -2,7 +2,7 @@
  *  Jelly. a sweet unobtrusive javascript framework
  *  for jQuery and Rails
  *
- *  version 0.7.7
+ *  version 0.8.1
  *
  * Copyright (c) 2009 Pivotal Labs
  * Licensed under the MIT license.
@@ -21,8 +21,9 @@ if (!Function.prototype.bind) {
   }
 }
 Jelly.init = function() {
-  this.components = [];
   this.observers = [];
+  this.observers.pending = [];
+  this.attach = this.Observers.attach;
   this.notifyObservers = this.Observers.notify;
   this.Components.initCalled = false;
   this.Pages.init();
@@ -32,65 +33,79 @@ Jelly.init = function() {
   });
 };
 
-Jelly.attach = function() {
-  for (var i = 0; i < arguments.length; i++) {
-    var definition = arguments[i];
-    var component = (typeof definition.component == "string") ?
-                    eval(definition.component) :
-                    definition.component;
-    var evaluatedDefinition = {
-      component: component,
-      arguments: definition.arguments
-    };
-    this.components.push(evaluatedDefinition);
-    if (Jelly.Components.initCalled) {
-      Jelly.Components.initComponentFromDefinition(evaluatedDefinition);
+Jelly.Components = {
+  init: function() {
+    for (var i = 0; i < Jelly.observers.pending.length; i++) {
+      Jelly.Observers.initPending.call(Jelly.observers, Jelly.observers.pending[i]);
     }
+    this.initCalled = true;
   }
 };
 
-Jelly.Components = {
-  init: function() {
-    for (var i = 0; i < Jelly.components.length; i++) {
-      this.initComponentFromDefinition(Jelly.components[i]);
+Jelly.Observers = {
+  attach: function() {
+    if (this == Jelly) {
+      return Jelly.Observers.attach.apply(this.observers, arguments);
+    }
+    this.pending = this.pending || [];
+    for (var i = 0; i < arguments.length; i++) {
+      var definition = arguments[i];
+      var component = (typeof definition.component == "string") ?
+                      eval(definition.component) :
+                      definition.component;
+      var evaluatedDefinition = {
+        component: component,
+        arguments: definition.arguments
+      };
+      this.pending.push(evaluatedDefinition);
+      if (Jelly.Components.initCalled) {
+        Jelly.Observers.initPending.call(this, evaluatedDefinition);
+      }
     }
-    this.initCalled = true;
   },
-  initComponentFromDefinition: function(definition) {
+
+  initPending: function(definition) {
     var observer;
     if (definition.component.init) {
       observer = definition.component.init.apply(definition.component, definition.arguments);
     }
-    Jelly.observers.push(observer ? observer : definition.component);
-  }
-};
+    this.push(observer ? observer : definition.component);
+  },
 
-Jelly.Observers = {
-  notify: function(params) {
-    if (this == Jelly) return Jelly.Observers.notify.call(this.observers, params);
-    var observers = this.slice(0);
+  notify: function(callbacks) {
+    if (this == Jelly) {
+      return Jelly.Observers.notify.apply(this.observers, arguments);
+    }
+    if (!$.isArray(callbacks)) {
+      callbacks = [callbacks];
+    }
 
-    // Deprecate 'on' in favor of making each page action a Component.
-    if (params.on) {
-      var additionalObserver = eval(params.on);
-      if (observers.indexOf(additionalObserver) == -1) {
-        observers.push(additionalObserver);
+    var observers = this.slice(0);
+    for (var i = 0; i < callbacks.length; i++) {
+      var callback = callbacks[i];
+
+      // Deprecate 'on' in favor of making each page action a Component.
+      if (callback.on) {
+        var additionalObserver = eval(callback.on);
+        if (observers.indexOf(additionalObserver) == -1) {
+          observers.push(additionalObserver);
+        }
       }
-    }
 
-    for (var i = 0; i < observers.length; i++) {
-      var observer = observers[i];
-      if (observer[params.method]) {
-        if (observer.detach && observer.detach()) {
-          Jelly.Observers.garbageCollectObserver.call(this, observer);
-        } else {
-          observer[params.method].apply(observer, params.arguments);
+      for (var j = 0; j < observers.length; j++) {
+        var observer = observers[j];
+        if (observer[callback.method]) {
+          if (observer.detach && observer.detach()) {
+            Jelly.Observers.garbageCollectObserver.call(this, observer);
+          } else {
+            observer[callback.method].apply(observer, callback.arguments);
+          }
         }
       }
-    }
 
-    if (params.attach) {
-      Jelly.attach.apply(Jelly, params.attach);
+      if (callback.attach) {
+        Jelly.Observers.attach.apply(this, callback.attach);
+      }
     }
   },
 

data/jelly.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{jelly}
-  s.version = "0.7.7"
+  s.version = "0.8.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Pivotal Labs, Inc"]
-  s.date = %q{2009-12-28}
+  s.date = %q{2009-12-29}
   s.description = %q{Jelly provides a set of tools and conventions for creating rich ajax/javascript web applications with jQuery and Ruby on Rails.}
   s.email = %q{opensource@pivotallabs.com}
   s.extra_rdoc_files = [

data/lib/jelly/jelly_controller.rb

@@ -3,6 +3,14 @@ module JellyController
   include Jelly::Common
 
   def jelly_callback(callback_base_name = @action_name, options = {}, &block)
+    raw_jelly_callback(options) do
+      arguments = block.try(:call) || []
+      jelly_callback_hash("on_#{callback_base_name}", *arguments).merge(options)
+    end
+  end
+
+  def raw_jelly_callback(options={}, &block)
+    options.symbolize_keys!
     options[:format] ||= if request.xhr?
       :json
     elsif params[:callback]
@@ -10,14 +18,12 @@ module JellyController
     else
       :iframe
     end
-    render :inline => jelly_callback_erb("on_#{callback_base_name}", options, block)
+    render :inline => jelly_callback_erb(options, &block)
   end
 
-  def jelly_callback_erb(callback_name, options, block)
+  def jelly_callback_erb(options={}, &block)
     options[:format] ||= :json
-    @callback_name = callback_name
-    @options = options
-    @block = block
+    @jelly_block = block
     case options[:format].to_sym
       when :iframe
         "<textarea>#{jelly_callback_erb_template}</textarea>"
@@ -32,9 +38,7 @@ module JellyController
   def jelly_callback_erb_template
     <<-ERB
       <%= begin
-        args = @block ? instance_eval(&@block) : []
-        args = [args] unless args.is_a?(Array)
-        json = {"method" => @callback_name, "arguments" => args}.reverse_merge(@options).to_json
+        json = instance_eval(&@jelly_block).to_json
         @jsonp_callback ? "\#{@jsonp_callback}(\#{json});" : json
       end %>
     ERB

data/spec/controllers/jelly_controller_spec.rb

@@ -15,6 +15,54 @@ describe ApplicationController do
       @controller.respond_to?(:jelly_callback).should be_true
     end
 
+    context "when given a format" do
+      describe "json" do
+        it "responds with a json hash, even if the request is not xhr" do
+          stub(request).xhr? {false}
+
+          @controller.send(:jelly_callback, 'foo', {'format' => :json, 'bar' => 'baz'}) do
+            "grape"
+          end
+          callback = JSON.parse(response.body)
+          callback["method"].should == "on_foo"
+          callback["arguments"].should == ["grape"]
+          callback["bar"].should == "baz"
+        end
+      end
+
+      describe "jsonp" do
+        it "responds with a jsonp callback based on the callback param" do
+          @controller.params[:callback] = "Jelly.notifyObservers"
+
+          @controller.send(:jelly_callback, 'foo', {'format' => :jsonp, 'bar' => 'baz'}) do
+            "grape"
+          end
+          json = Regexp.new('Jelly\.notifyObservers\((.*)\);').match(response.body)[1]
+          callback = JSON.parse(json)
+          callback["method"].should == "on_foo"
+          callback["arguments"].should == ["grape"]
+          callback["bar"].should == "baz"
+        end
+      end
+
+      describe "iframe" do
+        it "responds with a the json in a textarea tag" do
+          @controller.send(:jelly_callback, 'foo', {'format' => :iframe, 'bar' => 'baz'}) do
+            "grape"
+          end
+          body = response.body
+          body.should =~ /^<textarea>/
+          body.should =~ /<\/textarea>$/
+          doc = Nokogiri::HTML(body)
+
+          callback = JSON.parse(doc.at("textarea").inner_html)
+          callback["method"].should == "on_foo"
+          callback["arguments"].should == ["grape"]
+          callback["bar"].should == "baz"
+        end
+      end
+    end
+
     context "when the request is XHR" do
       before do
         stub(request).xhr? {true}
@@ -71,81 +119,123 @@ describe ApplicationController do
         end
       end
     end
+  end
 
-    describe "#jelly_callback_erb" do
-      before do
-        stub(request).xhr? {true}
+  describe "#raw_jelly_callback" do
+    attr_reader :response
+    before do
+      @response = Struct.new(:body).new
+      stub(@controller).render do |params|
+        response.body = ERB.new(params[:inline]).result(@controller.send(:binding))
       end
+    end
+
+    it "have the method included" do
+      @controller.respond_to?(:raw_jelly_callback).should be_true
+    end
+
+    context "when given a format" do
+      describe "json" do
+        it "responds with a json hash, even if the request is not xhr" do
+          stub(request).xhr? {false}
 
-      context "with options" do
-        it "should work with a block" do
-          erb = @controller.send(:jelly_callback_erb, 'foo', {'bar' => 'baz'}, lambda{'grape'})
-          JSON.parse(ERB.new(erb).result(@controller.send(:binding))).should == {
-            'method' => 'foo',
-            'arguments' => ['grape'],
-            'bar' => 'baz',
-            'format' => 'json'
-          }
+          @controller.send(:raw_jelly_callback, :format => :json) do
+            jelly_callback_hash("foo", "grape").merge('bar' => 'baz')
+          end
+          callback = JSON.parse(response.body)
+          callback["method"].should == "foo"
+          callback["arguments"].should == ["grape"]
+          callback["bar"].should == "baz"
         end
+      end
+
+      describe "jsonp" do
+        it "responds with a jsonp callback based on the callback param" do
+          @controller.params[:callback] = "Jelly.notifyObservers"
 
-        it "should work without a block" do
-          erb = @controller.send(:jelly_callback_erb, 'foo', {'bar' => 'baz'}, nil)
-          JSON.parse(ERB.new(erb).result(@controller.send(:binding))).should == {
-            'method' => 'foo',
-            'arguments' => [],
-            'bar' => 'baz',
-            'format' => 'json'
-          }
+          @controller.send(:raw_jelly_callback, :format => :jsonp) do
+            jelly_callback_hash("foo", "grape").merge('bar' => 'baz')
+          end
+          json = Regexp.new('Jelly\.notifyObservers\((.*)\);').match(response.body)[1]
+          callback = JSON.parse(json)
+          callback["method"].should == "foo"
+          callback["arguments"].should == ["grape"]
+          callback["bar"].should == "baz"
         end
+      end
+
+      describe "iframe" do
+        it "responds with a the json in a textarea tag" do
+          @controller.send(:raw_jelly_callback, :format => :iframe) do
+            jelly_callback_hash("foo", "grape").merge('bar' => 'baz')
+          end
+          body = response.body
+          body.should =~ /^<textarea>/
+          body.should =~ /<\/textarea>$/
+          doc = Nokogiri::HTML(body)
 
-        it "should work if options are passed with symbol keys" do
-          erb = @controller.send(:jelly_callback_erb, 'foo', {:bar => 'baz'}, nil)
-          JSON.parse(ERB.new(erb).result(@controller.send(:binding))).should == {
-            'method' => 'foo',
-            'arguments' => [],
-            'bar' => 'baz',
-            'format' => 'json'
-          }
+          callback = JSON.parse(doc.at("textarea").inner_html)
+          callback["method"].should == "foo"
+          callback["arguments"].should == ["grape"]
+          callback["bar"].should == "baz"
         end
       end
+    end
+
+    context "when the request is XHR" do
+      before do
+        stub(request).xhr? {true}
+      end
 
-      context "without options" do
-        it "should work with a block" do
-          erb = @controller.send(:jelly_callback_erb, 'foo', {}, lambda{'grape'})
-          JSON.parse(ERB.new(erb).result(@controller.send(:binding))).should == {
-            'method' => 'foo',
-            'arguments' => ['grape'],
-            'format' => 'json'
-          }
+      it "responds with a json hash" do
+        @controller.send(:raw_jelly_callback) do
+          jelly_callback_hash("foo", "grape").merge('bar' => 'baz')
         end
+        callback = JSON.parse(response.body)
+        callback["method"].should == "foo"
+        callback["arguments"].should == ["grape"]
+        callback["bar"].should == "baz"
+      end
+
+    end
 
-        it "should work with a block of more than one thing" do
-          erb = @controller.send(:jelly_callback_erb, 'foo', {}, lambda{['grape','tangerine']})
-          JSON.parse(ERB.new(erb).result(@controller.send(:binding))).should == {
-            'method' => 'foo',
-            'arguments' => ['grape','tangerine'],
-            'format' => 'json'
-          }
+    context "when the request is not XHR" do
+      before do
+        stub(request).xhr? {false}
+      end
+
+      context "when there is a callback param" do
+        before do
+          @controller.params[:callback] = "Jelly.notifyObservers"
         end
 
-        it "should work without a block" do
-          erb = @controller.send(:jelly_callback_erb, 'foo', {}, nil)
-          JSON.parse(ERB.new(erb).result(@controller.send(:binding))).should == {
-            'method' => 'foo',
-            'arguments' => [],
-            'format' => 'json'
-          }
+        it "responds with a call to the given callback method with the json as an argument" do
+          @controller.send(:raw_jelly_callback) do
+            jelly_callback_hash("foo", "grape").merge('bar' => 'baz')
+          end
+          json = Regexp.new('Jelly\.notifyObservers\((.*)\);').match(response.body)[1]
+          callback = JSON.parse(json)
+          callback["method"].should == "foo"
+          callback["arguments"].should == ["grape"]
+          callback["bar"].should == "baz"
         end
       end
 
-      it "should escape html in the arguments" do
-        block = lambda{'<div class="foo"></div>'}
-        erb = @controller.send(:jelly_callback_erb, 'foo', {}, block)
-        JSON.parse(ERB.new(erb).result(@controller.send(:binding))).should == {
-          'method' => 'foo',
-          'arguments' => ['<div class="foo"></div>'],
-          'format' => 'json'
-        }
+      context "when there is not a callback param" do
+        it "wraps the json response in a textarea tag to support File Uploads in an iframe target (see: http://malsup.com/jquery/form/#code-samples)" do
+          @controller.send(:raw_jelly_callback) do
+            jelly_callback_hash("foo", "grape").merge('bar' => 'baz')
+          end
+          body = response.body
+          body.should =~ /^<textarea>/
+          body.should =~ /<\/textarea>$/
+          doc = Nokogiri::HTML(body)
+
+          callback = JSON.parse(doc.at("textarea").inner_html)
+          callback["method"].should == "foo"
+          callback["arguments"].should == ["grape"]
+          callback["bar"].should == "baz"
+        end
       end
     end
   end

data/spec/spec_helper.rb

@@ -2,6 +2,7 @@
 # from the project root directory.
 ENV["RAILS_ENV"] ||= 'test'
 ENV['RAILS_ROOT'] ||= File.dirname(__FILE__) + '/rails_root'
+ARGV.push("-b")
 require File.expand_path(File.join(ENV['RAILS_ROOT'], 'config/environment.rb'))
 require 'rubygems'
 gem "test-unit"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: honkster-jelly
 version: !ruby/object:Gem::Version 
-  version: 0.7.7
+  version: 0.8.1
 platform: ruby
 authors: 
 - Pivotal Labs, Inc
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-28 00:00:00 -08:00
+date: 2009-12-29 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency