rory 0.9.1 → 0.9.2

data/spec/lib/rory/cli/generate_spec.rb

@@ -1,16 +0,0 @@
-require "rory/cli"
-
-RSpec.describe Rory::CLI::Generate do
-  describe "#app" do
-    it "starts Generators::Application" do
-      proxy = instance_double(Rory::CLI::Generators::Application)
-      allow(proxy).to receive(:parent_options=).with({})
-      allow(Rory::CLI::Generators::Application).to receive(:new).
-        with(["frog"], any_args).
-        and_return(proxy)
-
-      expect(proxy).to receive(:invoke_all)
-      subject.app("frog")
-    end
-  end
-end

data/spec/lib/rory/cli/generators/application_spec.rb

@@ -1,35 +0,0 @@
-require "rory/cli"
-
-describe Rory::CLI::Generators::Application do
-  let(:options) { {} }
-  let(:args) { ["an app"] }
-  subject { described_class.new(args, options, :destination_root => sandbox_directory) }
-
-  after(:each) do
-    FileUtils.rm_rf sandbox_directory
-  end
-
-  context "with default options" do
-    it "generates a new application directory with no optional files" do
-      capture_output { subject.invoke_all }
-      expect(sandbox_directory.join("an_app")).to be_a_directory
-      expect(sandbox_directory.join("an_app", "config.ru")).to be_a_file
-      expect(sandbox_directory.join("an_app", ".rspec")).not_to be_a_file
-    end
-
-    it "logs the output" do
-      result = capture_output { subject.invoke_all }
-      expect(result).to include("create  an_app")
-    end
-  end
-
-  context "with default options" do
-    let(:options) { { rspec: true } }
-
-    it "adds rspec files" do
-      capture_output { subject.invoke_all }
-      expect(sandbox_directory.join("an_app", ".rspec")).to be_a_file
-      expect(sandbox_directory.join("an_app", "spec", "spec_helper.rb")).to be_a_file
-    end
-  end
-end

data/spec/lib/rory/cli/root_spec.rb

@@ -1,30 +0,0 @@
-require "rory/cli"
-
-RSpec.describe Rory::CLI::Root do
-  describe "#version" do
-    it "says the current Rory VERSION constant" do
-      expect(subject).to receive(:say).with("rory #{Rory::VERSION}")
-      subject.version
-    end
-  end
-
-  describe "#generate" do
-    it "delegates to generate" do
-      expect(Rory::CLI::Root.subcommand_classes["generate"]).
-        to eq(Rory::CLI::Generate)
-    end
-  end
-
-  describe "#new" do
-    it "starts Generators::Application" do
-      proxy = instance_double(Rory::CLI::Generators::Application)
-      allow(proxy).to receive(:parent_options=).with({})
-      allow(Rory::CLI::Generators::Application).to receive(:new).
-        with(["frog"], any_args).
-        and_return(proxy)
-
-      expect(proxy).to receive(:invoke_all)
-      subject.new("frog")
-    end
-  end
-end

data/spec/lib/rory/cli_spec.rb

@@ -1,10 +0,0 @@
-require "rory/cli"
-
-RSpec.describe Rory::CLI do
-  describe "#start" do
-    it "delegates to Root class" do
-      allow(Rory::CLI::Root).to receive(:start).and_return(:started)
-      expect(described_class.start).to eq :started
-    end
-  end
-end

data/spec/lib/rory/controller_spec.rb

@@ -1,261 +0,0 @@
-describe Rory::Controller do
-  subject { Rory::Controller.new(@request, @routing) }
-
-  before :each do
-    @routing = {
-      :route => Rory::Route.new('', :to => 'test#letsgo')
-    }
-
-    @request = double('Rack::Request', {
-      :params => { 'violet' => 'invisibility', :dash => 'superspeed' },
-      :script_name => 'script_root'
-    })
-  end
-
-  it_has_behavior 'path_generation' do
-    let(:path_generator) {
-      Rory::Controller.new(@request, @routing, Fixture::Application)
-    }
-  end
-
-  describe '#layout' do
-    it 'defaults to nil' do
-      expect(subject.layout).to be_nil
-    end
-  end
-
-  describe '#params' do
-    it 'returns params from request, converted for indifferent key access' do
-      expect(subject.params).to eq({
-        'violet' => 'invisibility',
-        'dash' => 'superspeed',
-        :violet => 'invisibility',
-        :dash => 'superspeed'
-      })
-    end
-  end
-
-  describe "#redirect" do
-    it "delegates to dispatcher from request" do
-      @routing[:dispatcher] = dispatcher = double
-      expect(dispatcher).to receive(:redirect).with(:whatever)
-      subject.redirect(:whatever)
-    end
-  end
-
-  describe "#render_not_found" do
-    it "delegates to dispatcher from request" do
-      @routing[:dispatcher] = dispatcher = double
-      expect(dispatcher).to receive(:render_not_found)
-      subject.render_not_found
-    end
-  end
-
-  describe "#base_path" do
-    it "returns script_name from request" do
-      expect(subject.base_path).to eq 'script_root'
-    end
-  end
-
-  describe "#present" do
-    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
-
-      context "on sub-subclass" do
-        let(:grandchild) { Class.new(FilteredController) }
-        let(:greatgrandchild) { Class.new(grandchild) }
-        subject { greatgrandchild.new(@request, @routing) }
-
-        it "assembles list of all filter actions from ancestry" do
-          grandchild.before_action :do_a_jig
-          greatgrandchild.before_action :take_a_deep_breath
-
-          [:pickle_something, :make_it_tasty, :do_a_jig, :take_a_deep_breath, :letsgo, :rub_tummy, :sleep, :render].each do |m|
-            expect(subject).to receive(m).ordered
-          end
-          subject.present
-        end
-      end
-
-      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
-
-      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
-
-      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
-
-      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'
-        })
-        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
-      subject.instance_variable_set(:@response, 'Forced response')
-      expect(subject.present).to eq('Forced response')
-    end
-
-    it "sends a previously set @body to render" do
-      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
-      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
-      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!"]
-      ])
-    end
-
-    it "returns given body as a rack response" do
-      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"]
-      ])
-    end
-  end
-
-  describe "#json_requested?" do
-    it "delegates to dispatcher" do
-      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
-      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
-      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
-      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 "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
-      expect(subject.generate_body_from_template('test/letsgo', :app => Fixture::Application)).to eq("Let's go content")
-    end
-
-    it "returns renderer output" do
-      allow(Rory::Renderer).to receive(:new).
-        with('not/real', subject.default_renderer_options).
-        and_return(double('Renderer', :render => '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
-      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 },
-        :app => :scooby,
-        :base_path => 'script_root'
-      }
-      allow(Rory::Renderer).to receive(:new).
-        with('also/fake', renderer_options).
-        and_return(double('Renderer', :render => '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
-      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
-      allow(subject).to receive(:json_requested?).and_return(true)
-      expect(subject.default_content_type).to eq('application/json')
-    end
-
-    it "returns 'application/json' if options has :json key" do
-      allow(subject).to receive(:json_requested?).and_return(false)
-      expect(subject.default_content_type(:json => 'woo')).to eq('application/json')
-    end
-  end
-end

data/spec/lib/rory/dispatcher_spec.rb

@@ -1,187 +0,0 @@
-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
-      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
-      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 ".rack_app" do
-    it "returns a callable object that dispatches to a new dispatcher" do
-      allow(Rack::Request).to receive(:new).with(:env).and_return(:a_request)
-      allow(described_class).to receive(:new).with(:a_request, :the_app).and_return(subject)
-      allow(subject).to receive(:dispatch).and_return(:the_dispatch)
-      expect(described_class.rack_app(:the_app).call(:env)).to eq(:the_dispatch)
-    end
-  end
-
-  describe "#dispatch" do
-    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
-      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(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(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(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
-      allow(request).to receive_messages(:params => {})
-    end
-
-    it "returns route from request if already set" do
-      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
-      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
-      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
-      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
-      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
-      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
-      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
-      subject = Rory::Dispatcher.new(request)
-      expect(subject.route).to be_nil
-    end
-
-    it "returns nil if route found but method is not allowed" do
-      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
-      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'
-      })
-
-      expect(request.params).to eq({:path=>"some-thing_or-other", :very_awesome=>"wicked"})
-    end
-  end
-end