gin 1.0.4 → 1.1.0

data/History.rdoc

@@ -1,3 +1,19 @@
+=== 1.1.0 / 2013-07-10
+
+* Major Enhancements
+  * Test helper methods and assertions
+  * Template/View support with tilt
+  * New config implementation with auto-(re)loading
+  * App instances are individually configurable
+  * Gin command for easy new app generation
+
+* Minor Enhancements
+  * Routes now support multiple embedded params between slashes
+
+* Bugfixes
+  * Lots of thread-safety fixes
+  * Fixes to rare reloader path issue
+
 === 1.0.4 / 2013-03-19
 
 * Minor Enhancements

data/Manifest.txt

@@ -1,11 +1,11 @@
-.autotest
-.gitignore
 History.rdoc
 Manifest.txt
 README.rdoc
 Rakefile
+bin/gin
 lib/gin.rb
 lib/gin/app.rb
+lib/gin/cache.rb
 lib/gin/config.rb
 lib/gin/constants.rb
 lib/gin/controller.rb
@@ -18,7 +18,9 @@ lib/gin/reloadable.rb
 lib/gin/request.rb
 lib/gin/response.rb
 lib/gin/router.rb
+lib/gin/rw_lock.rb
 lib/gin/stream.rb
+lib/gin/test.rb
 public/400.html
 public/404.html
 public/500.html
@@ -29,10 +31,16 @@ public/gin_sm.png
 test/app/app_foo.rb
 test/app/controllers/app_controller.rb
 test/app/controllers/foo_controller.rb
+test/app/layouts/bar.erb
+test/app/layouts/foo.erb
+test/app/views/bar.erb
 test/mock_config/backend.yml
+test/mock_config/invalid.yml
 test/mock_config/memcache.yml
 test/mock_config/not_a_config.txt
+test/mock_app.rb
 test/test_app.rb
+test/test_cache.rb
 test/test_config.rb
 test/test_controller.rb
 test/test_errorable.rb
@@ -42,3 +50,5 @@ test/test_helper.rb
 test/test_request.rb
 test/test_response.rb
 test/test_router.rb
+test/test_rw_lock.rb
+test/test_test.rb

data/README.rdoc

@@ -7,8 +7,15 @@
 Gin is a small Ruby web framework, built on Rack, which borrows from
 Sinatra expressiveness, and targets larger applications.
 
+== Getting Started
+
+Gin provides a simple command for setting up a new application.
+  $ gin path/to/appname
+
 == Hello World
 
+A Hello World application requires at minimum a Gin::App instance and a Gin::Controller.
+
   # config.ru
   require 'gin'
 
@@ -22,10 +29,36 @@ Sinatra expressiveness, and targets larger applications.
 
   run MyApp.new
 
+== Why Gin?
+
+Gin tries to fill a need for a framework that's simple and lightweight, yet scalable for large applications. Gin is comparable to Sinatra in performance and memory consumption, but supports multiple controllers and filters.
+
+=== Features
+
+* Easily mount multiple apps as Rack middleware
+* Simple and fast RESTful routing
+* Controller classes and action arguments
+* Inheritable Before/After filter chains
+* Response streaming
+* Asset urls with cache-busting and CDN support
+* Configs for multiple environments
+* Periodic config reloading
+* Inheritable error handling
+* In-app middleware
+* Rack-Session and Rack-Protection
+* Dev-mode auto-reloading
+* Templates (layouts/views) with Tilt
+
+=== What's Not Included
+
+* Helpers - those are called Modules in Ruby
+* ORM - choose your own library
+
 == Requirements
 
 * rack
 * rack-protection
+* tilt
 
 == Install
 

data/Rakefile

@@ -11,6 +11,11 @@ Hoe.spec 'gin' do
 
   self.extra_deps << ['rack',            '~>1.1']
   self.extra_deps << ['rack-protection', '~>1.0']
+  self.extra_deps << ['tilt',            '~>1.4']
+
+  self.extra_dev_deps << ['nokogiri', '~>1.5.9']
+  self.extra_dev_deps << ['plist',    '~>3.1.0']
+  self.extra_dev_deps << ['bson',     '~>1.9.0']
 end
 
 # vim: syntax=ruby

data/TODO.rdoc

@@ -0,0 +1,7 @@
+- Extend router functionality to allow multiple %s per node.
+
+= Maybe
+- Custom environment names for dev, test, stage, and prod
+- Find a better default non-locking logger
+- Bundler-runtime-free
+  - script/server equivalent

data/bin/gin

@@ -0,0 +1,158 @@
+#!/usr/bin/env ruby
+
+$: << File.join(File.dirname(__FILE__), "../lib") if $0 == "bin/gin"
+require 'gin'
+
+class Gin::Cmd
+  def self.run argv=ARGV
+    show_help if argv.empty? || argv.delete("-h") || argv.delete("--help")
+
+    bare = !!argv.delete("--bare")
+
+    path = argv.pop
+    error("Missing app_name argument. Use gin -h for help.") if !path
+
+    error("Invalid options #{argv.join(", ")}.") unless argv.empty?
+
+    name           = File.basename(path)
+    dir            = File.expand_path(path)
+    parent_ru_path = File.expand_path(File.join(dir, "..", "*.ru"))
+    standalone     = Dir[parent_ru_path].empty?
+
+    make_dirs(dir, bare)
+
+    app_class_name = Gin.camelize(name)
+    make_config_ru(app_class_name, name, dir) if standalone
+    make_console(name, dir) if standalone
+    make_app_rb(app_class_name, name, dir, standalone)
+    make_home_ctrl_rb(app_class_name, name, dir)
+
+    puts "You're all set! Your new app is waiting at #{dir}.\n\n"
+    exit 0
+  end
+
+
+  def self.error msg
+    $stderr.puts "#{msg}\n\n"
+    exit 1
+  end
+
+
+  def self.show_help
+    puts <<-STR
+
+gin #{Gin::VERSION}
+
+Create a new Gin application.
+
+  gin <path/to/app_name>
+
+Examples:
+
+  $ gin my_website
+  $ gin my_api --bare
+
+Options:
+      --bare    Don't create view-related files/dirs
+  -h  --help    Show this screen
+
+Gin applications created in a directory containing
+a *.ru file will not generate its own config.ru.
+
+    STR
+    true
+  end
+
+
+  def self.make_dirs dir, bare=false
+    error("Can't create directory: #{dir} already exists") if File.directory?(dir)
+
+    Dir.mkdir(dir)
+
+    unless bare
+      Dir.mkdir(File.join(dir, "views"))
+      Dir.mkdir(File.join(dir, "layouts"))
+      Dir.mkdir(File.join(dir, "public"))
+      Dir.mkdir(File.join(dir, "public", "js"))
+      Dir.mkdir(File.join(dir, "public", "css"))
+      Dir.mkdir(File.join(dir, "public", "img"))
+    end
+
+    Dir.mkdir(File.join(dir, "lib"))
+    Dir.mkdir(File.join(dir, "config"))
+    Dir.mkdir(File.join(dir, "controllers"))
+  end
+
+
+  def self.make_home_ctrl_rb app_class_name, name, dir
+    contents = <<-STR
+class #{app_class_name}::HomeController < Gin::Controller
+  def index
+<<-HTML
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Welcome to Gin</title>
+    <link rel="stylesheet" type="text/css" href="/gin.css"/>
+  </head>
+  <body style="">
+    <div class="canvas">
+      <img src="/gin_sm.png" class="logo"/>
+      <h1>Welcome to Gin</h1>
+      <p>Gin is a lightweight framework geared towards API and Website development.</br>
+Start building your app by editing your app's root <strong>.rb</strong> file and 
+your <strong>HomeController</strong> at <strong>controllers/home_controller.rb</strong>.</p>
+      <p><center>The <a href="http://yaks.me/gin/wiki" target="_blank">WIKI</a> is available for help and documentation.
+      </center></p>
+    </div>
+  </body>
+</html>
+HTML
+  end
+end
+    STR
+
+    File.write(File.join(dir, "controllers/home_controller.rb"), contents)
+  end
+
+
+  def self.make_app_rb app_class_name, name, dir, standalone
+    contents = <<-STR
+require 'gin'
+
+$:.unshift( File.expand_path('../lib', __FILE__) )
+#{"$:.unshift( File.expand_path('../controllers', __FILE__) )\n" if standalone}
+
+class #{app_class_name} < Gin::App
+  require '#{"#{name}/controllers/" if !standalone}home_controller'
+  mount #{app_class_name}::HomeController, "/"
+end
+    STR
+
+    File.write(File.join(dir, "#{name}.rb"), contents)
+  end
+
+
+  def self.make_config_ru app_class_name, name, dir
+    contents = <<-STR
+$:.unshift File.expand_path("..", __FILE__)
+require '#{name}'
+run #{app_class_name}.new
+    STR
+
+    filepath = File.join(dir, 'config.ru')
+    File.write(filepath, contents)
+  end
+
+
+  def self.make_console name, dir
+    filepath = File.join(dir, 'console')
+    bash = "irb -I \"$( dirname \"${BASH_SOURCE[0]}\" )\" -r #{name}\n"
+    File.write(filepath, bash)
+    require 'fileutils'
+    FileUtils.chmod "u=wrx,go=rx", filepath
+  end
+end
+
+
+Gin::Cmd.run

data/lib/gin.rb

@@ -1,7 +1,8 @@
 require 'rack'
+require 'tilt'
 
 class Gin
-  VERSION = '1.0.4'
+  VERSION = '1.1.0'
 
   LIB_DIR    = File.expand_path("..", __FILE__)            #:nodoc:
   PUBLIC_DIR = File.expand_path("../../public/", __FILE__) #:nodoc:
@@ -16,6 +17,10 @@ class Gin
     def http_status; 404; end
   end
 
+  class MissingConfig < Error; end
+
+  class TemplateMissing < Error; end
+
 
   ##
   # Change string to underscored version.
@@ -29,6 +34,16 @@ class Gin
   end
 
 
+  ##
+  # Change string to camel-case version.
+
+  def self.camelize str
+    str = str.dup
+    str.gsub!(/\/([^_:])/){|m| "::#{$1.upcase}" }
+    str.gsub!(/(^|_+)([^_:])/){|m| $2.upcase }
+  end
+
+
   ##
   # Create a URI query from a Hash.
 
@@ -110,13 +125,15 @@ class Gin
   require 'gin/core_ext/rack_commonlogger'
 
   require 'gin/constants'
-  require 'gin/app'
+  require 'gin/cache'
   require 'gin/router'
   require 'gin/config'
   require 'gin/request'
   require 'gin/response'
+  require 'gin/rw_lock'
   require 'gin/stream'
   require 'gin/errorable'
   require 'gin/filterable'
   require 'gin/controller'
+  require 'gin/app'
 end

data/lib/gin/app.rb

@@ -18,10 +18,10 @@ class Gin::App
   class RouterError < Gin::Error; end
 
   CALLERS_TO_IGNORE = [ # :nodoc:
-    /\/gin(\/(.*?))?\.rb$/,             # all gin code
-    /lib\/tilt.*\.rb$/,                 # all tilt code
+    /lib\/gin(\/(.*?))?\.rb/,           # all gin code
+    /lib\/tilt.*\.rb/,                  # all tilt code
     /^\(.*\)$/,                         # generated code
-    /rubygems\/custom_require\.rb$/,    # rubygems require hacks
+    /rubygems\/custom_require\.rb/,     # rubygems require hacks
     /active_support/,                   # active_support require hacks
     /bundler(\/runtime)?\.rb/,          # bundler require hacks
     /<internal:/,                       # internal in ruby >= 1.9.2
@@ -30,17 +30,41 @@ class Gin::App
 
 
   def self.inherited subclass   #:nodoc:
+    subclass.setup
+  end
+
+
+  def self.setup   # :nodoc:
     caller_line = caller.find{|line| !CALLERS_TO_IGNORE.any?{|m| line =~ m} }
     filepath = File.expand_path(caller_line.split(/:\d+:in `/).first)
-    dir      = File.dirname(filepath)
-    subclass.root_dir dir
-    subclass.instance_variable_set("@source_file", filepath)
-    subclass.instance_variable_set("@source_class", subclass.to_s)
+    dir = File.dirname(filepath)
+
+    @source_file  = filepath
+    @source_class = self.to_s
+    @templates    = Gin::Cache.new
+    @md5s         = Gin::Cache.new
+    @reload_mutex = Mutex.new
+    @autoreload   = nil
+    @instance     = nil
+
+    @options = {}
+    @options[:root_dir]       = dir
+    @options[:environment]    = ENV['RACK_ENV'] || ENV_DEV
+    @options[:error_delegate] = Gin::Controller
+    @options[:middleware]     = []
+    @options[:logger]         = $stdout
+    @options[:router]         = Gin::Router.new
+    @options[:session_secret] = SESSION_SECRET
+    @options[:protection]     = false
+    @options[:sessions]       = false
+    @options[:config_reload]  = false
+    @options[:layout]         = :layout
+    @options[:template_engines] = Tilt.mappings.merge(nil => [Tilt::ERBTemplate])
   end
 
 
   ##
-  # Create a new intance of the app and call it.
+  # Create a new instance of the app and call it.
 
   def self.call env
     @instance ||= self.new
@@ -48,6 +72,35 @@ class Gin::App
   end
 
 
+  ##
+  # Hash of the full Gin::App configuration.
+  # Result of using class-level setter methods such as Gin::App.environment.
+
+  def self.options
+    @options
+  end
+
+
+  ##
+  # Returns the source file of the current app.
+
+  def self.source_file
+    @source_file
+  end
+
+
+  def self.namespace #:nodoc:
+    # Parent namespace of the App class. Used for reloading purposes.
+    Gin.const_find(@source_class.split("::")[0..-2]) if @source_class
+  end
+
+
+  def self.source_class #:nodoc:
+    # Lookup the class from its name. Used for reloading purposes.
+    Gin.const_find(@source_class) if @source_class
+  end
+
+
   ##
   # Enable or disable auto-app reloading.
   # On by default in development mode.
@@ -55,21 +108,36 @@ class Gin::App
   # In order for an app to be reloadable, the libs and controllers must be
   # required from the Gin::App class context, or use MyApp.require("lib").
   #
-  # Reloading is not supported for applications defined in the config.ru file.
+  # Gin::App class reloading is not supported for applications defined in
+  # the config.ru file. Dependencies will, however, still be reloaded.
+  #
+  # Autoreload must be enabled before any calls to Gin::App.require for
+  # those files to be reloaded.
+  #
+  #   class MyApp < Gin::App
+  #
+  #     # Only reloaded in development mode
+  #     require 'nokogiri'
+  #
+  #     autoreload false
+  #     # Never reloaded
+  #     require 'static_thing'
+  #
+  #     autoreload true
+  #     # Reloaded every request
+  #     require 'my_app/home_controller'
+  #   end
 
   def self.autoreload val=nil
     @autoreload = val unless val.nil?
+    reload = @autoreload.nil? ? self.environment == ENV_DEV : @autoreload
 
-    if @autoreload.nil?
-      @autoreload = File.extname(source_file) != ".ru" && development?
+    if reload
+      Object.send :require, 'gin/reloadable' unless defined?(Gin::Reloadable)
+      include Gin::Reloadable                unless self < Gin::Reloadable
     end
 
-    if @autoreload && (!defined?(Gin::Reloadable) || !include?(Gin::Reloadable))
-      Object.send :require, 'gin/reloadable'
-      include Gin::Reloadable
-    end
-
-    @autoreload
+    reload
   end
 
 
@@ -121,38 +189,47 @@ class Gin::App
 
 
   ##
-  # Returns the source file of the current app.
-
-  def self.source_file
-    @source_file
-  end
-
+  # Get or set the CDN asset host (and path).
+  # If block is given, evaluates the block on every read.
 
-  def self.namespace #:nodoc:
-    # Parent namespace of the App class. Used for reloading purposes.
-    Gin.const_find(@source_class.split("::")[0..-2]) if @source_class
+  def self.asset_host host=nil, &block
+    @options[:asset_host] = host  if host
+    @options[:asset_host] = block if block_given?
+    @options[:asset_host]
   end
 
 
-  def self.source_class #:nodoc:
-    # Lookup the class from its name. Used for reloading purposes.
-    Gin.const_find(@source_class) if @source_class
+  def self.make_config opts={}  # :nodoc:
+    Gin::Config.new opts[:environment] || self.environment,
+        dir:    opts[:config_dir]    || self.config_dir,
+        logger: opts[:logger]        || self.logger,
+        ttl:    opts[:config_reload] || self.config_reload
   end
 
 
   ##
-  # Get or set the root directory of the application.
-  # Defaults to the app file's directory.
+  # Access the config for your application, loaded from the config_dir.
+  #   # config/memcache.yml
+  #   default: &default
+  #     host: example.com
+  #     connections: 1
+  #   development: *default
+  #     host: localhost
+  #
+  #   # access from App class
+  #   CACHE = Memcache.new( MyApp.config['memcache.host'] )
+  #
+  # The config object is shared across all instances of the App and has
+  # thread-safety built-in.
 
-  def self.root_dir dir=nil
-    @root_dir = dir if dir
-    @root_dir
+  def self.config
+    @options[:config] ||= make_config
   end
 
 
   ##
   # Get or set the path to the config directory.
-  # Defaults to root_dir + "config"
+  # Defaults to "<root_dir>/config"
   #
   # Configs are expected to be YAML files following this pattern:
   #   default: &default
@@ -168,108 +245,129 @@ class Gin::App
   # the current environment will be accessible.
 
   def self.config_dir dir=nil
-    @config_dir = dir if dir
-    @config_dir ||= File.join(root_dir, "config")
+    if String === dir
+      @options[:config_dir] = dir
+      @options[:config].dir = dir if @options[:config]
+    end
+
+    @options[:config_dir] || File.join(self.root_dir, "config")
   end
 
 
   ##
-  # Access the config for your application, loaded from the config_dir.
-  #   # config/memcache.yml
-  #   default: &default
-  #     host: example.com
-  #     connections: 1
-  #   development: *default
-  #     host: localhost
+  # Get or set the config max age for auto-reloading in seconds.
+  # Turns config reloading off if set to false. Defaults to false.
+  # Config only gets reloaded on demand.
+  #
+  #   # Set to 10 minutes
+  #   config_reload 600
   #
-  #   # access from App class or instance
-  #   config.memcache['host']
+  #   # Set to never reload
+  #   config_reload false
 
-  def self.config
-    @config ||= Gin::Config.new environment, config_dir
+  def self.config_reload ttl=nil
+    unless ttl.nil?
+      @options[:config_reload] = ttl
+      @options[:config].ttl = ttl if @options[:config]
+    end
+    @options[:config_reload]
   end
 
 
   ##
-  # Loads all configs from the config_dir.
+  # Set the default templating engine to use for various
+  # file extensions, or by default:
+  #   # Default for .markdown and .md files
+  #   default_template Tilt::MarukuTemplate, 'markdown', 'md'
+  #
+  #   # Default for files without preset default
+  #   default_template Tilt::BlueClothTemplate
 
-  def self.load_config
-    return unless File.directory?(config_dir)
-    config.dir = config_dir
-    config.load!
+  def self.default_template klass, *extensions
+    extensions = [nil] if extensions.empty?
+    extensions.each{|ext|
+      (@options[:template_engines][ext] ||= []).unshift klass }
   end
 
 
   ##
-  # Get or set the path to the public directory.
-  # Defaults to root_dir + "public"
+  # Get or set the current environment name,
+  # by default ENV ['RACK_ENV'], or "development".
 
-  def self.public_dir dir=nil
-    @public_dir = dir if dir
-    @public_dir ||= File.join(root_dir, "public")
+  def self.environment env=nil
+    if env
+      @options[:environment] = env
+      @options[:config].environment = env if @options[:config]
+    end
+    @options[:environment]
   end
 
 
   ##
-  # Get or set the CDN asset host (and path).
-  # If block is given, evaluates the block on every read.
+  # Define a Gin::Controller as a catch-all error rendering controller.
+  # This can be a dedicated controller, or a parent controller
+  # such as AppController. Defaults to Gin::Controller.
+  #
+  # The error delegate should handle the following errors
+  # for creating custom pages for Gin errors:
+  #   Gin::NotFound, Gin::BadRequest, ::Exception
 
-  def self.asset_host host=nil, &block
-    @asset_host = host  if host
-    @asset_host = block if block_given?
-    host = @asset_host.respond_to?(:call) ? @asset_host.call : @asset_host
+  def self.error_delegate ctrl=nil
+    @options[:error_delegate] = ctrl if ctrl
+    @options[:error_delegate]
   end
 
 
   ##
-  # Returns the asset host for a given asset name. This is useful when assigning
-  # a block for the asset_host. The asset_name argument is passed to the block.
+  # Get or set the layout name. Layout file location is assumed to be in
+  # the views_dir. If the views dir has a controller wildcard '*', the layout
+  # is assumed to be one level above the controller-specific directory.
+  #
+  # Defaults to :layout.
 
-  def self.asset_host_for asset_name
-     @asset_host.respond_to?(:call) ? @asset_host.call(asset_name) : @asset_host
+  def self.layout name=nil
+    @options[:layout] = name if name
+    @options[:layout]
   end
 
 
   ##
-  # Returns the first 8 bytes of the asset file's md5.
-  # File path is assumed relative to the public_dir.
-
-  def self.asset_version path
-    path = File.expand_path(File.join(public_dir, path))
-    return unless File.file?(path)
+  # Get or set the directory for view layouts.
+  # Defaults to the "<root_dir>/layouts".
 
-    @asset_versions       ||= {}
-    @asset_versions[path] ||= md5(path)
+  def self.layouts_dir dir=nil
+    @options[:layouts_dir] = dir if dir
+    @options[:layouts_dir] || File.join(root_dir, 'layouts')
   end
 
 
-  MD5 = RUBY_PLATFORM =~ /darwin/ ? 'md5 -q' : 'md5sum' #:nodoc:
+  ##
+  # Get or set the logger for your application. Loggers must respond
+  # to the << method.
 
-  def self.md5 path #:nodoc:
-    `#{MD5} #{path}`[0...8]
+  def self.logger new_logger=nil
+    if new_logger
+      @options[:logger] = new_logger
+      @options[:config].logger = new_logger if @options[:config]
+    end
+    @options[:logger]
   end
 
 
   ##
-  # Define a Gin::Controller as a catch-all error rendering controller.
-  # This can be a dedicated controller, or a parent controller
-  # such as AppController. Defaults to Gin::Controller.
-  #
-  # The error delegate should handle the following errors
-  # for creating custom pages for Gin errors:
-  #   Gin::NotFound, Gin::BadRequest, ::Exception
+  # Cache of file md5s shared across all instances of an App class.
+  # Used for static asset versioning.
 
-  def self.error_delegate ctrl=nil
-    @error_delegate = ctrl if ctrl
-    @error_delegate ||= Gin::Controller
+  def self.md5s
+    @md5s
   end
 
 
   ##
-  # Router instance that handles mapping Rack-env -> Controller#action.
+  # List of internal app middleware.
 
-  def self.router
-    @router ||= Gin::Router.new
+  def self.middleware
+    @options[:middleware]
   end
 
 
@@ -296,22 +394,45 @@ class Gin::App
 
 
   ##
-  # Add middleware internally to the app.
-  # Middleware statuses and Exceptions will NOT be
-  # handled by the error_delegate.
+  # Use rack-protection or not. Supports assigning
+  # hash for options. Defaults to false.
 
-  def self.use middleware, *args, &block
-    ary = [middleware, *args]
-    ary << block if block_given?
-    self.middleware << ary
+  def self.protection opts=nil
+    @options[:protection] = opts unless opts.nil?
+    @options[:protection]
   end
 
 
   ##
-  # List of internal app middleware.
+  # Get or set the path to the public directory.
+  # Defaults to "<root_dir>/public"
 
-  def self.middleware
-    @middleware ||= []
+  def self.public_dir dir=nil
+    @options[:public_dir] = dir if dir
+    @options[:public_dir] || File.join(root_dir, "public")
+  end
+
+
+  def self.reload_mutex # :nodoc:
+    @reload_mutex
+  end
+
+
+  ##
+  # Get or set the root directory of the application.
+  # Defaults to the app file's directory.
+
+  def self.root_dir dir=nil
+    @options[:root_dir] = File.expand_path(dir) if dir
+    @options[:root_dir]
+  end
+
+
+  ##
+  # Router instance that handles mapping Rack-env -> Controller#action.
+
+  def self.router
+    @options[:router]
   end
 
 
@@ -320,9 +441,8 @@ class Gin::App
   # hash for options. Defaults to false.
 
   def self.sessions opts=nil
-    @session = opts unless opts.nil?
-    @session = false if @session.nil?
-    @session
+    @options[:sessions] = opts unless opts.nil?
+    @options[:sessions]
   end
 
 
@@ -331,36 +451,117 @@ class Gin::App
   # Defaults to a new random value on boot.
 
   def self.session_secret val=nil
-    @session_secret = val if val
-    @session_secret ||= "%064x" % Kernel.rand(2**256-1)
+    @options[:session_secret] = val if val
+    @options[:session_secret]
   end
 
 
   ##
-  # Use rack-protection or not. Supports assigning
-  # hash for options. Defaults to false.
+  # Cache of precompiled templates, shared across all instances of a
+  # given App class.
 
-  def self.protection opts=nil
-    @protection = opts unless opts.nil?
-    @protection = false if @protection.nil?
-    @protection
+  def self.templates
+    @templates
   end
 
 
   ##
-  # Get or set the current environment name,
-  # by default ENV ['RACK_ENV'], or "development".
+  # Add middleware internally to the app.
+  # Middleware statuses and Exceptions will NOT be
+  # handled by the error_delegate.
 
-  def self.environment env=nil
-    @environment = env if env
-    @environment ||= ENV['RACK_ENV'] || ENV_DEV
+  def self.use middleware, *args, &block
+    ary = [middleware, *args]
+    ary << block if block_given?
+    self.middleware << ary
+  end
+
+
+  ##
+  # Get or set the path to the views directory.
+  # The wildcard '*' will be replaced by the controller name.
+  #
+  # Defaults to "<root_dir>/views"
+
+  def self.views_dir dir=nil
+    @options[:views_dir] = dir if dir
+    @options[:views_dir] || File.join(root_dir, 'views')
+  end
+
+
+  opt_reader :protection, :sessions, :session_secret, :middleware
+  opt_reader :error_delegate, :router, :logger
+  opt_reader :layout, :layouts_dir, :views_dir, :template_engines
+  opt_reader :root_dir, :public_dir, :environment
+
+  class_proxy :mime_type, :md5s, :templates, :reload_mutex, :autoreload
+
+  # App to fallback on if Gin::App is used as middleware and no route is found.
+  attr_reader :rack_app
+
+  # Options applied to the Gin::App instance. Typically a result of
+  # class-level configuration methods, such as Gin::App.environment.
+  attr_reader :options
+
+  # Internal Rack stack.
+  attr_reader :stack
+
+  ##
+  # Create a new Rack-mountable Gin::App instance, with an optional
+  # rack_app and options.
+
+  def initialize rack_app=nil, options={}
+    if Hash === rack_app
+      options   = rack_app
+      @rack_app = nil
+    else
+      @rack_app = rack_app
+    end
+
+    @options = {
+      config_dir:  self.class.config_dir,
+      public_dir:  self.class.public_dir,
+      layouts_dir: self.class.layouts_dir,
+      views_dir:   self.class.views_dir,
+      config:      self.class.config
+    }.merge(self.class.options).merge(options)
+
+    @options[:config] = self.class.make_config(@options) if
+      @options[:environment] != @options[:config].environment ||
+      @options[:config_dir] != @options[:config].dir ||
+      @options[:config_reload] != @options[:config].ttl
+
+    validate_all_controllers!
+
+    @app   = self
+    @stack = build_app Rack::Builder.new
+  end
+
+
+  ##
+  # Access the config for your application, loaded from the config_dir.
+  #   # config/memcache.yml
+  #   default: &default
+  #     host: example.com
+  #     connections: 1
+  #   development: *default
+  #     host: localhost
+  #
+  #   # access from App instance
+  #   @app.config['memcache.host']
+  #
+  # The config object is shared across all instances of the App and has
+  # thread-safety built-in.
+
+  def config
+    @options[:config]
   end
 
 
   ##
   # Check if running in development mode.
 
-  def self.development?
+  def development?
     self.environment == ENV_DEV
   end
 
@@ -368,7 +569,7 @@ class Gin::App
   ##
   # Check if running in test mode.
 
-  def self.test?
+  def test?
     self.environment == ENV_TEST
   end
 
@@ -376,7 +577,7 @@ class Gin::App
   ##
   # Check if running in staging mode.
 
-  def self.staging?
+  def staging?
     self.environment == ENV_STAGE
   end
 
@@ -384,47 +585,84 @@ class Gin::App
   ##
   # Check if running in production mode.
 
-  def self.production?
+  def production?
     self.environment == ENV_PROD
   end
 
 
-  class_proxy :protection, :sessions, :session_secret, :middleware, :autoreload
-  class_proxy :error_delegate, :router
-  class_proxy :root_dir, :public_dir
-  class_proxy :mime_type, :asset_host_for, :asset_host, :asset_version
-  class_proxy :environment, :development?, :test?, :staging?, :production?
-  class_proxy :load_config, :config, :config_dir
+  ##
+  # Returns the asset host for a given asset name. This is useful when assigning
+  # a block for the asset_host. The asset_name argument is passed to the block.
+
+  def asset_host_for asset_name
+     @options[:asset_host].respond_to?(:call) ?
+      @options[:asset_host].call(asset_name) : @options[:asset_host]
+  end
 
-  # Application logger. Defaults to log to $stdout.
-  attr_accessor :logger
 
-  # App to fallback on if Gin::App is used as middleware and no route is found.
-  attr_reader :rack_app
+  ##
+  # Returns the default asset host.
 
-  # Internal Rack stack.
-  attr_reader :stack
+  def asset_host
+    asset_host_for(nil)
+  end
 
 
   ##
-  # Create a new Rack-mountable Gin::App instance, with an optional
-  # rack_app and logger.
+  # Returns the first 8 bytes of the asset file's md5.
+  # File path is assumed relative to the public_dir.
+
+  def asset_version path
+    path = File.expand_path(File.join(public_dir, path))
+    md5(path)
+  end
 
-  def initialize rack_app=nil, logger=nil
-    load_config
 
-    if !rack_app.respond_to?(:call) && rack_app.respond_to?(:<<) && logger.nil?
-      @rack_app = nil
-      @logger   = rack_app
-    else
-      @rack_app = rack_app
-      @logger   = $stdout
+  MD5 = RUBY_PLATFORM =~ /darwin/ ? 'md5 -q' : 'md5sum' #:nodoc:
+
+  ##
+  # Returns the first 8 characters of a file's MD5 hash.
+  # Values are cached for future reference.
+
+  def md5 path
+    return unless File.file?(path)
+    self.md5s[path] ||= `#{MD5} #{path}`[0...8]
+  end
+
+
+  ##
+  # Returns the tilt template for the given template name.
+  # Returns nil if no template file is found.
+  #   template_for 'user/show'
+  #   #=> <Tilt::ERBTemplate @file="views/user/show.erb" ...>
+  #
+  #   template_for 'user/show.haml'
+  #   #=> <Tilt::HamlTemplate @file="views/user/show.haml" ...>
+  #
+  #   template_for 'non-existant'
+  #   #=> nil
+
+  def template_for path, engine=nil
+    templates.cache([path, engine]) do
+      if file = template_files(path).first
+        ext = File.extname(file)
+        ext = ext.empty? ? nil : ext[1..-1]
+        engine ||= template_engines[ext].first
+        engine.new(file) if engine
+      end
     end
+  end
 
-    validate_all_controllers!
 
-    @app   = self
-    @stack = build_app Rack::Builder.new
+  ##
+  # Returns an Array of file paths that match a valid path and maps
+  # to a known template engine.
+  #   app.template_files 'views/foo'
+  #   #=> ['views/foo.erb', 'views/foo.md']
+
+  def template_files path
+    exts = template_engines.keys.map{|e| "." << e if e }.join(",")
+    Dir["#{path}{#{exts}}"]
   end
 
 
@@ -435,16 +673,17 @@ class Gin::App
   # If you use this in production, you're gonna have a bad time.
 
   def reload!
-    @mutex ||= Mutex.new
+    reload_mutex.synchronize do
+      self.class.erase_dependencies!
 
-    @mutex.synchronize do
-      self.class.erase! [self.class.source_file],
-                        [self.class.name.split("::").last],
-                        self.class.namespace
+      if File.extname(self.class.source_file) != ".ru"
+        self.class.erase! [self.class.source_file],
+                          [self.class.name.split("::").last],
+                          self.class.namespace
+        require self.class.source_file
+      end
 
-      self.class.erase_dependencies!
-      require self.class.source_file
-      @app = self.class.source_class.new @rack_app, @logger
+      @app = self.class.source_class.new @rack_app, @options
     end
   end
 
@@ -497,8 +736,8 @@ class Gin::App
 
 
   ##
-  # Returns a static file Rack response Array from the given gin.static
-  # env filename.
+  # Returns a static file Rack response Array from the filename set
+  # in env['gin.static'].
 
   def call_static env
     with_log_request(env) do
@@ -509,7 +748,8 @@ class Gin::App
 
   ##
   # Check if the request is for a static file and set the gin.static env
-  # variable to the filepath.
+  # variable to the filepath. Returns true if request is to a static asset,
+  # otherwise false.
 
   def static! env
     filepath = %w{GET HEAD}.include?(env[REQ_METHOD]) &&
@@ -526,6 +766,7 @@ class Gin::App
   # Check if the request routes to a controller and action and set
   # gin.controller, gin.action, gin.path_query_hash,
   # and gin.http_route env variables.
+  # Returns true if a route is found, otherwise false.
 
   def route! env
     http_route = "#{env[REQ_METHOD]} #{env[PATH_INFO]}"
@@ -566,7 +807,8 @@ class Gin::App
       "No route exists for: #{env[REQ_METHOD]} #{env[PATH_INFO]}" unless
       ctrl && action
 
-    ctrl.new(self, env).call_action action
+    env[GIN_CTRL] = ctrl.new(self, env)
+    env[GIN_CTRL].call_action action
 
   rescue ::Exception => err
     handle_error(err, env)
@@ -599,10 +841,12 @@ class Gin::App
     now  = Time.now
     time = now - env[GIN_TIMESTAMP] if env[GIN_TIMESTAMP]
 
-    ctrl, action = env[GIN_CTRL], env[GIN_ACTION]
+    ctrl, action = env[GIN_CTRL].class, env[GIN_ACTION]
     target = "#{ctrl}##{action}" if ctrl && action
+    target = resp[2].path if !target && resp[2].respond_to?(:path)
+    target = "<stream>" if !target && (!(Array === resp[2]) || !resp[2].empty?)
 
-    @logger << ( LOG_FORMAT % [
+    logger << ( LOG_FORMAT % [
         env[FWD_FOR] || env[REMOTE_ADDR] || "-",
         env[REMOTE_USER] || "-",
         now.strftime(TIME_FORMAT),
@@ -640,10 +884,10 @@ class Gin::App
 
   def setup_sessions builder
     return unless sessions
-    options = {}
-    options[:secret] = session_secret if session_secret
-    options.merge! sessions.to_hash if sessions.respond_to? :to_hash
-    builder.use Rack::Session::Cookie, options
+    opts = {}
+    opts[:secret] = session_secret if session_secret
+    opts.merge! sessions.to_hash if sessions.respond_to? :to_hash
+    builder.use Rack::Session::Cookie, opts
   end
 
 
@@ -651,11 +895,11 @@ class Gin::App
     return unless protection
     require 'rack-protection' unless defined?(Rack::Protection)
 
-    options = Hash === protection ? protection.dup : {}
-    options[:except] = Array options[:except]
-    options[:except] += [:session_hijacking, :remote_token] unless sessions
-    options[:reaction] ||= :drop_session
-    builder.use Rack::Protection, options
+    opts = Hash === protection ? protection.dup : {}
+    opts[:except] = Array opts[:except]
+    opts[:except] += [:session_hijacking, :remote_token] unless sessions
+    opts[:reaction] ||= :drop_session
+    builder.use Rack::Protection, opts
   end
 
 
@@ -663,13 +907,13 @@ class Gin::App
   # Make sure all controller actions have a route, or raise a RouterError.
 
   def validate_all_controllers!
-    actions = {}
+    actions_map = {}
 
     router.each_route do |route, ctrl, action|
-      (actions[ctrl] ||= []) << action
+      (actions_map[ctrl] ||= []) << action
     end
 
-    actions.each do |ctrl, actions|
+    actions_map.each do |ctrl, actions|
       not_mounted   = ctrl.actions - actions
       raise RouterError, "#{ctrl}##{not_mounted[0]} has no route." unless
         not_mounted.empty?
@@ -679,4 +923,7 @@ class Gin::App
         extra_mounted.empty?
     end
   end
+
+
+  setup
 end