scorched 0.5

data/lib/scorched/dynamic_delegate.rb

@@ -0,0 +1,22 @@
+module Scorched
+  # Unlike most delegator's that delegate to an object, this delegator delegates to a runtime expression, and so the
+  # target object can be dynamic.
+  module DynamicDelegate
+    def delegate(target_literal, *methods)
+      methods.each do |method|
+        method = method.to_sym
+        class_eval <<-CODE
+          def #{method}(*args, &block)
+            #{target_literal}.__send__(#{method.inspect}, *args, &block)
+          end
+        CODE
+      end
+    end
+    
+    def alias_each(methods)
+      methods.each do |m|
+        alias_method yield(m), m
+      end
+    end
+  end
+end

data/lib/scorched/error.rb

@@ -0,0 +1,5 @@
+module Scorched
+  class Error < StandardError
+    
+  end
+end

data/lib/scorched/options.rb

@@ -0,0 +1,54 @@
+module Scorched
+  class Options < Hash
+    # Redefine all methods as delegates of the underlying local hash.
+    extend DynamicDelegate
+    alias_each(Hash.instance_methods(false)) { |m| "_#{m}" }
+    delegate 'to_hash', *Hash.instance_methods(false).reject { |m|
+      [:[]=, :clear, :delete, :delete_if, :merge!, :replace, :shift, :store].include? m
+    }
+    
+    alias_method :<<, :replace
+    
+    # sets parent Options object and returns self
+    def parent!(parent)
+      @parent = parent
+      self
+    end
+    
+    def to_hash(inherit = true)
+      (inherit && Hash === @parent) ? @parent.to_hash.merge(self) : {}.merge(self)
+    end
+    
+    def inspect
+      "#<#{self.class}: local#{_inspect}, merged#{to_hash.inspect}>"
+    end
+  end
+  
+  class << self
+    def Options(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::Options === superclass.#{accessor_name}
+              @#{accessor_name} = Options.new.parent!(parent)
+            end
+          end
+        end
+
+        def #{accessor_name}(*args)
+          self.class.#{accessor_name}(*args)
+        end
+      MOD
+      m
+    end
+  end
+end
+

data/lib/scorched/request.rb

@@ -0,0 +1,34 @@
+module Scorched
+  class Request < Rack::Request
+    # Keeps track of the matched URL portions and what object handled them.
+    def breadcrumb
+      env['breadcrumb'] ||= []
+    end
+    
+    # Returns a hash of captured strings from the last matched URL in the breadcrumb.
+    def captures
+      breadcrumb.last ? breadcrumb.last[:captures] : []
+    end
+    
+    def all_captures
+      breadcrumb.map { |v| v[:captures] }
+    end
+    
+    def matched_path
+      join_paths(breadcrumb.map{|v| v[:url]})
+    end
+    
+    def unmatched_path
+      path = path_info.partition(matched_path).last
+      path[0,0] = '/' unless path[0] == '/'
+      path
+    end
+  
+  private
+    
+    # Joins an array of path segments ensuring a single forward slash seperates them.
+    def join_paths(paths)
+      paths.join('/').gsub(%r{/+}, '/')
+    end
+  end
+end

data/lib/scorched/response.rb

@@ -0,0 +1,18 @@
+module Scorched
+  class Response < Rack::Response
+    # Merges another response object (or response array) into self in order to preserve references to this response
+    # object.
+    def merge!(response)
+      return self if response == self
+      if Rack::Response === response
+        response.finish
+        self.status = response.status
+        self.header.merge!(response.header)
+        self.body = []
+        response.each { |v| self.body << v }
+      else
+        self.status, @header, self.body = response
+      end
+    end
+  end
+end

data/lib/scorched/static.rb

@@ -0,0 +1,16 @@
+module Scorched
+  class Static
+    def initialize(app, options={})
+      @app = app
+      @options = options
+      dir = options.delete(:dir) || 'public'
+      options[:cache_control] ||= 'no-cache'
+      @file_server = Rack::File.new(dir, options)
+    end
+
+    def call(env)
+      response = @file_server.call(env)
+      response[0] >= 400 ? @app.call(env) : response 
+    end
+  end
+end

data/lib/scorched/version.rb

@@ -0,0 +1,3 @@
+module Scorched
+  VERSION = '0.5'
+end

data/lib/scorched/view_helpers.rb

@@ -0,0 +1,39 @@
+# In its own file for no other reason than to keep all the extra non-essential bells and whistles in their own file,
+# which can be easily excluded if needed.
+
+module Scorched
+  module ViewHelpers
+    
+    # Renders the given string or file path using the Tilt templating library.
+    # Options hash is merged with the controllers _view_config_. Tilt template options are passed through. 
+    # The template engine is derived from file name, or otherwise as specified by the _:engine_ option. If String is
+    # given, _:engine_ option must be set.
+    #
+    # Refer to Tilt documentation for a list of valid template engines.
+    def render(string_or_file, options = {}, &block)
+      options = view_config.merge(explicit_options = options)
+      engine = (derived_engine = Tilt[string_or_file.to_s]) || Tilt[options[:engine]]
+      raise Error, "Invalid or undefined template engine: #{options[:engine].inspect}" unless engine
+      if Symbol === string_or_file
+        file = string_or_file.to_s
+        file = file << ".#{options[:engine]}" unless derived_engine
+        file = File.join(options[:dir], file) if options[:dir]
+        template = engine.new(file, nil, options)
+      else
+        template = engine.new(nil, nil, options) { string_or_file }
+      end
+      
+      # The following chunk of code is responsible for preventing the rendering of layouts within views.
+      options[:layout] = false if @_no_default_layout && !explicit_options[:layout]
+      begin
+        @_no_default_layout = true
+        output = template.render(self, options[:locals], &block)
+      ensure
+        @_no_default_layout = false
+      end
+      output = render(options[:layout], options.merge(layout: false)) { output } if options[:layout]
+      output
+    end
+    
+  end
+end

data/scorched.gemspec

@@ -0,0 +1,19 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require 'scorched/version' # Load scorched to inspect it for information, such as version.
+
+Gem::Specification.new 'scorched', Scorched::VERSION do |s|
+  s.summary           = "Light-weight, DRY as a desert, web framework for Ruby"
+  s.description       = "A lightweight Sinatra-inspired web framework for web sites and applications of any size."
+  s.authors           = ["Tom Wardrop"]
+  s.email             = "tom@tomwardrop.com"
+  s.homepage          = "http://scorchedrb.com"
+  s.files             = Dir.glob(`git ls-files`.split("\n") - %w[.gitignore])
+  s.test_files        = Dir.glob('spec/**/*_spec.rb')
+  s.rdoc_options      = %w[--line-numbers --inline-source --title Scorched --encoding=UTF-8]
+
+  s.add_dependency 'rack', '~> 1.4'
+  s.add_dependency 'rack-accept', '~> 0.4.5'
+  s.add_dependency 'tilt', '~> 1.3'
+  s.add_development_dependency 'rack-test', '~> 0.6'
+  s.add_development_dependency 'rspec', '~> 2.9'
+end

data/spec/collection_spec.rb

@@ -0,0 +1,46 @@
+require_relative './helper.rb'
+
+class CollectionA
+  include Scorched::Collection('middleware')
+end
+
+class CollectionB < CollectionA
+end
+
+class CollectionC < CollectionB
+end
+
+module Scorched
+  describe Collection do
+    it "defaults to an empty set" do
+      CollectionA.middleware.should == Set.new
+    end
+  
+    it "can be set to a given set" do
+      my_set = Set.new(['horse', 'cat', 'dog'])
+      CollectionA.middleware.replace my_set
+      CollectionA.middleware.should == my_set
+    end
+    
+    it "automatically converts arrays to sets" do
+      array = ['horse', 'cat', 'dog']
+      CollectionA.middleware.replace array
+      CollectionA.middleware.should == array.to_set
+    end
+  
+    it "recursively inherits from parents by default" do
+      CollectionB.middleware.should == CollectionA.middleware
+      CollectionC.middleware.should == CollectionA.middleware
+    end
+  
+    it "allows values to be overridden without modifying the parent" do
+      CollectionB.middleware << 'rabbit'
+      CollectionB.middleware.should include('rabbit')
+      CollectionA.middleware.should_not include('rabbit')
+    end
+    
+    it "provides access to a copy of internal set" do
+      CollectionB.middleware.to_set(false).should == Set.new(['rabbit'])
+    end
+  end
+end

data/spec/controller_spec.rb

@@ -0,0 +1,565 @@
+require_relative './helper.rb'
+
+module Scorched
+  describe Controller do
+    let(:generic_handler) do
+      proc { |env| [200, {}, ['ok']] }
+    end
+    
+    it "contains a default set of configuration options" do
+      app.config.should be_a(Options)
+      app.config.length.should > 0
+    end
+    
+    it "contains a set of default conditions" do
+      app.conditions.should be_a(Options)
+      app.conditions.length.should > 0
+      app.conditions[:methods].should be_a(Proc)
+    end
+    
+    describe "basic route handling" do
+      it "gracefully handles 404 errors" do
+        response = rt.get '/'
+        response.status.should == 404
+      end
+    
+      it "handles a root rack call correctly" do
+        app << {url: '/$', target: generic_handler}
+        response = rt.get '/'
+        response.status.should == 200
+      end
+    
+      it "does not maintain state between requests" do
+        app << {url: '/state', target: proc { |env| [200, {}, [@state = 1 + @state.to_i]] }}
+        response = rt.get '/state'
+        response.body.should == '1'
+        response = rt.get '/state'
+        response.body.should == '1'
+      end
+      
+      it "raises exception when invalid mapping hash given" do
+        expect {
+          app << {url: '/'}
+        }.to raise_error(ArgumentError)
+        expect {
+          app << {target: generic_handler}
+        }.to raise_error(ArgumentError)
+      end
+    end
+    
+    describe "URL matching" do
+      it 'always matches from the beginning of the URL' do
+        app << {url: 'about', target: generic_handler}
+        response = rt.get '/about'
+        response.status.should == 404
+      end
+      
+      it "matches eagerly by default" do
+        request = nil
+        app << {url: '/*', target: proc do |env|
+          request = env['rack.request']; [200, {}, ['ok']]
+        end}
+        response = rt.get '/about'
+        request.captures.should == ['about']
+      end
+      
+      it "can be forced to match end of URL" do
+        app << {url: '/about$', target: generic_handler}
+        response = rt.get '/about/us'
+        response.status.should == 404
+        app << {url: '/about', target: generic_handler}
+        response = rt.get '/about/us'
+        response.status.should == 200
+      end
+      
+      it "can match anonymous wildcards" do
+        request = nil
+        app << {url: '/anon/*/**', target: proc do |env|
+          request = env['rack.request']; [200, {}, ['ok']]
+        end}
+        response = rt.get '/anon/jeff/has/crabs'
+        request.captures.should == ['jeff', 'has/crabs']
+      end
+      
+      it "can match named wildcards (ignoring anonymous captures)" do
+        request = nil
+        app << {url: '/anon/:name/*/::infliction', target: proc do |env|
+          request = env['rack.request']; [200, {}, ['ok']]
+        end}
+        response = rt.get '/anon/jeff/smith/has/crabs'
+        request.captures.should == {name: 'jeff', infliction: 'has/crabs'}
+      end
+      
+      it "can match regex and preserve anonymous captures" do
+        request = nil
+        app << {url: %r{/anon/([^/]+)/(.+)}, target: proc do |env|
+          request = env['rack.request']; [200, {}, ['ok']]
+        end}
+        response = rt.get '/anon/jeff/has/crabs'
+        request.captures.should == ['jeff', 'has/crabs']
+      end
+      
+      it "can match regex and preserve named captures (ignoring anonymous captures)" do
+        request = nil
+        app << {url: %r{/anon/(?<name>[^/]+)/([^/]+)/(?<infliction>.+)}, target: proc do |env|
+          request = env['rack.request']; [200, {}, ['ok']]
+        end}
+        response = rt.get '/anon/jeff/smith/has/crabs'
+        request.captures.should == {name: 'jeff', infliction: 'has/crabs'}
+      end
+      
+      it "matches routes based on priority, otherwise giving precedence to those defined first" do
+        app << {url: '/', priority: -1, target: proc { |env| self.class.mappings.shift; [200, {}, ['four']] }}
+        app << {url: '/', target: proc { |env| self.class.mappings.shift; [200, {}, ['two']] }}
+        app << {url: '/', target: proc { |env| self.class.mappings.shift; [200, {}, ['three']] }}
+        app << {url: '/', priority: 2, target: proc { |env| self.class.mappings.shift; [200, {}, ['one']] }}
+        rt.get('/').body.should == 'one'
+        rt.get('/').body.should == 'two'
+        rt.get('/').body.should == 'three'
+        rt.get('/').body.should == 'four'
+      end
+    end
+    
+    describe "conditions" do
+      it "contains a default set of conditions" do
+        app.conditions.should be_a(Options)
+        app.conditions.should include(:methods, :media_type)
+        app.conditions.each { |k,v| v.should be_a(Proc) }
+      end
+      
+      it "executes route only if all conditions return true" do
+        app << {url: '/', conditions: {methods: 'POST'}, target: generic_handler}
+        response = rt.get "/"
+        response.status.should == 404
+        response = rt.post "/"
+        response.status.should == 200
+        
+        app.conditions[:has_name] = proc { |name| request.GET['name'] }
+        app << {url: '/about', conditions: {methods: ['GET', 'POST'], has_name: 'Ronald'}, target: generic_handler}
+        response = rt.get "/about"
+        response.status.should == 404
+        response = rt.get "/about", name: 'Ronald'
+        response.status.should == 200
+      end
+      
+      it "raises exception when condition doesn't exist or is invalid" do
+        app << {url: '/', conditions: {surprise_christmas_turkey: true}, target: generic_handler}
+        expect {
+          rt.get "/"
+        }.to raise_error(Scorched::Error)
+      end
+      
+      it "falls through to next route when conditions are not met" do
+        app << {url: '/', conditions: {methods: 'POST'}, target: proc { |env| [200, {}, ['post']] }}
+        app << {url: '/', conditions: {methods: 'GET'}, target: proc { |env| [200, {}, ['get']] }}
+        rt.get("/").body.should == 'get'
+        rt.post("/").body.should == 'post'
+      end
+    end
+    
+    describe "route helpers" do
+      it "allows end points to be defined more succinctly" do
+        route_proc = app.route('/*', 2, methods: 'GET') { |capture| capture }
+        mapping = app.mappings.first
+        mapping.should == {url: mapping[:url], priority: 2, conditions: {methods: 'GET'}, target: route_proc}
+        rt.get('/about').body.should == 'about'
+      end
+      
+      it "can provide a mapping proc without mapping it" do
+        block = proc { |capture| capture }
+        wrapped_block = app.route(&block)
+        app.mappings.length.should == 0
+        block.should_not == wrapped_block
+        app << {url: '/*', target: wrapped_block}
+        rt.get('/turkey').body.should == 'turkey'
+      end
+      
+      it "provides a method for every HTTP method" do
+        [:get, :post, :put, :delete, :options, :head, :patch].each do |m|
+          app.send(m, '/say_cool') { 'cool' }
+          rt.send(m, '/say_cool').body.should == (m == :head ? '' : 'cool')
+        end
+      end
+      
+      it "always matches to the end of the URL (implied $)" do
+        app.get('/') { 'awesome '}
+        rt.get('/dog').status.should == 404
+        rt.get('/').status.should == 200
+      end
+    end
+    
+    describe "sub-controllers" do
+      it "can be given no arguments" do
+        app.controller do
+          get('/') { 'hello' }
+        end
+        response = rt.get('/')
+        response.status.should == 200
+        response.body.should == 'hello'
+      end
+      
+      it "can take mapping options" do
+        app.controller priority: -1, conditions: {methods: 'POST'} do
+          route('/') { 'ok' }
+        end
+        app.mappings.first[:priority].should == -1
+        rt.get('/').status.should == 404
+        rt.post('/').body.should == 'ok'
+      end
+      
+      it "should ignore the already matched portions of the path" do
+        app.controller url: '/article' do
+          get('/*') { |title| title }
+        end
+        rt.get('/article/hello-world').body.should == 'hello-world'
+      end
+      
+      it "inherits from parent class, or any other class" do
+        app.controller.superclass.should == app
+        app.controller(String).superclass.should == String
+      end
+    end
+    
+    describe "before/after filters" do
+      they "run directly before and after the target action" do
+        order = []
+        app.get('/') { order << :action }
+        app.after { order << :after }
+        app.before { order << :before }
+        rt.get('/')
+        order.should == [:before, :action, :after]
+      end
+      
+      they "run in the context of the controller (same as the route)" do
+        route_instance = nil
+        before_instance = nil
+        after_instance = nil
+        app.get('/') { route_instance = self }
+        app.before { before_instance = self }
+        app.after { after_instance = self }
+        rt.get('/')
+        route_instance.should == before_instance
+        route_instance.should == after_instance
+      end
+      
+      they "should run even if no route matches" do
+        counter = 0
+        app.before { counter += 1 }
+        app.after { counter += 1 }
+        rt.delete('/').status.should == 404
+        counter.should == 2
+      end
+      
+      they "can take an optional set of conditions" do
+        counter = 0
+        app.before(methods: ['GET', 'PUT']) { counter += 1  }
+        app.after(methods: ['GET', 'PUT']) { counter += 1  }
+        rt.post('/')
+        rt.get('/')
+        rt.put('/')
+        counter.should == 4
+      end
+      
+      describe "nesting" do
+        example "filters inherit but only run once" do
+          before_counter, after_counter = 0, 0
+          app.before { before_counter += 1  }
+          app.after { after_counter += 1  }
+          subcontroller = app.controller { get('/') { 'wow' } }
+          subcontroller.filters[:before].should == app.filters[:before]
+          subcontroller.filters[:after].should == app.filters[:after]
+          
+          rt.get('/')
+          before_counter.should == 1
+          after_counter.should == 1
+          
+          # Hitting the subcontroller directly should yield the same results.
+          before_counter, after_counter = 0, 0
+          Rack::Test::Session.new(subcontroller).get('/')
+          before_counter.should == 1
+          after_counter.should == 1
+        end
+        
+        example "before filters run from outermost to inner" do
+          order = []
+          app.before { order << :outer }
+          app.controller { before { order << :inner } }
+          rt.get('/')
+          order.should == [:outer, :inner]
+        end
+        
+        example "after filters run from innermost to outermost" do
+          order = []
+          app.after { order << :outer }
+          app.controller { after { order << :inner } }
+          rt.get('/')
+          order.should == [:inner, :outer]
+        end
+      end
+    end
+    
+    describe "error filters" do
+      let(:app) do
+        Class.new(Scorched::Controller) do
+          route '/' do
+            raise StandardError
+          end
+        end
+      end
+      
+      they "catch exceptions" do
+        app.error { response.status = 500 }
+        rt.get('/').status.should == 500
+      end
+      
+      they "receive the exception object as their first argument" do
+        error = nil
+        app.error { |e| error = e }
+        rt.get('/')
+        error.should be_a(StandardError)
+      end
+      
+      they "try the next handler if the previous handler returns false" do
+        handlers_called = 0
+        app.error { handlers_called += 1 }
+        app.error { handlers_called += 1 }
+        rt.get '/'
+        handlers_called.should == 1
+        
+        app.error_filters.clear
+        handlers_called = 0
+        app.error { handlers_called += 1; false }
+        app.error { handlers_called += 1 }
+        rt.get '/'
+        handlers_called.should == 2
+      end
+      
+      they "still runs after filters if route error is handled" do
+        app.after { response.status = 111 }
+        app.error { true }
+        rt.get('/').status.should == 111
+      end
+      
+      they "can handle exceptions in before/after filters" do
+        app.error { |e| response.write e.class.name }
+        app.after { raise ArgumentError }
+        rt.get('/').body.should == 'StandardErrorArgumentError'
+      end
+      
+      they "only get called once per error" do
+        times_called = 0
+        app.error { times_called += 1 }
+        rt.get '/'
+        times_called.should == 1
+      end
+      
+      they "fall through when unhandled" do
+        expect {
+          rt.get '/'
+        }.to raise_error(StandardError)
+      end
+      
+      they "can optionally filter on one or more exception types" do
+        app.get('/arg_error') { raise ArgumentError }
+        
+        app.error(StandardError, ArgumentError) { true }
+        rt.get '/'
+        rt.get '/arg_error'
+        
+        app.error_filters.clear
+        app.error(ArgumentError) { true }
+        expect {
+          rt.get '/'
+        }.to raise_error(StandardError)
+        rt.get '/arg_error'
+      end
+      
+      they "can take an optional set of conditions" do
+        app.error(methods: ['GET', 'PUT']) { true  }
+        expect {
+          rt.post('/')
+        }.to raise_error(StandardError)
+        rt.get('/')
+        rt.put('/')
+      end
+    end
+    
+    describe "middleware" do
+      let(:app) do
+        Class.new(Scorched::Controller) do
+          self.middleware << proc { use Scorched::SimpleCounter }
+          get '/'do
+            request.env['scorched.simple_counter']
+          end
+          controller url: '/sub_controller' do
+            get '/' do
+              request.env['scorched.simple_counter']
+            end
+          end
+        end
+      end
+      
+      it "is only included once by default" do
+        rt.get('/').body.should == '1'
+        rt.get('/sub_controller').body.should == '1'
+      end
+      
+      it "can be explicitly included more than once in sub-controllers" do
+        app.mappings[-1][:target].middleware << proc { use Scorched::SimpleCounter }
+        rt.get('/').body.should == '1'
+        rt.get('/sub_controller').body.should == '2'
+      end
+    end
+    
+    describe "halting" do
+      it "short circuits current request" do
+        has_run = false
+        app.get('/') { halt; has_run = true }
+        rt.get '/'
+        has_run.should be_false
+      end
+      
+      it "takes an optional status" do
+        app.get('/') { halt 401 }
+        rt.get('/').status.should == 401
+      end
+      
+      it "still processes filters" do
+        app.after { response.status = 403 }
+        app.get('/') { halt }
+        rt.get('/').status.should == 403
+      end
+      
+      it "short circuits filters if halted within filter" do
+        app.before { halt }
+        app.after { response.status = 403 }
+        rt.get('/').status.should == 200
+      end
+    end
+    
+    describe "configuration" do
+      describe "strip_trailing_slash" do
+        it "is set to redirect by default" do
+          app.config[:strip_trailing_slash].should == :redirect
+          app.get('/test') { }
+          response = rt.get('/test/')
+          response.status.should == 307
+          response['Location'].should == '/test'
+        end
+        
+        it "can be set to ignore trailing slash while pattern matching" do
+          app.config[:strip_trailing_slash] = :ignore
+          hit = false
+          app.get('/test') { hit = true }
+          rt.get('/test/').status.should == 200
+          hit.should == true
+        end
+        
+        it "can be set not do nothing with a trailing slash" do
+          app.config[:strip_trailing_slash] = false
+          app.get('/test') { }
+          rt.get('/test/').status.should == 404
+          
+          app.get('/test/') { }
+          rt.get('/test/').status.should == 200
+        end
+      end
+      
+      describe "static_dir" do
+        it "is set to serve static files from 'public' directory by default" do
+          app.config[:static_dir].should == 'public'
+          response = rt.get('/static.txt')
+          response.status.should == 200
+          response.body.should == 'My static file!'
+        end
+        
+        it "can be disabled" do
+          app.config[:static_dir] = false
+          response = rt.get('/static.txt')
+          response.status.should == 404
+        end
+      end
+      
+      describe "sessions" do
+        it "provides convenience method for accessing the Rack session" do
+          rack_session = nil
+          app.get('/') { rack_session = session }
+          rt.get('/')
+          rack_session.should be_nil
+          app.middleware << proc { use Rack::Session::Cookie, secret: 'test' }
+          rt.get('/')
+          rack_session.should be_a(Rack::Session::Abstract::SessionHash)
+        end
+        
+        describe "flash" do
+          before(:each) do
+            app.middleware << proc { use Rack::Session::Cookie, secret: 'test' }
+          end
+          
+          it "keeps session variables that live for one page load" do
+            app.get('/set') { flash[:cat] = 'meow' }
+            app.get('/get') { flash[:cat] }
+            
+            rt.get('/set')
+            rt.get('/get').body.should == 'meow'
+            rt.get('/get').body.should == ''
+          end
+          
+          it "always reads from the original request flash" do
+            app.get('/') do
+              flash[:counter] = flash[:counter] ? flash[:counter] + 1 : 0
+              flash[:counter].to_s
+            end
+            
+            rt.get('/').body.should == ''
+            rt.get('/').body.should == '0'
+            rt.get('/').body.should == '1'
+          end
+          
+          it "can only remove flash variables if the flash object is accessed" do
+            app.get('/set') { flash[:cat] = 'meow' }
+            app.get('/get') { flash[:cat] }
+            app.get('/null') { }
+            
+            rt.get('/set')
+            rt.get('/null')
+            rt.get('/get').body.should == 'meow'
+            rt.get('/get').body.should == ''
+          end
+          
+          it "can keep multiple sets of flash session variables" do
+            app.get('/set_animal') { flash(:animals)[:cat] = 'meow' }
+            app.get('/get_animal') { flash(:animals)[:cat] }
+            app.get('/set_name') { flash(:names)[:jeff] = 'male' }
+            app.get('/get_name') { flash(:names)[:jeff] }
+            
+            rt.get('/set_animal')
+            rt.get('/set_name')
+            rt.get('/get_animal').body.should == 'meow'
+            rt.get('/get_name').body.should == 'male'
+            rt.get('/get_animal').body.should == ''
+            rt.get('/get_name').body.should == ''
+          end
+        end
+      end
+      
+      describe "cookie helper" do
+        it "sets, retrieves and deletes cookies" do
+          app.get('/') { cookie :test }
+          app.post('/') { cookie :test, 'hello' }
+          app.post('/goodbye') { cookie :test, {value: 'goodbye', expires: Time.now() + 999999 } }
+          app.delete('/') { cookie :test, nil }
+          
+          rt.get('/').body.should == ''
+          rt.post('/')
+          rt.get('/').body.should == 'hello'
+          rt.post('/goodbye')
+          rt.get('/').body.should == 'goodbye'
+          rt.delete('/')
+          rt.get('/').body.should == ''
+        end
+      end
+      
+    end
+  end
+end