rory 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 55512769abc5665735db9609c9d1dcc541b37e9f
-  data.tar.gz: c60a1ce6cec4f650cbfee24e77462d8461a01d8d
+  metadata.gz: f460afe6851a0ebbff77cd5459bf5dc2e4637c6c
+  data.tar.gz: f22a44a3d6141f2db251415ce18724e172fb9ca1
 SHA512:
-  metadata.gz: ce94a5c75d20071fc852dcbc71f4c887456ebe76cada4e62e96ae41c1578115229889cd00c83d7187f5e2e159d8047ede5f1d9f0bd46e988f85e76ff489eb27c
-  data.tar.gz: ff2b069e3e5a65f07610ecd9b32fdea59264e29e7c009f34312a9eacdfbad5217d0db62a7f37ecd1135c0219953d56c8ff2447ec713c8bf848ae2e28ba15b433
+  metadata.gz: 101bc4e7b9de76e550b74eae963664d84f04a70e497d3016f6f117b74ef0140a9939362b6a338fadb6b82558b430682a6a677550c9513341b103723ab176325a
+  data.tar.gz: afc2f14d5c59c4e4ba834813b3c2e82f5f6cbec9f8518c8a7f29e90c28dc9dc135904e70aa79da71189e5765b9e9826d24c5faba2dcae2766be8f5b94cafe227

data/lib/rory/controller.rb

@@ -107,7 +107,7 @@ module Rory
     end
 
     def generate_json_from_object(object, opts = {})
-      object.to_json
+      Rory::Support.encode_as_json(object)
     end
 
     def generate_for_render(opts = {})

data/lib/rory/support.rb

@@ -29,5 +29,22 @@ module Rory
         require file
       end
     end
+
+    def encode_as_json(object)
+      hashed = if object.is_a?(Array)
+        object.map { |o| try_to_hash(o) }
+      else
+        try_to_hash(object)
+      end
+      hashed.to_json
+    end
+
+    def try_to_hash(object)
+      if object.respond_to?(:to_hash)
+        object.to_hash
+      else
+        object
+      end
+    end
   end
 end

data/lib/rory/version.rb

@@ -1,3 +1,3 @@
 module Rory
-  VERSION = '0.5.0'
+  VERSION = '0.5.1'
 end

data/spec/lib/rory/controller_spec.rb

@@ -1,4 +1,6 @@
 describe Rory::Controller do
+  subject { Rory::Controller.new(@request, @routing) }
+
   before :each do
     @routing = {
       :route => Rory::Route.new('', :to => 'test#letsgo')
@@ -18,15 +20,13 @@ describe Rory::Controller do
 
   describe '#layout' do
     it 'defaults to nil' do
-      controller = Rory::Controller.new(@request, @routing)
-      expect(controller.layout).to be_nil
+      expect(subject.layout).to be_nil
     end
   end
 
   describe '#params' do
     it 'returns params from request, converted for indifferent key access' do
-      controller = Rory::Controller.new(@request, @routing)
-      expect(controller.params).to eq({
+      expect(subject.params).to eq({
         'violet' => 'invisibility',
         'dash' => 'superspeed',
         :violet => 'invisibility',
@@ -39,8 +39,7 @@ describe Rory::Controller do
     it "delegates to dispatcher from request" do
       @routing[:dispatcher] = dispatcher = double
       expect(dispatcher).to receive(:redirect).with(:whatever)
-      controller = Rory::Controller.new(@request, @routing)
-      controller.redirect(:whatever)
+      subject.redirect(:whatever)
     end
   end
 
@@ -48,117 +47,109 @@ describe Rory::Controller do
     it "delegates to dispatcher from request" do
       @routing[:dispatcher] = dispatcher = double
       expect(dispatcher).to receive(:render_not_found)
-      controller = Rory::Controller.new(@request, @routing)
-      controller.render_not_found
+      subject.render_not_found
     end
   end
 
   describe "#base_path" do
     it "returns script_name from request" do
-      controller = Rory::Controller.new(@request, @routing)
-      expect(controller.base_path).to eq 'script_root'
+      expect(subject.base_path).to eq 'script_root'
     end
   end
 
   describe "#present" do
-    it "calls filters and action from route if exists on controller" do
-      controller = FilteredController.new(@request, @routing)
-      [:pickle_something, :make_it_tasty, :letsgo, :rub_tummy, :sleep, :render].each do |m|
-        expect(controller).to receive(m).ordered
+    context "with filters" do
+      subject { FilteredController.new(@request, @routing) }
+
+      it "calls filters and action from route if exists on controller" do
+        [:pickle_something, :make_it_tasty, :letsgo, :rub_tummy, :sleep, :render].each do |m|
+          expect(subject).to receive(m).ordered
+        end
+        subject.present
       end
-      controller.present
-    end
 
-    it "short circuits if a before_action generates a response" do
-      controller = FilteredController.new(@request, @routing)
-      def controller.pickle_something
-        @response = 'stuff'
-      end
-      [:make_it_tasty, :letsgo, :rub_tummy, :sleep, :render].each do |m|
-        expect(controller).to receive(m).never
+      it "short circuits if a before_action generates a response" do
+        def subject.pickle_something
+          @response = 'stuff'
+        end
+        [:make_it_tasty, :letsgo, :rub_tummy, :sleep, :render].each do |m|
+          expect(subject).to receive(m).never
+        end
+        subject.present
       end
-      controller.present
-    end
 
-    it "does not short circuit after_actions if action generates response" do
-      controller = FilteredController.new(@request, @routing)
-      def controller.letsgo
-        @response = 'stuff'
+      it "does not short circuit after_actions if action generates response" do
+        def subject.letsgo
+          @response = 'stuff'
+        end
+        expect(subject).to receive(:pickle_something).ordered
+        expect(subject).to receive(:make_it_tasty).ordered
+        expect(subject).to receive(:letsgo).ordered.and_call_original
+        expect(subject).to receive(:rub_tummy).ordered
+        expect(subject).to receive(:sleep).ordered
+        expect(subject).to receive(:render).never
+        subject.present
       end
-      expect(controller).to receive(:pickle_something).ordered
-      expect(controller).to receive(:make_it_tasty).ordered
-      expect(controller).to receive(:letsgo).ordered.and_call_original
-      expect(controller).to receive(:rub_tummy).ordered
-      expect(controller).to receive(:sleep).ordered
-      expect(controller).to receive(:render).never
-      controller.present
-    end
 
-    it "doesn't try to call action from route if nonexistent on controller" do
-      controller = FilteredController.new(@request, @routing)
-      allow(@routing[:route]).to receive(:action).and_return('no worries')
-      [:pickle_something, :make_it_tasty, :rub_tummy, :sleep, :render].each do |m|
-        expect(controller).to receive(m).ordered
+      it "doesn't try to call action from route if nonexistent on controller" do
+        allow(@routing[:route]).to receive(:action).and_return('no worries')
+        [:pickle_something, :make_it_tasty, :rub_tummy, :sleep, :render].each do |m|
+          expect(subject).to receive(m).ordered
+        end
+        expect { subject.present }.not_to raise_error
       end
-      expect { controller.present }.not_to raise_error
-    end
 
-    it "filters before and after actions on :only and :except" do
-      @routing[:route] = Rory::Route.new('', :to => 'test#eat')
-      controller = FilteredController.new(@request, @routing)
-      expect(controller).to receive(:make_it_tasty).ordered
-      expect(controller).to receive(:make_it_nutritious).ordered
-      expect(controller).to receive(:eat).ordered
-      expect(controller).to receive(:rub_tummy).ordered
-      expect(controller).to receive(:smile).ordered
-      expect(controller).to receive(:sleep).never
-      expect(controller).to receive(:render).ordered
-      controller.present
-    end
+      it "filters before and after actions on :only and :except" do
+        @routing[:route] = Rory::Route.new('', :to => 'test#eat')
+        expect(subject).to receive(:make_it_tasty).ordered
+        expect(subject).to receive(:make_it_nutritious).ordered
+        expect(subject).to receive(:eat).ordered
+        expect(subject).to receive(:rub_tummy).ordered
+        expect(subject).to receive(:smile).ordered
+        expect(subject).to receive(:sleep).never
+        expect(subject).to receive(:render).ordered
+        subject.present
+      end
 
-    it "filters before and after actions on :if and :unless" do
-      @routing[:route] = Rory::Route.new('', :to => 'test#eat')
-      @request = double('Rack::Request', {
-        :params => { 'horses' => 'missing' },
-        :script_name => 'script_root'
-      })
-      controller = FilteredController.new(@request, @routing)
-      expect(controller).to receive(:make_it_tasty).never
-      expect(controller).to receive(:make_it_nutritious).ordered
-      expect(controller).to receive(:eat).ordered
-      expect(controller).to receive(:rub_tummy).never
-      expect(controller).to receive(:smile).ordered
-      expect(controller).to receive(:sleep).never
-      expect(controller).to receive(:render).ordered
-      controller.present
+      it "filters before and after actions on :if and :unless" do
+        @routing[:route] = Rory::Route.new('', :to => 'test#eat')
+        @request = double('Rack::Request', {
+          :params => { 'horses' => 'missing' },
+          :script_name => 'script_root'
+        })
+        expect(subject).to receive(:make_it_tasty).never
+        expect(subject).to receive(:make_it_nutritious).ordered
+        expect(subject).to receive(:eat).ordered
+        expect(subject).to receive(:rub_tummy).never
+        expect(subject).to receive(:smile).ordered
+        expect(subject).to receive(:sleep).never
+        expect(subject).to receive(:render).ordered
+        subject.present
+      end
     end
 
     it "just returns a response if @response exists" do
-      controller = Rory::Controller.new(@request, @routing)
-      controller.instance_variable_set(:@response, 'Forced response')
-      expect(controller.present).to eq('Forced response')
+      subject.instance_variable_set(:@response, 'Forced response')
+      expect(subject.present).to eq('Forced response')
     end
 
     it "sends a previously set @body to render" do
-      controller = Rory::Controller.new(@request, @routing)
-      controller.instance_variable_set(:@body, 'Forced body')
-      allow(controller).to receive(:render).with(:body => 'Forced body').and_return("Forced response")
-      expect(controller.present).to eq('Forced response')
+      subject.instance_variable_set(:@body, 'Forced body')
+      allow(subject).to receive(:render).with(:body => 'Forced body').and_return("Forced response")
+      expect(subject.present).to eq('Forced response')
     end
 
     it "returns the result of render" do
-      controller = Rory::Controller.new(@request, @routing)
-      allow(controller).to receive(:render).with(:body => nil).and_return("The response")
-      expect(controller.present).to eq('The response')
+      allow(subject).to receive(:render).with(:body => nil).and_return("The response")
+      expect(subject.present).to eq('The response')
     end
   end
 
   describe "#render" do
     it "returns the result of #generate_body_for_render as a rack response" do
-      controller = Rory::Controller.new(@request, @routing)
-      allow(controller).to receive(:default_content_type).and_return("a prison")
-      allow(controller).to receive(:generate_for_render).and_return("Valoop!")
-      expect(controller.render).to eq([
+      allow(subject).to receive(:default_content_type).and_return("a prison")
+      allow(subject).to receive(:generate_for_render).and_return("Valoop!")
+      expect(subject.render).to eq([
         200,
         {'Content-type' => 'a prison', 'charset' => 'UTF-8'},
         ["Valoop!"]
@@ -166,9 +157,8 @@ describe Rory::Controller do
     end
 
     it "returns given body as a rack response" do
-      controller = Rory::Controller.new(@request, @routing)
-      allow(controller).to receive(:default_content_type).and_return("snooj/woz")
-      expect(controller.render(:body => 'Forced body')).to eq([
+      allow(subject).to receive(:default_content_type).and_return("snooj/woz")
+      expect(subject.render(:body => 'Forced body')).to eq([
         200,
         {'Content-type' => 'snooj/woz', 'charset' => 'UTF-8'},
         ["Forced body"]
@@ -178,58 +168,51 @@ describe Rory::Controller do
 
   describe "#json_requested?" do
     it "delegates to dispatcher" do
-      controller = Rory::Controller.new(@request, @routing)
-      allow(controller).to receive(:dispatcher).and_return(double(:json_requested? => :snakes))
-      expect(controller.json_requested?).to eq(:snakes)
+      allow(subject).to receive(:dispatcher).and_return(double(:json_requested? => :snakes))
+      expect(subject.json_requested?).to eq(:snakes)
     end
   end
 
   describe "#generate_for_render" do
     it "renders and returns the default template if not json" do
-      controller = Rory::Controller.new(@request, @routing)
-      allow(controller).to receive(:generate_body_from_template).with("test/letsgo", {}).and_return("Whee")
-      expect(controller.generate_for_render).to eq("Whee")
+      allow(subject).to receive(:generate_body_from_template).with("test/letsgo", {}).and_return("Whee")
+      expect(subject.generate_for_render).to eq("Whee")
     end
 
     it "renders and returns the given template if not json" do
-      controller = Rory::Controller.new(@request, @routing)
-      allow(controller).to receive(:generate_body_from_template).with("engines", {}).and_return("Oh dear")
-      expect(controller.generate_for_render(:template => 'engines')).to eq("Oh dear")
+      allow(subject).to receive(:generate_body_from_template).with("engines", {}).and_return("Oh dear")
+      expect(subject.generate_for_render(:template => 'engines')).to eq("Oh dear")
     end
 
     it "returns json version of given json object if json" do
-      controller = Rory::Controller.new(@request, @routing)
-      allow(controller).to receive(:generate_json_from_object).with(:an_object, {}).and_return("Oh dear")
-      expect(controller.generate_for_render(:json => :an_object)).to eq("Oh dear")
+      allow(subject).to receive(:generate_json_from_object).with(:an_object, {}).and_return("Oh dear")
+      expect(subject.generate_for_render(:json => :an_object)).to eq("Oh dear")
     end
   end
 
   describe "#generate_json_from_object" do
-    it "returns given object as json" do
-      controller = Rory::Controller.new(@request, @routing)
-      object = double(:to_json => :jsonified)
-      expect(controller.generate_json_from_object(object)).to eq(:jsonified)
+    it "encodes given object as json" do
+      allow(Rory::Support).to receive(:encode_as_json).with(:foo).and_return(:encoded_foo)
+      expect(subject.generate_json_from_object(:foo)).to eq(:encoded_foo)
     end
   end
 
   describe "#generate_body_from_template" do
     it "returns rendered template with given name" do
-      controller = Rory::Controller.new(@request, @routing)
-      expect(controller.generate_body_from_template('test/letsgo')).to eq("Let's go content")
+      expect(subject.generate_body_from_template('test/letsgo')).to eq("Let's go content")
     end
 
     it "returns renderer output" do
-      controller = Rory::Controller.new(@request, @routing)
       allow(Rory::Renderer).to receive(:new).
-        with('not/real', controller.default_renderer_options).
+        with('not/real', subject.default_renderer_options).
         and_return(double('Renderer', :render => 'Here ya go'))
-      expect(controller.generate_body_from_template('not/real')).to eq('Here ya go')
+      expect(subject.generate_body_from_template('not/real')).to eq('Here ya go')
     end
 
     it "passes layout, exposed locals, and app to renderer" do
-      controller = Rory::Controller.new(@request, @routing, :scooby)
-      controller.expose(:a => 1)
-      allow(controller).to receive(:layout).and_return('pretend')
+      subject = Rory::Controller.new(@request, @routing, :scooby)
+      subject.expose(:a => 1)
+      allow(subject).to receive(:layout).and_return('pretend')
       renderer_options = {
         :layout => 'pretend',
         :locals => { :a => 1 },
@@ -239,21 +222,19 @@ describe Rory::Controller do
       allow(Rory::Renderer).to receive(:new).
         with('also/fake', renderer_options).
         and_return(double('Renderer', :render => 'Scamazing!'))
-      expect(controller.generate_body_from_template('also/fake')).to eq('Scamazing!')
+      expect(subject.generate_body_from_template('also/fake')).to eq('Scamazing!')
     end
   end
 
   describe "#default_content_type" do
     it "returns 'text/html' if not json" do
-      controller = Rory::Controller.new(@request, @routing)
-      allow(controller).to receive(:json_requested?).and_return(false)
-      expect(controller.default_content_type).to eq('text/html')
+      allow(subject).to receive(:json_requested?).and_return(false)
+      expect(subject.default_content_type).to eq('text/html')
     end
 
     it "returns 'application/json' if json requested" do
-      controller = Rory::Controller.new(@request, @routing)
-      allow(controller).to receive(:json_requested?).and_return(true)
-      expect(controller.default_content_type).to eq('application/json')
+      allow(subject).to receive(:json_requested?).and_return(true)
+      expect(subject.default_content_type).to eq('application/json')
     end
   end
 end

data/spec/lib/rory/support_spec.rb

@@ -64,4 +64,24 @@ describe Rory::Support do
       expect(described_class.tokenize(:yourFaceIsNice)).to eq('your_face_is_nice')
     end
   end
+
+  describe ".encode_as_json" do
+    it "returns given object as json" do
+      object = double(:to_json => :jsonified)
+      expect(described_class.encode_as_json(object)).to eq(:jsonified)
+    end
+
+    it "calls to_hash first if object responds to it" do
+      object = double(:to_hash => { 'april' => 'friday' })
+      expect(described_class.encode_as_json(object)).to eq({ 'april' => 'friday' }.to_json)
+    end
+
+    it "converts each member of an array" do
+      object = [
+        double(:to_hash => :smurf),
+        double(:to_hash => :nerf)
+      ]
+      expect(described_class.encode_as_json(object)).to eq([:smurf, :nerf].to_json)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rory
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Ravi Gadad
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-12 00:00:00.000000000 Z
+date: 2015-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack