honkster-jelly 0.9.1 → 0.9.2

data/spec/javascript/spec_helper.js

@@ -0,0 +1,7 @@
+//Jelly.add("MyPage", {
+//  on_my_method : function(){}
+//});
+//var page = Jelly.all["MyPage"];
+//
+//var My = {};
+//My.Class = {on_my_method: function() {console.debug("foo bar")}};

data/spec/jelly/common_spec.rb

@@ -0,0 +1,56 @@
+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_notify_hash" do
+    it "creates a hash with a method and arguments" do
+      fixture.jelly_notify_hash("my_method", 1, 2, 3).should == {
+        "method" => "my_method",
+        "arguments" => [1, 2, 3]
+      }
+    end
+  end
+
+  describe "#jelly_method_call_hash" do
+    it "creates a hash with a object, method, and arguments" do
+      fixture.jelly_method_call_hash("MyObject", "my_method", 1, 2, 3).should == {
+        "on" => "MyObject",
+        "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_notify_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_notify_attach_hash.should == {
+          "attach" => attachments
+        }
+      end
+    end
+  end
+end

data/spec/jelly/jelly_controller_spec.rb

@@ -0,0 +1,331 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+describe ApplicationController, :type => :controller do
+  render_views
+  include ActionController::Testing
+  
+  describe "#jelly_callback" do
+    attr_reader :template
+    before do
+      stub(@controller).render do |params|
+        @template = @controller.view_context
+        @controller.instance_variables.each do |var|
+          @template.instance_variable_set(var, @controller.instance_variable_get(var))
+        end
+        response.body = @template.render(params)
+      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
+            @controller.jelly_notify_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
+            @controller.jelly_notify_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
+            @controller.jelly_notify_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
+          @controller.jelly_notify_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
+            @controller.jelly_notify_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
+            @controller.jelly_notify_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/jelly/jelly_helper_spec.rb

@@ -0,0 +1,88 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+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! 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">')
+      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
+
+  describe "#application_jelly_files" do
+    context "when passing in a jelly path" do
+      it "returns the javascript files in /javascipts/:jelly_path/pages and /javascipts/:jelly_path/components" do
+        my_rails_root = File.join(File.dirname(__FILE__), '/../fixtures')
+        files = helper.application_jelly_files("foo", my_rails_root)
+        files.should_not be_empty
+        files.should =~ ['foo/components/paw', 'foo/components/teeth', 'foo/pages/lions', 'foo/pages/tigers', 'foo/pages/bears']
+      end
+    end
+
+    context "when not passing in a jelly path" do
+      it "returns the javascript files in /javascipts/pages and /javascipts/components" do
+        my_rails_root = File.join(File.dirname(__FILE__), '/../fixtures')
+        files = helper.application_jelly_files("", my_rails_root)
+        files.should_not be_empty
+        files.should =~ ['components/component1', 'pages/page1']
+      end
+    end
+  end
+
+  describe "#attach_javascript_component" do
+    before do
+      def helper.form_authenticity_token
+        "12345"
+      end
+    end
+
+    after do
+      helper.clear_jelly_attached()
+    end
+
+    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')
+      helper.instance_variable_get(:@jelly_attachments).should == [
+        {'component' => "MyComponent", 'arguments' => ['arg1', 'arg2', 'arg3']},
+        {'component' => "MyComponent", 'arguments' => ['arg1', 'arg2', 'arg5']},
+      ]
+    end
+
+    it "adds a call to Jelly.attach in an jQuery(document).ready block" do
+      helper.attach_javascript_component("MyComponent", 'arg1', 'arg2', 'arg3')
+      expected_args = ['arg1','arg2','arg3'].to_json
+      helper.instance_variable_get(:@jelly_attachments).should == [
+        {'component' => "MyComponent", 'arguments' => ['arg1', 'arg2', 'arg3']}
+      ]
+
+      html = helper.spread_jelly
+      doc = Nokogiri::HTML(html)
+      document_ready_tag = doc.css("script")[1]
+      document_ready_tag.inner_html.should include("jQuery(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
+
+end