maveric 0.3.1 → 0.4.0

data/lib/maveric.rb

@@ -3,34 +3,33 @@
 #
 # == Resources
 #
-# Maveric can normally be found on {rubyforge}[http://maveric.rubyforge.org/]
-# with it's project page {here}[http://rubyforge.org/projects/maveric/].
+# 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.
-#
-# Maveric's home away from home is http://code.stadik.net which contains
-# many other things.
+# behind rubyforge in terms of updates.
 #
 # == Version
 #
-# This is 0.1.0, the first real release of Maveric. It's rough around the edges
-# and several squishy bits in the middle. At the moment it's still operation
-# conceptualization over algorithm implementation. It's usable, but kinda.
+# 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.
 #
-# Ahh, 0.2.0, wherein we reevaluate ourselves and our ways and eliminate the
-# cruft and improve our efficiency. We have a new implementation of Route
-# going on, they're now regexps. The ServerError class has been removed, now any
-# subclass of Exception can be raised. One of the larger differences is greater
-# customization of Maveric and Controller instances through extending methods.
-# These are touched upon in their respective docs. Have fun!
+# 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.
 #
-# I was hoping for a 0.2.1 with refined documentation, updated plugins, and a
-# better execution path. Instead I got all of that as well as altering basic
-# implementation details and adding pre and post processors for Controller and
-# refinment of Maveric's. With the degree of changes we get 0.3.0! Nothing
-# but good stuff yo.
+# Check other documentation for a full list of changes.
 #
 # == Authors
 #
@@ -84,26 +83,17 @@
 # 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 0.2.0 which will hopefully
-# be all that I want. Everything beyond 1.0.0 will be improvements and
+# 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.
 #
-# = Features
-# * Optional sessions
-# * Flexible and strong route setup
-# * Sharing of a Controller between Maveric instances is facilitated
-# * Inheritance is highly respected
-#
 # == Not so Maveric
 #
-# Maveric has additional classes to allow you to run Maveric behind different
+# 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.
 #
-# NOTE: Beyond Maveric 0.1.0 extensions have not been touched, future releases
-# should include updates. AFAIK they should work.
-#
 # For these examples we will utilize the simplest functional Maveric possible
 #   require 'maveric'
 #   class Maveric::Index < Maveric::Controller
@@ -112,34 +102,29 @@
 #     end
 #   end
 #
-# To use CGI:
-#   Maveric.new.dispatch.to_s
+# To use CGI: (not cgi.rb)
+#   puts Maveric.new.dispatch.to_s
 #
 # To use FastCGI:
 #   require 'maveric/fastcgi'
-#   ::Maveric::FCGI.new(MyMaveric)
+#   ::Maveric::FCGI(MyMaveric.new)
 #
 # To use Mongrel:
 #   require 'maveric/mongrel'
 #   h = ::Mongrel::HttpHandler ip, port
-#   h.register mountpoint, ::Maveric::MongrelHandler.new(MyMaveric)
+#   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.
-#   ::Maveric::FCGI.new(MyMaveric, :path_prefix => mountpoint
-#   h.register mountpoint, ::Maveric::MongrelHandler.
-#     new(MyMaveric, :path_prefix => mountpoint)
+#   mav = MyMaveric.new :path_prefix => mountpoint
+#   ::Maveric::FCGI(mav)
+#   h.register mountpoint, mav
 #
 # --------------------------------
-#
-# NOTE: Due to rampant debugging and benchmarking there is a plethora of
-# pointless time checks in place. Anything greater than the WARN level on the
-# logging output tends to output a good deal of information. DEBUG is not for
-# the meek.
-require 'log4r'
-require 'stringio'
+require 'uri'
+require 'set'
 require 'maveric/extensions'
 
 ##
@@ -150,45 +135,17 @@ require 'maveric/extensions'
 # trickery.
 class Maveric
   ## Implementation details.
-  VERSION='0.3.1'
-
+  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.
-  @adj_env = []
+  @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
-
-    ## Builds a logging object if there's not one yet, then returns it.
-    def log
-      unless defined? @@maveric_logger
-        @@maveric_logger = Log4r::Logger.new 'mvc'
-        @@maveric_logger.outputters = Log4r::Outputter['stderr']
-        @@maveric_logger.level = Log4r::INFO
-        @@maveric_logger.info "#{self} #{::Maveric::VERSION}"+
-          " integrated at #{Time.now}"
-      end
-      @@maveric_logger
-    end
-
-    ## Performs URI escaping.
-    def escape(s)
-      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
-        '%'+$1.unpack('H2'*$1.size).join('%').upcase
-      }.tr(' ', '+')
-    end
-
-    ## Unescapes a URI escaped string.
-    def unescape(s)
-      s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
-        [$1.delete('%')].pack('H*')
-      }
-    end
-
     ##
     # Parses a query string by breaking it up around the
     # delimiting characters.  You can also use this to parse
@@ -198,8 +155,8 @@ class Maveric
     # 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(Hash.new([])) { |h,p|
-        k, v = unescape(p).split('=',2)
+      (qs||'').split(/[#{delim}] */n).inject({}) { |h,p|
+        k, v = URI.decode(p).split('=',2)
         (h[k]||=[]) << v
         h
       }
@@ -211,12 +168,11 @@ class Maveric
     #
     # Might need to be rehauled to match query_parse's behaviour.
     def parse_multipart boundary, body
-      ::Maveric.type_check :body, body, IO, StringIO
       values = {}
       bound = /(?:\r?\n|\A)#{Regexp::quote('--'+boundary)}(?:--)?\r$/
       until body.eof?
         fv = {}
-        until body.eof? or /^#{EOL}$/=~l
+        until body.eof? or /^#{EOL}$/ =~ l
           case l = body.readline
           when /^Content-Type: (.+?)(\r$|\Z)/m
             fv[:type] = $1
@@ -225,59 +181,42 @@ class Maveric
           end
         end
 
-        o = unless fv[:filename] then ''
-          else fv[:tempfile] = Tempfile.new('MVC').binmode end
-        body.inject do |buf,line|
+        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
+        end # Merb and Camping do it faster.
 
         fv[:tempfile].rewind if fv.key? :tempfile
         values[fv[:name]] = fv.key?(:filename) ? fv : o
       end
-      body.rewind
+      body.rewind rescue nil # FCGI::Stream fun.
       values
     end
 
-    ##
-    # I have a penchant for static typing, so as a general assertion
-    # and insurance that the correct types of data are being passed I created
-    # this little checking method. It will test value to be an instance of
-    # any of the trailing class, or if the block provided evalutates as true.
-    def type_check name, value, *klasses, &test
-      return unless $DEBUG
-      # order of speed: #include?, #index, #any?
-      if i = klasses.any?{|k|value.is_a? k} then return i
-      elsif test and r = test[value] then return r
-      else
-        raise TypeError, "Expected #{klasses*' or '} for #{name},"+
-          " got #{value.class}:#{value.inspect}."
-      end
-    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
+        a += nested_controllers c, stk unless c < ::Maveric
+        a
       end.compact.flatten
     end
 
     ##
     # Sets up a new Maveric with everything it needs for normal
     # operation. Many things are either copied or included from it's
-    # parent The logger is copied and Models and Views are included by
-    # their respective modules.
+    # parent. Models and Views are included by their respective modules.
     def inherited klass
-      ::Maveric.log.info "#{klass} inherits from #{self}."
       super
       parent = self
       klass.class_eval do
@@ -285,117 +224,134 @@ class Maveric
           module_eval { include parent::Models }
         const_set(:Views, Module.new).
           module_eval { include parent::Views }
-        @adj_env = parent.adjust_env.dup
+        @prepare_env = parent.prepare_env.dup
       end
     end
 
     ##
-    # If no argument is given, the array of actions is returned.
-    # 
-    # If a Symbol or String is given with no block, in prepare_env, the
-    # corresponding method is called with the environment hash as an argument.
-    # If a block is given then, in prepare_env, that block will be called
-    # with the environment hash as the single argument.
+    # 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 you are specifying other options you must explicitly state 
-    # :name => <chosen label> as an argument.
-    # Additional arguments include :test, which should be a Proc that
+    # 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
-    # block will run.
-    def adjust_env act={}, &block
-      ::Maveric.type_check :act, act, Hash, Symbol, String
-      return @adj_env if act.is_a? Hash and act.empty?
-      act = {:name => act} unless act.is_a? Hash
-      act[:do] = block
-      @adj_env << act
+    # 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
   end
 
+  ## Alias to Maveric.prepare_env
+  def prepare_env(*a, &b)
+    self.class.prepare_env(*a, &b)
+  end
+
   ##
-  # When instantiated, the Maveric decends through its constants for
-  # nested Controllers and adds them by their routes.
+  # Sets @options from +opts+ and initializes @routes.
+  # Adds routes from nested Controllers.
   def initialize opts={}
-    ::Maveric.log.info "#{self.class} instantiated at #{Time.now}"
-    ::Maveric.type_check :opts, opts, Hash
-    @options = {:path_prefix => '/'}.merge opts
-    @router = ::Maveric::Router.new
-    self.class.nested_controllers.each {|c| router.add c.routes, c }
+    @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
+
+  ## 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 }
   end
 
-  attr_reader :options, :router
+  ##
+  # 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 }
+  end
+
+  attr_reader :options, :routes
 
   ##
-  # Maveric's cue to start doing the heavy lifting. The env should be
+  # 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. The req_body argument should be a StringIO.
-  def process req_body=$stdin, env=ENV, opts={}
-    ::Maveric.log.info "#{self.class}#process\n  "+
-      "[#{Time.now}] #{env['REMOTE_ADDR']} => #{env['REQUEST_URI']}"
-    ::Maveric.type_check :req_body, req_body, StringIO
-    ::Maveric.type_check :env, env, Hash
+  # 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
-        env[:params].update env.key?(:multipart_boundary) ?
+        params = env.key?(:multipart_boundary) ?
           parse_multipart(env[:multipart_boundary], req_body) :
           ::Maveric.query_parse(req_body.read)
+        env[:params].update params
       end
 
-      unless env[:route][:controller] < ::Maveric::Controller
-        raise TypeError, "Route Controller of "+
-          "#{env[:route][:controller].class}. Expecting ::Maveric::Controller."
-      end
-
-      env[:route][:controller].new req_body, env, opts
-    rescue # we catch exception.is_a? StandardError
-      ::Maveric.log.error "#{Time.now}:\n#{$!.inspect}\n#{$!.backtrace*"\n"}"
-      begin
-        raise $! # this makes sense in a certain context...
-        # Here is where we should have transformational stuffs for accessorizing
-        # or customizing error pages. As long as someone doesn't get stupid
-        # about it.
-      rescue
-        return $!
-      end
+      env[:route].controller.new(req_body, env, opts)
+    rescue StandardError => e
+      error(e)
     end
   end
 
+  ## Override for custom error handling and/or styling.
+  def error err=$!
+    err
+  end
+
   ##
-  # The env argument should be a normal environment hash derived from HTTP.
+  # +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
-    ::Maveric.type_check :env, env, Hash
+    # 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
-    self.class.adjust_env.select do |act|
-      act[:test].nil? or act[:test][env]
-    end.each do |act|
-      ::Maveric.log.debug "#{self.class} prep_env #{act[:name]}"
-      if act[:do]
-        act[:do].call env
-      else
-        __send__ act[:name], env
-      end
+    prepare_env.each do |act|
+      next unless act[:test].nil? or act[:test][env]
+      (act[:run] || method(act[:name]))[env]
     end
   end
 
   ### Does this count as magic? No, just defaults.
-  adjust_env :route do |env|
-    url = ::Maveric.unescape env['REQUEST_URI']
-    env[:route] = env[:maveric].router[url]
+  prepare_env :route do |env|
+    env[:route] = env[:maveric].match env['REQUEST_URI']
   end
 
-  adjust_env :cookies do |env|
-    env[:cookies] = ::Maveric.query_parse env['HTTP_COOKIE'], ';,' 
+  prepare_env :cookies do |env|
+    env[:cookies] = ::Maveric.query_parse env['HTTP_COOKIE'], ';,'
   end
 
-  adjust_env :params do |env|
+  prepare_env :params do |env|
     env[:params]  = ::Maveric.query_parse env['QUERY_STRING']
   end
 
-  adjust_env :multipart_detect do |env|
+  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
@@ -403,17 +359,29 @@ class Maveric
     end
   end
 
-  ##
-  # Holds views related methods and helpers
+  ## Holds views related methods and helpers.
   module Views
-    def path_to c, a={}
-      ::Maveric.log.info "#{self.class}#path_to #{c} #{a.inspect}"
-      @env[:maveric].router.to(c).eject{|r| r.build a }
+    def _ content; content; end
+
+    def raw_file filename
+      File.read(filename)
+    end
+
+    def sprintf_file filename, *params
+      raw_file(filename) % [*params]
+    end
+
+    def erubis_file filename, binding
+      require 'erubis'
+      ::Erubis::Eruby.new(raw_file(filename)).result(binding)
+    end
+
+    def path_to controller, args={}
+      @env[:maveric].path_to controller, args
     end
   end
 
-  ##
-  # Repository for models. Still not really utilized.
+  ## Repository for models. Still not really utilized.
   module Models
   end
 end
@@ -442,13 +410,20 @@ end
 # a String.
 #
 # The instance variable @action contains a Symbol corresponding to the
-# Controller method to be called. The result of this call is assigned to
+# 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 = []
@@ -459,380 +434,265 @@ class Maveric::Controller
     def inherited klass
       parent = self
       klass.class_eval do
-        @routes = []
         @before = parent.before.dup
         @after = parent.after.dup
+        @routes = []
       end
     end
-    
+
     ## Removes currently set routes and adds the stated ones.
     def set_routes r, o={}
-      ::Maveric.type_check :r, r, String, Array
       clear_routes
-      r = [r] unless r.is_a? Array
-      r.flatten.map{|e| add_route e }
+      [r].flatten.map{|e| add_route e, o }
     end
-    
+
     ## Add a route to the Controller.
     def add_route r, o={}
-      ::Maveric.type_check :r, r, String, ::Maveric::Route
-      r = ::Maveric::Route.new r, o if r.is_a? String
-      @routes << r
+      # As each route may have its own specific options, we need to hold them
+      # seperately so we don't clobber.
+      @routes << [r, o]
     end
 
     ## Removes all currently set routes.
     def clear_routes
       @routes.clear
     end
-    
-    ## Returns a default Route based on the #nesting_path if no routes.
+
+    ## Unless routes have been set for this Controller, #routes returns nil.
     def routes
-      @routes.empty? ?
-        ::Maveric::Route.new(nesting_path) :
-        @routes
+      return nil if @routes.empty?
+      @routes
     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 before 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.
+    # 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 you are specifying other options, you must explicitly state 
-    # :name => <chosen label> as an argument.
-    # 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.
+    # 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.
+    #
+    # 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.
     #
     # NOTE: If you are referencing instance variables within the action,
-    # it is recommended that you create a method rather than a block.
-    def before act={}, &block
-      ::Maveric.type_check :act, act, Hash, Symbol, String
-      return @before if act.is_a? Hash and act.empty?
-      act = {:name => act} unless act.is_a? Hash
-      act[:do] = block
-      act[:only]=[*act[:only]] if act.key? :only
-      act[:exclude]=[*act[:exclude]] if act.key? :exclude
-      @before << act
+    # 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
     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 
+    #
+    # 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.
     #
-    # If you are specifying other options, you must explicitly state 
-    # :name => <chosen label> as an argument.
     # 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 act={}, &block
-      ::Maveric.type_check :act, act, Hash, Symbol, String
-      return @after if act.is_a? Hash and act.empty?
-      act = {:name => act} unless act.is_a? Hash
-      act[:do] = block
-      act[:only]=[*act[:only]] if act.key? :only
-      act[:exclude]=[*act[:exclude]] if act.key? :exclude
-      @after << act
+    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
     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
+
   ##
-  # Main processing method of Controller.
+  # 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.
   #
-  # The response body is set with the result of the specified action method
-  # if the result is a String and @body has not been set to a String. The
-  # action method is determined respectively by env[:route][:action],
-  # REQUEST_METHOD in downcased form, or 'get' by default.
+  # * @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'.
   #
-  # By the time the Controller.new is done running, it should have @status,
+  # 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={}
-    ::Maveric.log.warn "Provided env has not been properly processed, results "+
-      "may vary!" unless ([:maveric, :route, :params, :cookies]-env.keys).empty?
-    ::Maveric.type_check :req_body, req_body, StringIO, IO
-    ::Maveric.type_check :env, env, Hash
-    ::Maveric.type_check :opts, opts, Hash
-
     @status, @headers = 200, {'Content-Type'=>'text/html'}
     @env, @in = env, req_body
     @cookies = @env[:cookies].dup
 
-    action ||= @env[:route][:action] rescue nil
+    if @env[:maveric]
+      extend @env[:maveric].class::Models
+      extend @env[:maveric].class::Views
+    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
 
-    ::Maveric.log.debug "#{self.class} action #{@action.inspect}"
-
-    self.class.before.select do |act|
-      (act[:only].nil? or act[:only].include? @action) and \
-      (act[:exclude].nil? or not act[:exclude].include? @action)
-    end.each do |act|
-      ::Maveric.log.debug "#{self.class} before #{act[:name]}"
-      if act[:do]
-        act[:do].call self
-      else
-        __send__ act[:name], self
-      end
-    end
-
-    raise NoMethodError, [503, "#{@action} not implemented.", nil, @env] if \
-      REQUEST_METHODS.include? @action and not respond_to? @action
+    before @action, self
     @body = __send__ @action
-
-    self.class.after.select do |act|
-      (act[:only].nil? or act[:only].include? @action) and \
-      (act[:exclude].nil? or not act[:exclude].include? @action)
-    end.each do |act|
-      ::Maveric.log.debug "#{self.class} after #{act[:name]}"
-      if act[:do]
-        act[:do].call self
-      else
-        __send__ act[:name], self
-      end
-    end
-
-    ::Maveric.log.debug self # omg, masochistic.
+    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
-    response = "Status: #{@status}" + ::Maveric::EOL # Status message? :/
-    response << @headers.map{|k,v| "#{k}: #{v}" }*::Maveric::EOL
-    response << ::Maveric::EOL*2 + @body
+  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
   end
 
   private
 
   ##
-  # TODO: Doc me. ehird is confused
-  #
   # 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=''
-    ::Maveric.log.debug "#{self.class}#render"+
-      " #{view.inspect}, #{s[0..100].inspect}"
-    ::Maveric.type_check :view, view, Symbol, String
-    ::Maveric.type_check :s, s, String
     s = yield s if block_given?
-    s = __send__ view, s if respond_to? view
+    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
+      or caller.any?{|l| l=~/`render'/ } # i don't like this but it works
     return s
   end
 
-  ##
-  # Standard Controller setup.
-  #
-  # Extends the Controller instance with the Views and Models modules of the
-  # pertinant Maveric instance.
-  def setup controller
-    controller.extend @env[:maveric].class::Models
-    controller.extend @env[:maveric].class::Views
+  ## 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
   end
 
   ##
-  # Standard Controller cleanup.
-  #
   # Folds the datasets of @cookie to @headers if they have been altered or
   # are new.
-  def cleanup controller
+  def cookies_fold controller
     @cookies.each do |k,v|
       next unless v != @env[:cookies][k]
-      @headers['Set-Cookie'] << "#{k}=#{::Maveric.escape(v)}"
+      @headers['Set-Cookie'] << "#{k}=#{URI.decode(v)}"
     end
   end
 
-  before :setup
-  after :cleanup
+  after :cookies_fold
 end
 
 ##
-# Instances of Route are used for determining how to act upon particular urls
-# in each Maveric instance. They are magical and simply complex creatures.
-# The Route class was inspired by Merb's implementation, which in turn were
-# inspired by Rails. One thing I think Rails has done nicely, to a point.
-#
-# The String path is turned into a Regexp in a very straight-forward manner.
-# Fragments of the path that begin with ':' followed by any number of
-# characters that aren't a typical URI delimiter or reserved character, and
-# optionally ending with another ':', are indicators of paramæters. The
-# trailing ':' is useful if the parameter occurs within a string of similar
-# characters.
-#
-# Parameters are replaced by default with the regexp of /(#{URI_CHAR}+)/ in
-# the final Route. If a parameter symbol matches a key in the opts hash the
-# associated value is placed into the Route instead.
-#
-class Maveric::Route < Regexp
+# 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}+):?~
 
-  # NOTE: The following examples shows a return value of the equivalent regexp
-  # and not the result of Route#inspect.
-  #
-  #   Route.new '/'
-  #     => /^\/$/                # with no groups or derived values
-  #   Route.new '/:value'
-  #     => /^\/([^/?:,&#]+)$/    # with group 1 assigned to :value
-  #   Route.new '/:val:ue'
-  #     => /^\/([^/?:,&#]+)ue$/ # with group 1 assigned to :val
-  #   Route.new '/:value', :value => 'print|find'
-  #     => /^\/(print|find)$/
-  #   Route.new '/:whtevr', :whtevr => '.*'
-  #     => /^\/(.*)$/            # if you want a real catch-all
-  def initialize path, opts={}
-    ::Maveric.type_check :path, path, String
-    ::Maveric.type_check :opts, opts, Hash
-
-    @path = path.dup.freeze
-    @options = opts.dup.freeze
-
-    regex, @params = __compile path, opts
-    @params.freeze
-    super %r~^#{regex}$~iu
-    freeze
-
-    ::Maveric.log.debug self.inspect
-  end
-
-  attr_reader :path, :params, :options
-
-  ##
-  # If given a hash that contains all of and only contains keys matching its
-  # parameters then a path will be built by interpolating the hash values for
-  # their corresponding parameters.
-  #
-  # NOTE: Should I or should I not pass the result to #route to ensure
-  # the generation of a compatible path?
-  def build arg
-    ::Maveric.log.debug "#{self.class}#build #{arg.inspect} : #{@params}"
-    ::Maveric.type_check :arg, arg, Hash
-    if @params.sort == arg.keys.sort
-      @options.
-        merge(arg).
-        inject(@path){|r,(k,v)| r.sub /:#{k}:?/, v }
-    end
-  end
-
-  ##
-  # When given a path that matches the Route itself, a hash is returned with
-  # keys being parameters and values being the associated value gathered from
-  # the path.
-  def route path
-    ::Maveric.log.debug "#{self.class}#route #{path.inspect} : #{self}"
-    ::Maveric.type_check :path, path, String
-    if self =~ path
-      @options.
-        merge( Hash[ *@params.zip($~.captures).flatten ] ).
-        update(nil => self) # should be safe enough.
-    end
-  end
-
   ##
-  # This is an attempt as path correction. The String root is treated as a
-  # prefix to the generating path to be removed, from which a new Route will
-  # be generated.
+  # 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.
   #
-  #   r = Route.new '/foo/bar/qux'
-  #   r.reroot('/foo') == Route.new('/bar/qux')
-  #     => true
-  def reroot root, opts={}
-    ::Maveric.type_check :root, root, String
-    self.class.new @path.sub(/^#{root}\/?/,'/'), @options.merge(opts)
-  end
-
-  ##
-  # As Route is a subclass of a core lib class, the inspect isn't as
-  # informative as we'd like. So we override it.
-  def inspect
-    "#<%s:0x%x %s %s %s>" % [
-      self.class,
-      [object_id<<1].pack('i').unpack('I')[0],
-      super,
-      @params.inspect,
-      @path.inspect
-    ] # we don't include @options, I know.
-  end
-
-  private
-
-  ##
-  # Builds a regex 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.
-  def __compile path, opts
-    ::Maveric.type_check :path, path, String
-    ::Maveric.type_check :opts, opts, Hash
+  # 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
-      param = $1.to_sym
-      raise ArgumentError, "Duplicated parameter in path."+
-        " <#{param.inspect}>" if params.include? param
-      params << param
+    regex = @path.gsub PARAM_MATCH do
+      params << param = $1.to_sym
       "(#{opts[param] || URI_CHAR+'+'})"
     end
-    [regex, params]
+    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
-end
 
-## Storage of routes and routing mechanisms.
-class Maveric::Router
-  def initialize opts={}
-    @routings = Hash.new
-  end
-  
-  ## Returns a list of the controllers with listed routes.
-  def controllers
-    @routings.values.uniq
-  end
+  attr_reader :path, :regex, :opts, :struct, :controller
 
   ##
-  # Places one or more routes to a Controller. Will generate a new Route if
-  # a route is a String. Accepts an Array for routes to add several at a time.
-  def add routes, controller, opts={}
-    ::Maveric.log.info "#{self.class}#add"+
-      " #{routes.inspect} #{controller.inspect}"
-    ::Maveric.type_check :controller, controller, Class
-    ::Maveric.type_check :routes, routes, Array, String, ::Maveric::Route
-    routes = [routes] unless routes.is_a? Array
-    routes.flatten.map do |route|
-      ::Maveric.type_check :route, route, String, ::Maveric::Route
-      route = ::Maveric::Route.new route, opts if route.instance_of? String
-      @routings[route] = controller
-    end
-  end
-
-  ## Return an array of routes mapped to a controller.
-  def to controller
-    @routings.map{|(r,d)| r if d == controller }.compact
+  # 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
 
   ##
-  # Matches the given path against the collection of routes.
-  # Returns nil the appropriate Route#route result with :controller
-  # mapped to the associated Controller.
-  def [] path
-    ::Maveric.type_check :path, path, String
-    @routings.eject do |(r,c)|
-      b=r.route(path) and {:controller=>c}.update b
-    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