maveric 0.4.0 → 1.0.0

data/README

@@ -0,0 +1,56 @@
+- Maveric
+
+Maveric is a MVC overlay for Rack.
+
+The dominant idea behind Maveric is as little magic as possible, being as
+flexible as possible.
+
+The use of a Maveric is simple.
+
+class MyApp < Maveric
+  def get
+    render {'<p>Hello World!</p>'}
+  end
+end
+
+env['PATH_INFO']    # => '/'
+MyApp.call(env)[0]  # => 200
+
+env['PATH_INFO']    # => '/index'
+MyApp.call(env)[0]  # => 200
+
+By default the method used to generate a response is the lower case form of the
+http method. GET requests call #get, POST requests call #post, and so on. A 404
+is returned if a the appropriate method is not defined.
+
+-- Actions
+
+To override this you may redefine #action= as needed.
+
+class MyApp < Maveric
+  def action= method
+    if method == :get and @request.path_info == '/'
+      @action = :index
+    else
+      super
+    end
+  end
+  def index
+    render {'<p>Hello World!</p>'}
+  end
+end
+
+-- The Render Method
+
+Provides a simple way to format data.
+
+class MyApp < Maveric
+  module Views
+    def html data
+      '<p>'+data.to_s+'</p>'
+    end
+  end
+  def get
+    render :html { 'Hello World!' }
+  end
+end

data/lib/maveric.rb

@@ -1,698 +1,294 @@
-##
-# = Maveric: A simple, non-magical, framework
-#
-# == Resources
-#
-# Maveric releases can normally be found on
-# {rubyforge}[http://rubyforge.org/projects/maveric/].
-# Documentation sits at {rubyforge}[http://maveric.rubyforge.org/] as well.
-# Maveric's code base resides at rubyforge as well, but will eventually be
-# located at {devjavu}[http://maveric.devjavu.com/].
-#
-# Maveric is also listed at the RAA as
-# {maveric}[http://raa.ruby-lang.org/project/maveric/]. This page lags a bit
-# behind rubyforge in terms of updates.
-#
-# == Version
-#
-# We are at version 0.4.0 and approaching a solid,  stable,  and  full  release.
-# It's not often I complete a project to a public release, often relegating the
-# the half completed code to my code vault and it never seeing the light of day
-# again. So this is definately a yey!
-#
-# Version 0.4.0 refines the Route class and interactions by utilizing a Struct.
-# Maveric no longer depends on any lib outside of core or stdlibs allowing you
-# to only install Maveric for functionality. We are now using -w and -d switches
-# during development and striving for concise *and* correct code.
-#
-# Maveric addons have been revised, giving the current functionality of Maveric
-# to FastCGI and Mongrel. A plugin to WEBrick has been provided, but is untested
-# and not supported.
-#
-# Check other documentation for a full list of changes.
-#
-# == Authors
-#
-# Maveric is designed and coded by {blink}[mailto:blinketje@gmail.com]
-# of #ruby-lang on irc.freenode.net
-#
-# == Licence
-#
-# This software is licensed under the
-# {CC-GNU LGPL}[http://creativecommons.org/licenses/LGPL/2.1/]
-#
-# == Disclaimer
-#
-# This software is provided "as is" and without any express or
-# implied warranties, including, without limitation, the implied
-# warranties of merchantability and fitness for a particular purpose.
-# Authors are not responsible for any damages, direct or indirect.
-#
-# = Maveric: History
-#
-# Maveric was initially designed as a replacement for Camping in the style of a
-# Model-View-Controller framework. Early implementations aimed to reduce the
-# amount of "magic" to 0. Outstanding magic of Camping is that nothing is
-# related due to the reading, gsub-ing, and eval-ing of the Camping source file
-# Also, even the unobfuscated/unabridged version of Camping is a bit hard to
-# follow at times.
-#
-# However, the result of this initial attempt was a spaghetti of winding code,
-# empty template modules, and rediculous inheritance paths between the template
-# modules and a plethora of dynamically generated classes and modules. I got
-# more complaints with that particular jumble of code than any other, evar.
-#
-# The next iteration of Maveric was a seeking of simplification and departure
-# from the concept of cloning Camping and its functionality and settling for
-# Camping-esqe. At this point, I started talking to ezmobius on #ruby-lang and
-# their Merb project. We talked a bit about merging and brainstorming but my
-# lone wolf tendencies stirred me away from such an endeavour, but I came away
-# a compatriot and inspiration for a new routing methodology inspired by Merb's.
-# The result is the Route that's been stable since, only varying in method
-# placement and data management.
-#
-# After building to a version that stood on it's owned and was able to run a
-# variance of my website as functional as the Camping version. I noticed a few
-# tendncies of my coding and refactored. I also redesigned the concept from a
-# modules that included the Maveric module to that of subclassing Maveric, which
-# is a Mongrel::HttpHandlerPlugin. This allowed the running of Maveric apps
-# without using Mongrel::CampingHandler as well as not worrying about namespace
-# clobbering.
-#
-# Because ehird from #ruby-lang was whining about it so much I removed its
-# dependancy on Mongrel sooner than later. Maveric should now be very maveric.
-#
-# Because Maveric 0.1.0 worked, but still didn't do things the way I wanted
-# I revised and refactored codes and algorithms into future versions which will
-# hopefully be all that I want. Everything beyond 1.0.0 will be improvements and
-# extensions.
-#
-# == Not so Maveric
-#
-# Maveric has additional libs to allow you to run Maveric behind different
-# http server implementations. CGI, FastCGI, and Mongrel are supported. If
-# another service exists that you'd like to have supported please submit a
-# patch of a good reason why.
-#
-# For these examples we will utilize the simplest functional Maveric possible
-#   require 'maveric'
-#   class Maveric::Index < Maveric::Controller
-#     def get
-#       'Hello, world!'
-#     end
-#   end
-#
-# To use CGI: (not cgi.rb)
-#   puts Maveric.new.dispatch.to_s
-#
-# To use FastCGI:
-#   require 'maveric/fastcgi'
-#   ::Maveric::FCGI(MyMaveric.new)
-#
-# To use Mongrel:
-#   require 'maveric/mongrel'
-#   h = ::Mongrel::HttpHandler ip, port
-#   h.register mountpoint, MyMaveric.new
-#   h.join.run
-#
-# However, if your script is mounted at a point other than /, use the
-# :path_prefix option to adjust your routes. This affects all routes generated
-# from MyMaveric.
-#   mav = MyMaveric.new :path_prefix => mountpoint
-#   ::Maveric::FCGI(mav)
-#   h.register mountpoint, mav
-#
-# --------------------------------
+# Author: scytrin@stadik.net
 require 'uri'
-require 'set'
-require 'maveric/extensions'
-
-##
-# = The Maveric: Yeargh.
-# The Maveric may be used alone or may be used in a cadre of loosely aligned
-# Maveric instances. The Maveric stands tall and proud, relying on it's fine
-# family and it's inventory of goods to get things done with little magic or
-# trickery.
-class Maveric
-  ## Implementation details.
-  VERSION='0.4.0'
-  ## Standard end of line for HTTP
-  EOL="\r\n"
-  ## Group 1 wil contain a boundary for multipart/form-data bodies.
-  MP_BOUND_REGEX = /\Amultipart\/form-data.*boundary=\"?([^\";, ]+)\"?/n
-  ## Contains a list of environment preprocessors.
-  @prepare_env = []
-
-  # I hate putting utility methods here, rather than in some module, but
-  # I don't see how to do it without getting messy.
-  class << self
-    ##
-    # Parses a query string by breaking it up around the
-    # delimiting characters.  You can also use this to parse
-    # cookies by changing the characters used in the second
-    # parameter (which defaults to ';,').
-    #
-    # This will return a hash of parameters, values being contained in an
-    # array. As a warning, the default value is an empty array, not nil.
-    def query_parse(qs, delim = '&;')
-      (qs||'').split(/[#{delim}] */n).inject({}) { |h,p|
-        k, v = URI.decode(p).split('=',2)
-        (h[k]||=[]) << v
-        h
-      }
-    end
+require 'rack'
 
-    ##
-    # Parse a multipart/form-data entity. Adapated from cgi.rb. The body
-    # argument may either be a StringIO or a IO of subclass thereof.
-    #
-    # Might need to be rehauled to match query_parse's behaviour.
-    def parse_multipart boundary, body
-      values = {}
-      bound = /(?:\r?\n|\A)#{Regexp::quote('--'+boundary)}(?:--)?\r$/
-      until body.eof?
-        fv = {}
-        until body.eof? or /^#{EOL}$/ =~ l
-          case l = body.readline
-          when /^Content-Type: (.+?)(\r$|\Z)/m
-            fv[:type] = $1
-          when /^Content-Disposition: form-data;/
-            $'.scan(/(?:\s(\w+)="([^"]+)")/) {|w| fv[w[0].intern] = w[1] }
-          end
-        end
+module Maveric
+  # Should contain methods to be shared amongst various maverics
+  module Helpers; end
 
-        o = fv[:filename] ? '' : fv[:tempfile] = Tempfile.new('MVC').binmode
-        body.inject do |buf, line|
-          o << buf.chomp and break if bound =~ line
-          o << buf
-          line
-        end # Merb and Camping do it faster.
+  # Should contain various views to be utilized by various maverics
+  module Views; attr_reader :maveric; TEMPLATES = {}; end
 
-        fv[:tempfile].rewind if fv.key? :tempfile
-        values[fv[:name]] = fv.key?(:filename) ? fv : o
-      end
-      body.rewind rescue nil # FCGI::Stream fun.
-      values
-    end
 
-    ##################### Non-utility methods
-
-    ##
-    # A recursive method to hunt out subclasses of Controller nested
-    # within a Maveric subclass. Used in the setting up of autoroutes.
-    # Disregards everything within a nested Maveric subclass.
-    def nested_controllers realm=self, stk=[]
-      stk << realm #We don't need to visit the same thing twice.
-      realm.constants.map do |c|
-        next if stk.include?(c = realm.const_get(c)) or not c.is_a? Module
-        a = []
-        a << c if c < ::Maveric::Controller
-        a += nested_controllers c, stk unless c < ::Maveric
-        a
-      end.compact.flatten
-    end
+  # The current instance is stored in the passed environment under the key
+  # 'maveric'. A Rack::Request of the current request is provided at @request.
+  def initialize env
+    env['maveric'] = self
+    @request = Rack::Request.new env
+    @route, @action = self.class.routes.empty? ?
+      [nil, :index] : self.class.routes.find{|(r,d)| r === env['PATH_INFO'] }
+    extend self.class::Helpers
+    self.init_hook if self.respond_to? :init_hook
+  end
+  attr_reader :request, :route, :action
 
-    ##
-    # Sets up a new Maveric with everything it needs for normal
-    # operation. Many things are either copied or included from it's
-    # parent. Models and Views are included by their respective modules.
-    def inherited klass
-      super
-      parent = self
-      klass.class_eval do
-        const_set(:Models, Module.new).
-          module_eval { include parent::Models }
-        const_set(:Views, Module.new).
-          module_eval { include parent::Views }
-        @prepare_env = parent.prepare_env.dup
-      end
-    end
 
-    ##
-    # Actions are kept in an array to maintain running order.
-    #
-    # This is where you'd add environmental preprocessors to a Maveric. Please
-    # note that actions are copied to subclasses at definition time.
-    #
-    # If +action+ is a Symbol and no block is provided, in #prepare_environment,
-    # the corresponding method is called with the environment hash as an 
-    # argument.
-    # If a block is given then that block will be called with the environment
-    # hash as the single argument.
-    #
-    # Additional arguments honored include :test, which should be a Proc that
-    # accepts a single argument. The argument will be the environment
-    # hash and the boolean result of the block will determine if the
-    # action will be run upon the environment.
-    def prepare_env action=nil, opts={}, &block
-      if action.is_a? Symbol
-        @prepare_env << opts.update(:name => action, :run => block)
-      else @prepare_env end
-    end
+  # Will return a 404 type Response if the set action is invalid. Will
+  # generate a new response if a previous one is not cached or +renew+ is true.
+  #
+  # If the response responds to :finish, it will return the result, otherwise
+  # the response itself will be returned.
+  def response renew=false
+    raise Response, 404 unless @action and respond_to? @action
+    @response = __send__ @action if not @response or renew
+  rescue Response
+    warn('Response: '+$!.inspect)
+    @response = $!.to_a
+  rescue
+    warn('Rescue: '+$!.inspect)
+    body = $!.message + "\n\t" + $@[0..10]*"\n\t"
+    @request.env['rack.errors'].puts body
+    body << "\n\t" << $@[11..-1]*"\n\t"
+    @request.env.sort.each{|(k,v)| body << "\n#{k}\n\t#{v.inspect}" }
+    @response = [ 500, {
+      'Content-Type' => 'text/plain',
+      'Content-Length' => body.length.to_s
+    }, body.to_a ]
   end
 
-  ## Alias to Maveric.prepare_env
-  def prepare_env(*a, &b)
-    self.class.prepare_env(*a, &b)
-  end
 
-  ##
-  # Sets @options from +opts+ and initializes @routes.
-  # Adds routes from nested Controllers.
-  def initialize opts={}
-    @options = {:path_prefix => self.class.to_path(true)}
-    @options.update opts
-    @routes = Set.new
-    self.class.nested_controllers.each do |cont|
-      routes = cont.routes
-      routes ||= [[cont.to_path(0).sub(/^#{self.class.to_path(0)}\/?/,'/'),{}]]
-      routes.each {|route,ropts| add_route cont, route, ropts }
-    end
-  end
+  private
 
-  ## Passes arguments to ::Maveric::Route.new and adds the result to @routes.
-  def add_route controller, path, opts={}
-    @routes << ::Maveric::Route.new(controller, path, opts)
-  end
 
-  ##
-  # Returns the first non nil result of Route#match across @routes. Will remove
-  # the option setting of :path_prefix form the beginning of the path.
-  def match path
-    path = path.sub(/^#{@options[:path_prefix]}\/?/, '/') if \
-      @options.key? :path_prefix
-    @routes.eject {|route| route.match path }
+  # Powerhouse method to build a response. TODO: doc
+  def respond *args, &blk
+    headers = Hash === args.last ? args.pop : {}
+    seed = (Symbol === args.last && args.last) ? '' : args.pop
+    views, args = args.reverse.partition{|e| Symbol === e }
+
+    bad = views.map{|e|e.to_s} - self.class::Views.instance_methods
+    raise ArgumentError, 'Invalid views: '+bad.inspect unless bad.empty?
+    warn 'Invalid arguments: '+args.inspect unless args.empty?
+
+    response = Rack::Response.new
+    response.headers.update self.class.headers
+    response.headers.update headers.
+      reject{|(k,v)| !k.is_a? String or !v.is_a? String }
+    response.extend self.class::Views
+    response.instance_variable_set '@maveric', self
+
+    catch :response do
+      yield response if block_given?
+      body = views.inject(seed){|b,v| response.__send__(v,b) }.to_s
+      response.length = Rack::Utils.bytesize body
+      response.body = body.to_a
+      return response.finish
+    end
   end
 
-  ##
-  # Returns the first non nil result of Route#path_to across the subset of
-  # @routes that aim at +controller+.
-  def path_to controller, args={}
-    @routes.eject {|route| route.controller == controller and route.path_to args }
+
+  # Provides a simple way of generating a redirection response, relative to
+  # the current url.
+  def redirect uri
+    uri = URI(uri).normalize
+    uri = URI(@request.url).merge uri
+    [ 303, { 'Location'=>uri.to_s,
+        'Content-Type'=>'text/plain',
+        'Content-Length'=>'0'
+      }, [] ]
   end
 
-  attr_reader :options, :routes
-
-  ##
-  # Maveric's cue to start doing the heavy lifting. +env+ should be
-  # a hash with the typical assignments from an HTTP environment or crying
-  # and whining will ensue. +req_body+ should be an IO compatible instance.
-  def dispatch req_body=$stdin, env=ENV, opts={}
-    begin
-      prepare_environment env unless env.key? :maveric
-      raise RuntimeError, [404, "Page not found."] unless env[:route]
-
-      # If this is a POST request we need to load data from the body
-      if env['REQUEST_METHOD'] =~ /^post$/i
-        params = env.key?(:multipart_boundary) ?
-          parse_multipart(env[:multipart_boundary], req_body) :
-          ::Maveric.query_parse(req_body.read)
-        env[:params].update params
-      end
 
-      env[:route].controller.new(req_body, env, opts)
-    rescue StandardError => e
-      error(e)
-    end
+  def routes_to dest
+    self.class.routes.select{|(r,d)| d === dest }
   end
 
-  ## Override for custom error handling and/or styling.
-  def error err=$!
-    err
-  end
 
-  ##
-  # +env+ should be a normal environment hash derived from HTTP.
-  # Run through actions specified by Maveric.prepare_env in the order stated,
-  # testing env against act[:test] if present to determine if it will be used,
-  # and runs the action on env.
-  def prepare_environment env
-    # DEV-NOTE: This method is seperated from prepare_env, in contrast to
-    # #before and #after in Controller, due to the fact one Maveric instance
-    # exists for each service, rather than for each occurance of env per
-    # request.
-    env.update :maveric => self
-    prepare_env.each do |act|
-      next unless act[:test].nil? or act[:test][env]
-      (act[:run] || method(act[:name]))[env]
-    end
+  def route_to dest
+    routes_to(dest).find{|(r,d)| String === d }
   end
 
-  ### Does this count as magic? No, just defaults.
-  prepare_env :route do |env|
-    env[:route] = env[:maveric].match env['REQUEST_URI']
-  end
 
-  prepare_env :cookies do |env|
-    env[:cookies] = ::Maveric.query_parse env['HTTP_COOKIE'], ';,'
-  end
 
-  prepare_env :params do |env|
-    env[:params]  = ::Maveric.query_parse env['QUERY_STRING']
-  end
+  # Methods provided to construct a maveric
+  module Class
+    # Default headers for Maveric instantiation.
+    attr_reader :routes, :headers
+    attr_writer :mount
+
+    # Scours through './templates', unless provided an alternate directory,
+    # and adds templates and a method to maveric::Views. Currently handles
+    # haml and erb files.
+    def add_templates directory='templates/*'
+      Dir.glob directory do |file| p file
+        next unless File.readable? file               and tmpl = File.read(file)
+        next unless extn = File.extname(file)         and not extn.empty?
+        next unless name = File.basename(file, extn)  and not name.empty?
+        view = case extn
+        when '.haml'
+          require 'haml' rescue next
+          puts "Defining HAML template view " + name.inspect
+          haml = Haml::Engine.new tmpl
+          proc{|content| haml.render self, :content => content }
+        when '.erb'
+          require 'erb' rescue next
+          puts "Defining ERB template view " + name.inspect
+          erb = ERB.new tmpl
+          erb.filename = file
+          proc{|content| erb.result(binding) }
+        else
+          puts "Defining sprintf template view " + name.inspect
+          proc{|content| sprintf self, content }
+        end
 
-  prepare_env :multipart_detect do |env|
-    if not env.key? :multipart_boundary \
-      and env['REQUEST_METHOD'] =~ /^post$/i \
-      and env['CONTENT_TYPE'] =~ MP_BOUND_REGEX
-      env[:multipart_boundary] = $1
+        self::Views::TEMPLATES[name] = view
+        self::Views.__send__ :define_method, name, &view
+      end
     end
-  end
 
-  ## Holds views related methods and helpers.
-  module Views
-    def _ content; content; end
+    # Instantiates a maveric with the provided environment, then calls
+    # maveric#response
+    def call env
+      new(env).response
+    end
 
-    def raw_file filename
-      File.read(filename)
+    def routing mountpoint, routes
+      @mount = mountpoint
+      routes.each{|d,a| route d, *a }
     end
 
-    def sprintf_file filename, *params
-      raw_file(filename) % [*params]
+    def route d, *a
+      a.flatten.each{|r| @routes << [r, d] }
     end
 
-    def erubis_file filename, binding
-      require 'erubis'
-      ::Erubis::Eruby.new(raw_file(filename)).result(binding)
+    def mount
+      @mount || self.name.downcase.gsub(/^|::/, '/')
     end
 
-    def path_to controller, args={}
-      @env[:maveric].path_to controller, args
+    def self.extend_object obj
+      obj.instance_variable_set '@routes',  []
+      obj.instance_variable_set '@headers', Rack::Utils::HeaderHash.new
+      super
     end
-  end
 
-  ## Repository for models. Still not really utilized.
-  module Models
+    def inspect
+      "#{self.name}:'#{mount}':#{routes.inspect}"
+    end
   end
-end
 
-##
-# Controllers are the classes that do the actual handling and processing of
-# requests. The number of normal methods is kept low to prevent clobbering by
-# user defined methods.
-#
-# === Placing a Controller
-#
-# They may be defined in any location, but if they are defined in a nested
-# location within the Maveric class being used to serve at a particular
-# location, on instantialization of the Maveric they will automatically
-# be added at either the routes specified in their class definition or
-# at the default route which is derived from their name and their nesting.
-#
-# === Working in Controller
-#
-# Within an instance of Controller: @env contains the environment hash; @in
-# contains the request body, and @cookies contains a hash of cookie values.
-#
-# In addition @status, @header, and @body may be set to appropriate values
-# for the response. Note that @headers should be a Hash, @status should be an
-# Integer corresponding to a real HTTP status code, and @body should contain
-# a String.
-#
-# The instance variable @action contains a Symbol corresponding to the
-# Controller method being called. The result of this call is assigned to
-# @body.
-#
-# Those are the only instance variables you should be warned against playing
-# with frivously. All instance variables are initially assigned before the
-# before actions have been run, with the exception of @body which is set
-# after @action is called.
-#
-# It's recommended all work be done within methods of Controller, rather than
-# overriding the inherited methods of Controller, but really it's up to you.
-#
-# NOTE: Due to the extension of the Controller instance by the View and Models
-# modules of the operating Maveric, one must take care not to overlap method
-# names. I hope to remove this 'feature' in a future version.
-class Maveric::Controller
-  REQUEST_METHODS = [:post, :get, :put, :delete, :head] # CRUDY
-  @before = []
-  @after = []
 
+
+  @maverics = [] unless defined? @maverics
+  @last_hash = nil
+  @map = nil
   class << self
-    ## Family is important.
-    def inherited klass
-      parent = self
-      klass.class_eval do
-        @before = parent.before.dup
-        @after = parent.after.dup
-        @routes = []
-      end
+    attr_reader :maverics
+
+    def inspect
+      "Maveric#{maverics.inspect}"
     end
 
-    ## Removes currently set routes and adds the stated ones.
-    def set_routes r, o={}
-      clear_routes
-      [r].flatten.map{|e| add_route e, o }
+    # Generates a Rack::URLMap compatible hash composed of all maverics and
+    # their mount points. Will be regenerated if the list of maverics have
+    # changed.
+    def map
+      return @map if @map and @last_hash == @maverics.hash
+      @last_hash = @maverics.hash
+      @map = @maverics.inject({}) do |h,m|
+        h.store m.mount, m
+        h
+      end
     end
 
-    ## Add a route to the Controller.
-    def add_route r, o={}
-      # As each route may have its own specific options, we need to hold them
-      # seperately so we don't clobber.
-      @routes << [r, o]
+    # Generates a Rack::URLMap from the result of Maveric.map
+    def urlmap
+      return @urlmap if @urlmap and @last_hash == @maverics.hash
+      @urlmap = Rack::URLMap.new self.map
     end
 
-    ## Removes all currently set routes.
-    def clear_routes
-      @routes.clear
+    # Maps to a call to the result of Maveric.urlmap
+    def call env
+      self.urlmap.call env
     end
 
-    ## Unless routes have been set for this Controller, #routes returns nil.
-    def routes
-      return nil if @routes.empty?
-      @routes
+    # Returns itself, or a Rack::Cascade when provided an app
+    def new app=nil
+      return self unless app
+      Rack::Cascade.new [app, self]
     end
 
-    ##
-    # If no arguments are given, the array of actions is returned. The first
-    # argument should be a Symbol and should be the name of the action.
-    #
-    # If the second argument is omitted or a collection of hashed options,
-    # then an action is added to the array of actions with +action+ as its
-    # name. If a block is provided it will be run, else the controller instance
-    # method of the same name of the action will be run.
-    # For conditional execution of the action you may provide a list of what
-    # actions it should exclusively run on or not run on, via :only and
-    # :exclude respectively.
+    # When a maveric is subclassed, the superclass' headers inherited. Views
+    # and Helpers modules are also included into the subclass' corresponding
+    # modules.
     #
-    # If the second argument is an instance of Controller then the actions are
-    # conditionally, on the basis of :only and :exclude lists, run on the
-    # controller.
+    # By default, the first class to inherit from Maveric is assigned the mount
+    # point of '/'.
     #
-    # NOTE: If you are referencing instance variables within the action,
-    # it is recommended that you create a method rather than a block. Unless
-    # you want to do instance_eval fun, but anyways.
-    def before action=nil, opts={}, &block
-      if action.is_a? Symbol
-        if opts.is_a? ::Maveric::Controller
-          @before.each do |act|
-            next unless (act[:only].nil? or act[:only].include? action) \
-              and (act[:exclude].nil? or not act[:exclude].include? action)
-            (act[:run] || controller.method(act[:name]))[opts]
-          end
-        else # opts should be a Hash
-          opts[:only] = [*opts[:only]] if opts.key? :only
-          opts[:exclude] = [*opts[:exclude]] if opts.key? :exclude
-          @before << opts.update(:name => action, :run => block)
-        end
-      else @before end
+    # A maveric's default mount point is by default derived from it's full
+    # name. For example: Object would be '/object', Module would be '/module',
+    # and Rack::Auth::OpenID would be '/rack/auth/openid'.
+    def included obj
+      super
+      obj.extend Maveric::Class
+      %w'Helpers Views'.each do |name|
+        next if obj.const_defined?(name)
+        obj.const_set(name, Module.new).
+          instance_eval{ include Maveric.const_get(name) }
+      end
+      obj.mount = '/' if @maverics.empty?
+      @maverics << obj
     end
 
-    ##
-    # If no argument is given, the array of actions is returned.
-    #
-    # If a Symbol or String is given with no block, during Controller
-    # initialization after the action is called, the corresponding
-    # method is called with the Controller instance as an argument.
-    # If a block is given, the block is called with the controller
-    # instance as an argument instead.
-    #
-    # Additional arguments include :only and :exclude, whose values should
-    # be a Symbol or an Array of such that correspond with actions that
-    # they should only run on or not run on.
-    #
-    # NOTE: If you are referencing instance variables within the action,
-    # it is recommended that you create a method rather than a block.
-    def after action=nil, opts={}, &block
-      if action.is_a? Symbol
-        if opts.is_a? ::Maveric::Controller
-          @after.each do |act|
-            next unless (act[:only].nil? or act[:only].include? action) \
-              and (act[:exclude].nil? or not act[:exclude].include? action)
-            (act[:run] || controller.method(act[:name]))[opts]
-          end
-        else # opts should be a Hash
-          opts[:only] = [*opts[:only]] if opts.key? :only
-          opts[:exclude] = [*opts[:exclude]] if opts.key? :exclude
-          @after << opts.update(:name => action, :run => block)
-        end
-      else @after end
+    def extend_object obj
+      warn 'Maveric should only be included.'
+      return obj
     end
   end
 
-  ## Alias to Controller.before
-  def before(*a, &b)
-    self.class.before(*a, &b)
-  end
 
-  ## Alias to Controller.after
-  def after(*a, &b)
-    self.class.before(*a, &b)
-  end
 
-  ##
-  # Within the initialization of controller, resulting in the object returned
-  # by the call to Maveric#dispatch, you are the busy bee. This hive has several
-  # instance variables which are set down for you to derive all the information
-  # you might need.
+  # Response is an Exception class that can be raised from within a call to
+  # maveric#response, with 401, 403, and 404 errors provided.
+  #
+  # <tt>raise Maveric::Response, 404</tt> will look up 404 via Response#[] and
+  # if a value is found, it is utilized to set the status, headers, and body.
   #
-  # * @env contains the HTTP environment hash with the special keys of:
-  #   * :maveric, who's value is the Maveric instance the request has called upon
-  #   * :route, which contains a struct instance which was returned by
-  #     Route#match that helped us get here.
-  #   * :params, containing a hash of QUERY_STRING data. If REQUEST_METHOD
-  #     is 'post' then parameter data from the request bod is overlayed.
-  #   * :cookies, which contains hashed data parsed from HTTP_COOKIE.
-  #   * plugins or extensions to Maveric may add other special hash pairs
-  #     to @env, such as :session, by 'maveric/sessions'.
-  # * @cookies contains a hash
-  #   header. If you plan on adding or altering cookie data, do it here.
-  # * @in contains a reference to the input stream of the http request. Note that
-  #   if REQUEST_METHOD is 'post' then it has probably already been read.
-  # * @action is the controller instance method to be called. The returned
-  #   value of the call should be a string, which will be assigned to @body.
-  # * @status, by default is 200. And @headers, which by default only sets
-  #   Content-Type to 'text/html'.
+  # <tt>raise Maveric::Response, 'Bad stuff'</tt> will generate a plain-text
+  # 500 response with the message as the body of the response.
   #
-  # By the time the Controller.new is done running, it will have @status,
-  # @headers, and @body set. @status should be an Integer matching the
-  # http status code, @headers a string keyed hash of http headers, and @body
-  # to a string of the http response body.
-  def initialize req_body=$stdin, env=ENV, opts={}
-    @status, @headers = 200, {'Content-Type'=>'text/html'}
-    @env, @in = env, req_body
-    @cookies = @env[:cookies].dup
-
-    if @env[:maveric]
-      extend @env[:maveric].class::Models
-      extend @env[:maveric].class::Views
+  # Additional or replacement responses should be set via Response#[]= and
+  # should be valid rack responses.
+  class Response < Exception
+    DEFAULT, @r = [500, 'text/plain'], {}
+    def self.[] e; @r[e]; end
+    def self.[]= e, v; @r[e]=v; end
+    def initialize err
+      resp = Response[err] || [ DEFAULT[0],
+        { 'Content-Type' => DEFAULT[1], 'Content-Length' => err.length.to_s },
+        err]
+      @status, @headers, @body = resp
+      super @body
     end
-
-    action ||= @env[:route].action rescue nil
-    action ||= @env[:route].route.opts[:default_action] rescue nil
-    action ||= @env['REQUEST_METHOD'].downcase rescue nil
-    action ||= 'get'
-    @action = action.to_sym
-
-    before @action, self
-    @body = __send__ @action
-    after @action, self
-  end
-
-  attr_reader :status, :headers, :body
-
-  ## A simple way to retrive pertinant data
-  def to_a # to_splat in 1.9
-    [@status, @headers, @body]
-  end
-
-  ## For quick and raw response outputting!
-  def to_http raw=true
-    response = if not raw then 'Status:'
-      elsif @env and @env.key? 'HTTP_VERSION' then @env['HTTP_VERSION']
-      else 'HTTP/1.1' end
-    response += " #{self.status}" + ::Maveric::EOL # Status message? :/
-    response << self.headers.map{|k,v| "#{k}: #{v}" }*::Maveric::EOL
-    response << ::Maveric::EOL*2 + self.body
+    def each; @body.each{|line| yield line }; end
+    def to_a; [@status, @headers, self]; end # to_splat in 1.9
+    alias_method :finish, :to_a
   end
+end
 
-  private
 
-  ##
-  # This is a simple method, really. The only confusing part is the expressions
-  # just above the return. Controller#render calls itself. That is all.
-  def render view, s=''
-    s = yield s if block_given?
-    raise ArgumentError, "The View #{view.inspect} not defined." unless \
-      respond_to? view
-    s = __send__ view, s
-    s = render :layout, s unless view.to_s[/^(_|layout$)/] \
-      or caller.any?{|l| l=~/`render'/ } # i don't like this but it works
-    return s
-  end
 
-  ## Provides a better error report if the method is a standard http method.
-  def method_missing m, *a, &b
-    raise NoMethodError, [503, "#{m} not implemented.", nil, @env] if \
-      REQUEST_METHODS.include? m
-    super
+class Rack::Request
+  # Allows the request to provide the current maveric.
+  def maveric; @env['maveric']; end
+  # Provides the compliment to #fullpath.
+  def site_root
+    url = scheme + "://" + host
+    url << ":#{port}" if \
+      scheme == "https" && port != 443 || \
+      scheme == "http"  && port != 80
+    url
   end
-
-  ##
-  # Folds the datasets of @cookie to @headers if they have been altered or
-  # are new.
-  def cookies_fold controller
-    @cookies.each do |k,v|
-      next unless v != @env[:cookies][k]
-      @headers['Set-Cookie'] << "#{k}=#{URI.decode(v)}"
-    end
-  end
-
-  after :cookies_fold
+  def url; site_root + fullpath; end
 end
 
-##
-# Encapsulating route functionality into a single class.
-#
-# Route instances are typically stored in a Maveric instance and used
-# for matching incoming paths to controllers. After a #match is made
-# the resulting Struct instance has members consisting of the parameters
-# of the seed path, as well as struct[:controller] pointing to the
-# destination Controller and struct[:route] pointing to the Route
-# instance itself.
-class Maveric::Route
-  ## A negative class of URI delimiting and reserved characters.
-  URI_CHAR = '[^/?:,&#]'
-  ## Standard pattern for finding parameters in provided paths.
-  PARAM_MATCH= %r~:(#{URI_CHAR}+):?~
-
-  ##
-  # Builds a regex and respective param list from path by parsing out
-  # fragments matching PARAM_MATCH and replacing them with either a
-  # corresponding symbol from the opts hash or the default regex.
-  #
-  # The final Route instance is utilized to build paths and match
-  # absolute paths for routing.
-  def initialize controller, path, opts={}
-    @controller = controller
-    @path = path.dup.freeze
-    params = []
-    regex = @path.gsub PARAM_MATCH do
-      params << param = $1.to_sym
-      "(#{opts[param] || URI_CHAR+'+'})"
-    end
-    raise ArgumentError, "Duplicated parameters in path."+
-      " <#{params.inspect}>" if params.size != params.uniq.size
-    @struct = Struct.new(:route, :controller, *params)
-    @regex = /\A#{regex}\z/.freeze
-    @opts = opts.reject{|k,v| !params.include? k }.freeze
-  end
 
-  attr_reader :path, :regex, :opts, :struct, :controller
 
-  ##
-  # Matches the Route's regex against path, returning a Struct instance
-  # of the resulting data, or nil.
-  def match path
-    @regex =~ path and @struct.new(self, @controller, *$~.captures)
-  end
-
-  ##
-  # Returns nil unless all parameters are included in args, preventing the
-  # creation of incomplete paths, otherwise returns a path string.
-  def path_to args
-    return nil unless @opts.keys.sort == args.keys.sort
-    args.inject(@path){|u,(k,v)| u.sub(/#{k.inspect}:?/, v.to_s) }
-  end
-end
+Maveric::Response[401] = [401,
+  {'Content-Type'=>'text/plain','Content-Length'=>'13'},
+  ['Unauthorized.']]
+Maveric::Response[403] = [403,
+  {'Content-Type'=>'text/plain','Content-Length'=>'15'},
+  ['Not authorized.']]
+Maveric::Response[404] = [404,
+  {'Content-Type'=>'text/plain','Content-Length'=>'10'},
+  ['Not Found.']]