usher 0.6.8 → 0.7.0

data/lib/usher.rb

@@ -11,10 +11,11 @@ require File.join('usher', 'util')
 require File.join('usher', 'delimiters')
 
 class Usher
-  attr_reader :root, :named_routes, :routes, :splitter,
-              :delimiters, :delimiters_regex, :priority_lookups,
-              :parent_route, :generator, :grapher
-
+  attr_reader   :root, :named_routes, :routes, :splitter,
+                :delimiters, :delimiters_regex, :priority_lookups,
+                :parent_route, :generator, :grapher
+  attr_accessor :route_class
+  
   alias_method :priority_lookups?, :priority_lookups
 
   # Returns whether the route set is empty
@@ -24,13 +25,13 @@ class Usher
   #   set.add_route('/test')
   #   set.empty? => false
   def empty?
-    @routes.empty?
+    routes.empty?
   end
 
   # Returns the number of routes
   #
   def route_count
-    @routes.size
+    routes.size
   end
 
   # Resets the route set back to its initial state
@@ -71,6 +72,7 @@ class Usher
   # Example, you create a route with a destination of :controller => 'test', :action => 'action'. If you made a call to generator with :controller => 'test', 
   # :action => 'action', it would pick that route to use for generation.
   def initialize(options = nil)
+    self.route_class                     = Usher::Route
     self.generator                       = options && options.delete(:generator)
     self.delimiters                      = Delimiters.new(options && options.delete(:delimiters) || ['/', '.'])
     self.valid_regex                     = options && options.delete(:valid_regex) || '[0-9A-Za-z\$\-_\+!\*\',]+'
@@ -119,7 +121,7 @@ class Usher
   #   set.delete_named_route(:test_route, '/test')
   def delete_named_route(name, path, options = nil)
     delete_route(path, options)
-    @named_routes.delete(name)
+    named_routes.delete(name)
   end
 
   # Attaches a +route+ to a +name+
@@ -128,7 +130,7 @@ class Usher
   #   route = set.add_route('/test')
   #   set.name(:test, route)
   def name(name, route)
-    @named_routes[name.to_sym] = route
+    named_routes[name.to_sym] = route
     route
   end
 
@@ -206,9 +208,9 @@ class Usher
   # * Any other key is interpreted as a requirement for the variable of its name.
   def add_route(path, options = nil)
     route = get_route(path, options)
-    @root.add(route)
-    @routes << route
-    @grapher.add_route(route)
+    root.add(route)
+    routes << route
+    grapher.add_route(route)
     route.parent_route = parent_route if parent_route
     route
   end
@@ -219,8 +221,8 @@ class Usher
   #   set.delete_route('/test')
   def delete_route(path, options = nil)
     route = get_route(path, options)
-    @root.delete(route)
-    @routes = @root.unique_routes
+    root.delete(route)
+    @routes = root.unique_routes
     rebuild_grapher!
     route
   end
@@ -232,11 +234,7 @@ class Usher
   #   route = set.add_route('/test')
   #   set.recognize(Request.new('/test')).path.route == route => true
   def recognize(request, path = request.path)
-    response = @root.find(request, path, @splitter.split(path))
-    if response && !response.path.dynamic?
-      response.path.cached_response = response
-    end
-    response
+    root.find(request, path, splitter.split(path))
   end
 
   # Recognizes a +path+ and returns +nil+ or an Usher::Node::Response, which is a struct containing a Usher::Route::Path and an array of arrays containing the extracted parameters. Convenience method for when recognizing on the request object is unneeded.
@@ -255,7 +253,7 @@ class Usher
   #   route = set.add_route('/:controller/:action')
   #   set.path_for_options({:controller => 'test', :action => 'action'}) == path.route => true
   def path_for_options(options)
-    @grapher.find_matching_path(options)
+    grapher.find_matching_path(options)
   end
 
   def parent_route=(route)
@@ -273,10 +271,10 @@ class Usher
       original.routes.each do |route|
         new_route = route.dup
         new_route.router = self
-        @root.add(new_route)
-        @routes << new_route
+        root.add(new_route)
+        routes << new_route
         if name = inverted_named_routes[route]
-          @named_routes[name] = new_route
+          named_routes[name] = new_route
         end
       end
       send(:generator=, original.generator.class.new) if original.can_generate?
@@ -337,8 +335,8 @@ class Usher
       end
     end
 
-    if conditions
-      conditions.keys.all?{|k| request_methods.include?(k)} or raise
+    if conditions && !conditions.empty?
+      conditions.keys.all?{|k| request_methods.include?(k)} or raise("You are trying to use request methods that don't exist in the request_methods supplied #{conditions.keys.join(', ')} -> #{conditions.keys.select{|k| request_methods.include?(k)}.join(", ")}")
     end
 
     if priority
@@ -353,7 +351,7 @@ class Usher
 
   def rebuild_grapher!
     @grapher = Grapher.new(self)
-    @routes.each{|r| @grapher.add_route(r)}
+    routes.each{|r| grapher.add_route(r)}
   end
   
 end

data/spec/private/rack/dispatch_spec.rb

@@ -5,6 +5,21 @@ require 'rack'
 route_set = Usher::Interface.for(:rack)
 route_set.extend(CallWithMockRequestMixin)
 
+describe "Usher (for rack) route dispatching" do
+  before(:each) do
+    @route_set = Usher::Interface.for(:rack, :redirect_on_trailing_delimiters => true)
+    @route_set.extend(CallWithMockRequestMixin)
+    @app = MockApp.new("Hello World!")
+    @route_set.add('/sample').to(@app)
+  end
+
+  it "should dispatch a request" do
+    response = @route_set.call_with_mock_request('/sample/')
+    response.headers["Location"].should == "/sample"
+  end
+
+end
+
 describe "Usher (for rack) route dispatching" do
   before(:each) do
     route_set.reset!

data/spec/private/rails3/dispatch_spec.rb

@@ -0,0 +1,274 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
+require "usher"
+require 'rack'
+
+route_set = Usher::Interface.for(:rails3)
+route_set.extend(CallWithMockRequestMixin)
+
+describe "Usher (for rack) route dispatching" do
+  before(:each) do
+    route_set.reset!
+    @app = MockApp.new("Hello World!")
+  end
+
+  describe "HTTP GET" do
+    before(:each) do
+      route_set.reset!
+      route_set.add_route(@app, {:path_info => '/sample', :request_method => 'GET'})
+    end
+
+    it "should dispatch a request" do
+      response = route_set.call_with_mock_request
+      response.body.should eql("Hello World!")
+    end
+
+  end
+
+  #describe "HTTP POST" do
+  #  before(:each) do
+  #    route_set.reset!
+  #    route_set.add('/sample', :conditions => {:request_method => 'POST'}).to(@app)
+  #    route_set.add('/sample').to(MockApp.new("You shouldn't get here if you are using POST"))
+  #  end
+  #
+  #  it "should dispatch a POST request" do
+  #    response = route_set.call_with_mock_request('/sample', 'POST')
+  #    response.body.should eql("Hello World!")
+  #  end
+  #
+  #  it "shouldn't dispatch a GET request" do
+  #    response = route_set.call_with_mock_request('/sample', 'GET')
+  #    response.body.should eql("You shouldn't get here if you are using POST")
+  #  end
+  #
+  #  it "should write usher.params" do
+  #    response = route_set.call_with_mock_request("/sample", 'POST')
+  #    @app.env["usher.params"].should == {}
+  #  end
+  #end
+  #
+  #it "should returns HTTP 404 if route doesn't exist" do
+  #  response = route_set.call_with_mock_request("/not-existing-url")
+  #  response.status.should eql(404)
+  #end
+  #
+  #describe "shortcuts" do
+  #  describe "get" do
+  #    before(:each) do
+  #      route_set.reset!
+  #      route_set.get('/sample').to(@app)
+  #    end
+  #
+  #    it "should dispatch a GET request" do
+  #      response = route_set.call_with_mock_request("/sample", "GET")
+  #      response.body.should eql("Hello World!")
+  #    end
+  #
+  #    it "should dispatch a HEAD request" do
+  #      response = route_set.call_with_mock_request("/sample", "HEAD")
+  #      response.body.should eql("Hello World!")
+  #    end
+  #  end
+  #end
+  #
+  #describe "non rack app destinations" do
+  #  it "should route to a default application when using a hash" do
+  #    $captures = []
+  #    @default_app = lambda do |e|
+  #      $captures << :default
+  #      Rack::Response.new("Default").finish
+  #    end
+  #    @router = Usher::Interface.for(:rack)
+  #    @router.default(@default_app)
+  #    @router.add("/default").to(:action => "default")
+  #    response = @router.call(Rack::MockRequest.env_for("/default"))
+  #    $captures.should == [:default]
+  #  end
+  #end
+  #
+  #describe "mounted rack instances" do
+  #  before do
+  #    @bad_app = mock("bad_app")
+  #
+  #    @usher2 = Usher::Interface.for(:rack)
+  #    @usher2.add("/good" ).to(@app)
+  #    @usher2.add("/bad"  ).match_partially!.to(@bad_app)
+  #    @usher2.add("/some(/:foo)").to(@app)
+  #
+  #    @usher3 = Usher::Interface.for(:rack)
+  #    @usher3.add("(/)", :default_values => {:optional_root => true} ).to(@app)
+  #
+  #    @usher2.add("/optional_mount").match_partially!.to(@usher3)
+  #
+  #    route_set.add("/baz", :default_values => {:baz => "baz"}).match_partially!.to(@usher3)
+  #    route_set.add("/foo/:bar", :default_values => {:foo => "foo"}).match_partially!.to(@usher2)
+  #    route_set.add("/foo", :default_values => {:controller => :foo}).to(@app)
+  #  end
+  #
+  #  it "should match the route without nesting" do
+  #    @app.should_receive(:call).once.with{ |e| e['usher.params'].should == {:controller => :foo}}
+  #    route_set.call(Rack::MockRequest.env_for("/foo"))
+  #  end
+  #
+  #  it "should match the route where the last part is optional" do
+  #    @app.should_receive(:call).once.with do |e|
+  #      e['usher.params'].should == {
+  #        :optional_root  => true,
+  #        :baz            => 'baz'
+  #      }
+  #    end
+  #    route_set.call(Rack::MockRequest.env_for("/baz/"))
+  #  end
+  #
+  #  it "should match when a mounted apps root route is optional" do
+  #    @app.should_receive(:call).once.with do |e|
+  #      e['usher.params'].should == {
+  #        :optional_root => true,
+  #        :foo           => "foo",
+  #        :bar           => "bar"
+  #      }
+  #    end
+  #    route_set.call(Rack::MockRequest.env_for("/foo/bar/optional_mount"))
+  #  end
+  #
+  #  it "should match the route where the last part is empty" do
+  #    @app.should_receive(:call).once.with do |e|
+  #      e['usher.params'].should == {
+  #        :baz            => 'baz',
+  #        :optional_root  => true
+  #      }
+  #    end
+  #    route_set.call(Rack::MockRequest.env_for("/baz"))
+  #  end
+  #
+  #  it "should route through the first route, and the second to the app" do
+  #    @app.should_receive(:call).once.with{|e| e['usher.params'].should == {:bar => "bar", :foo => "foo"}}
+  #    result = route_set.call(Rack::MockRequest.env_for("/foo/bar/good"))
+  #  end
+  #
+  #  it "should go through to the bad app" do
+  #    @bad_app.should_receive(:call).once.with{|e| e['usher.params'].should == {:bar => "some_bar", :foo => "foo"}}
+  #    result = route_set.call(Rack::MockRequest.env_for("/foo/some_bar/bad"))
+  #  end
+  #
+  #  it "should match optional routes paramters" do
+  #    @app.should_receive(:call).once.with{|e| e['usher.params'].should == {:bar => "bar", :foo => "a_different_foo"}}
+  #    route_set.call(Rack::MockRequest.env_for("/foo/bar/some/a_different_foo"))
+  #  end
+  #
+  #  describe "SCRIPT_NAME & PATH_INFO" do
+  #    it "shouldn't update the script name for a fully consumed route" do
+  #      @app.should_receive(:call).once.with do |e|
+  #        e['SCRIPT_NAME'].should == ""
+  #        e['PATH_INFO'].should   == "/foo"
+  #      end
+  #      route_set.call(Rack::MockRequest.env_for("/foo"))
+  #    end
+  #
+  #    it "should update the script name and path info for a partially consumed route" do
+  #      @app.should_receive(:call).once.with do |e|
+  #        e['SCRIPT_NAME'].should == "/partial"
+  #        e['PATH_INFO'].should   == "/bar/baz"
+  #      end
+  #
+  #      route_set.add("/partial").match_partially!.to(@app)
+  #      route_set.call(Rack::MockRequest.env_for("/partial/bar/baz"))
+  #    end
+  #
+  #    it "should consume the path through a mounted usher" do
+  #      @bad_app.should_receive(:call).once.with do |e|
+  #        e['SCRIPT_NAME'].should == "/foo/bar/bad"
+  #        e['PATH_INFO'].should   == "/leftovers"
+  #      end
+  #
+  #      route_set.call(Rack::MockRequest.env_for("/foo/bar/bad/leftovers"))
+  #    end
+  #
+  #    it "should not modify SCRIPT_NAME in place since thin freezes it" do
+  #      @app.should_receive(:call).once
+  #      env = Rack::MockRequest.env_for("/foo/bar/good")
+  #      env["SCRIPT_NAME"] = "".freeze
+  #      route_set.call(env)
+  #    end
+  #  end
+  #
+  #  describe "dupping" do
+  #    before do
+  #      @app  = mock("app")
+  #      @u1   = Usher::Interface.for(:rack)
+  #      @u2   = Usher::Interface.for(:rack)
+  #
+  #      @u1.add("/one", :default_values => {:one => :one}).to(@app)
+  #      @u1.add("/mount").match_partially!.to(@u2)
+  #
+  #      @u2.add("/app", :default_values => {:foo => :bar}).to(@app)
+  #
+  #    end
+  #
+  #    it "should allow me to dup the router" do
+  #      @app.should_receive(:call).twice.with{|e| e['usher.params'].should == {:one => :one}}
+  #      @u1.call(Rack::MockRequest.env_for("/one"))
+  #      u1_dash = @u1.dup
+  #      u1_dash.call(Rack::MockRequest.env_for("/one"))
+  #    end
+  #
+  #    it "should allow me to dup the router and add a new route without polluting the original" do
+  #      @app.should_receive(:call).with{|e| e['usher.params'].should == {:foo => :bar}}
+  #      u1_dash = @u1.dup
+  #      u1_dash.add("/foo", :default_values => {:foo => :bar}).to(@app)
+  #      u1_dash.call(Rack::MockRequest.env_for("/foo"))
+  #      @app.should_not_receive(:call)
+  #      @u1.call(Rack::MockRequest.env_for("/foo"))
+  #    end
+  #
+  #    it "should allow me to dup the router and nested routers should remain intact" do
+  #      @app.should_receive(:call).with{|e| e['usher.params'].should == {:foo => :bar}}
+  #      u1_dash = @u1.dup
+  #      u1_dash.call(Rack::MockRequest.env_for("/mount/app"))
+  #    end
+  #
+  #    it "should allow me to dup the router and add more routes" do
+  #      @app.should_receive(:call).with{|e| e['usher.params'].should == {:another => :bar}}
+  #
+  #      u3 = Usher::Interface.for(:rack)
+  #      u1_dash = @u1.dup
+  #
+  #      u3.add("/another_bar", :default_values => {:another => :bar}).to(@app)
+  #      u1_dash.add("/some/mount").match_partially!.to(u3)
+  #
+  #      u1_dash.call(Rack::MockRequest.env_for("/some/mount/another_bar"))
+  #
+  #      @app.should_not_receive(:call)
+  #      @u1.call(Rack::MockRequest.env_for("/some/mount/another_bar"))
+  #    end
+  #  end
+  #end
+  #
+  #describe "use as middlware" do
+  #  it "should allow me to set a default application to use" do
+  #    @app.should_receive(:call).with{|e| e['usher.params'].should == {:middle => :ware}}
+  #
+  #    u = Usher::Interface.for(:rack)
+  #    u.default @app
+  #    u.add("/foo", :default_values => {:middle => :ware}).name(:foo)
+  #
+  #    u.call(Rack::MockRequest.env_for("/foo"))
+  #  end
+  #
+  #  it "should use the default application when no routes match" do
+  #    env = Rack::MockRequest.env_for("/not_a_route")
+  #    @app.should_receive(:call).with(env)
+  #    u = Usher::Interface.for(:rack)
+  #    u.default @app
+  #    u.call(env)
+  #  end
+  #
+  #  it "should allow me to set the application after initialization" do
+  #    @app.should_receive(:call).with{|e| e['usher.params'].should == {:after => :stuff}}
+  #    u = Usher::Interface.for(:rack)
+  #    u.default @app
+  #    u.add("/foo", :default_values => {:after => :stuff})
+  #    u.call(Rack::MockRequest.env_for("/foo"))
+  #  end
+  #end
+end

data/spec/private/recognize_spec.rb

@@ -332,6 +332,20 @@ describe "Usher route recognition" do
     @route_set.recognize(build_request(:method => "get", :path => "/asdf")).should be_nil
   end
 
+  it "should match a variable inbetween two secondary delimiters" do
+    @route_set.add_route("/o.:slug.gif").to(:test)
+    response = @route_set.recognize(build_request(:method => "get", :path => "/o.help.gif"))
+    response.destination.should == :test
+    response.params.should == [[:slug, "help"]]
+  end
+  
+  it "should match a route with no path" do
+    route = @route_set.add_route(nil, :conditions => {:protocol => 'http'}).to(:test)
+    @route_set.recognize(build_request({:method => 'post', :protocol => 'http', :path => '/foo'})).destination.should == :test
+    @route_set.recognize(build_request({:method => 'post', :protocol => 'http', :path => '/bar'})).destination.should == :test
+    @route_set.recognize(build_request({:method => 'post', :protocol => 'https', :path => '/foo'})).should be_nil
+  end
+  
   describe "partial recognition" do
     it "should partially match a route" do
       route = @route_set.add_route("/foo")

data/spec/rails2_2/compat.rb

@@ -0,0 +1,3 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
+require File.expand_path(File.join(File.dirname(__FILE__), 'vendor', 'rails', 'config', 'environment'))
+

data/spec/{private/rails2_2 → rails2_2}/generate_spec.rb

@@ -1,4 +1,3 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
 require File.expand_path(File.join(File.dirname(__FILE__), 'compat'))
 require "usher"
 

data/spec/{private/rails2_2 → rails2_2}/path_spec.rb

@@ -1,4 +1,3 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
 require File.expand_path(File.join(File.dirname(__FILE__), 'compat'))
 require "usher"
 

data/spec/{private/rails2_2 → rails2_2}/recognize_spec.rb

@@ -1,4 +1,3 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
 require File.expand_path(File.join(File.dirname(__FILE__), 'compat'))
 require "usher"
 

data/spec/rails2_2/vendor/rails/app/controllers/application.rb

@@ -0,0 +1,15 @@
+# Filters added to this controller apply to all controllers in the application.
+# Likewise, all the methods added will be available for all controllers.
+
+class ApplicationController < ActionController::Base
+  helper :all # include all helpers, all the time
+
+  # See ActionController::RequestForgeryProtection for details
+  # Uncomment the :secret if you're not using the cookie session store
+  protect_from_forgery # :secret => '<%= app_secret %>'
+  
+  # See ActionController::Base for details 
+  # Uncomment this to filter the contents of submitted sensitive data parameters
+  # from your application log (in this case, all fields with names like "password"). 
+  # filter_parameter_logging :password
+end

data/spec/rails2_2/vendor/rails/app/helpers/application_helper.rb

@@ -0,0 +1,3 @@
+# Methods added to this helper will be available to all templates in the application.
+module ApplicationHelper
+end

data/spec/rails2_2/vendor/rails/config/boot.rb

@@ -0,0 +1,109 @@
+# Don't change this file!
+# Configure your app in config/environment.rb and config/environments/*.rb
+
+RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
+
+module Rails
+  class << self
+    def boot!
+      unless booted?
+        preinitialize
+        pick_boot.run
+      end
+    end
+
+    def booted?
+      defined? Rails::Initializer
+    end
+
+    def pick_boot
+      (vendor_rails? ? VendorBoot : GemBoot).new
+    end
+
+    def vendor_rails?
+      File.exist?("#{RAILS_ROOT}/vendor/rails")
+    end
+
+    def preinitialize
+      load(preinitializer_path) if File.exist?(preinitializer_path)
+    end
+
+    def preinitializer_path
+      "#{RAILS_ROOT}/config/preinitializer.rb"
+    end
+  end
+
+  class Boot
+    def run
+      load_initializer
+      Rails::Initializer.run(:set_load_path)
+    end
+  end
+
+  class VendorBoot < Boot
+    def load_initializer
+      require "#{RAILS_ROOT}/vendor/rails/railties/lib/initializer"
+      Rails::Initializer.run(:install_gem_spec_stubs)
+    end
+  end
+
+  class GemBoot < Boot
+    def load_initializer
+      self.class.load_rubygems
+      load_rails_gem
+      require 'initializer'
+    end
+
+    def load_rails_gem
+      if version = self.class.gem_version
+        gem 'rails', version
+      else
+        gem 'rails'
+      end
+    rescue Gem::LoadError => load_error
+      $stderr.puts %(Missing the Rails #{version} gem. Please `gem install -v=#{version} rails`, update your RAILS_GEM_VERSION setting in config/environment.rb for the Rails version you do have installed, or comment out RAILS_GEM_VERSION to use the latest version installed.)
+      exit 1
+    end
+
+    class << self
+      def rubygems_version
+        Gem::RubyGemsVersion rescue nil
+      end
+
+      def gem_version
+        if defined? RAILS_GEM_VERSION
+          RAILS_GEM_VERSION
+        elsif ENV.include?('RAILS_GEM_VERSION')
+          ENV['RAILS_GEM_VERSION']
+        else
+          parse_gem_version(read_environment_rb)
+        end
+      end
+
+      def load_rubygems
+        require 'rubygems'
+        min_version = '1.3.1'
+        unless rubygems_version >= min_version
+          $stderr.puts %Q(Rails requires RubyGems >= #{min_version} (you have #{rubygems_version}). Please `gem update --system` and try again.)
+          exit 1
+        end
+
+      rescue LoadError
+        $stderr.puts %Q(Rails requires RubyGems >= #{min_version}. Please install RubyGems and try again: http://rubygems.rubyforge.org)
+        exit 1
+      end
+
+      def parse_gem_version(text)
+        $1 if text =~ /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/
+      end
+
+      private
+        def read_environment_rb
+          File.read("#{RAILS_ROOT}/config/environment.rb")
+        end
+    end
+  end
+end
+
+# All that for this:
+Rails.boot!

data/spec/rails2_2/vendor/rails/config/environment.rb

@@ -0,0 +1,74 @@
+# Be sure to restart your server when you modify this file
+
+# Uncomment below to force Rails into production mode when
+# you don't control web/app server and can't set it the proper way
+# ENV['RAILS_ENV'] ||= 'production'
+
+# Specifies gem version of Rails to use when vendor/rails is not present
+
+# Bootstrap the Rails environment, frameworks, and default configuration
+require File.join(File.dirname(__FILE__), 'boot')
+
+Rails::Initializer.run do |config|
+  # Settings in config/environments/* take precedence over those specified here.
+  # Application configuration should go into files in config/initializers
+  # -- all .rb files in that directory are automatically loaded.
+  # See Rails::Configuration for more options.
+
+  # Skip frameworks you're not going to use. To use Rails without a database
+  # you must remove the Active Record framework.
+  # config.frameworks -= [ :active_record, :active_resource, :action_mailer ]
+
+  # Specify gems that this application depends on. 
+  # They can then be installed with "rake gems:install" on new installations.
+  # You have to specify the :lib option for libraries, where the Gem name (sqlite3-ruby) differs from the file itself (sqlite3)
+  # config.gem "bj"
+  # config.gem "hpricot", :version => '0.6', :source => "http://code.whytheluckystiff.net"
+  # config.gem "sqlite3-ruby", :lib => "sqlite3"
+  # config.gem "aws-s3", :lib => "aws/s3"
+
+  # Only load the plugins named here, in the order given. By default, all plugins 
+  # in vendor/plugins are loaded in alphabetical order.
+  # :all can be used as a placeholder for all plugins not explicitly named
+  # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
+
+  # Add additional load paths for your own custom dirs
+  # config.load_paths += %W( #{RAILS_ROOT}/extras )
+
+  # Force all environments to use the same logger level
+  # (by default production uses :info, the others :debug)
+  # config.log_level = :debug
+
+  # Make Time.zone default to the specified zone, and make Active Record store time values
+  # in the database in UTC, and return them converted to the specified local zone.
+  # Run "rake -D time" for a list of tasks for finding time zone names. Comment line to use default local time.
+  config.time_zone = 'UTC'
+
+  # The internationalization framework can be changed to have another default locale (standard is :en) or more load paths.
+  # All files from config/locales/*.rb,yml are added automatically.
+  # config.i18n.load_path << Dir[File.join(RAILS_ROOT, 'my', 'locales', '*.{rb,yml}')]
+  # config.i18n.default_locale = :de
+
+  # Your secret key for verifying cookie session data integrity.
+  # If you change this key, all old sessions will become invalid!
+  # Make sure the secret is at least 30 characters and all random, 
+  # no regular words or you'll be exposed to dictionary attacks.
+  config.action_controller.session = {
+    :session_key => '_<%= app_name %>_session',
+    :secret      => '<%= app_secret %>'
+  }
+
+  # Use the database for sessions instead of the cookie-based default,
+  # which shouldn't be used to store highly confidential information
+  # (create the session table with "rake db:sessions:create")
+  # config.action_controller.session_store = :active_record_store
+
+  # Use SQL instead of Active Record's schema dumper when creating the test database.
+  # This is necessary if your schema can't be completely dumped by the schema dumper,
+  # like if you have constraints or database-specific column types
+  # config.active_record.schema_format = :sql
+
+  # Activate observers that should always be running
+  # Please note that observers generated using script/generate observer need to have an _observer suffix
+  # config.active_record.observers = :cacher, :garbage_collector, :forum_observer
+end