honkster-jelly 0.8.14 → 0.9.0

data/.gitignore

@@ -1,3 +0,0 @@
-.idea
-*.svn
-pkg

data/spec/jelly/common_spec.rb

@@ -1,56 +0,0 @@
-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

@@ -1,327 +0,0 @@
-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_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
-            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
-            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
-          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
-            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
-            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

@@ -1,88 +0,0 @@
-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')
-      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 an $(document).ready block" do
-      helper.attach_javascript_component("MyComponent", 'arg1', 'arg2', 'arg3')
-      expected_args = ['arg1','arg2','arg3'].to_json
-      assigns[: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("$(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