scorched 0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7468f10cbee0373d243fd4d66dd081ea4b1cecc9
+  data.tar.gz: 6225d5221e70a5ba5f3b68d8c6db0144f34d9dfc
+SHA512:
+  metadata.gz: 91385d8f1501c564b9ba510ab3d4faef763ea4d6cee6d79b2a23c74cf8511352c8b0c7443360031e8b4ae3149c33c216c4b4b7311eac03d3bee9ce348d075b81
+  data.tar.gz: e0d15fc7205e937a8249599833bf9b2a74c9e3abaa3db4decef548eb6292185b53d3da0eede09439efdf5b4deb205b9563d256ed4a93365c3b31270c8db6f5e1

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2013 Tom Wardrop
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Milestones.md

@@ -0,0 +1,65 @@
+Milestones
+==========
+
+Changelog
+---------
+
+### v0.5
+* Implemented view rendering using Tilt.
+* Added session method for convenience, and implemented helper for flash session data.
+* Added cookie helper for conveniently setting, retrieving and deleting cookies.
+* Static file serving actually works now
+  * Custom middleware Scorched::Static serves as a thin layer on top of Rack::File.
+* Added specs for each configuration option.
+* Using Ruby 2.0 features where applicable. No excuse not to be able to deploy on 2.0 by the time Scorched is ready for production.
+  * Keyword arguments instead of ``*args`` combined with ``Hash === args.last``.
+  * Replaced instances of __FILE__ with __dir__.
+* Added expected Rack middleware, Rack::MethodOverride and Rack::Head.
+    
+### v0.4
+* Make filters behave like middleware. Inheritable, but are only executed once.
+* Improved implementation of Options and Collection classes
+
+### v0.3 and earlier
+* Basic request handling and routing
+* String and Regex URL matching, with capture support
+* Implemented route conditions
+  * Added HTTP method condition which the route helpers depend on.
+* Added route helpers
+* Implemented support for sub-controllers
+* Implement before and after filters with proper execution order.
+* Configuration inheritance between controllers. This has been implemented as the Options class.
+* Mechanism for including Rack middleware.
+* Added more route conditions e.g. content-type, language, user-agent, etc.
+* Provide means to `halt` request.
+  * Added redirect helping for halting and redirecting request
+* Mechanism for handling exceptions in routes and before/after filters.
+* Added static resource serving. E.g. public folder.
+
+
+
+Remaining
+---------
+Some of these remaining features may be broken out into a separate contributor library to keep the core lean and focused.
+
+* Make specs for Collection and Options classes more thorough, e.g. test all non-reading modifiers such as clear, delete, etc.
+* Add view helpers
+  * Add helper to easily read and build HTTP query strings. Takes care of "?" and "&" logic, escaping, etc. This is
+    intended to make link building easier.
+  * Form populator
+* Provide a default error page somewhat similar to what Sinatra has.
+* Add debug logging to show each routing hop and the current environment (variables, mode, etc)
+* Environment optimised defaults
+  * Production
+    * Rack::Protection
+    * Disable static file serving
+  * Development
+    * Verbose logging to STDOUT
+    * use Rack::ShowExceptions
+    
+Unlikely
+--------
+* Mutex locking option? I'm of the opinion that the web server should be configured for the concurrency model of the application, rather than the framework.
+
+    
+More things will be added to these lists as they're thought of and considered.

data/README.md

@@ -0,0 +1,78 @@
+Scorched
+========
+
+*Light-weight, DRY as a desert, web framework for Ruby. Inspired by Sinatra, this framework is my vision of the next evolutionary step in light-weight ruby web frameworks.*
+
+Scorched honours the patrons of the past. It's not a complete reinvention of the lightweight web framework, but rather what I hope is an evolutionary enhancement. Most of the concepts are carried forward from predecessors. Scorched merely enhances those concepts in an attempt to extract their full potential, as well as offering up to scrutiny some entirely new idioms. All with the intention to make developing lightweight web apps in Ruby even more enjoyable.
+
+The name 'Scorched' is inspired by the main goal of the project, which is to DRY-up what the likes of Sinatra and Padrino left moist.
+
+
+The Errors of Our Past (aka. Areas of Moisty-ness)
+--------------------------------------------------
+I think the biggest mistake made by the predecessors of Scorched such as Sinatra/Padrino, was to not leverage the power
+of the class. The consequences of this made for some awkwardness. Helpers are a classical reinvention of what
+classes and modules were already made to solve. Scorched implements Controllers as Classes, which in addition to having their own DSL, allow defining and calling traditional class methods. Allowing developers to implement helpers and other common functionality as proper methods not only makes them more predictable and familiar, but of course allow such helpers to be inheritable via plain-old Class inheritance.
+
+Perhaps another error (or area of sogginess, if you will) has been a lack of consideration for the hierarchical nature of websites, and the fact that sub-directories are often expected to inherit attributes of their parents. Scorched supports sub-controllers to any arbitrary depth, with each controllers filters and route conditions applied along the way. This can assist many areas of web development, including security, restful interfaces, and interchangeable output formats.
+
+
+Design Philosophy
+-----------------
+Scorched has a relatively simple design philosophy. The main objective is to keep Scorched lean and generic. Scorched refrains from expressing too much opinion. The general idea behind Scorched is to give developers all the tools to quickly put together small, medium and perhaps even large websites and applications.
+
+There's little need for a framework to be opinionated if the opinions of the developer can be quickly and easily built into it on a per-application basis. To do this effectively, developers really need to understand Scorched, and the best way to lower facilitate that is to lower the learning curve by keeping the core design, logical, predictable, and concise. 
+
+
+First Impressions
+-----------------
+Below I present a sample of the API as it currently stands:
+
+    class MyApp < Scorched::Controller
+
+      # From the most simple route possible...
+      get '/' do
+        "Hello World"
+      end
+      
+      # To something that gets the muscle's flexing a little
+      route '/articles/:title/::opts', 2, methods: ['GET', 'POST'], content_type: :json do
+        # Do what you want in here. Note, the second argument is the optional route priority.
+      end
+      
+      # Anonymous controllers allow for convenient route grouping to which filters and conditions can be applied
+      controller conditions: {content_type: :json} do
+        get '/articles/*' do |page|
+          {title: 'Scorched Rocks', body: '...', created_at: '27/08/2012', created_by: 'Bob'}
+        end
+        
+        after do
+          response.to_json
+        end
+      end
+      
+      # The things you get for free by using Classes for Controllers (...that's directed at you Padrino)
+      def my_little_helper
+        # Do some crazy awesome stuff that no route can resist using.
+      end
+      
+      # You can always avoid the routing helpers and add mappings manually. Anything that responds to #call is a valid target, with the only minor exception being that proc's are instance_exec'd, not #call'd.
+      self << {url: '/admin', priority: 10, target: My3rdPartyAdminApp}
+      self << {url: '**', conditions: {maintenance_mode: true}, target: proc { |env|
+        @request.body << 'Maintenance underway, please be patient.'
+      }}
+    end
+    
+This API shouldn't look too foreign to anyone familiar with frameworks like Sinatra, and the potential power at hand should be obvious. The `route` method demonstrates a few minor features of Scorched:
+
+* Multi-method routes - Because sometimes the difference between a GET and POST can be a single line of code. If no methods are provided, the route receives all HTTP methods.
+* Named Wildcards - Not an original idea, but you may note the named wildcard with the double colon. This maps to the '**' glob directive, which will span forward-slashes while matching. The single asterisk (or colon) behaves like the single asterisk glob directive, and will not match forward-slashes.
+* Route priorities - Routes (referred to as mappings internally) can be assigned priorities. A priority can be any arbitrary number by which the routes are ordered. The higher the number, the higher the priority.
+* Conditions - Conditions are merely procs defined on the controller which are inherited (and can be overriden) by child controllers. When a request comes in, mappings that match the requested URL, first have their conditions evaluated in the context of the controller instance, before control is handed off to the target associated with that mapping. It's a very simple implementation that comes with a lot of potential.
+
+That should hopefully give you an example of how the core of Scorched is shaping up. This demonstrates only a subset of what Scorched will offer.
+
+
+Development Progress
+--------------------
+Please refer to [Milestones.md](Milestones.md) for a breakdown of development progress.

data/docs/be_creative.md

@@ -0,0 +1,32 @@
+Effortless REST
+---------------
+An easy way to serve multiple content-types:
+
+  class App < Scorched::Controller
+    def view(view = nil)
+      view ? env['app.view'] = view : env['app.view']
+    end
+  
+    after do
+      if check_condition?(:media_type, 'text/html')
+        response.body = [render(view)]
+      if check_condition?(:media_type, 'application/json')
+        response['Content-type'] = 'application/json'
+        response.body = [response.body.to_json]
+      elsif check_condition?(:media_type, 'application/pdf')
+        response['Content-type'] = 'application/pdf'
+        # response.body = [render_pdf(view)]
+      else
+        response.body = [render(view)]
+      end
+    end
+  
+    get '/' do
+      view :index
+      [
+        {title: 'Sweet Purple Unicorns', date: '08/03/2013'},
+        {title: 'Mellow Grass Men', date: '21/03/2013'}
+      ]
+    end
+  end
+  

data/docs/filters.md

@@ -0,0 +1,8 @@
+
+After Filters
+-------------
+
+
+Error Filters
+-------------
+Error filters are processed like regular filters, except they're called whenever an exception occurs. If an error filter returns false, it's assumed to be unhandled, and the next error filter is called. This continues until one of the following is true, 1) an error filter returns true, in which case the exception is assumed to be handled, 2) an error filter raises an exception itself, or 3) there are no more error handlers defined on the current controller, in which case the exception is re-raised.

data/docs/routing.md

@@ -0,0 +1,29 @@
+Patterns
+========
+All patterns attempt to match the remaining unmatched portion of the request path (the request path being rack's
+`path_info` variable). The unmatched path will always begin with a forward slash if the previously matched portion of the
+path ended at a forward slash, regardless of whether it actually included the forward slash in the match, or if the
+forward slash was the next character. As an example, if the request was to "/article/21", then both "/article/" => "/21"
+and "/article" => "/21" would match.
+    
+All patterns match from the beginning of the path. Matches that occur beyond the beginning of the path won't count as a
+match. So even though the pattern "article" would match "/article/21", it wouldn't count as a match because the match
+didn't start at a non-zero offset.
+
+If a pattern contains named captures, unnamed captures will be lost (this is how named regex captures work in Ruby). So
+if you name one capture, make sure you name any other captures you may want to access.
+
+String Patterns
+---------------
+* `*` - Matches all characters excluding the forward slash.
+* `**` - Matches all characters including the forward slash.
+* `:param` - Same as `*` except the capture is named to whatever the string following the single-colon is.
+* `::param` - Same as `**` except the capture is named to whatever the string following the double-colon is.
+* `$` - If placed at the end of a pattern, the pattern only matches if it matches the entire path. For routes, this is
+  implied, so it should only be explicitly added if trying to match a dollar sign character. If added anywhere other
+  than the end of the pattern, it will match the dollar sign character.
+
+
+Regex Patterns
+--------------
+Regex patterns offer more power and flexibility than string patterns (naturally). To be continued... (captures, named captures, etc).

data/docs/sharing_request_state.md

@@ -0,0 +1,5 @@
+Managing Request State
+----------------------
+Because Scorched allows sub-controllers to an arbitrary depth and treats all controllers equal (i.e has no concept of a _root_ controller), it means instance variables cannot be used to track, maintain or share request state between controllers. I mention this because instance variables are the most common way to manage the request state in the likes of Sinatra.
+
+As an example, consider the Scorched implementation of flash session data. This data must be shared between controllers throughout the life of the request. The solution here, which you can find by looking at the Scorched source code, is to use the Rack environment hash. It's the one object that's accessible throughout the entire life-cycle of a request, and it's what you should use to maintain request state between controllers and even other embedded Rack applications.

data/examples/media_types.rb

@@ -0,0 +1,18 @@
+require 'json'
+require_relative '../lib/scorched.rb'
+
+class MediaTypesExample < Scorched::Controller
+  
+  get '/', media_type: 'text/html' do
+    <<-HTML
+      <div><strong>Name: </strong> John Falkon</div>
+      <div><strong>Age: </strong> 39</div>
+      <div><strong>Occupation: </strong> Carpet Cleaner</div>
+    HTML
+  end
+  
+  get '/,', media_type: 'application/json' do
+    {name: 'John Falkon', age: 39, occupation: 'Carpet Cleaner'}.to_json
+  end
+  
+end

data/examples/media_types.ru

@@ -0,0 +1,2 @@
+require './media_types.rb'
+run MediaTypesExample

data/lib/scorched.rb

@@ -0,0 +1,19 @@
+# Gems
+require 'rack'
+require 'rack/accept'
+require 'tilt'
+
+# Stdlib
+require 'set'
+require 'logger'
+
+require_relative 'scorched/static'
+require_relative 'scorched/dynamic_delegate'
+require_relative 'scorched/options'
+require_relative 'scorched/collection'
+require_relative 'scorched/view_helpers'
+require_relative 'scorched/controller'
+require_relative 'scorched/error'
+require_relative 'scorched/request'
+require_relative 'scorched/response'
+require_relative 'scorched/version'

data/lib/scorched/collection.rb

@@ -0,0 +1,60 @@
+module Scorched
+  class Collection < Set
+    # Redefine all methods as delegates of the underlying local set.
+    extend DynamicDelegate
+    alias_each(Set.instance_methods(false)) { |m| "_#{m}" }
+    delegate 'to_set', *Set.instance_methods(false).reject { |m|
+      [:<<, :add, :add?, :clear, :delete, :delete?, :delete_if, :merge, :replace, :subtract].include? m
+    }
+    
+    # sets parent Collection object and returns self
+    def parent!(parent)
+      @parent = parent
+      self
+    end
+    
+    def to_set(inherit = true)
+      if inherit && (Set === @parent || Array === @parent)
+        # An important attribute of a Scorched::Collection is that the merged set is ordered from inner to outer.
+        Set.new.merge(self._to_a).merge(@parent.to_set)
+      else
+        Set.new.merge(self._to_a)
+      end
+    end
+    
+    def to_a(inherit = true)
+      to_set(inherit).to_a
+    end
+    
+    def inspect
+      "#<#{self.class}: #{_inspect}, #{to_set.inspect}>"
+    end
+  end
+  
+  class << self
+    def Collection(accessor_name)
+      m = Module.new
+      m.class_eval <<-MOD
+        class << self
+          def included(klass)
+            klass.extend(ClassMethods)
+          end
+        end
+
+        module ClassMethods
+          def #{accessor_name}
+            @#{accessor_name} || begin
+              parent = superclass.#{accessor_name} if superclass.respond_to?(:#{accessor_name}) && Scorched::Collection === superclass.#{accessor_name}
+              @#{accessor_name} = Collection.new.parent!(parent)
+            end
+          end
+        end
+
+        def #{accessor_name}(*args)
+          self.class.#{accessor_name}(*args)
+        end
+      MOD
+      m
+    end
+  end
+end

data/lib/scorched/controller.rb

@@ -0,0 +1,343 @@
+module Scorched
+  class Controller
+    include ViewHelpers
+    include Scorched::Options('config')
+    include Scorched::Options('view_config')
+    include Scorched::Options('conditions')
+    include Scorched::Collection('middleware')
+    include Scorched::Collection('before_filters')
+    include Scorched::Collection('after_filters')
+    include Scorched::Collection('error_filters')
+    
+    config << {
+      :strip_trailing_slash => :redirect, # :redirect => Strips and redirects URL ending in forward slash, :ignore => internally ignores trailing slash, false => does nothing.
+      :static_dir => 'public', # The directory Scorched should serve static files from. Set to false if web server or anything else is serving static files.
+      :logger => Logger.new(STDOUT)
+    }
+    
+    view_config << {
+      :dir => 'views', # The directory containing all the view templates, relative to the application root.
+      :layout => false, # The default layout template to use, relative to the view directory. Set to false for no default layout.
+      :engine => :erb
+    }
+    
+    conditions << {
+      charset: proc { |charsets|
+        [*charsets].any? { |charset| request.env['rack-accept.request'].charset? charset }
+      },
+      encoding: proc { |encodings|
+        [*encodings].any? { |encoding| request.env['rack-accept.request'].encoding? encoding }
+      },
+      host: proc { |host| 
+        (Regexp === host) ? host =~ request.host : host == request.host 
+      },
+      language: proc { |languages|
+        [*languages].any? { |language| request.env['rack-accept.request'].language? language }
+      },
+      media_type: proc { |types|
+        [*types].any? { |type| request.env['rack-accept.request'].media_type? type }
+      },
+      methods: proc { |accepts| 
+        [*accepts].include?(request.request_method)
+      },
+      user_agent: proc { |user_agent| 
+        (Regexp === user_agent) ? user_agent =~ request.user_agent : user_agent == request.user_agent 
+      },
+      status: proc { |statuses| 
+        [*statuses].include?(response.status)
+      },
+    }
+    
+    middleware << proc { |this|
+      use Rack::Head
+      use Rack::MethodOverride
+      use Rack::Accept
+      use Scorched::Static, :dir => this.config[:static_dir] if this.config[:static_dir]
+      use Rack::Logger, this.config[:logger] if this.config[:logger]
+    }
+    
+    class << self
+
+      def mappings
+        @mappings ||= []
+      end
+      
+      def filters
+        @filters ||= {before: before_filters, after: after_filters, error: error_filters}
+      end
+      
+      def call(env)
+        loaded = env['scorched.middleware'] ||= Set.new
+        app = lambda do |env|
+          instance = self.new(env)
+          instance.action
+        end
+
+        builder = Rack::Builder.new
+        middleware.reject{ |v| loaded.include? v }.each do |proc|
+          builder.instance_exec(self, &proc)
+          loaded << proc
+        end
+        builder.run(app)
+        builder.call(env)
+      end
+      
+      # Generates and assigns mapping hash from the given arguments.
+      #
+      # Accepts the following keyword arguments:
+      #   :url - The url pattern to match on. Required.
+      #   :target - A proc to execute, or some other object that responds to #call. Required.
+      #   :priority - Negative or positive integer for giving a priority to the mapped item.
+      #   :conditions - A hash of condition:value pairs
+      # Raises ArgumentError if required key values are not provided.
+      def map(url: nil, priority: nil, conditions: {}, target: nil)
+        raise ArgumentError, "Mapping must specify url pattern and target" unless url && target
+        priority = priority.to_i
+        insert_pos = mappings.take_while { |v| priority <= v[:priority]  }.length
+        mappings.insert(insert_pos, {
+          url: compile(url),
+          priority: priority,
+          conditions: conditions,
+          target: target
+        })
+      end
+      alias :<< :map
+      
+      # Creates a new controller as a sub-class of self (by default), mapping it to self using the provided mapping
+      # hash if one is provided. Returns the new anonymous controller class.
+      #
+      # Takes two optional arguments and a block: a parent class from which the generated controller class inherits
+      # from, a mapping hash to automatically map the new controller, and of course a block which defines the
+      # controller class.
+      #
+      # It's worth noting, however obvious, that the resulting class will only be a controller if the parent class is
+      # (or inherits from) a Scorched::Controller.
+      def controller(parent_class = self, **mapping, &block)
+        c = Class.new(parent_class, &block)
+        self << {url: '/', target: c}.merge(mapping)
+        c
+      end
+      
+      # Generates and returns a new route proc from the given block, and optionally maps said proc using the given args.
+      def route(url = nil, priority = nil, **conditions, &block)
+        target = lambda do |env|
+          env['rack.response'].body << instance_exec(*env['rack.request'].captures, &block)
+          env['rack.response']
+        end
+        self << {url: compile(url, true), priority: priority, conditions: conditions, target: target} if url
+        target
+      end
+
+      ['get', 'post', 'put', 'delete', 'head', 'options', 'patch'].each do |method|
+        methods = (method == 'get') ? ['GET', 'HEAD'] : [method.upcase]
+        define_method(method) do |*args, **conditions, &block|
+          conditions.merge!(methods: methods)
+          route(*args, **conditions, &block)
+        end
+      end
+      
+      def filter(type, *args, **conditions, &block)
+        filters[type.to_sym] << {args: args, conditions: conditions, proc: block}
+      end
+      
+      # A bit of syntactic sugar for #filter.
+      ['before', 'after', 'error'].each do |type|
+        define_method(type) do |*args, &block|
+          filter(type, *args, &block)
+        end
+      end
+      
+    private
+    
+      # Parses and compiles the given URL string pattern into a regex if not already, returning the resulting regexp
+      # object. Accepts an optional _match_to_end_ argument which will ensure the generated pattern matches to the end
+      # of the string.
+      def compile(url, match_to_end = false)
+        return url if Regexp === url
+        raise Error, "Can't compile URL of type #{url.class}. Must be String or Regexp." unless String === url
+        match_to_end = !!url.sub!(/\$$/, '') || match_to_end
+        pattern = url.split(%r{(\*{1,2}|(?<!\\):{1,2}[^/*$]+)}).each_slice(2).map { |unmatched, match|
+          Regexp.escape(unmatched) << begin
+            if %w{* **}.include? match
+              match == '*' ? "([^/]+)" : "(.+)"
+            elsif match
+              match[0..1] == '::' ? "(?<#{match[2..-1]}>.+)" : "(?<#{match[1..-1]}>[^/]+)"
+            else
+              ''
+            end
+          end
+        }.join
+        pattern << '$' if match_to_end
+        Regexp.new(pattern)
+      end
+    end
+    
+    def method_missing(method, *args, &block)
+      (self.class.respond_to? method) ? self.class.__send__(method, *args, &block) : super
+    end
+    
+    def initialize(env)
+      define_singleton_method :env do
+        env
+      end
+      env['rack.request'] ||= Request.new(env)
+      env['rack.response'] ||= Response.new
+    end
+    
+    def action
+      inner_error = nil
+      rescue_block = proc do |e|
+        raise unless filters[:error].any? do |f|
+          (f[:args].empty? || f[:args].any? { |type| e.is_a?(type) }) && check_conditions?(f[:conditions]) && instance_exec(e, &f[:proc])
+        end
+      end
+      
+      match = matches(true).first
+      begin
+        catch(:halt) do
+          if config[:strip_trailing_slash] == :redirect && request.path =~ %r{./$}
+            redirect(request.path.chomp('/'))
+          end
+          
+          run_filters(:before)
+          if match
+            request.breadcrumb << match
+            # Proc's are executed in the context of this controller instance.
+            target = match[:mapping][:target]
+            begin
+              catch(:halt) do
+                response.merge! (Proc === target) ? instance_exec(request.env, &target) : target.call(request.env)
+              end
+            rescue => inner_error
+              rescue_block.call(inner_error)
+            end
+          else
+            response.status = 404
+          end
+          run_filters(:after)
+        end
+      rescue => outer_error
+        outer_error == inner_error ? raise : rescue_block.call(outer_error)
+      end
+      response
+    end
+    
+    def match?
+      !matches(true).empty?
+    end
+    
+    # Finds mappings that match the currently unmatched portion of the request path, returning an array of all matches.
+    # If _short_circuit_ is set to true, it stops matching at the first positive match, returning only a single match.
+    def matches(short_circuit = false)
+      to_match = request.unmatched_path
+      to_match = to_match.chomp('/') if config[:strip_trailing_slash] == :ignore && to_match =~ %r{./$}
+      matches = []
+      mappings.each do |m|
+        m[:url].match(to_match) do |match_data|
+          if match_data.pre_match == ''
+            if check_conditions?(m[:conditions])
+              if match_data.names.empty?
+                captures = match_data.captures
+              else
+                captures = Hash[match_data.names.map{|v| v.to_sym}.zip match_data.captures]
+              end
+              matches << {mapping: m, captures: captures, url: match_data.to_s}
+              break if short_circuit
+            end
+          end
+        end
+      end
+      matches
+    end
+    
+    def check_conditions?(conds)
+      if !conds
+        true
+      else
+        conds.all? { |c,v| check_condition?(c, v) }
+      end
+    end
+    
+    def check_condition?(c, v)
+      raise Error, "The condition `#{c}` either does not exist, or is not a Proc object" unless Proc === self.conditions[c]
+      instance_exec(v, &self.conditions[c])
+    end
+    
+    def redirect(url, status = 307)
+      response['Location'] = url
+      halt(status)
+    end
+    
+    def halt(status = 200)
+      response.status = status
+      throw :halt
+    end
+    
+    # Convenience method for accessing Rack request.
+    def request
+      env['rack.request']
+    end
+    
+    # Convenience method for accessing Rack response.
+    def response
+      env['rack.response']
+    end
+    
+    # Convenience method for accessing Rack session.
+    def session
+      env['rack.session']
+    end
+    
+    # Flash session storage helper.
+    # Stores session data until the next time this method is called with the same arguments, at which point it's reset.
+    # The typical use case is to provide feedback to the user on the previous action they performed.
+    def flash(key = :flash)
+      raise Error, "Flash session data cannot be used without a valid Rack session" unless session
+      flash_hash = env['scorched.flash'] ||= {}
+      flash_hash[key] ||= {}
+      session[key] ||= {}
+      unless session[key].methods(false).include? :[]=
+        session[key].define_singleton_method(:[]=) do |k, v|
+          flash_hash[key][k] = v
+        end
+      end
+      session[key]
+    end
+    
+    after do
+      env['scorched.flash'].each { |k,v| session[k] = v } if session && env['scorched.flash']
+    end
+    
+    # Serves a thin layer of convenience to Rack's built-in methods: Request#cookies, Response#set_cookie, and
+    # Response#delete_cookie.
+    # If only one argument is given, the specified cookie is retreived and returned.
+    # If both arguments are supplied, the cookie is either set or deleted, depending on whether the second argument is
+    # nil, or otherwise is a hash containing the key/value pair ``:value => nil``.
+    # If you wish to set a cookie to an empty value without deleting it, you pass an empty string as the value
+    def cookie(name, *value)
+      name = name.to_s
+      if value.empty?
+        request.cookies[name]
+      else
+        value = Hash === value[0] ? value[0] : {value: value}
+        if value[:value].nil?
+          response.delete_cookie(name, value)
+        else
+          response.set_cookie(name, value)
+        end
+      end
+    end
+    
+  private
+  
+    def run_filters(type)
+      tracker = env['scorched.filters'] ||= {before: Set.new, after: Set.new}
+      filters[type].reject{ |f| tracker[type].include? f }.each do |f|
+        if check_conditions?(f[:conditions])
+          tracker[type] << f
+          instance_exec(&f[:proc])
+        end
+      end
+    end
+  end
+end