rory 0.3.1

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Ravi Gadad
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,19 @@
+= rory
+
+The Little Framework That Could, but why?
+
+== Contributing to rory
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2013 Ravi Gadad. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,18 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+require 'reek/rake/task'
+Reek::Rake::Task.new do |t|
+  t.fail_on_error = true
+  t.verbose = false
+  t.source_files = 'lib/**/*.rb'
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/lib/rory.rb

@@ -0,0 +1,19 @@
+ENV['RORY_STAGE'] ||= ENV['RACK_ENV'] || 'development'
+
+require 'yaml'
+require 'sequel'
+require 'rory/application'
+require 'rory/dispatcher'
+require 'rory/support'
+require 'rory/controller'
+
+module Rory
+  class << self
+    attr_accessor :application
+
+    def root
+      app = application
+      app && app.root
+    end
+  end
+end

data/lib/rory/application.rb

@@ -0,0 +1,110 @@
+require 'pathname'
+require 'logger'
+require 'rory/route_mapper'
+
+module Rory
+  # Main application superclass.  Applications should subclass this class,
+  # but currently no additional configuration is needed - just run '#spin_up'
+  # to connect the database so Sequel can do its magic.
+  class Application
+    # Exception raised if no root has been set for this Rory::Application subclass
+    class RootNotConfigured < StandardError; end
+
+    attr_reader :db, :db_config
+    attr_accessor :config_path
+
+    class << self
+      private :new
+      attr_reader :root
+
+      def inherited(base)
+        super
+        Rory.application = base.instance
+      end
+
+      def method_missing(*args, &block)
+        instance.send(*args, &block)
+      end
+
+      def respond_to?(method)
+        return true if instance.respond_to?(method)
+        super
+      end
+
+      def instance
+        @instance ||= new
+      end
+
+      def root=(root_path)
+        @root = Pathname.new(root_path).expand_path
+      end
+    end
+
+    def autoload_paths
+      @autoload_paths ||= %w(models controllers helpers)
+    end
+
+    def autoload_all_files
+      autoload_paths.each do |path|
+        Rory::Support.autoload_all_files_in_directory root_path.join(path)
+      end
+    end
+
+    def root
+      self.class.root
+    end
+
+    def root_path
+      root || raise(RootNotConfigured, "#{self.class.name} has no root configured")
+    end
+
+    def config_path
+      @config_path ||= begin
+        root_path.join('config')
+      end
+    end
+
+    def set_routes(&block)
+      @routes = RouteMapper.set_routes(&block)
+    end
+
+    def routes
+      unless @routes
+        load(File.join(config_path, 'routes.rb'))
+      end
+      @routes
+    end
+
+    def configure
+      yield self
+    end
+
+    def spin_up
+      connect_db
+    end
+
+    def load_config_data(config_type)
+      YAML.load_file(
+        File.expand_path(File.join(config_path, "#{config_type}.yml"))
+      )
+    end
+
+    def connect_db(environment = ENV['RORY_STAGE'])
+      @db_config = load_config_data(:database)
+      @db = Sequel.connect(@db_config[environment.to_s])
+      @db.loggers << logger
+    end
+
+    def call(env)
+      Rory::Dispatcher.new(Rack::Request.new(env), self).dispatch
+    end
+
+    def logger
+      @logger ||= begin
+        Dir.mkdir('log') unless File.exists?('log')
+        file = File.open(File.join('log', "#{ENV['RORY_STAGE']}.log"), 'a')
+        Logger.new(file)
+      end
+    end
+  end
+end

data/lib/rory/controller.rb

@@ -0,0 +1,65 @@
+require 'erb'
+
+module Rory
+  # Interface for Controller class.  Subclass this to create controllers
+  # with actions that will be called by the Dispatcher when a route matches.
+  class Controller
+    def initialize(request, context = nil)
+      @request = request
+      @route = request[:route]
+      @params = request.params
+      @context = context
+    end
+
+    def route_template
+      "#{@route[:controller]}/#{@route[:action]}"
+    end
+
+    def layout
+      nil
+    end
+
+    def render(template, opts = {})
+      opts = { :layout => layout }.merge(opts)
+      file = view_path(template)
+      output = ERB.new(File.read(file)).result(binding)
+      if layout = opts[:layout]
+        output = render(File.join('layouts', layout.to_s), { :layout => false }) { output }
+      end
+      @body = output
+    end
+
+    def view_path(template)
+      root = @context ? @context.root : Rory.root
+      File.expand_path(File.join('views', "#{template}.html.erb"), root)
+    end
+
+    def redirect(path)
+      @response = @request[:dispatcher].redirect(path)
+    end
+
+    def render_not_found
+      @response = @request[:dispatcher].render_not_found
+    end
+
+    def present
+      # if a method exists on the controller for the requested action, call it.
+      action = @route[:action]
+      self.send(action) if self.respond_to?(action)
+
+      if @response
+        # that method may have resulted in a response already being generated
+        # (such as a redirect, or 404, or other non-HTML response).  if so,
+        # just return that response.
+        @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.
+        # don't render the default template, in that case.
+        @body ||= render(route_template)
+        [200, {'Content-type' => 'text/html', 'charset' => 'UTF-8'}, [@body]]
+      end
+    end
+  end
+end

data/lib/rory/dispatcher.rb

@@ -0,0 +1,72 @@
+module Rory
+  # The dispatcher takes care of sending an incoming request to the
+  # appropriate controller, after examining the routes.
+  class Dispatcher
+    attr_reader :request
+    def initialize(rack_request, context = nil)
+      @request = rack_request
+      @request[:route] ||= nil
+      @request[:dispatcher] = self
+      @context = context
+    end
+
+    def route_map
+      @context ? @context.routes : []
+    end
+
+    def get_route
+      match = nil
+      route = route_map.detect do |route_hash|
+        match = route_hash[:regex].match(@request.path_info[1..-1])
+        methods = route_hash[:methods] || []
+        match && (methods.empty? || methods.include?(method.to_sym))
+      end
+      if route
+        symbolized_param_names = match.names.map { |name| name.to_sym }
+        @request.params.merge! Hash[symbolized_param_names.zip(match.captures)]
+      end
+      route
+    end
+
+    def dispatch
+      route = set_route_if_empty
+
+      if route
+        controller_name = Rory::Support.camelize("#{route[:controller]}_controller")
+        controller_class = Object.const_get(controller_name)
+        controller_class.new(@request, @context).present
+      else
+        render_not_found
+      end
+    end
+
+    def set_route_if_empty
+      @request[:route] ||= get_route
+    end
+
+    def method
+      override_method = @request.params.delete('_method')
+      method = if override_method && ['put', 'patch', 'delete'].include?(override_method.downcase)
+        override_method
+      else
+        @request.request_method
+      end
+      method.downcase
+    end
+
+    def redirect(path = '/')
+      unless path =~ /\:\/\//
+        path = "#{@request.scheme}://#{@request.host_with_port}#{path}"
+      end
+      return [ 302, {'Content-type' => 'text/html', 'Location'=> path }, ['Redirecting...'] ]
+    end
+
+    def render_not_found
+      return [ 404, {'Content-type' => 'text/html' }, ['Four, oh, four.'] ]
+    end
+
+    def inspect
+      @request.inspect # fixes issue for rspec and pretty_print
+    end
+  end
+end

data/lib/rory/route_mapper.rb

@@ -0,0 +1,35 @@
+module Rory
+  # Route mapper, used to convert the entries in 'config/routes.rb' into
+  # a routing table for use by the dispatcher.
+  class RouteMapper
+    class << self
+      def set_routes(&block)
+        mapper = new
+        mapper.instance_exec(&block)
+        mapper.routing_map
+      end
+    end
+
+    def initialize
+      @routes = []
+    end
+
+    def routing_map
+      @routes
+    end
+
+    def match(mask, options = {})
+      options[:to] ||= mask.split('/').first
+      mask.gsub!(/^\/$/, '')
+      regex = /^#{mask.gsub(/:([\w_]+)/, "(?<\\1>\[\^\\\/\]+)")}$/
+      controller, action = options[:to].split('#')
+      route = {
+        :controller => controller,
+        :action => action,
+        :regex => regex
+      }
+      route[:methods] = options[:methods] if options[:methods]
+      @routes << route
+    end
+  end
+end

data/lib/rory/support.rb

@@ -0,0 +1,29 @@
+module Rory
+  # Support methods for utility functionality such as string modification -
+  # could also be accomplished by monkey-patching String class.
+  module Support
+    module_function
+
+    def camelize(string)
+      string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+      string = string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
+    end
+
+    def extract_class_name_from_path(path)
+      name = File.basename(path).sub(/(.*)\.rb$/, '\1')
+      name = camelize(name)
+    end
+
+    def autoload_file(path)
+      path = File.expand_path(path)
+      name = extract_class_name_from_path(path)
+      Object.autoload name.to_sym, path
+    end
+
+    def autoload_all_files_in_directory(path)
+      Dir[Pathname.new(path).join('**', '*.rb')].each do |file|
+        Rory::Support.autoload_file file
+      end
+    end
+  end
+end

data/lib/rory/tasks.rb

@@ -0,0 +1,4 @@
+
+Dir[File.join(File.dirname(__FILE__), '..', 'tasks', '*.rake')].each do |path|
+  load path
+end

data/lib/rory/version.rb

@@ -0,0 +1,3 @@
+module Rory
+  VERSION = '0.3.1'
+end

data/lib/tasks/db.rake

@@ -0,0 +1,61 @@
+namespace :db do
+  task :load_extensions => :environment do
+    RORY_APP.db.extension :schema_dumper
+    Sequel.extension :migration
+  end
+
+  desc "Migrate database to current version (or given version if arg)"
+  task :migrate, [:version] => :load_extensions do |task, args|
+    latest_version = `cd #{File.join(Rory.root, 'db', 'migrate')} && ls -1 [0-9]*_*.rb | tail -1 | sed -e s/_.*$//`
+    args.with_defaults(:version => latest_version)
+    migration_dir = File.join(Rory.root, 'db', 'migrate')
+    Sequel::Migrator.run(RORY_APP.db, migration_dir, :target => args[:version].to_i)
+  end
+
+  desc "Drop and recreate a database"
+  task :purge => :load_extensions do
+    config = RORY_APP.db_config[ENV['RORY_STAGE']]
+    drop_database_from_config(config)
+    create_database_from_config(config)
+  end
+
+  namespace :schema do
+    desc "Dump schema from database into db/schema.rb"
+    task :dump => :load_extensions do
+      migration = RORY_APP.db.dump_schema_migration
+      schema_file = File.join(Rory.root, 'db', 'schema.rb')
+      File.open(schema_file, 'w') { |f| f.write migration }
+    end
+
+    desc "Loads schema from db/schema.rb into current environment's DB"
+    task :load => :load_extensions do
+      schema_file = File.read(File.join(Rory.root, 'db', 'schema.rb'))
+      eval(schema_file).apply(RORY_APP.db, :up)
+    end
+  end
+
+  namespace :test do
+    desc "Loads db/schema.rb into test database"
+    task :load => [:load_extensions, :purge] do
+      RORY_APP.connect_db('test')
+      Rake::Task["db:schema:load"].invoke
+    end
+
+    desc "Purges test database"
+    task :purge => :load_extensions do
+      ENV['RORY_STAGE'] = 'test'
+      Rake::Task["db:purge"].invoke
+    end
+
+    desc "Recreates empty test database from development's schema"
+    task :prepare => ['db:schema:dump', 'db:test:load']
+  end
+
+  def drop_database_from_config(config)
+    RORY_APP.db << "DROP DATABASE IF EXISTS \"#{config['database']}\""
+  end
+
+  def create_database_from_config(config)
+    RORY_APP.db << "CREATE DATABASE \"#{config['database']}\""
+  end
+end

data/lib/tasks/rory.rake

@@ -0,0 +1,16 @@
+namespace :log do
+  desc "Truncates all logs"
+  task :clear do
+    FileList[File.join('log', '*.log')].each do |file|
+      File.open(file, 'w').close
+    end
+  end
+end
+
+desc "Shows all rake tasks and their locations"
+task :tasks do
+  tasks = Rake.application.tasks.map { |t|
+    { 'name' => t.name, 'location' => t.locations }
+  }
+  puts tasks
+end

data/rory.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'rory/version'
+
+Gem::Specification.new do |s|
+  s.name = "rory"
+  s.version = Rory::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Ravi Gadad"]
+  s.email = ["ravi@screamingmuse.com"]
+  s.homepage = "http://github.com/screamingmuse/rory"
+  s.summary = "Another Ruby web framework. Just what the world needs."
+  s.description = <<-EOF
+An exercise: Untangle the collusion of Rails idioms
+from my Ruby knowledge, while trying to understand some
+Rails design decisions.
+
+See http://github.com/screamingmuse/rory for more info.
+EOF
+  s.required_ruby_version     = ">= 1.8.7"
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.extra_rdoc_files = ["LICENSE.txt", "README.rdoc"]
+  s.files = Dir['{lib/**/*,spec/**/*}'] +
+                  %w(LICENSE.txt Rakefile README.rdoc rory.gemspec)
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency 'rack', '>= 1.0'
+  s.add_runtime_dependency 'sequel', '~> 4.5'
+  s.add_runtime_dependency 'thin', '~> 1.6'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'reek'
+  s.add_development_dependency 'bundler', '~> 1.0'
+end
+

data/spec/application_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+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
+      end
+    end
+  end
+
+  describe '.config_path' do
+    it 'is set to {root}/config by default' do
+      Fixture::Application.config_path.should ==
+        Pathname.new(Fixture::Application.root).join('config')
+    end
+
+    it 'raises exception if root not set' do
+      Rory.application = nil
+      class RootlessApp < Rory::Application; end
+      expect {
+        RootlessApp.config_path
+      }.to raise_error(RootlessApp::RootNotConfigured)
+      Rory.application = Fixture::Application.instance
+    end
+  end
+
+  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
+    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
+    end
+  end
+
+  describe ".call" do
+    it "forwards arg to new dispatcher, and calls dispatch" do
+      dispatcher = stub(: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
+    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(
+        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
+    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(stub(:loggers => []))
+      Fixture::Application.connect_db('development')
+    end
+  end
+
+  describe ".routes" do
+    it "generates a routing table from route configuration" do
+      # note: we're comparing the inspected arrays here because the arrays
+      # won't be equal, despite appearing the same - this is because the Regexes
+      # are different objects.
+      Fixture::Application.routes.inspect.should == [
+        { :controller => 'foo', :action => 'bar', :regex => /^foo\/(?<id>[^\/]+)\/bar$/, :methods => [:get, :post] },
+        { :controller => 'monkeys', :action => nil, :regex => /^foo$/, :methods => [:put] },
+        { :controller => 'awesome', :action => 'rad', :regex => /^this\/(?<path>[^\/]+)\/is\/(?<very_awesome>[^\/]+)$/},
+        { :controller => 'root', :action => 'vegetable', :regex => /^$/, :methods => [:get] }
+      ].inspect
+    end
+  end
+
+  describe ".spin_up" do
+    it "connects the database" do
+      Rory::Application.any_instance.should_receive(:connect_db)
+      Rory::Application.spin_up
+    end
+  end
+
+  describe '.autoload_paths' do
+    after(:each) do
+      Fixture::Application.instance.instance_variable_set(:@autoload_paths, nil)
+    end
+
+    it 'includes models, controllers, and helpers by default' do
+      Fixture::Application.autoload_paths.should == ['models', 'controllers', 'helpers']
+    end
+
+    it 'accepts new paths' do
+      Fixture::Application.autoload_paths << 'chocolates'
+      Fixture::Application.autoload_paths.should == ['models', 'controllers', 'helpers', 'chocolates']
+    end
+  end
+
+  describe '.autoload_all_files' do
+    it 'autoloads all files in autoload_paths' do
+      Fixture::Application.any_instance.stub(:autoload_paths).and_return(['goats', 'rhubarbs'])
+      [:goats, :rhubarbs].each do |folder|
+        Rory::Support.should_receive(:autoload_all_files_in_directory).
+          with(Pathname.new(Fixture::Application.root).join("#{folder}"))
+      end
+      Fixture::Application.autoload_all_files
+    end
+  end
+end

data/spec/controller_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe Rory::Controller do
+  before :each do
+    @request = {
+      :route => {
+        :controller => 'test',
+        :action => 'letsgo'
+      }
+    }
+
+    @request.stub(:params => {})
+  end
+
+  describe '#layout' do
+    it 'defaults to nil' do
+      controller = Rory::Controller.new(@request)
+      controller.layout.should be_nil
+    end
+  end
+
+  describe "#render" do
+    it "returns text of template" do
+      controller = Rory::Controller.new(@request)
+      controller.render('test/static').should == 'Static content'
+    end
+
+    it "returns text of template in controller's layout" do
+      controller = Rory::Controller.new(@request)
+      controller.stub(:layout => 'surround')
+      controller.render('test/static').should == 'Surrounding Static content is fun'
+    end
+
+    it "handles symbolized layout name" do
+      controller = Rory::Controller.new(@request)
+      controller.stub(:layout => :surround)
+      controller.render('test/static').should == 'Surrounding Static content is fun'
+    end
+
+    it "returns text of template in given layout from options" do
+      controller = Rory::Controller.new(@request)
+      controller.render('test/static', :layout => 'surround').should == 'Surrounding Static content is fun'
+    end
+
+    it "evaluates ERB in controller's context" do
+      controller = Rory::Controller.new(@request)
+      controller.stub(:word).and_return('hockey')
+      controller.render('test/dynamic').should == 'Word: hockey'
+    end
+  end
+
+  describe "#redirect" do
+    it "delegates to dispatcher from request" do
+      @request[:dispatcher] = dispatcher = stub
+      dispatcher.should_receive(:redirect).with(:whatever)
+      controller = Rory::Controller.new(@request)
+      controller.redirect(:whatever)
+    end
+  end
+
+  describe "#render_not_found" do
+    it "delegates to dispatcher from request" do
+      @request[:dispatcher] = dispatcher = stub
+      dispatcher.should_receive(:render_not_found)
+      controller = Rory::Controller.new(@request)
+      controller.render_not_found
+    end
+  end
+
+  describe "#present" do
+    it "calls action from route if exists on controller" do
+      controller = Rory::Controller.new(@request)
+      controller.stub(:render)
+      controller.should_receive('letsgo')
+      controller.present
+    end
+
+    it "doesn't try to call action from route if nonexistent on controller" do
+      controller = Rory::Controller.new(@request)
+      controller.stub(:render)
+      controller.stub(:respond_to?).with('letsgo').and_return(false)
+      controller.should_receive('letsgo').never
+      controller.present
+    end
+
+    it "just returns a response if @response exists" do
+      controller = Rory::Controller.new(@request)
+      controller.instance_variable_set(:@response, 'Forced response')
+      controller.present.should == 'Forced response'
+    end
+
+    it "renders and returns the default template as a rack response" do
+      controller = Rory::Controller.new(@request)
+      controller.present.should == [
+        200,
+        {'Content-type' => 'text/html', 'charset' => 'UTF-8'},
+        ["Let's go content"]
+      ]
+    end
+
+    it "returns previously set @body as a rack response" do
+      controller = Rory::Controller.new(@request)
+      controller.instance_variable_set(:@body, 'Forced body')
+      controller.should_receive(:render).never
+      controller.present.should == [
+        200,
+        {'Content-type' => 'text/html', 'charset' => 'UTF-8'},
+        ["Forced body"]
+      ]
+    end
+  end
+
+  describe '#view_path' do
+    it 'returns path to template from context root' do
+      fake_context = double('Context', :root => 'marbles')
+      controller = Rory::Controller.new(@request, fake_context)
+      controller.view_path('goose').should == File.expand_path(File.join('views', 'goose.html.erb'), 'marbles')
+    end
+
+    it 'uses Rory.root if no context' do
+      controller = Rory::Controller.new(@request)
+      controller.view_path('goose').should == File.join(Rory.root, 'views', 'goose.html.erb')
+    end
+  end
+end

data/spec/dispatcher_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe Rory::Dispatcher do
+  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 == [
+        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 == [
+        302, {'Content-type' => 'text/html', 'Location'=> 'happy://somewhere.yay/example' }
+      ]
+    end
+  end
+
+  describe "#dispatch" do
+    it "renders a 404 if the requested path is invalid" do
+      @request = {}
+      @request.stub(:path_info => nil, :request_method => 'GET', :params => {})
+      @dispatcher = Rory::Dispatcher.new(@request, Fixture::Application)
+      @dispatcher.stub(:get_route).and_return(nil)
+      @dispatcher.dispatch[0..1].should == [404, {"Content-type"=>"text/html"}]
+    end
+
+    it "instantiates a controller with the parsed request and calls present" do
+      @request = {:whatever => :yay}
+      @request.stub(:path_info => '/', :request_method => 'GET', :params => {})
+      @dispatcher = Rory::Dispatcher.new(@request, Fixture::Application)
+      route = { :controller => 'stub' }
+      @dispatcher.stub(:get_route).and_return(route)
+      @dispatcher.dispatch.should == {
+        :whatever => :yay,
+        :route => route,
+        :dispatcher => @dispatcher,
+        :present_called => true # see StubController in /spec/fixture_app
+      }
+    end
+
+    it "uses existing route if given in request" do
+      @request = {:whatever => :yay, :route => { :controller => 'stub' } }
+      @request.stub(:path_info => '/', :request_method => 'GET', :params => {})
+      @dispatcher = Rory::Dispatcher.new(@request, Fixture::Application)
+      @dispatcher.should_receive(:get_route).never
+      @dispatcher.dispatch.should == {
+        :whatever => :yay,
+        :route => { :controller => 'stub' },
+        :dispatcher => @dispatcher,
+        :present_called => true # see StubController in /spec/fixture_app
+      }
+    end
+  end
+
+  describe "#get_route" do
+    before(:each) do
+      @request = {}
+      @request.stub(:params => {})
+      @dispatcher = Rory::Dispatcher.new(@request, Fixture::Application)
+    end
+
+    it "matches the path from the request to the routes table" do
+      @request.stub(:path_info => '/foo', :request_method => 'PUT')
+      @dispatcher.get_route.should == {
+        :controller => 'monkeys',
+        :action => nil,
+        :regex => /^foo$/,
+        :methods => [:put]
+      }
+    end
+
+    it "works with root url represented by slash" do
+      @request.stub(:path_info => '/', :request_method => 'GET')
+      @dispatcher.get_route.should == {
+        :controller => 'root',
+        :action => 'vegetable',
+        :regex => /^$/,
+        :methods => [:get]
+      }
+    end
+
+    it "returns nil if no route found" do
+      @request.stub(:path_info => '/umbrellas', :request_method => 'GET')
+      @dispatcher.get_route.should be_nil
+    end
+
+    it "returns nil if no context" do
+      @dispatcher = Rory::Dispatcher.new(@request)
+      @dispatcher.get_route.should be_nil
+    end
+
+    it "returns nil if route found but method is not allowed" do
+      @request.stub(:path_info => '/foo', :request_method => 'GET')
+      @dispatcher.get_route.should 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')
+      @dispatcher.get_route.inspect.should == {
+        :controller => 'awesome',
+        :action => 'rad',
+        :regex => /^this\/(?<path>[^\/]+)\/is\/(?<very_awesome>[^\/]+)$/,
+      }.inspect
+
+      @request.params.should == {:path=>"some-thing_or-other", :very_awesome=>"wicked"}
+    end
+  end
+
+  describe '#method' do
+    it 'returns downcased method from request' do
+      request = {:whatever => :yay}
+      request.stub(:path_info => '/', :request_method => 'POST', :params => {})
+      dispatcher = Rory::Dispatcher.new(request, Fixture::Application)
+      dispatcher.method.should == 'post'
+    end
+
+    ['put', 'patch', 'delete'].each do |override_method|
+      it "overrides request method if _method from params is #{override_method}" do
+        request = {:whatever => :yay}
+        request.stub(:path_info => '/', :request_method => 'POST', :params => {'_method' => override_method})
+        dispatcher = Rory::Dispatcher.new(request, Fixture::Application)
+        dispatcher.method.should == override_method
+      end
+    end
+
+    it 'ignores overriding _method if not valid' do
+      request = {:whatever => :yay}
+      request.stub(:path_info => '/', :request_method => 'POST', :params => {'_method' => 'rhubarb'})
+      dispatcher = Rory::Dispatcher.new(request, Fixture::Application)
+      dispatcher.method.should == 'post'
+    end
+  end
+end

data/spec/fixture_app/config/application.rb

@@ -0,0 +1,4 @@
+module Fixture
+  class Application < Rory::Application
+  end
+end

data/spec/fixture_app/config/routes.rb

@@ -0,0 +1,6 @@
+Fixture::Application.set_routes do
+  match 'foo/:id/bar', :to => 'foo#bar', :methods => [:get, :post]
+  match 'foo', :to => 'monkeys', :methods => [:put]
+  match 'this/:path/is/:very_awesome', :to => 'awesome#rad'
+  match '/', :to => 'root#vegetable', :methods => [:get]
+end

data/spec/fixture_app/controllers/stub_controller.rb

@@ -0,0 +1,10 @@
+class StubController
+  def initialize(args, context)
+    @args = args
+  end
+
+  def present
+    @args[:present_called] = true
+    @args
+  end
+end

data/spec/fixture_app/views/layouts/surround.html.erb

@@ -0,0 +1 @@
+Surrounding <%= yield %> is fun

data/spec/fixture_app/views/test/dynamic.html.erb

@@ -0,0 +1 @@
+Word: <%= word %>

data/spec/fixture_app/views/test/letsgo.html.erb

@@ -0,0 +1 @@
+Let's go content

data/spec/fixture_app/views/test/static.html.erb

@@ -0,0 +1 @@
+Static content

data/spec/rory_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Rory do
+  describe '.application' do
+    it 'is by default set to the Rory::Application instance' do
+      Rory.application.should == Fixture::Application.instance
+    end
+  end
+
+  describe '.root' do
+    it 'returns root of application' do
+      Rory.root.should == Rory.application.root
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+ENV['RORY_STAGE'] = 'test'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'rory'
+require 'rack'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+require_relative 'fixture_app/config/application'
+Fixture::Application.root = File.join(File.dirname(__FILE__), 'fixture_app')
+
+Fixture::Application.autoload_all_files
+
+RSpec.configure do |config|
+
+end

data/spec/support_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Rory::Support do
+  describe ".camelize" do
+    it "camelizes given snake-case string" do
+      Rory::Support.camelize('water_under_bridge').should == 'WaterUnderBridge'
+    end
+  end
+
+  describe '.autoload_file' do
+    it 'adds basename of given path to autoload list by default' do
+      path = '/fake_root/gas/is/cheap/in/good_old_america.rb'
+      Object.should_receive(:autoload).with(:GoodOldAmerica, path)
+      Rory::Support.autoload_file(path)
+    end
+  end
+
+  describe '.autoload_all_files_in_directory' do
+    it 'autoloads all files from given path' do
+      Dir.stub(:[]).with(Pathname.new('spinach').join('**', '*.rb')).
+        and_return(["pumpkins", "some_guy_dressed_as_liberace"])
+      Rory::Support.should_receive(:autoload_file).with("pumpkins")
+      Rory::Support.should_receive(:autoload_file).with("some_guy_dressed_as_liberace")
+      Rory::Support.autoload_all_files_in_directory('spinach')
+    end
+  end
+end

metadata

@@ -0,0 +1,213 @@
+--- !ruby/object:Gem::Specification
+name: rory
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+  prerelease: 
+platform: ruby
+authors:
+- Ravi Gadad
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.5'
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: reek
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: ! 'An exercise: Untangle the collusion of Rails idioms
+
+  from my Ruby knowledge, while trying to understand some
+
+  Rails design decisions.
+
+
+  See http://github.com/screamingmuse/rory for more info.
+
+'
+email:
+- ravi@screamingmuse.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- lib/rory/application.rb
+- lib/rory/controller.rb
+- lib/rory/dispatcher.rb
+- lib/rory/route_mapper.rb
+- lib/rory/support.rb
+- lib/rory/tasks.rb
+- lib/rory/version.rb
+- lib/rory.rb
+- lib/tasks/db.rake
+- lib/tasks/rory.rake
+- spec/application_spec.rb
+- spec/controller_spec.rb
+- spec/dispatcher_spec.rb
+- spec/fixture_app/config/application.rb
+- spec/fixture_app/config/routes.rb
+- spec/fixture_app/controllers/stub_controller.rb
+- spec/fixture_app/views/layouts/surround.html.erb
+- spec/fixture_app/views/test/dynamic.html.erb
+- spec/fixture_app/views/test/letsgo.html.erb
+- spec/fixture_app/views/test/static.html.erb
+- spec/rory_spec.rb
+- spec/spec_helper.rb
+- spec/support_spec.rb
+- LICENSE.txt
+- Rakefile
+- README.rdoc
+- rory.gemspec
+homepage: http://github.com/screamingmuse/rory
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Another Ruby web framework. Just what the world needs.
+test_files: []
+has_rdoc: