maveric 0.1.0

data/maveric.rb

@@ -0,0 +1,769 @@
+##
+# = Maveric: A simple, non-magical, framework
+#
+# == Version
+#
+# This is 0.1.0 th 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.
+# 
+# == 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.
+# 
+# = Features
+# * Sessions inherent (kept to each instance of Maveric)
+# * Flexible and strong route setup
+# * Sharing of a Controller between Maveric instances is facilitated
+# * Inheritance is highly respected
+# 
+# == Not so Maveric
+# 
+# For these examples we will utilize the simplest functional Maveric possible
+#   require 'maveric'
+#   class Maveric::HelloWorld < Maveric::Controller
+#     def get
+#       'Hello'
+#     end
+#   end
+# 
+# To use Mongrel:
+#   require 'maveric/mongrel'
+#   h = ::Mongrel::HttpHandler ip, port
+#   h.register mountpoint, ::Maveric::MongrelHandler.new(MyMaveric)
+#   h.join.run
+# 
+# To use FastCGI:
+#   require 'maveric/fastcgi'
+#   ::Maveric::FCGI.new(MyMaveric)
+# 
+# To use WEBrick, which I have come to loathe: 
+#   server = ::WEBrick::HTTPServer.new(:Port => 9090)
+#   trap('INT'){ puts "Shutting down server."; server.stop }
+#   server.mount '/', ::Maveric::WEBrickServlet, Maveric
+#   server.start
+# 
+# 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 => '/mount/point/here'
+# 
+# --------------------------------
+# 
+# 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 'benchmark'
+require 'stringio'
+
+class Module
+  protected
+  ##
+  # Decends through the heirarchy of classes and modules looking fot
+  # objects in constants that &test[const] == true
+  def nested_search d=0, &test
+    constants.map do |c| c, r = const_get(c), []
+      next if c == self
+      r << c if test[c]
+      r.concat c.nested_search(d+1, &test) if c.is_a? Class or c.is_a? Module
+      r
+    end.flatten.compact
+  end
+end
+
+##
+# = 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.
+# 
+# = Usage
+# We could technically have a running Maveric with:
+#   require 'maveric'
+#   class Maveric::Index < Maveric::Controller
+#     def get
+#       'Hello, world!'
+#     end
+#   end
+#   maveric = Maveric.new # I'm a real boy now!
+# But that's not very friendly or useful.
+class Maveric
+  EOL="\r\n"
+  MP_BOUND_REGEX = /\Amultipart\/form-data.*boundary=\"?([^\";, ]+)\"?/n
+
+  @log = Log4r::Logger.new 'mvc'
+  @log.outputters = Log4r::Outputter['stderr']
+  @log.level = Log4r::INFO
+  #@sessions = Hash.new {|h,k| s = Maveric::Session.new; h[s.id]=s; }
+  @@sessions = Hash.new {|h,k| s = Maveric::Session.new; h[s.id]=s; }
+
+  @log.info "#{self.class} integrated at #{Time.now}"
+
+  class << self
+    ##
+    # Family is important.
+    #
+    # 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.
+    def inherited klass
+      Maveric.log.info "Maveric: #{klass} inherits from #{self}."
+      # By default a Maveric's logger is its parent's
+      klass.instance_variable_set :@log, @log
+      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 }
+      end
+    end
+
+    attr_reader :log
+
+    def sessions; @@sessions; 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
+    # cookies by changing the characters used in the second
+    # parameter (which defaults to ';,'.
+    def query_parse(qs, delim = '&;')
+      (qs||'').split(/[#{delim}] */n).inject({}) { |h,p|
+        k, v = unescape(p).split('=',2)
+        if h.key? k
+          if h[k].is_a? Array then h[k] << v
+          else h[k] = [h[k], v] end
+        else h[k] = v end
+        h
+      }
+    end
+
+    ##
+    # Parse a multipart/form-data entity. Adapated from cgi.rb. The body
+    # argument may either be a StringIO or a IO of sublcass thereof.
+    def parse_multipart boundary, body
+      ::Maveric.type_check :body, body, IO
+      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
+
+        o = unless fv[:filename] then ''
+          else fv[:tempfile] = Tempfile.new('MVC').binmode end
+        body.inject do |buf,line|
+          o << buf.chomp and break if bound =~ line
+          o << buf
+          line
+        end
+
+        fv[:tempfile].rewind if fv.key? :tempfile
+        values[fv[:name]] = fv.key?(:filename) ? fv : o
+      end
+      body.rewind
+      values
+    end
+
+    ## Help us find our contained implicit Controller classes.
+    def contained_controllers
+      nested_search {|v| v.is_a? Class and v < ::Maveric::Controller }
+    end
+
+    ## So we don't have ginormous test+raise statements everywhere.
+    def type_check name, value, *klasses, &test
+      if klasses.any? {|klass| value.is_a? klass } then return true
+      elsif test and test[value] then return true
+      else
+        raise TypeError, "Expected #{klasses*' or '} for #{name},"+
+          " got #{value.class}:#{value.inspect}."
+      end
+    end
+  end
+
+  ##
+  # When instantiated, the Maveric look search through its constants for
+  # nested Controllers. If It finds them, they will be asked if they have
+  # already chosen their routes. If they haven't, a default route will
+  # be derived from their name. AClassName would become '/a_class_name'
+  # and Maveric::BongleBing::ThisPage would become '/bongle_bing/this_page'.
+  #
+  # FIXME: Does not do nested paths for a nested Controller
+  def initialize *opts
+    klass = self.class
+    klass.log.info "#{self.class} instantiated at #{Time.now}"
+    # We have no where to go. populate me plz!
+    @routings = []
+    # By default we use a global session repository
+    @sessions = @@sessions
+
+    # defualt settings
+    @path_prefix = ''
+    # let's hande some options!
+    if (hopts = opts[-1]).is_a? Hash
+      # should not end with / !!!!!
+      @path_prefix = hopts[:path_prefix] if hopts.key? :path_prefix
+    end
+
+    # auto population
+    unless (controllers = klass.contained_controllers).empty?
+      controllers.each do |c|
+        klass.log.info "Setting routes for #{c}."
+        r = if not c.routes.empty? then c.routes
+          elsif (s = c.to_s[/::(.*)/,1]) =~ /^index$/i then '/'
+          else # I see we want to be difficult
+            '/'+s.gsub(/([^A-Z_])([A-Z])/){$1+'_'+$2}.downcase
+          end
+        set_routes c, *r
+      end
+    end
+  end
+
+  attr_reader :routings, :sessions
+  def log; self.class.log; end
+
+  ##
+  # Creates a Route to the object c. The c argument should be a Proc or a 
+  # Maveric::Controller subclass.
+  def add_route  c, r
+    log.info "#{self}#add_route #{c} #{r.inspect}"
+    route = Route.new @path_prefix+r, c
+    @routings.delete_if{|e| e === route } << route
+  end
+
+  ## Creates routes to object c, via Maveric#add_route
+  def add_routes c, *r
+    r.flatten.map {|route| add_route c, route }
+  end
+
+  ##
+  # Removes all routes directed at c, and adds routes to the given object,
+  # viaa Maveric#add_routes 
+  def set_routes c, *r
+    log.info "#{self}#set_route #{c} #{r.inspect}"
+    @routings.delete_if{|e| e.run == c }
+    add_routes c, *r
+  end
+
+  ##
+  # The env argument should be a normal environment hash derived from HTTP.
+  #
+  # Determines session info then sets the Maveric and the session info into 
+  # the environment hash at the keys of :maveric and :session respectively.
+  # Parses the REQUEST_URI to determine the appropriate routing and compiles
+  # the route info. Checks the REQUEST_METHOD for the post method and tests
+  # for a multipart/form-data payload.
+  def prep_env env
+    ::Maveric.type_check :env, env, Hash
+    class << env; include HashGenOnKey; end
+    env[:maveric] = self
+
+    # determines the appropriate route and build the route info.
+    url = Maveric.unescape env['REQUEST_URI']
+    route, rinfo = routings.
+      find {|r| o = r.match_url(url) and break [r, o] }
+    env.update :route => route, :route_info => rinfo
+    #::Maveric.log.warn env.map{|k,v|"#{k}: #{v.inspect}"}*"\n"
+
+    # determine if there's a multipart boundary
+    if env['REQUEST_METHOD'] =~ /^post$/i \
+      and env['CONTENT_TYPE'] =~ MP_BOUND_REGEX
+      env[:multipart_boundary] = $1
+    end
+
+    env[:params]
+    # session data!
+    session_id = env[:cookies][Maveric::Session::COOKIE_NAME]
+    session_id = session_id[0] if session_id.is_a? Array
+    env[:session] = sessions[ session_id ]
+    env
+  end
+
+  ##
+  # A Maveric's cue to start doing the heavy lifting. The 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 String, StringIO,
+  # or an IO or subclass thereof instance.
+  def dispatch req_body=$stdin, env=ENV, *opts
+    log.info "#{self.class}#dispatch #{id=Integer(rand*10000)}\n  "+
+      "[#{Time.now}] #{env['REMOTE_ADDR']} => #{env['REQUEST_URI']}"
+    ::Maveric.type_check :req_body, req_body, IO, StringIO
+    ::Maveric.type_check :env, env, Hash
+    response = ''
+    n = Benchmark.measure do
+      response = begin
+        prep_env env unless [:maveric, :route, :route_info].all?{|k|env.key? k}
+        raise ServerError, [404, "Page not found. Sorry!"] unless env[:route]
+
+        if env['REQUEST_METHOD'] =~ /^post$/i
+          qparams = env.key?(:multipart_boundary) ?
+            parse_multipart(env[:multipart_boundary], req_body) :
+            Maveric.query_parse(req_body.read)
+          env[:params].update qparams
+        end
+
+        env[:route].run[req_body, env, *opts]
+      rescue ServerError then $!
+      rescue 
+        log.fatal "#{Time.now}: #{$!.to_s}\n#{$!.backtrace*"\n"}"
+        # have a nice fail, then have a hard fail if something fails there.
+        begin
+          ServerError.new($!)
+        end
+      end
+    end
+    log.info "#{self.class}#dispatch #{id}\n#{n}".chomp
+    response
+  end
+end
+
+##
+# Conveniance class to build simple error responses. Raise it from within a
+# dispatch to attain a quick end to a possibly messy situation.
+#
+# TODO: Adapt it to be a subclass of Maveric::Controller
+class Maveric::ServerError < RuntimeError
+
+  class << self
+    ##
+    # If given an instance of the same class it shall return that class as
+    # doubling up is wasteful.
+    def new a
+      a.instance_of?(self) ? a : super(a)
+    end
+    alias_method :exception, :new
+  end
+
+  ##
+  # After a bit of experimenting with Exception and raise I determinee a fun
+  # and simple way to generate fast HTTP response error thingies. As long as
+  # you're within a call to dispatch (with no further rescue clauses) the
+  # ServerError will propogate up and be returned. As a ServerError has similar
+  # accessors as a Controller, they should be compatible with any outputting
+  # implimentation.
+  #
+  # If the status code is 5xx (500 by default) then a backtrace is appended to
+  # the response body.
+  #
+  #   raise ServerErrpr; # 500 error
+  #   raise ServerError, 'Crap!'; # 500 error with message set to 'Crap!'
+  #   raise ServerError, $!; # 500 error with same message and backtrace as
+  #     # $! with a note in the message as to  the original exception class
+  #   raise ServerError, [status, headers, body, *other_data] # Magic!
+  #
+  # In the final example line an Array is passed to raise as a second argument
+  # rather than a String. This only works as intended if the first element is
+  # an Integer. This is taken as the HTTP status code. The next element is
+  # tested to be a Hash, if so then it's values are merged into the HTTP
+  # headers. Then next item is tested to be a String, if so it is appended to
+  # the response body. All remaining elements are appended to the response
+  # body in inspect format.
+  def initialize data=nil
+    @status, @headers, @body = 500, {'Content-Type'=>'text/plain'}, ''
+    case msg = data
+    when Exception
+      msg = @body << data.class.to_s+" "+data.message
+      set_backtrace data.backtrace
+      @body << "\n\n"+data.backtrace*"\n"
+    when String
+      @body << msg
+    when Array
+      if data[0].is_a? Integer
+        # [status, headers, body, request]
+        @status = data.shift
+        @headers.update data.shift if data.first.is_a? Hash
+        @body.concat data.shift if data.first.is_a? String
+        msg = @body.dup
+        @body << "\n\n#{data.map{|e|e.inspect}*"\n"}" unless data.empty?
+      end
+    end
+    if @status/100%10 == 5
+      @body << "\n\n#{$!}\n#{$@[0..10]*"\n"}"
+    end
+    super msg
+  end
+  attr_reader :status, :headers, :body
+
+  ## Allows fun with splat (*).
+  def to_a
+    [
+      (@status.dup.freeze rescue @status), 
+      @headers.dup.freeze, 
+      @body.dup.freeze, 
+      (@env.dup.freeze rescue @env)
+    ].freeze
+  end
+
+  ## Fun with raw output!
+  def to_s
+    status, headers, body, e, i = to_a
+    response = "Status: #{status}"+Maveric::EOL
+    response << headers.map{|(k,v)| "#{k}: #{v}" }*Maveric::EOL
+    response << Maveric::EOL*2
+    response << body
+  end
+end
+
+##
+# Contains session data and provides conveniance in generating an appropriate
+# cookie.
+class Maveric::Session
+  COOKIE_NAME = 'SESSIONID'
+  DURATION = 15*60
+  KEY_GRADE = 16
+  KEY_LENGTH = 16
+
+  ## Do you want to alter the duration of sessions? M'kay.
+  def initialize duration=DURATION
+    @id = Array.new(KEY_LENGTH){rand(KEY_GRADE).to_s(KEY_GRADE)}*''
+    @duration, @data = duration, {}
+    Maveric.log.debug self
+  end
+  attr_reader :id, :expires, :duration, :data
+  attr_writer :duration
+
+  ##
+  # Update the Session's lifetime by @duration seconds from the time this
+  # method is called. Returns self for chaining uses.
+  #
+  # NOTE: No bookeeping algorithms are implemented, so a Session will last
+  # forever (within the app, the client's cookie will expire) at this point.
+  def touch
+    @expires = Time.now.gmtime + Integer(@duration)
+    Maveric.log.info "#{self.class}#touch: #{self.inspect}"
+    self
+  end
+
+  ##
+  # Representation of the Session in cookie form. Session specific data 
+  # is not used in any way.
+  def to_s env=Hash.new{|h,k|"#{k} not defined"}
+    touch unless @expires
+    c = "#{COOKIE_NAME}=#{id};" #required
+    c << " expires=#{@expires.httpdate}" if @expires
+    c << " path=#{env['SCRIPT_NAME']};"
+    c << " domain=#{env['SERVER_NAME']};"
+    c << " secure" if false
+    c
+  end
+end
+
+##
+# Instances of Route are used for determining how to act upon particular urls
+# in each Maveric instance. Routes should be defined in terms of / as the 
+# mount point of the Maveric. The following code would print the request
+# instance on the request of '/foo/'.
+#   Maveric.add_route '/', proc{p @request}
+#   mongrelserver.register('/foo', Maveric::MongrelHandler(Maveric))
+class Maveric::Route
+  ## Seperator characters.
+  URI_CHAR = '[^/?:,&#]'
+
+  ##
+  # Create a Route from the String route where varying parts of the url are
+  # represented as Symbol like sigils. The run argument should be a Proc or
+  # a Maveric::Controller subclass.
+  #   Route.new '/:page', proc{|request| p request.params[:params][:page] }
+  #   Route.new '/:page', MyController # MyController < Maveric::Controller
+  def initialize route, run
+    ::Maveric.type_check :route, route, String
+    ::Maveric.type_check :run, run, Proc, ::Maveric::Controller do |k|
+      k < ::Maveric::Controller
+    end
+    @run = run
+    @route = route.gsub /\/+/, '/'
+    @params = []
+    @regex = Regexp.new '^'+@route.gsub(/\/:(#{URI_CHAR}+)/){
+      @params << $1.to_sym
+      raise 'Duplicated parameters.' unless @params.uniq.size == @params.size
+      "/(#{URI_CHAR}+)"
+    }+'$'
+    Maveric.log.debug self
+  end
+  attr_reader :route, :run, :regex, :params
+
+  ##
+  # Create a url from a Hash by replacing the Symbol like sigils of the route
+  # with the corresponding hash values. An incomplete url may be returned if
+  # not all values of @params do not have corresponding value in the given 
+  # Hash.
+  def build_url hsh
+    Maveric.log.debug "#{self.class}#build_url"+
+      " #{hsh.inspect} : #{self.inspect}"
+    #@params.inject(@route){|r,k| r.gsub(/#{k.inspect}/, hsh[k]) }
+    hsh.inject(@route){|r,(k,v)| r.gsub(/:#{k}/, v.to_s) }
+  end
+
+  ##
+  # Build a Hash by picking out portions of the provided url that correspond
+  # to each sigil of the route. Returns nil if the url does not match.
+  def match_url url
+    Maveric.log.debug "#{self.class}#match_url"+
+      " #{url.inspect} : #{self.inspect}"
+    return nil unless md = @regex.match(url)
+    Hash[ *@params.zip(md.captures).flatten ]
+  end
+
+  ##
+  # Provides comparisons with instances of Array, Hash, Strings or Proc, as
+  # well as subclasses of Maveric::Controller.
+  def === arg
+    Maveric.log.debug "#{self.class}#==="+
+      " #{arg.inspect} : #{self.inspect}"
+    case arg
+    when Array  then arg.size == @params.size and \
+      not arg.any?{|v|!@params.include?(v)}
+    when Hash   then self === arg.keys
+    when String then @regex.match(arg).nil?
+    when Proc   then @run == arg
+    when Class  then @run == arg if arg < Maveric::Controller
+    end
+  end
+end
+
+##
+# Controller instances are the work horses of Maveric instances, pulling them
+# around the wide prarie of the net, lashed by means of a Route.
+# 
+# They may be defined anywhere you want, being contained in a Maveric is not
+# needed, all that is needed is for that class to be a subclass of 
+# Maveric::Controller. While you may do everything to the all-father of
+# Maveric::Controller that you can do with a child, it is not recommended for
+# the great one are prone to pass down their weirding ways to their children
+# which will probably instigate a small war or other conflicts later on.
+# 
+# If the methods get, post, put, or delete are called (typically called in
+# Controller.new when setting the body of the response) and they haven't been
+# defined then a ServerError is thrown with a status of 503.
+# 
+# * Access to the raw request is provided through @request.
+# * Cookies are reflected in @cookies, alterations will be passed to the 
+#   client response.
+#   * Alteration of the session id cookie is not recommended.
+# * HTTP headers should be set in @headers. The HTTP status should be set 
+#   in @status. Cookies from @cookies are included at the end of processing.
+class Maveric::Controller
+  REQUEST_METHODS = [:post, :get, :put, :delete, :head] # CRUD
+
+  @routes = []
+  class << self
+    ## Added to allow utilitilizing of Route#run[stuff]
+    alias_method :[], :new
+    def add_route r
+      @routes << r
+    end
+    def set_routes *r
+      @routes.clear
+      r.flatten.map{|e| add_route e }
+    end
+    def inherited klass
+      klass.instance_variable_set :@routes, @routes.dup
+    end
+    attr_reader :routes
+  end
+
+  ##
+  # Main processing method of Controller. After initial setup it will call
+  # its method with name equivalent to REQUEST_METHOD or 'get' in downcased
+  # form. The result of this method is used as the response body.
+  def initialize req_body, env, *opts
+    Maveric.log.warn "Provided env has not been properly processed, results "+
+      "may vary!" unless ([:maveric, :route, :route_info]-env.keys).empty?
+    ::Maveric.type_check :req_body, req_body, IO, StringIO
+    Maveric.log.debug env
+    @status, @headers = 200, {'Content-Type'=>'text/html'}
+    @env = env
+    @in = req_body
+    @cookies = @env[:cookies].dup
+    method = (@env['REQUEST_METHOD'] || 'get').downcase
+
+    n = Benchmark.measure{@body = __send__(method)}
+    Maveric.log.info "#{self.class}@body\n#{n}".chomp
+
+    @headers['Set-Cookie'] = [@env[:session].touch.to_s(@env)]
+    @cookies.each do |k,v|
+      next unless v != @env[:cookies][k]
+      @headers['Set-Cookie'] << \
+        "#{k}=#{Maveric.escape(v)}; path=#{@env['SCRIPT_NAME']}"
+    end
+    Maveric.log.debug self
+  end
+
+  attr_reader :status, :headers, :body
+
+  ##
+  # This is the new renderer. It uses nothing. Yay, configurability!
+  def render view, s=''
+    Maveric.log.debug "#{self.class}#render"+
+      " #{view.inspect}, #{s}"
+    ::Maveric.type_check :view, view, Symbol, String
+    extend @env[:maveric].class::Views
+    n = Benchmark.measure do
+      s = __send__ view, s if respond_to? view
+      s = __send__ :layout, s unless view.to_s[/^(_|layout$)/]
+    end
+    Maveric.log.info "#{self.class}#render #{view.inspect}\n#{n}".chomp
+    return s
+  end
+
+  ## Allows fun with splat (8).
+  def to_a
+    [
+      (@status.dup.freeze rescue @status), 
+      @headers.dup.freeze, 
+      @body.dup.freeze, 
+      (@env.dup.freeze rescue @env)
+    ].freeze
+  end
+
+  ## Because simple output is sometimes needed
+  def to_s
+    response = "Status: #{@status}" + Maveric::EOL
+    response << @headers.map{|k,v| "#{k}: #{v}" }*Maveric::EOL
+    response << Maveric::EOL*2 + @body
+  end
+
+  ##
+  # If the method requested is a standard HTTP REQUEST_METHOD name then
+  # we've probably just requested something not implemented. So, we throw
+  # a 503 error!
+  def method_missing m, *a, &b
+    Maveric.log.debug "#{self.class}#missing_method"+
+      "( #{m.inspect}, #{a.inspect}, #{b.inspect}) "
+    raise ServerError, [503, "Method #{m} not implemented.", @env] if \
+      REQUEST_METHODS.include? m
+    super m, *a, &b
+  end
+end
+
+##
+# Repository for global Views helpers and methods. For Maveric specific
+# views they should be defined in the Views module within the Maveric
+# subclass itself.
+#
+# NOTE: They really shouldn't be going here, but I cannot recall a better 
+# location to place helper methods. Truthfully, Views related helpers should
+# go here, while Controller related ones should be in their Controller.
+module Maveric::Views
+  def path_to c, a={}
+    path = ''
+    n = Benchmark.measure do
+      path = (@env['SCRIPT_NAME']+@env[:maveric].routings.find do |r|
+        r === a and u = r.build_url(a) and break u if r === c
+      end).gsub /\/+/, '/'
+    end
+    Maveric.log.info "#{self.class}#path_to #{c} #{a.inspect}\n#{n}".chomp
+    path
+  end
+end
+
+## Container module for Models. Akin to Maveric::Views
+module Maveric::Models
+end
+
+##
+# Utilizes a hash in @@gen_on_key, with Symbol keys and Proc values, to
+# generate default values for keys that don't exist.
+#
+# Used to extend the environment hash to automatically build the
+# data hashes for cookies and query parameters (limited to those gathered from
+# QUERY_STRING). Each data hash is triggered and accessable from the keys of 
+# :cookies and :params, respectively.
+module HashGenOnKey
+  # Store procs for generating data sets on the look up of a particular key
+  @@gen_on_key = Hash[
+    :cookies,
+    proc{|h| Maveric.query_parse(h['HTTP_COOKIE'], ';,') },
+    :params,
+    proc{|h| Maveric.query_parse(h['QUERY_STRING']) }
+  ]
+
+  ## If a key has no assigned value then test to see if there's a generator.
+  def default k
+    unless @@gen_on_key.key? k then super k
+    else store k, @@gen_on_key[k][self]
+    end
+  end
+
+  ## If there's a symbol key or corresponding generator, then return the value.
+  def method_missing m, *a, &b
+    if key? m then self[m]
+    elsif @@gen_on_key.key? m then default m
+    else super m, *a, &b
+    end
+  end
+end

data/maveric/fastcgi.rb

@@ -0,0 +1,14 @@
+%w~fcgi~.each{|m|require m}
+
+class Maveric::FCGI
+  def initialize maveric, *opts
+    @maveric = maveric.new *opts
+    ::FCGI.each do |req|
+      req_body = ::StringIO.new( req.in.read || '' )
+      result = @maveric.dispatch req_body, req.env
+      req.out << "Status: 200 OK\r\n\r\n"
+      req.out << result.to_s
+      req.finish
+    end
+  end
+end

data/maveric/mongrel.rb

@@ -0,0 +1,44 @@
+%w~mongrel~.each{|m|require m}
+
+class Maveric::MongrelHandler < Mongrel::HttpHandler
+  def initialize maveric, opts={}
+    ::Maveric.type_check :maveric, maveric do |k| k <= ::Maveric end
+    ::Maveric.type_check :opts, opts, Hash
+    super()
+    @request_notify = true
+    @maveric = maveric.new opts
+  end
+
+  ##
+  # NOTE: Update doc.
+  def process request, response
+    Maveric.log.info "Mongrel+#{self.class}#process"
+    reply = @maveric.dispatch request.body, request.params
+    # output the result
+    response.start reply.status do |head,out|
+      reply.headers.each {|k,v| head[k] = v }
+      out.write reply.body
+    end
+  end
+
+  ## Prepares by loading session and reflection data into the request params.
+  def request_begins params
+    begin
+      Maveric.log.info "Mongrel+#{self.class}#request_begins"
+      @maveric.prep_env params
+    rescue
+      Maveric.log.fatal "#{$!.inspect}\n#{$@[0..5]*"\n"}"
+    end
+  end
+
+  ## Does nothing yet. Yet.
+  def request_progess params, clen, total
+    begin
+      Maveric.log.info "Mongrel+#{self.class}#request_progess"+
+        ": #{clen}/#{total}"
+      Maveric.log.debug params
+    rescue
+      Maveric.log.fatal "#{$!.inspect}\n#{$@[0..5]*"\n"}"
+    end
+  end
+end

data/maveric/stadik-impl.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/ruby
+%w~maveric maveric/mongrel erubis~.each{|m|require m}
+Dir.chdir File.dirname __FILE__
+
+class SDKNet < Maveric
+  def self.load_mime_map(file,mime={})
+    mime = mime.merge(YAML.load_file(file))
+    mime.each {|k,v| $log.warn{"WARNING: MIME type #{k} must start with '.'"} if k.index(".") != 0 }
+    mime
+  end
+  module Views
+    def standard content
+      menu = [
+        [path_to(Index, :page => 'about'), 'About', 'Myth/Truth'],
+        ['http://blog.stadik.net', 'Blog', 'Finding('+%w(Thought Home Popularity Greatness Definition Meaning Happiness Reason Love Life Intelligence Worth).at(rand(12))+')'],
+        [path_to(Index, :page => 'resume'), 'Resumé', 'I work'],
+        [path_to(Index, :page => 'link'), 'Linkage', 'here we go']
+      ]
+      std = <<-STD
+    <div class="tablist" id="pmenu">
+      <ul>
+        <li><a title="Home" href="<%= path_to(Index) %>"><img border="0" src="http://media.stadik.net/stadik.png" title="SDK | StaDiK" id="homelogo" alt="" /></a></li>
+        <% menu.each do |entry| %>
+        <li class='<%= 'here' if @page == entry[0] %>'><a href='<%= entry[0] %>' title='<%= entry[2] %>'><%= entry[1] %></a></li>
+        <% end %>
+      </ul>
+    </div>
+
+    <div id='pcontent'>
+<!-- START CONTENT -->
+
+<%= content %>
+
+<!-- END CONTENT -->
+    </div>
+
+    <div class="tablist" id="pfoot">
+      <ul>
+        <li><a href="http://www.gvisit.com/map.php?sid=9e05735b2b78466e2fbc8538bf9b0c1c">where</a></li>
+        <li><a href="http://validator.w3.org/check?uri=referer">valid?</a></li>
+        <li><a>1995-2006&#169;SDKm</a><a rel="licence" title="All content on this website (including text, photographs, audio files, and any other original works), unless otherwise noted, is licensed under a Creative Commons License." href="http://creativecommons.org/licenses/by-nc-nd/2.5/">CCL:2.5</a></li>
+      </ul>
+    </div>
+      STD
+      ::Erubis::Eruby.new(std).result(binding)
+    end
+    def layout content
+      lyt = <<-LAYOUT
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC>
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+  <head>
+    <title>StaDiK.net</title>
+    <link rel="stylesheet" href="/z/style.css" type="text/css" media="screen"/>
+    <meta content="text/html; charset=utf-8" http-equiv="Content-Type"/>
+    <meta name="DC.title" content="StaDiK Motions"/>
+    <meta name="DC.description" content="Scytrin&amp;apos;s mucking about on the net."/>
+    <meta name="DC.creator.name" content="Scytrin dai Kinthra"/>
+    <meta name="geo.position" content="37.3069;-121.9271"/>
+    <meta name="geo.placename" content="San Jose"/>
+    <meta name="geo.region" content="US-CA"/>
+    <meta name="microid" content="5abf847090c9afe2172e0efe6636ba2c86e3d60d"/>
+    <% if @page and File.exists?(csf=@page+'.css') %>
+    <link rel='stylesheet' href='/z/<%= csf %>' type='text/css' media='screen' />
+    <% end %>
+  </head>
+  <body id="<%= @page || 'default' %>">
+<%= content %>
+  </body>
+</html>
+      LAYOUT
+      ::Erubis::Eruby.new(lyt).result(binding)
+    end
+  end
+  class Index < Controller
+    MIME_MAP = SDKNet.
+      load_mime_map('mime.yaml')
+    set_routes %w~/ /:page~
+    def get
+      @page = @env[:route_info][:page] || 'home'
+
+      fns = Dir[File.join(Dir.pwd,@page)+'.*'].
+        delete_if{|e| File.basename(e)[/^\./] }.
+        select{|e| MIME_MAP.include?(File.extname(e)) }
+
+      if fn = fns.inject do |f,e| # going to hell for this code.
+          %w{.wiki .erb .html .htm .txt}.include?(File.extname(e)) ? e : f
+        end
+        content = File.read(fn)
+        content = ::Erubis::Eruby.new(content).
+          result(binding) if File.extname(fn)=='.erb'
+        render :standard, content
+      else
+        raise ::Maveric::ServerError, [404, 'Fucking drop bears.']
+      end
+    end
+  end
+end
+
+h = Mongrel::HttpServer.new("0.0.0.0", "9081")
+h.register("/", Maveric::MongrelHandler.new(SDKNet))
+Signal.trap('INT') do
+  puts "Shutting down server."
+  h.acceptor.raise Mongrel::StopServer
+end
+h.run.join
+
+__END__
+
+require 'ruby-prof'
+result = RubyProf.profile { h.run.join }
+RubyProf::GraphHtmlPrinter.new(result).
+  print(File.open('prof.html','w'), 0)

data/maveric/webrick.rb

@@ -0,0 +1,33 @@
+%w~webrick webrick/httpservlet/abstract~.each{|m|require m}
+
+## Adaptation of CampingHandler, quick works.
+class Maveric::WEBrickServlet < WEBrick::HTTPServlet::AbstractServlet
+
+  ## 
+  # As a WEBrick servlet, but pass all but the first option to the Maveric on
+  # initialization. The Maveric (not an instance) is expected as the first 
+  # option.
+  def initialize server, maveric, *opts
+    ::Maveric.type_check :maveric, maveric do |k| k <= ::Maveric end
+    @maveric = maveric.new *@options
+    super server, *opts
+  end
+
+  ## We don't need no stinkin' do_* methods.
+  def service req, res
+    begin
+      ::Maveric.log.warn req.inspect
+      req_body = StringIO.new(req.body || '')
+      env = req.meta_vars
+      env['REQUEST_URI'] = req.unparsed_uri
+      result = @maveric.dispatch req_body, env, req
+      result.headers.each do |k, v|
+        if k =~ /^X-SENDFILE$/i then @local_path = v
+        else [*v].each {|x| res[k] = x } end
+      end
+      res.status, h, res.body = *result
+    rescue ::Maveric::ServerError => error
+      Maveric.log.fatal "WEBrick done got f'd up: #{error.inspect}"
+    end
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: maveric
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-01-19 00:00:00 -07:00
+summary: A simple, non-magical, framework
+require_paths: 
+- .
+email: blinketje@gmail.com
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: maveric
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- blink
+files: 
+- maveric.rb
+- maveric/mongrel.rb
+- maveric/fastcgi.rb
+- maveric/webrick.rb
+- maveric/stadik-impl.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: log4r
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: