fastr 0.0.2 → 0.0.3

data/README.rdoc

@@ -14,6 +14,7 @@ Micro web framework for Ruby. Should be used with an EventMachine rack server.
 The directory structure is similar to rails:
 
 * app/(config/controller/views/models)
+* public
 * lib
 * test
 
@@ -27,6 +28,13 @@ The routes are configured in app/config/routes.rb
   	#route.for '/test', :to => 'home#index'
   end
   
+== Settings
+
+Various settings can be configured in app/config/settings.rb
+
+  config.log_level = Logger::DEBUG
+  config.cache_templates = true
+  
 == Controller
   
   class HomeController < Fastr::Controller
@@ -34,6 +42,24 @@ The routes are configured in app/config/routes.rb
       render(:text, "Hello, world!")
     end
   end
+  
+= Request/Response Information
+
+== Headers
+
+You can set response headers by accessing the attribute headers:
+
+  self.headers['My-Header'] = 'value'
+  
+== Cookies
+
+You can read cookies by accessing the attribute cookies:
+
+  puts self.cookies['MY_SESS_COOKIE']
+  
+Set cookie:
+
+  set_cookie("sess", myuniquekey, {:expires => Time.now + 3600})
 
 == Return a view in a controller
 
@@ -46,6 +72,10 @@ You can also use the following render methods:
 With HAML, the template is rendered and any instance variables in your controller are available in the template.
 
   render(:haml, :template => "index") # this searches for index.haml in your app/views/ folder
+  
+JSON:
+
+  render(:json, {:status => "ok", :message => "done"})
 
 == Deferred Responses
 
@@ -73,9 +103,67 @@ The following is an example of a controller action.
         response.succeed
       }
       
+      # This is used to get a callback when the request's connection is closed
+      response.closed do
+        puts "Connection closed."
+      end
+      
       response.task(long_task, callback)
     end
   end
+  
+== Plugins
+
+Fastr searches the custom/plugins directory in your application's root directory for loading plugins.
+
+Example structure:
+
+* custom/plugins/my_test/plugin.rb
+* custom/plugins/my_test/lib/*.rb
+
+When a plugin is found, the plugin.rb file is loaded. It should contain a module that matches the name of your plugin, ending with the word plugin.
+
+Example:
+
+Directory: my_test
+
+Module name: MyTestPlugin
+
+Here is an example plugin and what is currently supported:
+
+  module MyTestPlugin
+    def self.after_boot(app)
+      puts "booted: #{app}"
+    end
+
+    def self.before_dispatch(app, env)
+      env
+    end
+
+    def self.after_dispatch(app, env, response)
+      response
+    end
+  end
+  
+== Static Files
+
+Anything stored in the public folder in your project's root directory will be served as a static file. This directory is checked before the routes. The mime type is set based on the file's extension.
+
+== Change Log
+
+0.3
+
+* Added kqueue/epoll.
+* Fixed dependencies.
+* Added loading of model and lib directories.
+* Added settings file.
+* Added controller params.
+* Added ability to disable template caching.
+* Added closed callback for deferred responses.
+* Added static file serving.
+* Added JSON rendering.
+* Added response headers and cookie handling.
+* Added plugins.
 
 == Current Status
 

data/bin/fastr

@@ -11,7 +11,7 @@ module Fastr
     
     # Directory Structre
 
-    dirs = ['app/config', 'app/controllers', 'app/views', 'app/models', 'lib', 'test']
+    dirs = ['app/config', 'app/controllers', 'app/views', 'app/models', 'lib', 'test', 'public', 'custom/plugins']
     dirs.each do |dir| 
       FileUtils.mkdir_p("#{app_name}/#{dir}")
     end 
@@ -29,7 +29,8 @@ module Fastr
     # Rack file
     File.open("#{app_name}/config.ru", "w") do |f|
       f.puts("require 'fastr'")
-      f.puts("EM.kqueue = true # OS X")
+      f.puts("EM.kqueue = true if EM.kqueue?")
+      f.puts("EM.epoll = true if EM.epoll?")
       f.puts("fastrApp = Fastr::Application.new(File.expand_path(File.dirname(__FILE__)))")
       f.puts("app = lambda { |env|")
       f.puts("\tfastrApp.dispatch(env)")
@@ -38,6 +39,13 @@ module Fastr
       f.close
     end
     
+    # Settings file
+    File.open("#{app_name}/app/config/settings.rb", "w") do |f|
+      f.puts("config.log_level = Logger::DEBUG")
+      f.puts("config.cache_templates = true")
+      f.close
+    end
+    
     # Gemfile
     File.open("#{app_name}/Gemfile", 'a') do |f|
       f.puts "source :gemcutter"

data/lib/fastr/application.rb

@@ -1,32 +1,88 @@
 require 'logger'
+require 'cgi'
+require 'mime/types'
 
 module Fastr  
   class Application
     include Fastr::Log
-
-    attr_accessor :router, :app_path
     
+    SETTINGS_FILE = "app/config/settings.rb"
+    INIT_FILE = "app/config/init.rb"
+    PUBLIC_FOLDER = "public"
+
+    attr_accessor :router, :app_path, :settings, :plugins
+
+    # These are resources we are watching to change.
+    # They will be reloaded upon change.
+    @@load_paths = {
+      :controller => "app/controllers/*.rb",
+      :model => "app/models/*.rb",
+      :lib => "lib/*.rb"
+    }
+
+    # Sets the application's initial state to booting and then kicks off the boot.
     def initialize(path)
       self.app_path = path
-      
+      self.settings = Fastr::Settings.new(self)
+      self.plugins = []
       @booting = true
       boot
     end
     
+    # Convenience wrapper for do_dispatch
+    # This is the heart of the server, called indirectly by a Rack aware server. 
     def dispatch(env)
       return [500, {}, "Server Not Ready"] if @booting
       
       begin 
-        do_dispatch(env)
+        new_env = plugin_before_dispatch(env)
+        plugin_after_dispatch(new_env, do_dispatch(new_env))
       rescue Exception => e
         bt = e.backtrace.join("\n")
         [500, {}, "Exception: #{e}\n\n#{bt}"]
       end
     end
     
-    def do_dispatch(env)
+    def plugin_before_dispatch(env)
+      new_env = env
+      
+      self.plugins.each do |plugin|
+        if plugin.respond_to? :before_dispatch
+          new_env = plugin.send(:before_dispatch, self, env)
+        end
+      end
+      
+      new_env
+    end
+    
+    def plugin_after_dispatch(env, response)
+      new_response = response
+      
+      self.plugins.each do |plugin|
+        if plugin.respond_to? :after_dispatch
+          new_response = plugin.send(:after_dispatch, self, env, response)
+        end
+      end
+      
+      new_response
+    end
+    
+    def plugin_after_boot
+      self.plugins.each do |plugin|
+        if plugin.respond_to? :after_boot
+          new_env = plugin.send(:after_boot, self)
+        end
+      end
+    end
+    
+    # Route, instantiate controller, return response from controller's action.
+    def do_dispatch(env)      
       path = env['PATH_INFO']
       
+      # Try to serve a public file
+      ret = dispatch_public(env, path)
+      return ret if not ret.nil?
+      
       log.debug "Checking for routes that match: #{path}"
       route = router.match(env)
 
@@ -43,12 +99,14 @@ module Fastr
         log.info "Routing to controller: #{klass}, action: #{action}"
         
         obj = Module.const_get(klass).new
-        obj.env = env
+        setup_controller(obj, env)
         
-        ret = obj.send(action)
+        code, hdrs, body = *obj.send(action)
+
+        # Merge headers with anything specified in the controller
+        hdrs.merge!(obj.headers)
         
-        #[200, {}, "ok"]
-        ret
+        [code, hdrs, body]
       else
         [404, {"Content-Type" => "text/plain"}, "404 Not Found: #{path}"]
       end
@@ -56,6 +114,57 @@ module Fastr
     
     private
     
+    def dispatch_public(env, path)
+      path = "#{self.app_path}/#{PUBLIC_FOLDER}/#{path[1..(path.length - 1)]}"
+      if not File.directory? path and File.exists? path
+        f = File.open(path)
+        hdrs = {}
+        
+        type = MIME::Types.type_for(File.basename(path))
+        
+        hdrs["Content-Type"] = type.to_s if not type.nil?
+        
+        return [200, hdrs, f.read]
+      else
+        return nil
+      end
+    end
+    
+    def setup_controller(controller, env)
+      controller.env = env
+      controller.params = {}
+      controller.headers = {}
+
+      CGI::parse(env['QUERY_STRING']).each do |k,v|
+        if v.length == 1
+          controller.params[k] = v[0]
+        else
+          controller.params[k] = v
+        end
+      end
+      
+      controller.cookies = get_cookies(env)
+      
+      
+      controller.app = self
+    end
+    
+    def get_cookies(env)
+      if env.has_key? "HTTP_COOKIE"
+        cookies = env['HTTP_COOKIE'].split(';')
+        c = {}
+        cookies.each do |cookie|
+          info = cookie.strip.split("=")
+          if info.length == 2
+            c[info[0].strip] = info[1].strip 
+          end
+        end
+        c
+      else
+        {}
+      end
+    end
+    
     #
     # This is used to initialize the application.
     # It runs in a thread because startup depends on EventMachine running
@@ -65,11 +174,20 @@ module Fastr
         sleep 1 until EM.reactor_running?
         
         begin
+          log.info "Loading application..."
+          
+          load_settings
+          Fastr::Plugin.load(self)
           load_app_classes
           setup_router
           setup_watcher
           
+          log.info "Application loaded successfully."
+          
           @booting = false
+          
+          plugin_after_boot
+          app_init
         rescue Exception => e
           log.error "#{e}"
           puts e.backtrace
@@ -79,33 +197,59 @@ module Fastr
       end
     end
     
+    # Initializes the router and loads the routes.
     def setup_router
       self.router = Fastr::Router.new(self)
       self.router.load
     end
   
+    # Loads all application classes. Called on startup.
     def load_app_classes
-      log.debug "Loading application classes..."
-      Dir["#{self.app_path}/app/controllers/*.rb"].each do |f|
-        log.debug "Loading: #{f}"
-        load(f)
+      @@load_paths.each do |name, path|
+        log.debug "Loading #{name} classes..."
+        
+        Dir["#{self.app_path}/#{path}"].each do |f|
+          log.debug "Loading: #{f}"
+          load(f)
+        end
       end
     end
     
+    def app_init
+      return if not File.exists? INIT_FILE
+      
+      init_file = File.open(INIT_FILE)
+      self.instance_eval(init_file.read)
+    end
+    
+    def load_settings
+      return if not File.exists? SETTINGS_FILE
+      
+      config_file = File.open(SETTINGS_FILE)
+      self.instance_eval(config_file.read)
+    end
+    
+    # Watch for any file changes in the load paths.
     def setup_watcher
       this = self
       Handler.send(:define_method, :app) do 
         this
       end
       
-      Dir["#{self.app_path}/app/controllers/*.rb"].each do |f|
-        EM.watch_file(f, Handler)
+      @@load_paths.each do |name, path|
+        Dir["#{self.app_path}/#{path}"].each do |f|
+          EM.watch_file(f, Handler)
+        end
       end
     end
     
+    def config
+      return self.settings
+    end
+    
     module Handler
       def file_modified
-        app.log.info "Reloading file: #{path}"
+        app.log.debug "Reloading file: #{path}"
         load(path)
       end
     end

data/lib/fastr/controller.rb

@@ -1,6 +1,6 @@
 module Fastr
   class Controller
-    attr_accessor :env
+    attr_accessor :env, :params, :app, :headers, :cookies
     
     include Fastr::Template
     include Fastr::Deferrable
@@ -8,5 +8,28 @@ module Fastr
     def self.inherited(kls)
       kls.instance_eval('include Fastr::Log')
     end
+    
+    def set_cookie(key, value, options={})
+      cookie = ["#{key}=#{value};"]
+      
+      
+      if options.has_key? :expires and options[:expires].kind_of? Time
+        options[:expires] = options[:expires].utc.strftime('%a, %d-%b-%Y %H:%M:%S GMT')
+      end
+      
+      options.each do |k,v|
+        cookie << "#{k}=#{v.to_s};"
+      end
+      
+      
+      
+      cookie_val = cookie.join(' ')
+      
+      if self.headers['Set-Cookie'].nil?
+        self.headers['Set-Cookie'] = [cookie_val]
+      else
+        self.headers['Set-Cookie'] << cookie_val
+      end
+    end
   end
 end

data/lib/fastr/deferrable.rb

@@ -23,6 +23,10 @@ module Fastr
       EM.defer(operation, callback)
     end
     
+    def closed(&cb)
+      self.errback(&cb)
+    end
+    
     def finish
       self.succeed
     end

data/lib/fastr/extensions/string.rb

@@ -0,0 +1,10 @@
+class String
+  def camelcase
+    split = self.split('_')
+    newStr = []
+    
+    split.each { |s| newStr << s.capitalize }
+    
+    newStr.join('')
+  end
+end

data/lib/fastr/filter.rb

@@ -0,0 +1,44 @@
+module Fastr
+  module Filter
+    def self.included(kls)
+      
+      kls.extend(ClassMethods)
+      puts kls
+      puts kls.instance_variable_get(:@filters).inspect
+    end
+    
+    module ClassMethods
+      def before_filter(*args)
+        methods = []
+        options = {}
+        puts self
+        args.each do |arg|
+          if arg.kind_of? Symbol
+            methods << arg
+          elsif arg.kind_of? Hash
+            options = arg
+          end
+        end
+        
+        setup_filter(methods, options)
+      end
+      
+      def setup_filter(methods, options)
+        if self.instance_variable_defined? :@filters
+          f = self.instance_variable_get(:@filters)
+        else
+          f = []
+          self.instance_variable_set(:@filters, f)
+        end
+
+        if options.has_key? :only and options[:only].kind_of? Array
+          f << {:methods => methods, :only => options[:only]}
+        elsif options.has_key? :except and options[:except].kind_of? Array
+          f << {:methods => methods, :except => options[:except]}
+        else
+          f << {:methods => methods, :all => true}
+        end
+      end
+    end
+  end
+end

data/lib/fastr/logger.rb

@@ -2,11 +2,19 @@ require 'logger'
 
 module Fastr
   module Log   
+    @log_level = Logger::DEBUG
+    @log_location = STDOUT
+    @log_classes = []
+    
     def self.included(kls)
+      level = @log_level
+      log_classes = @log_classes
+      log_location = @log_location
+      
       kls.instance_eval do
-        @logger = Logger.new(STDOUT)
-        @logger.level = Logger::DEBUG
-        @logger.formatter = Fastr::Log::Formatter.new(kls)
+        @logger = Fastr::Log.create_logger(log_location, level, kls)
+        
+        log_classes << @logger
         
         def logger
           @logger
@@ -19,6 +27,20 @@ module Fastr
         end
       end
     end
+    
+    def self.create_logger(location, level, kls)
+      logger = Logger.new(location)
+      logger.level = level
+      logger.formatter = Fastr::Log::Formatter.new(kls)
+      logger
+    end
+    
+    def self.level=(level)      
+      @log_level = level
+      @log_classes.each do |log|
+        log.level = level
+      end
+    end
 
     class Formatter < Logger::Formatter
       attr_accessor :progname

data/lib/fastr/plugin.rb

@@ -0,0 +1,41 @@
+module Fastr
+  module Plugin
+    include Fastr::Log
+    
+    PLUGIN_PATH = "custom/plugins"
+    
+    def self.load(app)
+      logger.debug "Loading plugins..."
+
+      if File.directory? "#{app.app_path}/#{PLUGIN_PATH}"
+        load_plugins_dir(app)
+      end
+    end
+    
+    def self.load_plugins_dir(app)
+      Dir.foreach("#{app.app_path}/#{PLUGIN_PATH}") do |filename|
+        if filename != '.' and filename != '..'
+          load_plugin(app, filename, "#{app.app_path}/#{PLUGIN_PATH}/#{filename}")
+        end
+      end
+    end
+    
+    def self.load_plugin(app, name, dir)
+      plugin_name = "#{name.camelcase}Plugin"
+      logger.debug "Loading plugin #{plugin_name}..."
+      
+      begin
+        require("#{dir}/plugin.rb")
+        m = Module.const_get(plugin_name)
+        
+        if File.directory? "#{dir}/lib"
+          Dir.glob(File.join("#{dir}/lib/**", "*.rb")).each { |f| require("#{f}") }
+        end
+        
+        app.plugins << m
+      rescue => e
+        logger.error "Unable to load plugin: #{e}"
+      end
+    end
+  end
+end

data/lib/fastr/session.rb

@@ -0,0 +1,5 @@
+module Fastr
+  module Session
+    
+  end
+end

data/lib/fastr/settings.rb

@@ -0,0 +1,16 @@
+module Fastr  
+  class Settings
+    include Fastr::Log
+    
+    attr_accessor :cache_templates
+    
+    def initialize(app)
+      @app = app
+      @cache_templates = true
+    end
+    
+    def log_level=(level)
+      Fastr::Log.level = level
+    end
+  end
+end

data/lib/fastr/template.rb

@@ -1,4 +1,5 @@
 require 'haml'
+require 'json'
 
 module Fastr
   module Template
@@ -22,8 +23,12 @@ module Fastr
       end
     end
     
-    def render_text(txt)
-      [200, {"Content-Type" => 'text/plain'}, txt]
+    def render_text(*args)
+      [200, {"Content-Type" => 'text/plain'}, [args[0]]]
+    end
+    
+    def render_json(*args)
+      [200, {"Content-Type" => 'application/json'}, args[0][0].to_json.to_s]
     end
     
     def render_haml(args)
@@ -34,12 +39,12 @@ module Fastr
       else
         tpl_data = File.read("app/views/#{tpl}.haml")
         haml_engine = Haml::Engine.new(tpl_data)
-        @@tpl_cache[tpl] = haml_engine
+        @@tpl_cache[tpl] = haml_engine if self.app.settings.cache_templates
       end
 
       resp = haml_engine.render(self)
       
-      [200, {"Content-Type" => "text/html"}, resp]
+      [200, {"Content-Type" => "text/html"}, [resp]]
     end
   end
 end

data/lib/fastr.rb

@@ -1,6 +1,8 @@
 module Fastr
   ROOT = File.expand_path(File.dirname(__FILE__))
   
+  require "#{ROOT}/fastr/extensions/string"
+  
   autoload :Application,      "#{ROOT}/fastr/application"
   autoload :Log,              "#{ROOT}/fastr/logger"
   autoload :Router,           "#{ROOT}/fastr/router"
@@ -8,4 +10,6 @@ module Fastr
   autoload :Controller,       "#{ROOT}/fastr/controller"
   autoload :Template,         "#{ROOT}/fastr/template"
   autoload :Deferrable,       "#{ROOT}/fastr/deferrable"
+  autoload :Settings,         "#{ROOT}/fastr/settings"
+  autoload :Plugin,           "#{ROOT}/fastr/plugin"
 end

data/test/fastr_app/app/config/routes.rb

@@ -0,0 +1,5 @@
+router.draw do |route|
+  route.for '/:controller/:action'
+  route.for '/home/:action', :action => '[A-Za-z]+'
+  route.for '/test', :to => 'home#index'
+end

data/test/fastr_app/app/controllers/fastr_app_controller.rb

@@ -0,0 +1,2 @@
+class FastrAppController
+end

data/test/helper.rb

@@ -1,10 +1,46 @@
 require 'rubygems'
+require 'eventmachine'
 require 'test/unit'
 require 'shoulda'
+require 'mocha'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
+
+APP_PATH = "#{File.expand_path(File.dirname(__FILE__))}/fastr_app"
+
 require 'fastr'
+EM.kqueue = true
+
+class NueteredBootingApplication < Fastr::Application
+  attr_reader :booted
+  def boot
+    @booted = true
+  end
+end
+
+class ManualBootingApplication < Fastr::Application
+  include Fastr::Log
+  
+  def initialize(path)
+    self.app_path = path
+    self.plugins = []
+    @booting = true
+  end
+end
 
 class Test::Unit::TestCase
+  def em_setup 
+    EM.run do
+      yield
+      EM.stop
+    end
+  end
 end
+
+class Fastr::Log::Formatter
+  def call(severity, time, progname, msg)
+    #block all logging output during testing
+    #puts "[#{severity}] [#{self.progname}]: #{msg}"
+  end
+end

data/test/test_application.rb

@@ -0,0 +1,39 @@
+require 'helper'
+
+class TestApplication < Test::Unit::TestCase
+    
+  context "New Application" do  
+    setup do
+      em_setup{ @application = NueteredBootingApplication.new("/some/path") }
+    end
+    
+    should "store startup path" do
+      assert_equal "/some/path",@application.app_path
+    end
+    
+    should "boot application" do
+      assert @application.booted
+    end
+  end
+    
+  context "Application Boot" do
+    setup do
+      em_setup {
+        @application = ManualBootingApplication.new(APP_PATH)
+        @application.send(:boot).join
+      }
+    end
+  
+    should "load app controllers" do
+      assert defined?(FastrAppController)
+    end
+    
+    should "create router" do
+      assert_not_nil @application.router
+    end
+    
+    should "setup routes from route file" do
+      assert_equal 3,@application.router.routes.size
+    end
+  end
+end

data/test/test_deferrable.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+class TestDeferrable < Test::Unit::TestCase
+    
+  context "Deferrable includer" do
+    setup do
+      @deferrable = DeferrableHost.new
+      em_setup do
+        @deferrable.defer_response(200, {"Content-Type" => "text/plain"}) do |response|
+          response.send_data("hey\n")
+
+          long_task = proc {
+            response.send_data("processing...\n")
+            return "finished"
+          }
+
+          callback = proc { |result|
+            response.send_data("#{result}\n")
+            response.succeed
+          }
+
+          response.task(long_task, callback)
+        end
+      end
+    end
+      
+    should "pass sent data data through to server callback" do
+      assert_not_nil @deferrable.callbacks.index("hey\n") 
+    end
+  
+    should "run long task sent through response" do
+      assert_not_nil @deferrable.callbacks.index("processing...\n")
+    end
+  end
+end
+
+class DeferrableHost
+  include Fastr::Deferrable
+  attr_accessor :callbacks
+  
+  def initialize
+    @callbacks = []
+  end
+  
+  def env
+    {"async.callback"=>
+      Proc.new{|array|
+        response = array[2]
+        response.each do |arg|
+          @callbacks << arg
+        end
+      }
+    }
+  end
+end

data/test/test_deferrable_response.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+class TestDeferrableResponse < Test::Unit::TestCase
+    
+  context "DeferrableResponse" do
+    setup do
+      Fastr::Deferrable
+      @response = Fastr::DeferrableResponse.new
+    end
+    
+    should "hold onto callback to push data through to" do
+      @response.each {|data| assert_equal "Some Data",data }
+      @response.send_data("Some Data")
+    end
+      
+    should "execute deferred tasks" do
+      Object.expects(:touch!).times(2)
+      em_setup do
+        task = proc { Object.touch! }
+        callback = proc { Object.touch! }
+        @response.task(task,callback)
+      end
+    end
+    
+    should "call success callback when told to finish" do
+      callback_path = nil
+      em_setup do 
+        @response.callback { callback_path = "success" }
+        @response.errback { callback_path = "failure" }
+        @response.finish 
+      end
+      assert_equal "success",callback_path
+    end
+  end
+end

data/test/test_router.rb

@@ -0,0 +1,100 @@
+require 'helper'
+
+class TestRouter < Test::Unit::TestCase
+  context "" do
+    setup { Fastr::Router.any_instance.stubs(:setup_watcher) }
+    
+    context "Newly Created Router" do
+      setup do
+        @router = Fastr::Router.new(NueteredBootingApplication.new(APP_PATH))
+      end
+    
+      should "initialize an empty routes structure" do
+        assert_equal [],@router.routes
+      end
+    
+      should "infer directory of routes file" do
+        assert_equal File.join(APP_PATH,"/app/config/routes.rb"),@router.route_file
+      end
+      
+      context "when matching routes" do
+        setup { @router.for('/:controller/:action') }
+        
+        should "map vars on valid route" do
+          assert_equal({:ok => {:controller=>"test_controller",:action=>"test_action"}}, @router.match({'PATH_INFO' => "/test_controller/test_action"}))
+        end
+        
+        should "return error map on invalid route" do
+          assert_equal({:error => :not_found},@router.match({'PATH_INFO' => "/2o4598g7vher0023801293479/123twretbnsf g//sdfb s/test_action"}))
+        end
+      end
+      
+      context "when parsing mapping" do
+        context "for standard controller" do
+          setup { parse_route('/:controller/:action') }
+        
+          should "build proper regex" do
+            assert_equal "^/(\\w+)/(\\w+)$",@route_map[:regex]
+          end
+        
+          should "have no extra arguments" do
+            assert_nil @route_map[:args]
+          end
+        
+          should "have var for controller and action" do
+            assert_equal [:controller,:action],@route_map[:vars]
+          end
+        
+          should "have an empty hash" do
+            assert @route_map[:hash].empty?
+          end
+        end
+        
+        context "with a regex match" do
+          setup { parse_route("/home/:action",:action => '[A-Za-z]+') }
+          
+          should "build proper regex" do
+            assert_equal "^/home/([A-Za-z]+)$",@route_map[:regex]
+          end
+        
+          should "have one argument for the action regex" do
+            assert_equal({:action=>"[A-Za-z]+"},@route_map[:args])
+          end
+        
+          should "have var for the action matcher" do
+            assert_equal [:action],@route_map[:vars]
+          end
+        
+          should "have an empty hash" do
+            assert @route_map[:hash].empty?
+          end
+        end
+        
+        context "with an exact match" do
+          setup { parse_route("/test",:to => 'home#index') }
+          
+          should "build proper regex" do
+            assert_equal "^/test$",@route_map[:regex]
+          end
+        
+          should "have one argument for the direct route" do
+            assert_equal({:to=>"home#index"},@route_map[:args])
+          end
+        
+          should "have no vars" do
+            assert @route_map[:vars].empty?
+          end
+        
+          should "have a hash for the mapping" do
+            assert_equal({:controller=>"home", :action=>"index"},@route_map[:hash])
+          end
+        end
+      end
+    end 
+  end
+  
+  def parse_route(route,*args)
+    @router.for(route,*args)
+    @route_map = @router.routes.first
+  end 
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fastr
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Chris Moos
@@ -15,10 +15,52 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-08 00:00:00 -07:00
+date: 2010-06-20 00:00:00 -07:00
 default_executable: fastr
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 47
+        segments: 
+        - 1
+        - 16
+        version: "1.16"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
 description: A fast, micro-framework for Ruby that should be run under EventMachine servers (thin)
 email: chris@tech9computers.com
 executables: 
@@ -34,13 +76,24 @@ files:
 - lib/fastr/controller.rb
 - lib/fastr/deferrable.rb
 - lib/fastr/exception.rb
+- lib/fastr/extensions/string.rb
+- lib/fastr/filter.rb
 - lib/fastr/logger.rb
+- lib/fastr/plugin.rb
 - lib/fastr/router.rb
+- lib/fastr/session.rb
+- lib/fastr/session/cookie.rb
+- lib/fastr/settings.rb
 - lib/fastr/template.rb
 - LICENSE
 - README.rdoc
+- test/fastr_app/app/config/routes.rb
+- test/fastr_app/app/controllers/fastr_app_controller.rb
 - test/helper.rb
-- test/test_fastr.rb
+- test/test_application.rb
+- test/test_deferrable.rb
+- test/test_deferrable_response.rb
+- test/test_router.rb
 - bin/fastr
 has_rdoc: true
 homepage: http://github.com/chrismoos/fastr
@@ -77,5 +130,10 @@ signing_key:
 specification_version: 3
 summary: Another rack web framework for Ruby.
 test_files: 
+- test/fastr_app/app/config/routes.rb
+- test/fastr_app/app/controllers/fastr_app_controller.rb
 - test/helper.rb
-- test/test_fastr.rb
+- test/test_application.rb
+- test/test_deferrable.rb
+- test/test_deferrable_response.rb
+- test/test_router.rb

data/test/test_fastr.rb

@@ -1,7 +0,0 @@
-require 'helper'
-
-class TestFastr < Test::Unit::TestCase
-  should "probably rename this file and start testing for real" do
-    flunk "hey buddy, you should probably rename this file and start testing for real"
-  end
-end