waves 0.7.3 → 0.7.5

data/lib/layers/orm/active_record.rb

@@ -0,0 +1,41 @@
+# class Symbol
+#   # Protect ActiveRecord from itself by undefining the to_proc method.
+#   # Don't worry, AR will redefine it.
+#   alias :extensions_to_proc :to_proc
+#   remove_method :to_proc
+# end
+# require 'active_record'
+# 
+# if defined?(Rake)
+#   require File.dirname(__FILE__) / :active_record / :tasks / :schema
+# end
+# 
+# module Waves
+#   module Orm
+# 
+#     Model = ::ActiveRecord::Base
+# 
+#     module ActiveRecord
+# 
+#       def active_record
+#         unless @active_record
+#           ::ActiveRecord::Base.establish_connection(config.database)
+#           @active_record = ::ActiveRecord::Base.connection
+#         end
+#         @active_record
+#       end
+# 
+#       def database
+#         @database ||= active_record
+#       end
+# 
+#       def model_config(context, name)
+#         active_record
+#         context.set_table_name(name)
+#       end
+# 
+#     end
+#   end
+# end
+# 
+# ::Application.extend(Waves::Orm::ActiveRecord)

data/lib/layers/orm/active_record/migrations/empty.rb.erb

@@ -0,0 +1,9 @@
+class <%= @class_name %> < ActiveRecord::Migration
+
+  def self.up
+  end
+
+  def self.down
+  end
+
+end

data/lib/layers/orm/active_record/tasks/schema.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) / ".." / ".." / :migration
+include Waves::Orm
+namespace :schema do
+
+  desc "Create a new ActiveRecord Migration using ENV['name']."
+  task :migration do |task|
+
+    source          = Migration.template(:active_record, ENV['template'])
+    destination     = Migration.destination(ENV['name'])
+    migration_name  = Migration.migration_name(ENV['name'])
+
+    context = {:class_name => migration_name.camel_case}
+
+    Migration.write_erb(context, source, destination)
+
+  end
+
+  desc 'Performs migration from version, to version.'
+  task :migrate => :connect do |task|
+    version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
+    ActiveRecord::Migrator.migrate(Migration.directory, version)
+  end
+
+  task :connect do
+    Application.database
+    ActiveRecord::Base.logger = Logger.new($stdout)
+  end
+
+end
+

data/lib/layers/orm/data_mapper.rb

@@ -0,0 +1,42 @@
+gem 'dm-core', '=0.9.0'
+
+require 'data_mapper'
+
+module Waves
+  module Layers
+    module ORM
+      
+      # Work in Progress
+      module DataMapper
+        
+        def self.included(app)
+          
+          def app.database
+            @adapter ||= ::DataMapper.setup(:main_repository, config.database[:database])
+          end
+          
+          app.instance_eval do
+
+            auto_eval :Models do
+              auto_load true, :directories => [:models]
+            end
+
+            auto_eval :Configurations do
+              auto_eval :Mapping do
+                before true do
+                  app.database #force adapter init if not already done
+                  ::DataMapper::Repository.context.push(::DataMapper::Repository.new(:main_repository))
+                end
+                always true do
+                  ::DataMapper::Repository.context.pop
+                end
+              end
+            end
+            
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/layers/orm/filebase.rb

@@ -0,0 +1,22 @@
+module Waves
+  module Layers
+    module ORM
+      
+      # Work in Progress
+      module Filebase
+        
+        def self.included(app)
+          app.module_eval do
+            auto_eval( :Models ) do
+              auto_eval( true ) { include Filebase::Model[ :db / self.name.snake_case ] }
+            end
+          end
+        end
+        
+      end
+    
+    end
+    
+  end
+  
+end

data/lib/layers/orm/migration.rb

@@ -0,0 +1,70 @@
+module Waves
+  module Orm # :nodoc:
+    # Helper methods to establish an inter-ORM standard for migrations
+    module Migration
+
+      # stuff in this file largely lifted from Sequel.  Thanks, bro.
+
+      # Glob pattern
+      MIGRATION_FILE_PATTERN = '[0-9][0-9][0-9]_*.rb'.freeze
+
+      # Where Waves keeps its migration files
+      def self.directory
+        :schema / :migrations
+      end
+
+      # Returns any found migration files in the supplied directory.
+      def self.migration_files(range = nil)
+        pattern = directory / MIGRATION_FILE_PATTERN
+        files = Dir[pattern].inject([]) do |m, path|
+          m[File.basename(path).to_i] = path
+          m
+        end
+        filtered = range ? files[range] : files
+        filtered ? filtered.compact : []
+      end
+
+      # Use the supplied version number or determine the next in sequence
+      # based on the migration files in the migration directory
+      def self.next_migration_version
+        version = ENV['version'] || latest_migration_version
+        version.to_i + 1
+      end
+
+      # Uses the migration files in the migration directory to determine
+      # the highest numbered existing migration.
+      def self.latest_migration_version
+        l = migration_files.last
+        l ? File.basename(l).to_i : nil
+      end
+
+      # If the user doesn't pass a name, defaults to "migration"
+      def self.migration_name(name=nil)
+        name || 'migration'
+      end
+
+      # Returns the path to the migration template file for the given ORM.
+      # <em>orm</em> can be a symbol or string
+      def self.template(orm, name=nil)
+        file = ( name || 'empty' ) + '.rb.erb'
+        source = File.dirname(__FILE__) / orm / :migrations / file
+      end
+
+      # Given a migration name, returns the path of the file that would be created.
+      def self.destination(name)
+        version = next_migration_version
+        directory / "#{'%03d' % version}_#{migration_name(name)}.rb"
+      end
+
+      # Takes an assigns hash as the Erubis context.  Keys in the hash become
+      # instance variable names.
+      def self.write_erb(context, source, destination)
+        code = Erubis::Eruby.new( File.read( source ) ).evaluate( context )
+        puts "Creating #{destination}"
+        File.write( destination, code )
+      end
+
+    end
+  end
+
+end

data/lib/layers/orm/sequel.rb

@@ -0,0 +1,82 @@
+gem 'sequel', '>= 2.0.0'
+require 'sequel'
+require File.dirname(__FILE__) / :sequel / :tasks / :schema if defined?(Rake)
+
+module Waves
+  module Layers
+    module ORM # :nodoc:
+      
+      # Sets up the Sequel connection and configures AutoCode on Models, so that constants in that
+      # namespace get loaded from file or created as subclasses of Models::Default
+      module Sequel
+
+        # On inclusion, this module:
+        # - creates on the application module a database method that establishes the Sequel connection
+        # - arranges for autoloading/autocreation of missing constants in the Models namespace
+        # - defines Sequel-specific helper methods on Waves::Controllers::Base
+        # 
+        # The controller helper methdods are:
+        # - all
+        # - find(name)
+        # - create
+        # - delete(name)
+        # - update(name)
+        #
+        def self.included(app)
+          
+          def app.database ; @sequel ||= ::Sequel.open( config.database ) ; end
+          
+          app.instance_eval do
+            
+            auto_create_module( :Models ) do
+              include AutoCode
+              auto_create_class :Default, ::Sequel::Model
+              auto_load :Default, :directories => [ :models ]
+            end
+            
+            auto_eval :Models do
+              auto_create_class true, app::Models::Default
+              auto_load true, :directories => [ :models ]
+              # set the Sequel dataset based on the model class name
+              # note that this is not done for app::Models::Default, as it isn't 
+              # supposed to represent a table
+              auto_eval true do
+                default = superclass.basename.snake_case.pluralize.intern
+                if @dataset && @dataset.opts[:from] != [ default ]
+                  # don't clobber dataset from autoloaded file
+                else
+                  set_dataset Waves.application.database[ basename.snake_case.pluralize.intern ]
+                end
+              end
+            end
+            
+            Waves::Controllers::Base.module_eval do
+              def all #:nodoc:
+                model.all
+              end
+              
+              def find( name ) #:nodoc:
+                model[ :name => name ] or not_found
+              end
+              
+              def create #:nodoc:
+                model.create( attributes )
+              end
+              
+              def delete( name ) #:nodoc:
+                find( name ).destroy
+              end
+              
+              def update( name ) #:nodoc:
+                instance = find( name )
+                instance.update_with_params( attributes )
+                instance
+              end
+            end
+            
+          end
+        end
+      end
+    end
+  end
+end

data/lib/layers/orm/sequel/migrations/empty.rb.erb

@@ -0,0 +1,9 @@
+class <%= @class_name %> < Sequel::Migration
+
+  def up
+  end
+
+  def down
+  end
+
+end

data/lib/layers/orm/sequel/tasks/schema.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) / ".." / ".." / :migration
+include Waves::Orm
+namespace :schema do
+
+  desc "Create a new Sequel Migration using ENV['name']."
+  task :migration do |task|
+
+    source          = Migration.template(:sequel, ENV['template'])
+    destination     = Migration.destination(ENV['name'])
+    migration_name  = Migration.migration_name(ENV['name'])
+
+    context = {:class_name => migration_name.camel_case}
+
+    Migration.write_erb(context, source, destination)
+
+  end
+
+  desc 'Performs migration from version, to version.'
+  task :migrate do |task|
+    version = ENV['version']; version = version.to_i unless version.nil?
+    Sequel::Migrator.apply( Waves.application.database, Migration.directory , version )
+  end
+
+end

data/lib/layers/simple.rb

@@ -0,0 +1,39 @@
+module Waves
+  
+  # Waves uses Layers to provide discrete, stackable, interchangeable bundles of functionality.
+  # 
+  # Developers can make use of Layers by including them directly in a Waves application:
+  # 
+  #   module MyApp
+  #     include SomeLayer
+  #   end
+  module Layers
+    
+    # Creates the Configurations namespace and establishes the standard autoload-or-autocreate
+    # rules.
+    module Simple
+      def self.included( app )
+
+        def app.config ; Waves.config ; end
+        def app.configurations ; self::Configurations ; end
+        
+        app.instance_eval do
+
+          include AutoCode
+          
+          auto_create_module( :Configurations ) do
+            include AutoCode
+            auto_create_class true, Waves::Configurations::Default
+            auto_load :Mapping, :directories => [:configurations]
+            auto_load true, :directories => [:configurations]
+            auto_eval :Mapping do
+              extend Waves::Mapping
+            end
+          end
+
+        end
+      end
+    end
+  end
+end
+      

data/lib/layers/simple_errors.rb

@@ -0,0 +1,26 @@
+module Waves
+  module Layers
+    # Configures Waves for minimal exception handling.  
+    # 
+    # For example,
+    # a NotFoundError results in response status of 404, with body text
+    # of "404 Not Found".
+    module SimpleErrors
+
+      def self.included( app )
+
+        app.instance_eval do
+
+          auto_eval :Configurations do
+            auto_eval :Mapping do
+              handle(Waves::Dispatchers::NotFoundError) do
+                 response.status = 404; response.body = "404 Not Found"
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/mapping/mapping.rb

@@ -1,14 +1,39 @@
 module Waves
 
-  # Waves::Mapping is a mixin for defining Waves URI mappings (mapping a request to Ruby code).
-  # Mappings can work against the request url, path, and elements of the request (such as the
-  # request method or accept header). Mappings may also include before, after, or wrap filters
-  # to be run if they match the request. Mappings are created using an appropriate mapping method
-  # along with a URL pattern (a string or regular expression), a hash of constraint options, and
-  # a block, which is the code to run if the pattern matches.
+  # Mappings in Waves are the interface between the request dispatcher and your
+  # application code.  The dispatcher matches each request against the mappings
+  # to determine a primary action and to collect sets of before, after, wrap, 
+  # and always actions.  The dispatcher also looks for an exception handler 
+  # registered in the mappings when attempting a rescue.
+  # 
+  # Each mapping associates a block with a set of constraints.  Mappings can be
+  # one of several types:
+  # 
+  # - action (the actual request processing and response)
+  # - handle (exception handling)
+  # - before 
+  # - after
+  # - wrap (registers its block as both a before and after action)
+  # - always (like an "ensure" clause in a rescue)
+  # 
+  # Actions are registered using path, url, or map.  The other types may be 
+  # registered using methods named after the type.
+  # 
+  # 
+  # The available constraints are:
+  # 
+  # - a string or regexp that the path or url must match
+  # - parameters to match against the HTTP request headers and the Rack-specific variables (e.g. 'rack.url_scheme')
+  # - an additional hash reserved for settings not related to the Rack request (e.g. giving Rack handers special instructions for certain requests.  See threaded? )
+  # 
+  # The dispatcher evaluates mapping blocks in an instance of ResponseProxy, 
+  # which provides access to foundational classes of a Waves application (i.e. controllers and views)
   #
   # == Examples
   #
+  #   resource = '([\w\-]+)'
+  #   name = '([\w\-\_\.\+\@]+)'
+  #
   #   path %r{^/#{resource}/#{name}/?$} do |resource, name|
   #     "Hello from a #{resource} named #{name.capitalize}."
   #   end
@@ -20,7 +45,7 @@ module Waves
   #   Hello from a person named John.
   #
   # The given block may simple return a string. The content type is inferred from the request
-  # if possible, otherwise it defaults to +text+/+html+. 
+  # if possible, otherwise it defaults to +text+/+html+.
   #
   #   path '/critters', :method => :post do
   #     request.content_type
@@ -28,31 +53,32 @@ module Waves
   #
   #   /critters # => 'text/html'
   #
-  # In this example, we match against a string and check to make sure that the request is a 
+  # In this example, we match against a string and check to make sure that the request is a
   # POST. If so, we return the request content_type. The request (and response) objects are
   # available from within the block implicitly.
   #
   # = Invoking Controllers and Views
   #
-  # You may invoking a controller or view method for the primary application by using the 
+  # You may invoke a controller or view method for the primary application by using the
   # corresponding methods, preceded by the +use+ directive.
   #
   # == Examples
   #
   #   path %r{^/#{resource}/#{name}/?$} do |resource, name|
-  #     use( resource ) | controller { find( name ) } | 
-  #       view { | instance | show( resource => instance ) }
+  #     resource( resource ) do
+  #       controller { find( name ) } |  view { | instance | show( resource => instance ) }
+  #     end
   #   end
   #
   # In this example, we take the same rule from above but invoke a controller and view method.
-  # We use the +use+ directive and the resource parameter to set the MVC instances we're going
+  # We use the +resource+ directive and the resource parameter to set the MVC instances we're going
   # to use. This is necessary to use the +controller+ or +view+ methods. Each of these take
   # a block as arguments which are evaluated in the context of the instance. The +view+ method
   # can further take an argument which is "piped" from the result of the controller block. This
   # isn't required, but helps to clarify the request processing. Within a view block, a hash
-  # may also be passed in, which is converted into instance variables for the view instance. In
-  # this example, the +show+ method is assigned to an instance variable with the same name as 
-  # the resource type.
+  # may also be passed in to the view method, which is converted into instance variables for the
+  # view instance. In this example, the +show+ method is assigned to an instance variable with the
+  # same name as the resource type.
   #
   # So given the same URL as above - /person/john - what will happen is the +find+ method for
   # the +Person+ controller will be invoked and the result passed to the +Person+ view's +show+
@@ -63,12 +89,12 @@ module Waves
   # controller and view can thus be completely decoupled and become easier to reuse separately.
   #
   #   url 'http://admin.foobar.com:/' do
-  #     use( admin ) | view { console }
+  #     resource( :admin ) { view { console } }
   #   end
   #
-  # In this example, we are using the +url+ method to map a subdomain of +foobar.com+ to the 
+  # In this example, we are using the +url+ method to map a subdomain of +foobar.com+ to the
   # console method of the Admin view. In this case, we did not need a controller method, so
-  # we simply didn't call one. 
+  # we simply didn't call one.
   #
   # = Mapping Modules
   #
@@ -76,112 +102,188 @@ module Waves
   # mapping module. Some rule sets come packaged with Waves, such as PrettyUrls (rules for
   # matching resources using names instead of ids). The simplest way to define such modules for
   # reuse is by defining the +included+ class method for the rules module, and then define
-  # the rules using +module_eval+. This will likely be made simpler in a future release, but
-  # see the PrettyUrls module for an example of how to do this.
+  # the rules using +module_eval+. See the PrettyUrls module for an example of how to do this.
   #
-  # *Important:* Using pre-packaged mapping rules does not prevent you from adding to or 
-  # overriding these rules. However, order does matter, so you should put your own rules 
+  # *Important:* Using pre-packaged mapping rules does not prevent you from adding to or
+  # overriding these rules. However, order does matter, so you should put your own rules
   # ahead of those your may be importing. Also, place rules with constraints (for example,
   # rules that require a POST) ahead of those with no constraints, otherwise the constrainted
   # rules may never be called.
-  
-	module Mapping
-		
-		# If the pattern matches and constraints given by the options hash are satisfied, run the
-		# block before running any +path+ or +url+ actions. You can have as many +before+ matches
-		# as you want - they will all run, unless one of them calls redirect, generates an 
-		# unhandled exception, etc.
-		def before( pattern, options=nil, &block )
-			filters[:before] << [ pattern, options, block ]
-		end
-		
-		# Similar to before, except it runs its actions after any matching +url+ or +path+ actions.
-		def after( pattern, options=nil, &block )
-			filters[:after] << [ pattern, options, block ]
-		end
-		
-		# Run the action before and after the matching +url+ or +path+ action.
-		def wrap( pattern, options=nil, &block )
-			filters[:before] << [ pattern, options, block ]
-			filters[:after] << [ pattern, options, block ]
-		end		
-
-    # Maps a request to a block. Don't use this method directly unless you know what 
+
+  module Mapping
+
+    # If the pattern matches and constraints given by the options hash are satisfied, run the
+    # block before running any +path+ or +url+ actions. You can have as many +before+ matches
+    # as you want - they will all run, unless one of them calls redirect, generates an
+    # unhandled exception, etc.
+    def before( path, options = {}, &block )
+      if path.is_a? Hash
+        options = path
+      else
+        options[:path] = path
+      end
+      filters[:before] << [ options, block ]
+    end
+
+    # Similar to before, except it runs its actions after any matching +url+ or +path+ actions.
+    # Note that after methods will run even if an exception is thrown during processing.
+    def after( path, options = {}, &block )
+      if path.is_a? Hash
+        options = path
+      else
+        options[:path] = path
+      end
+      filters[:after] << [ options, block ]
+    end
+
+    # Run the action before and after the matching +url+ or +path+ action.
+    def wrap( path, options = {}, &block )
+      if path.is_a? Hash
+        options = path
+      else
+        options[:path] = path
+      end
+      filters[:before] << [ options, block ]
+      filters[:after] << [ options, block ]
+    end
+
+    # Like after, but will run even when an exception is thrown. Exceptions in
+    # always mappings are simply logged and ignored.
+    def always( path, options = {}, &block )
+      if path.is_a? Hash
+        options = path
+      else
+        options[:path] = path
+      end
+      filters[:always] << [ options, block ]
+    end
+
+    # Maps a request to a block. Don't use this method directly unless you know what
     # you're doing. Use +path+ or +url+ instead.
-		def map( options, &block )
-			pattern = options[:path] || options[:url]
-			mapping << [ pattern, options, block ]
-		end
-		
-		# Match pattern against the +request.path+, along with satisfying any constraints 
-		# specified by the options hash. If the pattern matches and the constraints are satisfied,
-		# run the block. Only one +path+ or +url+ match will be run (the first one).
-		def path( pat, options = {}, &block )
-			options[:path] = pat; map( options, &block )
-		end
-
-		# Match pattern against the +request.url+, along with satisfying any constraints 
-		# specified by the options hash. If the pattern matches and the constraints are satisfied,
-		# run the block. Only one +path+ or +url+ match will be run (the first one).
-		def url( pat, options = {}, &block )
-			options[:url] = pat; map( options, block )
-		end
-		
-		# Match the given request against the defined rules. This is typically only called
-		# by a dispatcher object, so you shouldn't typically use it directly.
-		def []( request )
-
-			rx = { :before => [], :after => [], :action => nil }
-			
-			( filters[:before] + filters[:wrap] ).each do | pattern, options, function |
-				matches = pattern.match(request.path)
-				rx[:before] << [ function, matches[1..-1] ] if matches &&
-					( ! options || satisfy( request, options ))
-			end
-			
-			mapping.find do |pattern, options, function|
-				matches = pattern.match(request.path)
-				rx[:action] = [ function, matches[1..-1] ] if matches && 
-					( ! options || satisfy( request, options ) )
-			end
-			
-			( filters[:after] + filters[:wrap] ).each do | pattern, options, function |
-				matches = pattern.match(request.path)
-				rx[:after] << [ function, matches[1..-1] ] if matches &&
-					( ! options || satisfy( request, options ))
-			end
-			
-			not_found(request) unless rx[:action]
-			
-			return rx
-				
-		end		
-				
-		private
-		
-		def mapping; @mapping ||= []; end
-		
-		def filters; @filters ||= { :before => [], :after => [], :wrap => [] }; end
-
-		def not_found(request)
-			raise Waves::Dispatchers::NotFoundError.new( request.url + ' not found.')
-		end
-		
-		def satisfy( request, options )
-			options.each do |method, param|
-				return false unless self.send( method, param, request )
-			end
-			return true
-		end
-		
-		def method( method, request )
-			request.method == method
-		end
-		
-    # TODO: Add constraint for request accept header
-		def accept( format, request )
-		end
-		
-	end
+    def map( path, options = {}, params = {}, &block )
+      case path
+      when Hash
+        params = options; options = path
+      when String
+        options[:path] = path
+      end
+      mapping << [ options, params, block ]
+    end
+
+    # Match pattern against the +request.path+, along with satisfying any constraints
+    # specified by the options hash. If the pattern matches and the constraints are satisfied,
+    # run the block. Only one +path+ or +url+ match will be run (the first one).
+    def path( pat, options = {}, params = {}, &block )
+      options[:path] = pat; map( options, params, &block )
+    end
+
+    # Match pattern against the +request.url+, along with satisfying any constraints
+    # specified by the options hash. If the pattern matches and the constraints are satisfied,
+    # run the block. Only one +path+ or +url+ match will be run (the first one).
+    def url( pat, options = {}, params = {}, &block )
+      options[:url] = pat; map( options, params, &block )
+    end
+
+    # Maps the root of the application to a block. If an options hash is specified it must
+    # satisfy those constraints in order to run the block.
+    def root( options = {}, params = {}, &block )
+      path( %r{^/?$}, options, params, &block )
+    end
+    
+    # Maps an exception handler to a block.
+    def handle(exception, options = {}, &block )
+      handlers << [exception,options, block]
+    end
+
+    # Maps a request to a block that will be executed within it's
+    # own thread. This is especially useful when you're running
+    # with an event driven server like thin or ebb, and this block
+    # is going to take a relatively long time.
+    def threaded( pat, options = {}, params = {}, &block)
+      params[:threaded] = true
+      map( pat, options, params, &block)
+    end
+
+    # Determines whether the request should be handled in a separate thread. This is  used
+    # by event driven servers like thin and ebb, and is most useful for those methods that
+    # take a long time to complete, like for example upload processes. E.g.:
+    #
+    #   threaded("/upload", :method => :post) do
+    #     handle_upload
+    #   end
+    #
+    # You typically wouldn't use this method directly.
+    def threaded?( request )
+      mapping.find do | options, params, function |
+        match = match( request, options, function )
+        return params[:threaded] == true if match
+      end
+      return false
+    end
+    
+    # Match the given request against the defined rules. This is typically only called
+    # by a dispatcher object, so you shouldn't typically use it directly.
+    def []( request )
+
+      rx = { :before => [], :after => [], :always => [], :action => nil, :handlers => [] }
+
+      ( filters[:before] + filters[:wrap] ).each do | options, function |
+        matches = match( request, options, function )
+        rx[:before] << matches if matches
+      end
+
+      mapping.find do | options, params, function |
+        rx[:action] = match( request, options, function )
+        break if rx[:action]
+      end
+
+      ( filters[:after] + filters[:wrap] ).each do | options, function |
+        matches = match( request, options, function )
+        rx[:after] << matches if matches
+      end
+
+      filters[:always].each do | options, function |
+        matches = match( request, options, function )
+        rx[:always] << matches if matches
+      end
+
+      handlers.each do | exception, options, function |
+        matches = match( request, options, function )
+        rx[:handlers] << matches.unshift(exception) if matches
+      end
+
+      return rx
+    end
+
+    # Clear all mapping rules
+    def clear
+      @mapping = @filters = @handlers = nil;
+    end
+
+    private
+
+    def mapping; @mapping ||= []; end
+
+    def filters; @filters ||= { :before => [], :after => [], :wrap => [], :always => [] }; end
+
+    def handlers; @handlers ||= []; end
+
+    def match ( request, options, function )
+      return nil unless satisfy( request, options )
+      return [ function, nil ] if ( options[:path] == true or options[:url] == true )
+      matches = options[:path].match( request.path ) if options[:path]
+      matches = options[:url].match( request.url ) if options[:url]
+      return [ function, matches ? matches[1..-1] : nil ]
+    end
+
+    def satisfy( request, options )
+      options.nil? or options.all? do |name,wanted|
+        return true if wanted == true
+        got = request.send( name ) rescue request.env[  ( name =~ /^rack\./ ) ? name.to_s.downcase : name.to_s.upcase ]
+        ( ( wanted.is_a?(Regexp) and wanted.match( got.to_s ) ) or got.to_s == wanted.to_s ) unless ( wanted.nil? or got.nil? )
+      end
+    end
+  end
+  
 
 end