rory 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 73fd578d6e35268b6a7940ef886b86e1cd03f923
-  data.tar.gz: 51731d0b123a43034399bd0c27b409dcbc898b4c
+  metadata.gz: 55512769abc5665735db9609c9d1dcc541b37e9f
+  data.tar.gz: c60a1ce6cec4f650cbfee24e77462d8461a01d8d
 SHA512:
-  metadata.gz: 170ee5f9d5e4d1da5dc21c733d41cc26e1d8d0e12738c3edfb66739fcac09eca554019bb116b54d608f96658dcb4d3fd01b97d33acd7d9961309a1782eeb973a
-  data.tar.gz: f02a5ae7d109c79e84cf3e28205c6a42bdf8b321520adfa9868fe8489010b8caaf513b9734b5fe06b4dcd3fd53214796141e9786a4e2e3e9e90fbaec8011fd37
+  metadata.gz: ce94a5c75d20071fc852dcbc71f4c887456ebe76cada4e62e96ae41c1578115229889cd00c83d7187f5e2e159d8047ede5f1d9f0bd46e988f85e76ff489eb27c
+  data.tar.gz: ff2b069e3e5a65f07610ecd9b32fdea59264e29e7c009f34312a9eacdfbad5217d0db62a7f37ecd1135c0219953d56c8ff2447ec713c8bf848ae2e28ba15b433

data/lib/rory/controller.rb

@@ -8,6 +8,7 @@ module Rory
     include PathGeneration
 
     attr_accessor :locals
+    attr_reader :dispatcher
 
     class << self
       def before_actions
@@ -45,6 +46,10 @@ module Rory
       @locals = {}
     end
 
+    def json_requested?
+      dispatcher.json_requested?
+    end
+
     def expose(hsh)
       locals.merge!(hsh)
     end
@@ -77,18 +82,64 @@ module Rory
       }
     end
 
-    def render(template_name, opts = {})
+    def extract_options(options_or_template, opts = {})
+      if options_or_template.is_a?(Hash)
+        options_or_template
+      else
+        opts.merge(:template => options_or_template)
+      end
+    end
+
+    def set_response_defaults(opts)
+      opts[:content_type] ||= default_content_type
+      opts[:status] ||= 200
+      opts[:headers] = {
+        'Content-type' => default_content_type,
+        'charset' => 'UTF-8'
+      }.merge(opts[:headers] || {})
+    end
+
+    def render(options_or_template = nil, opts = {})
+      opts = extract_options(options_or_template, opts)
+      set_response_defaults(opts)
+      opts[:body] ||= generate_for_render(opts)
+      @response = [opts[:status], opts[:headers], [opts[:body]]]
+    end
+
+    def generate_json_from_object(object, opts = {})
+      object.to_json
+    end
+
+    def generate_for_render(opts = {})
+      object, template = opts.delete(:json), opts.delete(:template)
+      if object
+        generate_json_from_object(object, opts)
+      else
+        template ||= route_template
+        generate_body_from_template(template, opts)
+      end
+    end
+
+    def generate_body_from_template(template_name, opts = {})
       opts = default_renderer_options.merge(opts)
       renderer = Rory::Renderer.new(template_name, opts)
-      @body = renderer.render
+      renderer.render
     end
 
     def redirect(path)
-      @response = @dispatcher.redirect(path)
+      @response = dispatcher.redirect(path)
     end
 
     def render_not_found
-      @response = @dispatcher.render_not_found
+      @response = dispatcher.render_not_found
+    end
+
+    def default_content_type
+      if json_requested?
+        'application/json'
+      else
+        'text/html'
+      end
     end
 
     def present
@@ -103,11 +154,9 @@ module Rory
         @response
       else
         # even if there wasn't a full response generated, we might already have
-        # a @body, if render was explicitly called to render an alternate
-        # template, or if @body was explicitly assigned for some other reason.
+        # a @body, if @body was explicitly assigned for some reason.
         # don't render the default template, in that case.
-        @body ||= render(route_template)
-        [200, {'Content-type' => 'text/html', 'charset' => 'UTF-8'}, [@body]]
+        render(:body => @body)
       end
     end
 

data/lib/rory/dispatcher.rb

@@ -15,6 +15,34 @@ module Rory
       }
     end
 
+    def override_method
+      requested_override = request.params['_method']
+      return nil unless requested_override
+      if ['put', 'patch', 'delete'].include?(requested_override.downcase)
+        requested_override.downcase
+      end
+    end
+
+    def extension
+      File.extname(full_path)[1..-1]
+    end
+
+    def json_requested?
+      extension == 'json'
+    end
+
+    def full_path
+      @request.path_info[1..-1] || ''
+    end
+
+    def path_without_extension
+      full_path.gsub(/(.*)\.#{extension}$/, '\1')
+    end
+
+    def method
+      override_method || request.request_method.downcase
+    end
+
     def route
       @routing[:route] ||= get_route
     end
@@ -59,11 +87,11 @@ module Rory
 
     def get_route
       mapped_route = all_routes.detect do |route|
-        route.matches_request?(@request)
+        route.matches_request?(path_without_extension, method)
       end
       if mapped_route
         @request.params.delete('_method')
-        @request.params.merge! mapped_route.path_params(@request)
+        @request.params.merge! mapped_route.path_params(path_without_extension)
       end
       mapped_route
     end

data/lib/rory/route.rb

@@ -28,15 +28,15 @@ module Rory
       @options[:methods] || []
     end
 
-    def matches_request?(request)
-      @match = regex.match(request.path_info[1..-1] || '')
+    def matches_request?(path, method)
+      @match = regex.match(path)
       @match &&
         (methods.empty? ||
-          methods.include?(method_from_request(request).to_sym))
+          methods.include?(method.to_sym))
     end
 
-    def path_params(request)
-      @match ||= regex.match(request.path_info[1..-1] || '')
+    def path_params(path)
+      @match ||= regex.match(path)
       symbolized_param_names = @match.names.map { |name| name.to_sym }
       Hash[symbolized_param_names.zip(@match.captures)]
     end
@@ -50,17 +50,5 @@ module Rory
         :methods => @methods
       }
     end
-
-  private
-
-    def method_from_request(request)
-      override_method = request.params['_method']
-      method = if override_method && ['put', 'patch', 'delete'].include?(override_method.downcase)
-        override_method
-      else
-        request.request_method
-      end
-      method.downcase
-    end
   end
 end

data/lib/rory/version.rb

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

data/rory.gemspec

@@ -33,7 +33,7 @@ EOF
   s.add_runtime_dependency 'thin', '~> 1.0'
 
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'rspec', '~> 2'
+  s.add_development_dependency 'rspec', '~> 3'
   s.add_development_dependency 'capybara'
   s.add_development_dependency 'yard'
   s.add_development_dependency 'reek'

data/spec/fixture_app/config/routes.rb

@@ -11,5 +11,6 @@ Fixture::Application.set_routes do
   end
   match '/', :to => 'root#vegetable', :methods => [:get]
   match '/', :to => 'root#no_vegetable', :methods => [:delete]
+  match 'for_reals/switching', :to => 'for_reals#switching', :methods => [:get]
   match 'for_reals/:parbles', :to => 'for_reals#srsly', :methods => [:get]
 end

data/spec/fixture_app/controllers/for_reals_controller.rb

@@ -3,4 +3,12 @@ class ForRealsController < Rory::Controller
     expose :gibbit => @params[:parbles]
     expose :but_when => 'again'
   end
+
+  def switching
+    if json_requested?
+      render :json => { :a => 1 }
+    else
+      render 'for_reals/custom', :status => 404
+    end
+  end
 end

data/spec/fixture_app/views/for_reals/custom.html.erb

@@ -0,0 +1 @@
+Oh, a secret!

data/spec/lib/rory/application_spec.rb

@@ -2,15 +2,16 @@ describe Rory::Application do
   describe ".configure" do
     it 'yields the given block to self' do
       Fixture::Application.configure do |c|
-        c.should == Fixture::Application.instance
+        expect(c).to eq(Fixture::Application.instance)
       end
     end
   end
 
   describe '.config_path' do
     it 'is set to {root}/config by default' do
-      Fixture::Application.config_path.should ==
+      expect(Fixture::Application.config_path).to eq(
         Pathname.new(Fixture::Application.root).join('config')
+      )
     end
 
     it 'raises exception if root not set' do
@@ -25,14 +26,14 @@ describe Rory::Application do
 
   describe ".respond_to?" do
     it 'returns true if the instance said so' do
-      Fixture::Application.instance.should_receive(:respond_to?).with(:goat).and_return(true)
-      Fixture::Application.respond_to?(:goat).should be_true
+      expect(Fixture::Application.instance).to receive(:respond_to?).with(:goat).and_return(true)
+      expect(Fixture::Application.respond_to?(:goat)).to be_truthy
     end
 
     it 'does the usual thing if instance says no' do
-      Fixture::Application.instance.should_receive(:respond_to?).twice.and_return(false)
-      Fixture::Application.respond_to?(:to_s).should be_true
-      Fixture::Application.respond_to?(:obviously_not_a_real_method).should be_false
+      expect(Fixture::Application.instance).to receive(:respond_to?).twice.and_return(false)
+      expect(Fixture::Application.respond_to?(:to_s)).to be_truthy
+      expect(Fixture::Application.respond_to?(:obviously_not_a_real_method)).to be_falsey
     end
   end
 
@@ -40,27 +41,27 @@ describe Rory::Application do
     it "forwards arg to new dispatcher, and calls dispatch" do
       dispatcher = double(:dispatch => :expected)
       rack_request = double
-      Rack::Request.stub(:new).with(:env).and_return(rack_request)
-      Rory::Dispatcher.should_receive(:new).with(rack_request, Fixture::Application.instance).and_return(dispatcher)
-      Fixture::Application.call(:env).should == :expected
+      allow(Rack::Request).to receive(:new).with(:env).and_return(rack_request)
+      expect(Rory::Dispatcher).to receive(:new).with(rack_request, Fixture::Application.instance).and_return(dispatcher)
+      expect(Fixture::Application.call(:env)).to eq(:expected)
     end
   end
 
   describe ".load_config_data" do
     it "returns parsed yaml file with given name from directory at config_path" do
-      Fixture::Application.any_instance.stub(:config_path).and_return('Africa the Great')
-      YAML.stub(:load_file).with(
+      allow_any_instance_of(Fixture::Application).to receive(:config_path).and_return('Africa the Great')
+      allow(YAML).to receive(:load_file).with(
         File.expand_path(File.join('Africa the Great', 'foo_type.yml'))).
         and_return(:oscar_the_grouch_takes_a_nap)
-      Fixture::Application.load_config_data(:foo_type).should == :oscar_the_grouch_takes_a_nap
+      expect(Fixture::Application.load_config_data(:foo_type)).to eq(:oscar_the_grouch_takes_a_nap)
     end
   end
 
   describe ".connect_db" do
     it "sets up sequel connection to DB from YAML file" do
       config = { 'development' => :expected }
-      Fixture::Application.any_instance.stub(:load_config_data).with(:database).and_return(config)
-      Sequel.should_receive(:connect).with(:expected).and_return(double(:loggers => []))
+      allow_any_instance_of(Fixture::Application).to receive(:load_config_data).with(:database).and_return(config)
+      expect(Sequel).to receive(:connect).with(:expected).and_return(double(:loggers => []))
       Fixture::Application.connect_db('development')
     end
   end
@@ -74,6 +75,7 @@ describe Rory::Application do
         Rory::Route.new('rabbits/:chew', :to => 'rabbits#chew', :methods => [:get], :module => 'goose/wombat'),
         Rory::Route.new('', :to => 'root#vegetable', :methods => [:get]),
         Rory::Route.new('', :to => 'root#no_vegetable', :methods => [:delete]),
+        Rory::Route.new('for_reals/switching', :to => 'for_reals#switching', :methods => [:get]),
         Rory::Route.new('for_reals/:parbles', :to => 'for_reals#srsly', :methods => [:get])
       ]
     end
@@ -81,7 +83,7 @@ describe Rory::Application do
 
   describe ".spin_up" do
     it "connects the database" do
-      Rory::Application.any_instance.should_receive(:connect_db)
+      expect_any_instance_of(Rory::Application).to receive(:connect_db)
       Rory::Application.spin_up
     end
   end
@@ -92,20 +94,20 @@ describe Rory::Application do
     end
 
     it 'includes models, controllers, and helpers by default' do
-      Fixture::Application.auto_require_paths.should == ['models', 'controllers', 'helpers']
+      expect(Fixture::Application.auto_require_paths).to eq(['models', 'controllers', 'helpers'])
     end
 
     it 'accepts new paths' do
       Fixture::Application.auto_require_paths << 'chocolates'
-      Fixture::Application.auto_require_paths.should == ['models', 'controllers', 'helpers', 'chocolates']
+      expect(Fixture::Application.auto_require_paths).to eq(['models', 'controllers', 'helpers', 'chocolates'])
     end
   end
 
   describe '.require_all_files' do
     it 'requires all files in auto_require_paths' do
-      Fixture::Application.any_instance.stub(:auto_require_paths).and_return(['goats', 'rhubarbs'])
+      allow_any_instance_of(Fixture::Application).to receive(:auto_require_paths).and_return(['goats', 'rhubarbs'])
       [:goats, :rhubarbs].each do |folder|
-        Rory::Support.should_receive(:require_all_files_in_directory).
+        expect(Rory::Support).to receive(:require_all_files_in_directory).
           with(Pathname.new(Fixture::Application.root).join("#{folder}"))
       end
       Fixture::Application.require_all_files

data/spec/lib/rory/controller_spec.rb

@@ -19,7 +19,7 @@ describe Rory::Controller do
   describe '#layout' do
     it 'defaults to nil' do
       controller = Rory::Controller.new(@request, @routing)
-      controller.layout.should be_nil
+      expect(controller.layout).to be_nil
     end
   end
 
@@ -35,36 +35,10 @@ describe Rory::Controller do
     end
   end
 
-  describe "#render" do
-    it "returns renderer output" do
-      controller = Rory::Controller.new(@request, @routing)
-      allow(Rory::Renderer).to receive(:new).
-        with('not/real', controller.default_renderer_options).
-        and_return(double('Renderer', :render => 'Here ya go'))
-      controller.render('not/real').should == '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')
-      renderer_options = {
-        :layout => 'pretend',
-        :locals => { :a => 1 },
-        :app => :scooby,
-        :base_path => 'script_root'
-      }
-      allow(Rory::Renderer).to receive(:new).
-        with('also/fake', renderer_options).
-        and_return(double('Renderer', :render => 'Scamazing!'))
-      controller.render('also/fake').should == 'Scamazing!'
-    end
-  end
-
   describe "#redirect" do
     it "delegates to dispatcher from request" do
       @routing[:dispatcher] = dispatcher = double
-      dispatcher.should_receive(:redirect).with(:whatever)
+      expect(dispatcher).to receive(:redirect).with(:whatever)
       controller = Rory::Controller.new(@request, @routing)
       controller.redirect(:whatever)
     end
@@ -73,7 +47,7 @@ describe Rory::Controller do
   describe "#render_not_found" do
     it "delegates to dispatcher from request" do
       @routing[:dispatcher] = dispatcher = double
-      dispatcher.should_receive(:render_not_found)
+      expect(dispatcher).to receive(:render_not_found)
       controller = Rory::Controller.new(@request, @routing)
       controller.render_not_found
     end
@@ -122,12 +96,11 @@ describe Rory::Controller do
 
     it "doesn't try to call action from route if nonexistent on controller" do
       controller = FilteredController.new(@request, @routing)
-      allow(controller).to receive(:respond_to?).with(:letsgo).and_return(false)
-      expect(controller).to receive(:letsgo).never
+      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
       end
-      controller.present
+      expect { controller.present }.not_to raise_error
     end
 
     it "filters before and after actions on :only and :except" do
@@ -163,27 +136,124 @@ describe Rory::Controller do
     it "just returns a response if @response exists" do
       controller = Rory::Controller.new(@request, @routing)
       controller.instance_variable_set(:@response, 'Forced response')
-      controller.present.should == 'Forced response'
+      expect(controller.present).to eq('Forced response')
     end
 
-    it "renders and returns the default template as a rack response" do
+    it "sends a previously set @body to render" do
       controller = Rory::Controller.new(@request, @routing)
-      controller.present.should == [
+      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')
+    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')
+    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([
         200,
-        {'Content-type' => 'text/html', 'charset' => 'UTF-8'},
-        ["Let's go content"]
-      ]
+        {'Content-type' => 'a prison', 'charset' => 'UTF-8'},
+        ["Valoop!"]
+      ])
     end
 
-    it "returns previously set @body as a rack response" do
+    it "returns given body as a rack response" do
       controller = Rory::Controller.new(@request, @routing)
-      controller.instance_variable_set(:@body, 'Forced body')
-      controller.should_receive(:render).never
-      controller.present.should == [
+      allow(controller).to receive(:default_content_type).and_return("snooj/woz")
+      expect(controller.render(:body => 'Forced body')).to eq([
         200,
-        {'Content-type' => 'text/html', 'charset' => 'UTF-8'},
+        {'Content-type' => 'snooj/woz', 'charset' => 'UTF-8'},
         ["Forced body"]
-      ]
+      ])
+    end
+  end
+
+  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)
+    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")
+    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")
+    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")
+    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)
+    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")
+    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).
+        and_return(double('Renderer', :render => 'Here ya go'))
+      expect(controller.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')
+      renderer_options = {
+        :layout => 'pretend',
+        :locals => { :a => 1 },
+        :app => :scooby,
+        :base_path => 'script_root'
+      }
+      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!')
+    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')
+    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')
     end
   end
 end

data/spec/lib/rory/dispatcher_spec.rb

@@ -1,137 +1,178 @@
 describe Rory::Dispatcher do
+  subject { Rory::Dispatcher.new(request, Fixture::Application) }
+  let(:request) { {} }
+
+  describe "#extension" do
+    it "returns the extension of the path requested" do
+      allow(subject).to receive(:full_path).and_return("whatever/nerds.pickles")
+      expect(subject.extension).to eq("pickles")
+    end
+
+    it "returns nil if no extension" do
+      allow(subject).to receive(:full_path).and_return("whatever/nerds")
+      expect(subject.extension).to be_nil
+    end
+  end
+
+  describe "#path_without_extension" do
+    it "returns path with extension removed" do
+      allow(subject).to receive(:full_path).and_return("whatever/nerds.pickles")
+      expect(subject.path_without_extension).to eq("whatever/nerds")
+    end
+
+    it "returns path unchanged if no extension" do
+      allow(subject).to receive(:full_path).and_return("whatever/nerds")
+      expect(subject.path_without_extension).to eq("whatever/nerds")
+    end
+  end
+
+  describe "#json_requested?" do
+    it "returns true if extension is 'json'" do
+      allow(subject).to receive(:extension).and_return("json")
+      expect(subject.json_requested?).to be_truthy
+    end
+
+    it "returns false if extension is not 'json'" do
+      allow(subject).to receive(:extension).and_return("pachyderms")
+      expect(subject.json_requested?).to be_falsey
+    end
+  end
+
   describe "#redirect" do
     it "redirects to given path if path has scheme" do
-      dispatcher = Rory::Dispatcher.new({}, Fixture::Application)
-      redirection = dispatcher.redirect('http://example.example')
-      redirection[0..1].should == [
+      redirection = subject.redirect('http://example.example')
+      expect(redirection[0..1]).to eq([
         302, {'Content-type' => 'text/html', 'Location'=> 'http://example.example' }
-      ]
+      ])
     end
 
     it "adds request host and scheme and redirects if path has no scheme" do
-      request = {}
-      request.stub('scheme' => 'happy', 'host_with_port' => 'somewhere.yay')
-      dispatcher = Rory::Dispatcher.new(request, Fixture::Application)
-      redirection = dispatcher.redirect('/example')
-      redirection[0..1].should == [
+      allow(request).to receive_messages('scheme' => 'happy', 'host_with_port' => 'somewhere.yay')
+      redirection = subject.redirect('/example')
+      expect(redirection[0..1]).to eq([
         302, {'Content-type' => 'text/html', 'Location'=> 'happy://somewhere.yay/example' }
-      ]
+      ])
     end
   end
 
   describe "#dispatch" do
-    let(:dispatcher) { Rory::Dispatcher.new(request, Fixture::Application) }
-    let(:request) {
-      request = { :whatever => :yay }
-      request.stub(:path_info => '/', :request_method => 'GET', :params => {})
-      request
-    }
+    let(:request) { { :whatever => :yay } }
+    before(:each) do
+      allow(request).to receive_messages(:path_info => '/', :request_method => 'GET', :params => {})
+    end
 
     it "renders a 404 if the requested path is invalid" do
-      dispatcher.stub(:get_route).and_return(nil)
-      dispatcher.dispatch[0..1].should == [404, {"Content-type"=>"text/html"}]
+      allow(subject).to receive(:get_route).and_return(nil)
+      expect(subject.dispatch[0..1]).to eq([404, {"Content-type"=>"text/html"}])
     end
 
     it "instantiates a controller with the parsed request and calls present" do
       route = Rory::Route.new('', :to => 'stub#index')
-      allow(dispatcher).to receive(:get_route).and_return(route)
-      dispatcher.dispatch.should == {
+      allow(subject).to receive(:get_route).and_return(route)
+      expect(subject.dispatch).to eq({
         :whatever => :yay,
         :present_called => true # see StubController in /spec/fixture_app
-      }
+      })
     end
 
     it "dispatches properly to a scoped controller" do
       route = Rory::Route.new('', :to => 'lumpies#index', :module => 'goose')
-      allow(dispatcher).to receive(:get_route).and_return(route)
-      dispatcher.dispatch.should == {
+      allow(subject).to receive(:get_route).and_return(route)
+      expect(subject.dispatch).to eq({
         :whatever => :yay,
         :in_scoped_controller => true # see Goose::LumpiesController in /spec/fixture_app
-      }
+      })
     end
 
     it "dispatches properly to a nested scoped controller" do
       route = Rory::Route.new('', :to => 'rabbits#index', :module => 'goose/wombat')
-      allow(dispatcher).to receive(:get_route).and_return(route)
-      dispatcher.dispatch.should == {
+      allow(subject).to receive(:get_route).and_return(route)
+      expect(subject.dispatch).to eq({
         :whatever => :yay,
         :in_scoped_controller => true # see Goose::Wombat::RabbitsController in /spec/fixture_app
-      }
+      })
     end
   end
 
   describe "#route" do
     before(:each) do
-      @request = {}
-      @request.stub(:params => {})
-      @dispatcher = Rory::Dispatcher.new(@request, Fixture::Application)
+      allow(request).to receive_messages(:params => {})
     end
 
     it "returns route from request if already set" do
-      @dispatcher.instance_variable_set(:@routing, { :route => 'snaky pigeons' })
-      @dispatcher.route.should == 'snaky pigeons'
+      subject.instance_variable_set(:@routing, { :route => 'snaky pigeons' })
+      expect(subject.route).to eq('snaky pigeons')
     end
 
     it "matches the path from the request to the routes table" do
-      @request.stub(:path_info => '/foo/3/bar', :request_method => 'GET')
-      expect(@dispatcher.route).to eq Rory::Route.new('/foo/:id/bar', {
+      allow(request).to receive_messages(:path_info => '/foo/3/bar', :request_method => 'GET')
+      expect(subject.route).to eq Rory::Route.new('/foo/:id/bar', {
+        :to => 'foo#bar',
+        :methods => [:get, :post]
+      })
+    end
+
+    it "ignores extensions when matching path to routes table" do
+      allow(request).to receive_messages(:path_info => '/foo/3/bar.csv', :request_method => 'GET')
+      expect(subject.extension).to eq('csv')
+      expect(subject.route).to eq Rory::Route.new('/foo/:id/bar', {
         :to => 'foo#bar',
         :methods => [:get, :post]
       })
     end
 
     it "uses override method from params if exists" do
-      @request.stub(:path_info => '/', :params => { '_method' => 'delete' }, :request_method => 'PUT')
-      expect(@dispatcher.route).to eq Rory::Route.new('/', {
+      allow(request).to receive_messages(:path_info => '/', :params => { '_method' => 'delete' }, :request_method => 'PUT')
+      expect(subject.route).to eq Rory::Route.new('/', {
         :to => 'root#no_vegetable',
         :methods => [:delete]
       })
     end
 
     it "deletes override method from params" do
-      @request.stub(:path_info => '/', :params => { '_method' => 'delete', 'goats' => 'not_sheep' }, :request_method => 'PUT')
-      @dispatcher.route
-      expect(@request.params).to eq('goats' => 'not_sheep')
+      allow(request).to receive_messages(:path_info => '/', :params => { '_method' => 'delete', 'goats' => 'not_sheep' }, :request_method => 'PUT')
+      subject.route
+      expect(request.params).to eq('goats' => 'not_sheep')
     end
 
     it "works with empty path" do
-      @request.stub(:path_info => '', :request_method => 'GET')
-      expect(@dispatcher.route).to eq Rory::Route.new('/', {
+      allow(request).to receive_messages(:path_info => '', :request_method => 'GET')
+      expect(subject.route).to eq Rory::Route.new('/', {
         :to => 'root#vegetable',
         :methods => [:get]
       })
     end
 
     it "works with root url represented by slash" do
-      @request.stub(:path_info => '/', :request_method => 'GET')
-      expect(@dispatcher.route).to eq Rory::Route.new('/', {
+      allow(request).to receive_messages(:path_info => '/', :request_method => 'GET')
+      expect(subject.route).to eq Rory::Route.new('/', {
         :to => 'root#vegetable',
         :methods => [:get]
       })
     end
 
     it "returns nil if no route found" do
-      @request.stub(:path_info => '/umbrellas', :request_method => 'GET')
-      @dispatcher.route.should be_nil
+      allow(request).to receive_messages(:path_info => '/umbrellas', :request_method => 'GET')
+      expect(subject.route).to be_nil
     end
 
     it "returns nil if no context" do
-      @dispatcher = Rory::Dispatcher.new(@request)
-      @dispatcher.route.should be_nil
+      subject = Rory::Dispatcher.new(request)
+      expect(subject.route).to be_nil
     end
 
     it "returns nil if route found but method is not allowed" do
-      @request.stub(:path_info => '/foo', :request_method => 'GET')
-      @dispatcher.route.should be_nil
+      allow(request).to receive_messages(:path_info => '/foo', :request_method => 'GET')
+      expect(subject.route).to be_nil
     end
 
     it "assigns named matches to params hash" do
-      @request.stub(:path_info => '/this/some-thing_or-other/is/wicked', :request_method => 'GET')
-      expect(@dispatcher.route).to eq Rory::Route.new('/this/:path/is/:very_awesome', {
+      allow(request).to receive_messages(:path_info => '/this/some-thing_or-other/is/wicked', :request_method => 'GET')
+      expect(subject.route).to eq Rory::Route.new('/this/:path/is/:very_awesome', {
         :to => 'awesome#rad'
       })
 
-      @request.params.should == {:path=>"some-thing_or-other", :very_awesome=>"wicked"}
+      expect(request.params).to eq({:path=>"some-thing_or-other", :very_awesome=>"wicked"})
     end
   end
 end

data/spec/lib/rory/renderer/context_spec.rb

@@ -19,7 +19,7 @@ describe Rory::Renderer::Context do
       allow(Rory::Renderer).to receive(:new).
         with('not/real', passed_renderer_options).
         and_return(double('Renderer', :render => 'Here ya go'))
-      renderer_context.render('not/real').should == 'Here ya go'
+      expect(renderer_context.render('not/real')).to eq('Here ya go')
     end
 
     it "does not pass locals or layout to sub-renderer" do
@@ -35,7 +35,7 @@ describe Rory::Renderer::Context do
       allow(Rory::Renderer).to receive(:new).
         with('also/fake', passed_renderer_options).
         and_return(double('Renderer', :render => 'Scamazing!'))
-      renderer_context.render('also/fake').should == 'Scamazing!'
+      expect(renderer_context.render('also/fake')).to eq('Scamazing!')
     end
   end
 end

data/spec/lib/rory/renderer_spec.rb

@@ -2,33 +2,34 @@ describe Rory::Renderer do
   describe "#render" do
     it "returns text of template" do
       renderer = Rory::Renderer.new('test/static')
-      renderer.render.should == 'Static content'
+      expect(renderer.render).to eq('Static content')
     end
 
     it "returns text of template in given layout" do
       controller = Rory::Renderer.new('test/static', :layout => 'surround')
-      controller.render.should == 'Surrounding Static content is fun'
+      expect(controller.render).to eq('Surrounding Static content is fun')
     end
 
     it "handles symbolized layout name" do
       controller = Rory::Renderer.new('test/static', :layout => :surround)
-      controller.render.should == 'Surrounding Static content is fun'
+      expect(controller.render).to eq('Surrounding Static content is fun')
     end
 
     it "exposes locals to template" do
       controller = Rory::Renderer.new('test/dynamic', :locals => { :word => 'hockey' })
-      controller.render.should == 'Word: hockey'
+      expect(controller.render).to eq('Word: hockey')
     end
 
     it "can render nested templates" do
       controller = Rory::Renderer.new('test/double_nested', :locals => { :word => 'hockey' })
-      controller.render.should == 
+      expect(controller.render).to eq( 
         "Don't Say A Bad Word: Poop!"
+      )
     end
 
     it "exposes base_path to template" do
       controller = Rory::Renderer.new('test/a_link', :base_path => 'spoo')
-      controller.render.should == 'You came from spoo.'
+      expect(controller.render).to eq('You came from spoo.')
     end
   end
 
@@ -36,12 +37,12 @@ describe Rory::Renderer do
     it 'returns path to template from app root' do
       fake_app = double('Application', :root => 'marbles')
       renderer = Rory::Renderer.new('goose', :app => fake_app)
-      renderer.view_path.should == File.expand_path(File.join('views', 'goose.html.erb'), 'marbles')
+      expect(renderer.view_path).to eq(File.expand_path(File.join('views', 'goose.html.erb'), 'marbles'))
     end
 
     it 'uses Rory.root if no app specified' do
       renderer = Rory::Renderer.new('goose')
-      renderer.view_path.should == File.join(Rory.root, 'views', 'goose.html.erb')
+      expect(renderer.view_path).to eq(File.join(Rory.root, 'views', 'goose.html.erb'))
     end
   end
 end

data/spec/lib/rory/route_spec.rb

@@ -5,4 +5,11 @@ describe Rory::Route do
       expect(route.name).to eq 'pigeons_index'
     end
   end
+
+  describe "#path_params" do
+    it "extracts params from path into hash" do
+      route = described_class.new('/spoons/:spoon_id/forks/:fork_id', :to => 'cutlery#index')
+      expect(route.path_params('spoons/4/forks/yay')).to eq({ :spoon_id => "4", :fork_id => "yay" })
+    end
+  end
 end

data/spec/lib/rory/support_spec.rb

@@ -1,20 +1,20 @@
 describe Rory::Support do
   describe ".camelize" do
     it "camelizes given snake-case string" do
-      Rory::Support.camelize('water_under_bridge').should == 'WaterUnderBridge'
+      expect(Rory::Support.camelize('water_under_bridge')).to eq('WaterUnderBridge')
     end
 
     it "leaves already camel-cased string alone" do
-      Rory::Support.camelize('OliverDrankGasoline').should == 'OliverDrankGasoline'
+      expect(Rory::Support.camelize('OliverDrankGasoline')).to eq('OliverDrankGasoline')
     end
   end
 
   describe '.require_all_files_in_directory' do
     it 'requires all files from given path' do
-      Dir.stub(:[]).with(Pathname.new('spinach').join('**', '*.rb')).
+      allow(Dir).to receive(:[]).with(Pathname.new('spinach').join('**', '*.rb')).
         and_return(["pumpkins", "some_guy_dressed_as_liberace"])
-      Rory::Support.should_receive(:require).with("pumpkins")
-      Rory::Support.should_receive(:require).with("some_guy_dressed_as_liberace")
+      expect(Rory::Support).to receive(:require).with("pumpkins")
+      expect(Rory::Support).to receive(:require).with("some_guy_dressed_as_liberace")
       Rory::Support.require_all_files_in_directory('spinach')
     end
   end
@@ -31,37 +31,37 @@ describe Rory::Support do
     end
 
     it 'returns constant from camelized name' do
-      Rory::Support.constantize('OrigamiDeliveryMan').
-        should == OrigamiDeliveryMan
+      expect(Rory::Support.constantize('OrigamiDeliveryMan')).
+        to eq(OrigamiDeliveryMan)
     end
 
     it 'returns constant from snake-case string' do
-      Rory::Support.constantize('origami_delivery_man').
-        should == OrigamiDeliveryMan
+      expect(Rory::Support.constantize('origami_delivery_man')).
+        to eq(OrigamiDeliveryMan)
     end
 
     it 'returns namespaced constant' do
-      Rory::Support.constantize(
+      expect(Rory::Support.constantize(
         'origami_delivery_man/under_where/skippy'
-      ).should == OrigamiDeliveryMan::UnderWhere::Skippy
+      )).to eq(OrigamiDeliveryMan::UnderWhere::Skippy)
     end
   end
 
   describe '.tokenize' do
     it 'creates snake_case version of string' do
-      described_class.tokenize('Albus Dumbledore & his_friend').should == 'albus_dumbledore_and_his_friend'
+      expect(described_class.tokenize('Albus Dumbledore & his_friend')).to eq('albus_dumbledore_and_his_friend')
     end
 
     it 'uncamelizes' do
-      described_class.tokenize('thisStrangeJavalikeWord').should == 'this_strange_javalike_word'
+      expect(described_class.tokenize('thisStrangeJavalikeWord')).to eq('this_strange_javalike_word')
     end
 
     it 'returns nil if given nil' do
-      described_class.tokenize(nil).should be_nil
+      expect(described_class.tokenize(nil)).to be_nil
     end
 
     it 'also handles symbols' do
-      described_class.tokenize(:yourFaceIsNice).should == 'your_face_is_nice'
+      expect(described_class.tokenize(:yourFaceIsNice)).to eq('your_face_is_nice')
     end
   end
 end

data/spec/lib/rory_spec.rb

@@ -1,13 +1,13 @@
 describe Rory do
   describe '.application' do
     it 'is by default set to the Rory::Application instance' do
-      Rory.application.should == Fixture::Application.instance
+      expect(Rory.application).to eq(Fixture::Application.instance)
     end
   end
 
   describe '.root' do
     it 'returns root of application' do
-      Rory.root.should == Rory.application.root
+      expect(Rory.root).to eq(Rory.application.root)
     end
   end
 end

data/spec/requests/controller_spec.rb

@@ -1,9 +1,27 @@
 describe "Controller" do
   describe "presentation", :type => :feature do
-    it 'renders action template' do
+    it 'renders default action template' do
       visit '/for_reals/pickles'
 
       expect(page).to have_text("You've done it again, pickles!")
+      expect(page.status_code).to eq 200
+      expect(page.response_headers['Content-Type']).to eq('text/html')
+    end
+
+    it 'renders json' do
+      visit '/for_reals/switching.json'
+
+      expect(page).to have_text({ :a => 1 }.to_json)
+      expect(page.status_code).to eq 200
+      expect(page.response_headers['Content-Type']).to eq('application/json')
+    end
+
+    it 'renders custom template' do
+      visit '/for_reals/switching'
+
+      expect(page).to have_text("Oh, a secret!")
+      expect(page.status_code).to eq 404
+      expect(page.response_headers['Content-Type']).to eq('text/html')
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rory
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Ravi Gadad
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-27 00:00:00.000000000 Z
+date: 2015-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: capybara
   requirement: !ruby/object:Gem::Requirement
@@ -192,6 +192,7 @@ files:
 - spec/fixture_app/controllers/stub_controller.rb
 - spec/fixture_app/lib/dummy_middleware.rb
 - spec/fixture_app/views/for_reals/but_wait.html.erb
+- spec/fixture_app/views/for_reals/custom.html.erb
 - spec/fixture_app/views/for_reals/srsly.html.erb
 - spec/fixture_app/views/layouts/surround.html.erb
 - spec/fixture_app/views/test/a_link.html.erb