btakita-jelly 0.6.1 → 0.8.5

data/lib/jelly/jelly_helper.rb

@@ -1,4 +1,5 @@
 module JellyHelper
+  include Jelly::Common
 
   def application_jelly_files(jelly_files_path_from_javascripts = '', rails_root = RAILS_ROOT)
     rails_root = File.expand_path(rails_root)
@@ -11,36 +12,45 @@ module JellyHelper
   end
 
   def spread_jelly
+    attach_javascript_component("Jelly.Location")
+    attach_javascript_component("Jelly.Page", controller.controller_path.camelcase, controller.action_name)
+    <<-HTML
+      #{window_token_javascript_tag}
+      #{attach_javascript_component_javascript_tag(jelly_attached_components)}
+    HTML
+  end
+
+  def window_token_javascript_tag
+    javascript_tag("window._token = '#{form_authenticity_token}';")
+  end
+
+  def attach_javascript_component_javascript_tag(*components)
+    components = [components].flatten
     javascript_tag <<-JS
-      window._token = '#{form_authenticity_token}'
-      Jelly.activatePage('#{controller.controller_path.camelcase}', '#{controller.action_name}');
-      #{@content_for_javascript}
       $(document).ready(function() {
-        #{@content_for_javascript_on_ready}
+        Jelly.attach.apply(Jelly, #{components.to_json});
       });
     JS
   end
 
-  def clear_jelly_attached()
-    @jelly_attached_components = []
+  def clear_jelly_attached
+    jelly_attached_components.clear
   end
 
   def attach_javascript_component(component_name, *args)
-    @jelly_attached_components ||= []    
-    key = "page.attach(#{component_name}, #{args.to_json});"
-    unless @jelly_attached_components.include? key
-      @jelly_attached_components << key
-      content_for(:javascript, key)
+    key = jelly_attach_component_definition_hash(component_name, *args)
+    unless jelly_attached_components.include? key
+      jelly_attached_components << key
     end
   end
 
   def attach_javascript_component_on_ready(component_name, *args)
-    @jelly_attached_components_on_ready ||= []
-    key = "page.attach(#{component_name}, #{args.to_json});"
-    unless @jelly_attached_components_on_ready.include? key
-      @jelly_attached_components_on_ready << key
-      content_for(:javascript_on_ready, key)
-    end
+    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)
+  end
+
+  def jelly_attached_components
+    @jelly_attached_components ||= []
   end
 
 end

data/spec/controllers/jelly_controller_spec.rb

@@ -3,116 +3,300 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
 describe ApplicationController do
 
   describe "#jelly_callback" do
+    attr_reader :template
     before do
-      @controller.stub!(:render)
+      stub(@controller).render do |params|
+        @template = ActionView::Base.new(@controller.class.view_paths, {}, @controller)
+        template.send(:_evaluate_assigns_and_ivars)
+        response.body = ERB.new(params[:inline]).result(template.send(:binding))
+      end
     end
 
     it "have the method included" do
       @controller.respond_to?(:jelly_callback).should be_true
     end
 
-    it "should render inline the return of jelly_callback_erb" do
-      block = lambda{'foo yo'}
-      mock_erb = "whatever"
-      @controller.should_receive(:jelly_callback_erb).with("on_foo", {}, block).and_return(mock_erb)
-      @controller.should_receive(:render).with(:inline => mock_erb)
-      @controller.send(:jelly_callback, "foo", &block)
-    end
+    describe "Arguments block" do
+      describe "self" do
+        it "runs with the binding of the ERB template" do
+          self_in_block = nil
+          @controller.send(:jelly_callback, 'foo', :format => :json) do
+            self_in_block = self
+            12345
+          end
+          self_in_block.should == template
+        end
+      end
 
-    describe "#jelly_callback_erb" do
-      before do
-        request.stub!(:xhr?).and_return(true)
+      context "when an Array is returned from the block" do
+        it "sets the arguments to be an Array around the Hash" do
+          @controller.send(:jelly_callback, 'foo', :format => :json) do
+            ["foo", "bar"]
+          end
+          callback = JSON.parse(response.body)
+          callback["method"].should == "on_foo"
+          callback["arguments"].should == ["foo", "bar"]
+        end
       end
 
-      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'
-          }
+      context "when a non-array is returned in the block" do
+        context "when the argument is a Hash" do
+          it "sets the arguments to be an Array around the Hash" do
+            @controller.send(:jelly_callback, 'foo', :format => :json) do
+              {"foo" => "bar"}
+            end
+            callback = JSON.parse(response.body)
+            callback["method"].should == "on_foo"
+            callback["arguments"].should == [{"foo" => "bar"}]
+          end
+        end
+
+        context "when the argument is a String" do
+          it "sets the arguments to be an Array around the argument" do
+            @controller.send(:jelly_callback, 'foo', :format => :json) do
+              "foobar"
+            end
+            callback = JSON.parse(response.body)
+            callback["method"].should == "on_foo"
+            callback["arguments"].should == ["foobar"]
+          end
         end
 
-        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'
-          }
+        context "when the argument is a Number" do
+          it "sets the arguments to be an Array around the argument" do
+            @controller.send(:jelly_callback, 'foo', :format => :json) do
+              12345
+            end
+            callback = JSON.parse(response.body)
+            callback["method"].should == "on_foo"
+            callback["arguments"].should == [12345]
+          end
         end
+      end
+    end
 
-        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'
-          }
+    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
 
-      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']
-          }
+      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)
 
-        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']
-          }
+          callback = JSON.parse(doc.at("textarea").inner_html)
+          callback["method"].should == "on_foo"
+          callback["arguments"].should == ["grape"]
+          callback["bar"].should == "baz"
         end
+      end
+    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' => []
-          }
+    context "when the request is XHR" do
+      before do
+        stub(request).xhr? {true}
+      end
+
+      it "responds with a json hash" do
+        @controller.send(:jelly_callback, 'foo', {'bar' => 'baz'}) do
+          "grape"
         end
+        callback = JSON.parse(response.body)
+        callback["method"].should == "on_foo"
+        callback["arguments"].should == ["grape"]
+        callback["bar"].should == "baz"
       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>']
-        }
+    end
+
+    context "when the request is not XHR" do
+      before do
+        stub(request).xhr? {false}
       end
 
-      context "when the request is not an XHR" do
+      context "when there is a callback param" do
         before do
-          request.stub!(:xhr?).and_return(false)
+          @controller.params[:callback] = "Jelly.notifyObservers"
         end
 
-        it "should wrap json response in a textarea tag to support File Uploads in an iframe target (see: http://malsup.com/jquery/form/#code-samples)" do
-          erb = @controller.send(:jelly_callback_erb, 'foo', {'bar' => 'baz'}, lambda{'grape'})
-          result = ERB.new(erb).result(@controller.send(:binding))
-          result.should =~ /^<textarea>/
-          result.should =~ /<\/textarea>$/
+        it "responds with a call to the given callback method with the json as an argument" do
+          @controller.send(:jelly_callback, 'foo', {'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
 
-      context "when the request is an XHR" do
-        before do
-          request.stub!(:xhr?).and_return(true)
+      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(:jelly_callback, 'foo', {'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
+  end
+
+  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 "should not do the textarea nonsense" do
-          erb = @controller.send(:jelly_callback_erb, 'foo', {'bar' => 'baz'}, lambda{'grape'})
-          ERB.new(erb).result(@controller.send(:binding)).should_not =~ /textarea/
+    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}
+
+          @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"
+
+          @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)
+
+          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
 
+      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
+
+    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 "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
+
+      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
 end

data/spec/helpers/jelly_helper_spec.rb

@@ -2,14 +2,27 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
 
 describe JellyHelper do
 
-  describe "#init_specific_javascript" do
-    it "should create a javascript include tag to initialize the Page object" do
-      stub_controller = mock(Object, :controller_path => 'my_fun_controller', :action_name => 'super_good_action')
-      helper.should_receive(:controller).any_number_of_times.and_return(stub_controller)
-      helper.should_receive(:form_authenticity_token).and_return('areallysecuretoken')
+  def jelly_attach_arguments(html)
+    JSON.parse(Regexp.new('Jelly\.attach\.apply\(Jelly, (.*)\);').match(html)[1])
+  end
+
+  describe "#spread_jelly" do
+    before do
+      stub_controller = mock! do |controller|
+        controller.controller_path {'my_fun_controller'}
+        controller.action_name {'super_good_action'}
+      end
+      stub(helper).controller {stub_controller}
+      mock(helper).form_authenticity_token {'areallysecuretoken'}
+    end
+
+    it "should create a javascript include tag that attaches the Jelly.Location and Jelly.Page components" do
       output = helper.spread_jelly
       output.should include('<script type="text/javascript">')
-      output.should include("Jelly.activatePage('MyFunController', 'super_good_action');")
+      doc = Nokogiri::HTML(output)
+      argument = jelly_attach_arguments(doc.css("script")[1].inner_html)
+      argument.should include({'component' => "Jelly.Location", 'arguments' => []})
+      argument.should include({'component' => "Jelly.Page", 'arguments' => ['MyFunController', 'super_good_action']})
     end
   end
 
@@ -34,30 +47,40 @@ describe JellyHelper do
   end
 
   describe "#attach_javascript_component" do
+    before do
+      def helper.form_authenticity_token
+        "12345"
+      end
+    end
 
     after do
-      #need to clear this since it's saving state between tests
-      assigns[:content_for_javascript] = ""
       helper.clear_jelly_attached()
     end
 
-    it "fails to add multiple calls to page.attach for the same component" do
+    it "fails to add multiple calls to Jelly.attach for the same component" do
       helper.attach_javascript_component("MyComponent", 'arg1', 'arg2', 'arg3')
       helper.attach_javascript_component("MyComponent", 'arg1', 'arg2', 'arg3')
       helper.attach_javascript_component("MyComponent", 'arg1', 'arg2', 'arg5')
-      assigns[:content_for_javascript].should == 'page.attach(MyComponent, ["arg1","arg2","arg3"]);page.attach(MyComponent, ["arg1","arg2","arg5"]);'
+      assigns[:jelly_attached_components].should == [
+        {'component' => "MyComponent", 'arguments' => ['arg1', 'arg2', 'arg3']},
+        {'component' => "MyComponent", 'arguments' => ['arg1', 'arg2', 'arg5']},
+      ]
     end
 
-    it "adds a call to page.attach in the javascript content" do
+    it "adds a call to Jelly.attach in an $(document).ready block" do
       helper.attach_javascript_component("MyComponent", 'arg1', 'arg2', 'arg3')
       expected_args = ['arg1','arg2','arg3'].to_json
-      assigns[:content_for_javascript].should == "page.attach(MyComponent, #{expected_args});"
-    end
+      assigns[:jelly_attached_components].should == [
+        {'component' => "MyComponent", 'arguments' => ['arg1', 'arg2', 'arg3']}
+      ]
 
-    it "adds a call to page.attach in the javascript_on_ready content" do
-      helper.attach_javascript_component_on_ready("MyComponent", 'arg1', 'arg2', 'arg3')
-      expected_args = ['arg1','arg2','arg3'].to_json
-      assigns[:content_for_javascript_on_ready].should == "page.attach(MyComponent, #{expected_args});"
+      html = helper.spread_jelly
+      doc = Nokogiri::HTML(html)
+      document_ready_tag = doc.css("script")[1]
+      document_ready_tag.inner_html.should include("$(document).ready(function() {")
+      document_ready_part = document_ready_tag.inner_html.split("\n")[3]
+      arguments = jelly_attach_arguments(document_ready_part)
+      arguments.should include({'component' => "MyComponent", 'arguments' => ['arg1', 'arg2', 'arg3']})
     end
 
   end