jelly 0.6.5 → 0.8.10

data/spec/jelly/common_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+describe Jelly::Common do
+  attr_reader :fixture
+  before do
+    @fixture = Class.new do
+      include Jelly::Common
+    end.new
+  end
+
+  describe "#jelly_callback_hash" do
+    it "creates a hash with a method and arguments" do
+      fixture.jelly_callback_hash("my_method", 1, 2, 3).should == {
+        "method" => "my_method",
+        "arguments" => [1, 2, 3]
+      }
+    end
+  end
+
+  describe "#jelly_callback_attach_hash" do
+    context "when passed attachments" do
+      it "creates a hash with the attach param being set to the given attachments" do
+        attachments = [
+          fixture.jelly_attachment_hash("Foo", 1, 2),
+          fixture.jelly_attachment_hash("Bar", 3),
+        ]
+        fixture.jelly_callback_attach_hash(attachments).should == {
+          "attach" => attachments
+        }
+      end
+    end
+
+    context "when not passed attachments" do
+      it "creates a hash with the attach param being set to #jelly_attachments" do
+        attachments = [
+          fixture.jelly_attachment_hash("Foo", 1, 2),
+          fixture.jelly_attachment_hash("Bar", 3),
+        ]
+        stub(fixture).jelly_attachments {attachments}
+        fixture.jelly_callback_attach_hash.should == {
+          "attach" => attachments
+        }
+      end
+    end
+  end
+end

data/spec/jelly/jelly_controller_spec.rb

@@ -0,0 +1,327 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+describe ApplicationController, :type => :controller do
+
+  describe "#jelly_callback" do
+    attr_reader :template
+    before do
+      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
+
+    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
+
+      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 "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
+
+        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
+
+    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 there is a callback param" do
+      before do
+        @controller.params[:callback] = "Jelly.notifyObservers"
+      end
+
+      context "when the request is XHR" do
+        before do
+          stub(request).xhr? {true}
+        end
+
+        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 not XHR" do
+        before do
+          stub(request).xhr? {false}
+        end
+
+        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
+    end
+
+    context "when there is not a callback param" do
+      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
+
+      end
+
+      context "when the request is not XHR" do
+        before do
+          stub(request).xhr? {false}
+        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(: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
+  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 "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}/jelly_helper_spec.rb

@@ -1,19 +1,28 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
 
-describe JellyHelper do
+describe JellyHelper, :type => :helper do
+
+  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(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')
+      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.attach(Jelly.Location, #{[].to_json});")
-      output.should include("Jelly.attach(Jelly.Page, #{['MyFunController', 'super_good_action'].to_json});")
+      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
 
@@ -38,10 +47,13 @@ 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
 
@@ -49,19 +61,26 @@ describe JellyHelper 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 == 'Jelly.attach(MyComponent, ["arg1","arg2","arg3"]);Jelly.attach(MyComponent, ["arg1","arg2","arg5"]);'
+      assigns[:jelly_attachments].should == [
+        {'component' => "MyComponent", 'arguments' => ['arg1', 'arg2', 'arg3']},
+        {'component' => "MyComponent", 'arguments' => ['arg1', 'arg2', 'arg5']},
+      ]
     end
 
-    it "adds a call to Jelly.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 == "Jelly.attach(MyComponent, #{expected_args});"
-    end
+      assigns[:jelly_attachments].should == [
+        {'component' => "MyComponent", 'arguments' => ['arg1', 'arg2', 'arg3']}
+      ]
 
-    it "adds a call to Jelly.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 == "Jelly.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