gin 1.1.2 → 1.2.0

data/History.rdoc

@@ -1,7 +1,28 @@
+=== 1.2.0 / 2013-11-18
+
+* Major Enhancements
+  * Rubinius officially supported
+  * Support for rewriting or rerouting requests from the controller
+  * Support generic App-mountable controller-like objects
+
+* Minor Enhancements
+  * Allow enforcing server name for routing
+  * Cache#increase and Cache#decrease for numeric values
+  * More robust indifferent access hash implementation
+  * Removed support for passing default verb to Mount#default
+
+* Bugfixes
+  * Fix for ignored exclusions when adding filter to filter chain
+  * Fix for default controller create action request path mapping
+  * Reload bugfix which didn't recognize Controller classes in routes
+  * Fix to remove slashes from namespaced controller route names
+  * Don't convert numeric params that start with 0 to Integers
+  * Support negative numbers when converting param types
+
 === 1.1.2 / 2013-07-19
 
 * Minor Enhancements
-  * User the Ruby Logger instead of $stdout as the default logger
+  * Use the Ruby Logger instead of $stdout as the default logger
 
 * Bugfixes
   * Fixes to the RWLock which made reads blocking in some instances

data/Manifest.txt

@@ -5,22 +5,29 @@ Rakefile
 bin/gin
 lib/gin.rb
 lib/gin/app.rb
+lib/gin/asset_manifest.rb
+lib/gin/asset_pipeline.rb
 lib/gin/cache.rb
 lib/gin/config.rb
 lib/gin/constants.rb
 lib/gin/controller.rb
 lib/gin/core_ext/cgi.rb
+lib/gin/core_ext/float.rb
 lib/gin/core_ext/gin_class.rb
 lib/gin/core_ext/rack_commonlogger.rb
+lib/gin/core_ext/time.rb
 lib/gin/errorable.rb
 lib/gin/filterable.rb
+lib/gin/mountable.rb
 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/strict_hash.rb
 lib/gin/test.rb
+lib/gin/worker.rb
 public/400.html
 public/404.html
 public/500.html

data/TODO.rdoc

@@ -1,4 +1,49 @@
+== Asset Pipeline TODO
+- Write docs
+- Write tests
+
+- Consider app reload on file change
+- Consider auto-reload of browser page on app reload
+
+
+- Investigate image sprite generation
+- Investigate HTML helpers
+
+- Extend App.mount support:
+  mount "/path/to/dir", "/public"
+  mount MyResource, "/"
+
+- Static actions cache
+  - Perhaps with the implementation of a 'static' method on Router
+  - Cache and ETag page based on params => could lead to attack to bloat memory
+
+    mount HomeController, '/' do
+      get :index, '/', :cache => true
+      get :index, '/', :cache => 300 # 5 minutes
+    end
+
+- API description/resource support (maybe on mount)
+  - Example:
+    mount UserResource #=> includes Gin::RestResource
+  - Renders a static file to check for API changes on test
+
+
+= Done
+
+- Get multiple Gin apps to render assets to the same dir
+
+- Single asset-checking process that rebuilds assets
+  - Only updates changed assets
+  - Dev mode checks if asset generation process is done (maybe always happens on boot)
+
+
 = Maybe
 - Find a better default non-locking logger
+
 - Bundler-runtime-free
   - script/server equivalent
+
+- Gin common background or startup process for offsetting tasks such as asset generation?
+  - Sync mechanism for having a task be done by a unique process/thread
+  - Any number of processes/threads can do the asset file updating with flock
+  - Let user choose number of processes to do startup tasks.

data/bin/gin

@@ -1,23 +1,119 @@
 #!/usr/bin/env ruby
 
 $: << File.join(File.dirname(__FILE__), "../lib") if $0 == "bin/gin"
+require 'rubygems'
 require 'gin'
+require 'optparse'
 
 class Gin::Cmd
+
+  def self.parse_args argv
+    options = {}
+
+    opts = OptionParser.new do |opt|
+      opt.program_name = File.basename $0
+      opt.version = Gin::VERSION
+      opt.release = nil
+
+      opt.banner = <<-STR
+
+#{opt.program_name}-#{opt.version}
+
+Create and control Gin applications.
+
+  Usage:
+    #{opt.program_name} --help
+    #{opt.program_name} --version
+
+    #{opt.program_name} <app-path> [options]
+
+  Options:
+      STR
+
+      opt.on('-b', '--bare', 'Create lightweight Gin app') do
+        options[:bare] = true
+      end
+
+      opt.on('-m', '--middleware', 'Create a Gin app as middleware') do
+        options[:middleware] = true
+      end
+
+      opt.on('-A', '--assets', 'Render assets for the given Gin app') do
+        options[:action] = :render_assets
+      end
+
+      opt.separator nil
+
+      opt.on('-h', '--help', 'Print this help screen') do
+        puts opt
+        exit
+      end
+
+      opt.on('-v', '--version', 'Output Gin version and exit') do
+        puts Gin::VERSION
+        exit
+      end
+
+      opt.separator nil
+    end
+
+    opts.parse! argv
+
+    options[:app_path] = argv.shift
+    error("Missing app-path argument. Use gin -h for help.") if
+      !options[:app_path]
+
+    error("Invalid arguments #{argv.join(", ")}.") unless argv.empty?
+
+    options
+  end
+
+
   def self.run argv=ARGV
-    show_help if argv.empty? || argv.delete("-h") || argv.delete("--help")
+    options = parse_args(argv)
 
-    bare = !!argv.delete("--bare")
+    case options[:action]
+    when :render_assets
+      render_assets(options)
+    else
+      create_app(options)
+    end
+  end
+
+
+  def self.render_assets options
+    app_path = File.expand_path(options[:app_path])
+    app_filepath = nil
+
+    if File.file?(app_path)
+      app_filepath = app_path
+
+    elsif File.directory?(app_path)
+      ["#{File.basename(app_path)}.rb", "app.rb", "application.rb"].each do |name|
+        filepath = File.join(app_path, name)
+        app_filepath = filepath and break if File.file?(filepath)
+      end
+    end
 
-    path = argv.pop
-    error("Missing app_name argument. Use gin -h for help.") if !path
+    error("No such file or directory: #{options[:app_path]}") if !app_filepath
 
-    error("Invalid options #{argv.join(", ")}.") unless argv.empty?
+    $: << File.dirname(app_filepath)
+    require app_filepath
+
+    Gin::App.each do |app_klass|
+      puts "Generating assets for #{app_klass.name}..."
+      app_klass.new(:force_asset_pipeline => false).send(:create_asset_pipeline)
+    end
+  end
 
-    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?
+
+  def self.create_app options
+    bare = options[:bare]
+    path = options[:app_path].sub(/\.\w+$/, '')
+    standalone = !options[:middleware]
+
+    name = File.basename(path)
+    dir  = File.expand_path(path)
 
     make_dirs(dir, bare)
 
@@ -38,32 +134,6 @@ class Gin::Cmd
   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)
 

data/lib/gin.rb

@@ -3,7 +3,7 @@ require 'rack'
 require 'tilt'
 
 class Gin
-  VERSION = '1.1.2'
+  VERSION = '1.2.0'
 
   LIB_DIR    = File.expand_path("..", __FILE__)            #:nodoc:
   PUBLIC_DIR = File.expand_path("../../public/", __FILE__) #:nodoc:
@@ -22,6 +22,8 @@ class Gin
 
   class TemplateMissing < Error; end
 
+  class RouterError < Error; end
+
 
   ##
   # Change string to underscored version.
@@ -122,9 +124,12 @@ class Gin
 
 
   require 'gin/core_ext/cgi'
+  require 'gin/core_ext/time'
+  require 'gin/core_ext/float'
   require 'gin/core_ext/gin_class'
   require 'gin/core_ext/rack_commonlogger'
 
+  require 'gin/strict_hash'
   require 'gin/constants'
   require 'gin/cache'
   require 'gin/router'
@@ -135,6 +140,7 @@ class Gin
   require 'gin/stream'
   require 'gin/errorable'
   require 'gin/filterable'
+  require 'gin/mountable'
   require 'gin/controller'
   require 'gin/app'
 end

data/lib/gin/app.rb

@@ -15,8 +15,6 @@ class Gin::App
   extend GinClass
   include Gin::Constants
 
-  class RouterError < Gin::Error; end
-
   CALLERS_TO_IGNORE = [ # :nodoc:
     /lib\/gin(\/(.*?))?\.rb/,           # all gin code
     /lib\/tilt.*\.rb/,                  # all tilt code
@@ -28,6 +26,13 @@ class Gin::App
     /src\/kernel\/bootstrap\/[A-Z]/     # maglev kernel files
   ]
 
+  @@app_klasses = {}    #:nodoc:
+
+
+  def self.each &block    #:nodoc:
+    @@app_klasses.values.each(&block)
+  end
+
 
   def self.inherited subclass   #:nodoc:
     subclass.setup
@@ -39,11 +44,14 @@ class Gin::App
     filepath = File.expand_path(caller_line.split(/:\d+:in `/).first)
     dir = File.dirname(filepath)
 
+    @@app_klasses[self.name] = self unless self.name == "Gin::App"
+
     @source_file  = filepath
+    @app_name     = Gin.underscore(self.name).gsub("/", ".")
     @source_class = self.to_s
     @templates    = Gin::Cache.new
     @md5s         = Gin::Cache.new
-    @reload_mutex = Mutex.new
+    @reload_lock  = Gin::RWLock.new
     @autoreload   = nil
     @instance     = nil
 
@@ -81,6 +89,15 @@ class Gin::App
   end
 
 
+  ##
+  # Get or set the app name.
+
+  def self.app_name name=nil
+    @app_name = name if name
+    @app_name
+  end
+
+
   ##
   # Returns the source file of the current app.
 
@@ -188,6 +205,79 @@ class Gin::App
   end
 
 
+  ##
+  # Turn asset pipelining on or off. Defaults to turned on if any asset paths
+  # are present at boot time.
+  #   asset_pipeline true   # Force ON
+  #   asset_pipeline false  # Force OFF
+  #
+  # If you would rather handle asset generation manually through the `gin -A`
+  # command for production purposes, you can set asset_pipieline to false. The
+  # app will still know where to look for rendered assets.
+  #   asset_pipeline ENV['RACK_ENV'] == 'development'
+  #
+  # Passing a block will allow for configuration for Sprockets asset pipelining.
+  # Passed block yields a Sprockets::Environment instance.
+  #   asset_pipeline do |sprockets|
+  #     sprockets.append_path 'foo/assets'
+  #   end
+  #
+  # To keep memory usage low, Gin avoids loading Sprockets during the App
+  # runtime. If you however need Sprockets at runtime for your app,
+  # you may also pass a Sprockets::Environment instance to the
+  # asset_pipeline method:
+  #   sprockets = Sprockets::Environment.new
+  #   asset_pipeline sprockets
+
+  def self.asset_pipeline val=nil, &block
+    @options[:force_asset_pipeline] = val if !val.nil?
+    @options[:asset_config] = block if block_given?
+    @options[:force_asset_pipeline]
+  end
+
+
+  ##
+  # Get or set the globs to find asset files.
+  #   asset_paths "/path/to/other/shared/assets/*/"
+  #
+  # These globs will be expanded and added to the asset_pipeline Sprockets
+  # instance.
+  #
+  # Default globs are:
+  #   <root_dir>/assets/
+  #   <root_dir>/assets/*/
+  #   <root_dir>/lib/**/assets/
+  #   <root_dir>/lib/**/assets/*/
+  #   <root_dir>/vendor/**/assets/
+  #   <root_dir>/vendor/**/assets/*/
+
+  def self.asset_paths *paths
+    @options[:asset_paths] ||=
+      DEFAULT_ASSET_PATHS.map{|pa| File.join(root_dir, *pa) }
+    @options[:asset_paths].concat(paths) if !paths.empty?
+    @options[:asset_paths]
+  end
+
+  DEFAULT_ASSET_PATHS = [  #:nodoc:
+    %w{assets */},
+    %w{lib ** assets */},
+    %w{vendor ** assets */},
+    %w{assets/},
+    %w{lib ** assets/},
+    %w{vendor ** assets/}
+  ]
+
+
+  ##
+  # Directory where the asset pipeline should render static assets to.
+  # Defaults to <public_dir>/assets
+
+  def self.assets_dir dir=nil
+    @options[:assets_dir] = dir if dir
+    @options[:assets_dir] || File.join(public_dir, "assets")
+  end
+
+
   ##
   # Get or set the CDN asset host (and path).
   # If block is given, evaluates the block on every read.
@@ -201,9 +291,9 @@ class Gin::App
 
   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
+        :dir    => opts[:config_dir]    || self.config_dir,
+        :logger => opts[:logger]        || self.logger,
+        :ttl    => opts[:config_reload] || self.config_reload
   end
 
 
@@ -318,6 +408,23 @@ class Gin::App
   end
 
 
+  ##
+  # Get or set the Host header on responses if not set by the called action.
+  # If the enforce options is given, the app will only respond to requests that
+  # explicitly match the specified host, or regexp.
+  # This is useful for running multiple apps on the same middleware stack that
+  # might have conflicting routes, or need explicit per-host routing (such
+  # as an admin app).
+  #   hostname 'host.com'
+  #   hostname 'admin.host.com:443', :enforce => true
+  #   hostname 'admin.host.com', :enforce => /^admin\.(localhost|host\.com)/
+
+  def self.hostname host=nil, opts={}
+    @options[:host] = {:name => host}.merge(opts) if host
+    @options[:host][:name] if @options[:host]
+  end
+
+
   ##
   # 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
@@ -413,8 +520,8 @@ class Gin::App
   end
 
 
-  def self.reload_mutex # :nodoc:
-    @reload_mutex
+  def self.reload_lock # :nodoc:
+    @reload_lock
   end
 
 
@@ -493,8 +600,10 @@ class Gin::App
   opt_reader :error_delegate, :router, :logger
   opt_reader :layout, :layouts_dir, :views_dir, :template_engines
   opt_reader :root_dir, :public_dir, :environment
+  opt_reader :asset_paths, :assets_dir, :asset_config, :force_asset_pipeline
 
-  class_proxy :mime_type, :md5s, :templates, :reload_mutex, :autoreload
+  class_proxy :mime_type, :md5s, :templates, :reload_lock, :autoreload
+  class_proxy :app_name
 
   # App to fallback on if Gin::App is used as middleware and no route is found.
   attr_reader :rack_app
@@ -519,22 +628,28 @@ class Gin::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
+      :config_dir   => self.class.config_dir,
+      :public_dir   => self.class.public_dir,
+      :assets_dir   => self.class.assets_dir,
+      :asset_paths  => self.class.asset_paths,
+      :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[:environment]   != @options[:config].environment ||
+      @options[:config_dir]    != @options[:config].dir ||
       @options[:config_reload] != @options[:config].ttl
 
+    @override_options = options if autoreload
+
     validate_all_controllers!
 
     @app   = self
     @stack = build_app Rack::Builder.new
+
+    setup_asset_pipeline
   end
 
 
@@ -590,6 +705,32 @@ class Gin::App
   end
 
 
+  STATIC_PATH_CLEANER = %r{\.+/|/\.+}  #:nodoc:
+
+  ##
+  # Check if an asset exists.
+  # Returns the full path to the asset if found, otherwise nil.
+  # Does not support ./ or ../ for security reasons.
+
+  def asset path
+    path = path.gsub STATIC_PATH_CLEANER, ""
+
+    pub_filepath = File.expand_path(File.join(public_dir, path))
+    return pub_filepath if File.file? pub_filepath
+
+    ast_filepath = File.expand_path(File.join(assets_dir, path))
+    return ast_filepath if File.file? ast_filepath
+
+    pub_filepath.sub!(/(\.\w+)$/, '-*\1')
+    ast_filepath.sub!(/(\.\w+)$/, '-*\1')
+    filepath = Dir[pub_filepath, ast_filepath].first
+    return filepath if filepath
+
+    gin_filepath = File.expand_path(File.join(Gin::PUBLIC_DIR, path))
+    return gin_filepath if File.file? gin_filepath
+  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.
@@ -618,15 +759,21 @@ class Gin::App
   end
 
 
-  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]
+    self.md5s[path] ||= Digest::MD5.file(path).hexdigest[0...8]
+  end
+
+
+  ##
+  # The name defined by App.hostname.
+
+  def hostname
+    @options[:host][:name] if @options[:host]
   end
 
 
@@ -673,7 +820,7 @@ class Gin::App
   # If you use this in production, you're gonna have a bad time.
 
   def reload!
-    reload_mutex.synchronize do
+    reload_lock.write_sync do
       self.class.erase_dependencies!
 
       if File.extname(self.class.source_file) != ".ru"
@@ -683,7 +830,7 @@ class Gin::App
         require self.class.source_file
       end
 
-      @app = self.class.source_class.new @rack_app, @options
+      @app = self.class.source_class.new @rack_app, @override_options
     end
   end
 
@@ -692,30 +839,47 @@ class Gin::App
   # Default Rack call method.
 
   def call env
-    try_autoreload(env)
+    try_autoreload(env) do
+      valid_host = valid_host?(env)
 
-    if @app.route!(env)
-      @app.call!(env)
+      resp =
+        if valid_host && @app.route!(env)
+          @app.call!(env)
 
-    elsif @app.static!(env)
-      @app.call_static(env)
+        elsif valid_host && @app.static!(env)
+          @app.call_static(env)
 
-    elsif @rack_app
-      @rack_app.call(env)
+        elsif @rack_app
+          @rack_app.call(env)
 
-    else
-      @app.call!(env)
+        elsif !valid_host
+          bt  = caller
+          msg = "No route for host '%s:%s'" % [env[SERVER_NAME], env[SERVER_PORT]]
+          err = Gin::BadRequest.new(msg)
+          err.set_backtrace(bt)
+          handle_error(err, env)
+
+        else
+          @app.call!(env)
+        end
+
+      resp[1][HOST_NAME] ||=
+        (hostname || env[SERVER_NAME]).sub(/(:[0-9]+)?$/, ":#{env[SERVER_PORT]}")
+
+      resp
     end
   end
 
 
   ##
-  # Check if autoreload is needed and reload.
+  # Check if autoreload is needed, reload, and/or run block in a
+  # thread-safe manner.
 
-  def try_autoreload env
-    return if env[GIN_RELOADED] || !autoreload
+  def try_autoreload env, &block
+    return block.call if env[GIN_RELOADED] || !autoreload
     env[GIN_RELOADED] = true
     reload!
+    reload_lock.read_sync{ block.call }
   end
 
 
@@ -724,7 +888,7 @@ class Gin::App
 
   def call! env
     if env[GIN_STACK]
-      dispatch env, env[GIN_CTRL], env[GIN_ACTION]
+      dispatch env
 
     else
       env[GIN_STACK] = true
@@ -764,51 +928,68 @@ 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.
+  # gin.target, 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]}"
     return true if env[GIN_ROUTE] == http_route
 
-    env[GIN_CTRL], env[GIN_ACTION], env[GIN_PATH_PARAMS] =
+    env[GIN_TARGET], env[GIN_PATH_PARAMS] =
       router.resources_for env[REQ_METHOD], env[PATH_INFO]
 
     env[GIN_ROUTE] = http_route
 
-    !!(env[GIN_CTRL] && env[GIN_ACTION])
+    !!env[GIN_TARGET]
   end
 
 
-  STATIC_PATH_CLEANER = %r{\.+/|/\.+}  #:nodoc:
+  def rewrite_env env, *args  # :nodoc:
+    headers = args.pop if Hash === args.last && Hash === args[-2] && args[-2] != args[-1]
+    params  = args.pop if Hash === args.last
+
+    route = if String === args.first
+              verb = (headers && headers[REQ_METHOD] || 'GET').upcase
+              Gin::Router::Route.new(verb, args[0])
+            else
+              @app.router.route_to(*args)
+            end
+
+    new_env = env.dup
+    new_env.delete_if{|k, v| k.start_with?('gin.') }
+    new_env[GIN_RELOADED]  = env[GIN_RELOADED]
+    new_env[GIN_TIMESTAMP] = env[GIN_TIMESTAMP]
+
+    new_env.merge!(headers) if headers
+    route.to_env(params, new_env)
+  end
+
 
   ##
-  # Check if an asset exists.
-  # Returns the full path to the asset if found, otherwise nil.
-  # Does not support ./ or ../ for security reasons.
+  # Rewrites the given Rack env and processes the new request.
+  # You're probably looking for Gin::Controller#rewrite or
+  # Gin::Controller#reroute.
 
-  def asset path
-    path = path.gsub STATIC_PATH_CLEANER, ""
+  def rewrite! env, *args
+    new_env = rewrite_env(env, *args)
 
-    filepath = File.expand_path(File.join(public_dir, path))
-    return filepath if File.file? filepath
+    logger << "[REWRITE] %s %s -> %s %s\n" %
+      [env[REQ_METHOD], env[PATH_INFO], new_env[REQ_METHOD], new_env[PATH_INFO]]
 
-    filepath = File.expand_path(File.join(Gin::PUBLIC_DIR, path))
-    return filepath if File.file? filepath
+    call(new_env)
   end
 
 
   ##
   # Dispatch the Rack env to the given controller and action.
 
-  def dispatch env, ctrl, action
+  def dispatch env
     raise Gin::NotFound,
       "No route exists for: #{env[REQ_METHOD]} #{env[PATH_INFO]}" unless
-      ctrl && action
+      env[GIN_TARGET]
 
-    env[GIN_CTRL] = ctrl.new(self, env)
-    env[GIN_CTRL].call_action action
+    env[GIN_APP] = self
+    env[GIN_TARGET][0].call(env)
 
   rescue ::Exception => err
     handle_error(err, env)
@@ -841,10 +1022,7 @@ class Gin::App
     now  = Time.now
     time = now - env[GIN_TIMESTAMP] if env[GIN_TIMESTAMP]
 
-    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?)
+    target = request_target_name(env, resp)
 
     logger << ( LOG_FORMAT % [
         env[FWD_FOR] || env[REMOTE_ADDR] || "-",
@@ -861,6 +1039,21 @@ class Gin::App
   end
 
 
+  def request_target_name env, resp
+    if env[GIN_TARGET]
+      if Gin::Mountable === env[GIN_TARGET][0]
+        env[GIN_TARGET][0].display_name(env[GIN_TARGET][1])
+      else
+        "#{env[GIN_TARGET][0].inspect}->#{env[GIN_TARGET][1].inspect}"
+      end
+    elsif resp[2].respond_to?(:path)
+      resp[2].path
+    elsif !(Array === resp[2]) || !resp[2].empty?
+      "<stream>"
+    end
+  end
+
+
   def with_log_request env
     env[GIN_TIMESTAMP] ||= Time.now
     resp = yield
@@ -903,6 +1096,64 @@ class Gin::App
   end
 
 
+  def asset_pipeline
+    Thread.main[:"#{self.app_name}_asset_pipeline"]
+  end
+
+
+  def set_asset_pipeline pipe
+    pipe_key = :"#{self.app_name}_asset_pipeline"
+
+    old_pipe = Thread.main[pipe_key]
+    old_pipe.stop if old_pipe
+
+    Thread.main[pipe_key] = pipe
+  end
+
+
+  def use_asset_pipeline?
+    return !!force_asset_pipeline unless force_asset_pipeline.nil?
+    return false unless asset_paths
+    return @use_asset_pipeline if defined? @use_asset_pipeline
+    @use_asset_pipeline = !!Dir.glob(asset_paths).first
+  end
+
+
+  def setup_asset_pipeline
+    return unless use_asset_pipeline?
+
+    if development?
+      pipe = create_asset_pipeline
+      pipe.listen
+      set_asset_pipeline pipe
+
+    else
+      require 'gin/worker'
+      pidfile = File.join(self.root_dir, "#{self.app_name}.asset_pipeline.pid")
+      w = Gin::Worker.new(pidfile){ create_asset_pipeline }
+      w.run
+      w.wait
+    end
+  end
+
+
+  def asset_manifest_path
+    File.join(self.root_dir, "#{self.app_name}.asset_manifest")
+  end
+
+
+  def create_asset_pipeline
+    require 'gin/asset_pipeline'
+
+    pipe = Gin::AssetPipeline.new(asset_manifest_path,
+            assets_dir, asset_paths, force_asset_pipeline, &asset_config)
+
+    pipe.logger = self.logger
+    pipe.render_all if pipe.outdated?
+    pipe
+  end
+
+
   ##
   # Make sure all controller actions have a route, or raise a RouterError.
 
@@ -914,16 +1165,34 @@ class Gin::App
     end
 
     actions_map.each do |ctrl, actions|
-      not_mounted   = ctrl.actions - actions
-      raise RouterError, "#{ctrl}##{not_mounted[0]} has no route." unless
+      next unless Gin::Mountable === ctrl
+      ctrl.verify_mount!
+
+      not_mounted = ctrl.actions - actions
+      raise Gin::RouterError, "#{ctrl.display_name(not_mounted[0])} has no route" unless
         not_mounted.empty?
 
       extra_mounted = actions - ctrl.actions
-      raise RouterError, "#{ctrl}##{extra_mounted[0]} is not a method" unless
+      raise Gin::RouterError, "#{ctrl.display_name(extra_mounted[0])} is not an action" unless
         extra_mounted.empty?
     end
   end
 
 
+  def valid_host? env
+    return true unless @options[:host] && @options[:host][:enforce]
+
+    name, port = @options[:host][:name].split(":", 2)
+
+    if @options[:host][:enforce] == true
+      name == env[SERVER_NAME] && (port.nil? || port == env[SERVER_PORT])
+    else
+      @options[:host][:enforce] === "#{env[SERVER_NAME]}:#{env[SERVER_PORT]}" ||
+        @options[:host][:enforce] === env[SERVER_NAME] &&
+          (port.nil? || port == env[SERVER_PORT])
+    end
+  end
+
+
   setup
 end