public static function unavailable($send = true) {
    return static::status(503, $send);
  }
 
  /**
   * Sends a redirect header
   * 
   * @param boolean $send
   * @return string|null
   */
  public static function redirect($url, $code = 301, $send = true) {
 
    $status   = static::status($code, false); 
    $location = 'Location:' . $url;
 
    if(!$send) {
      return $status . "\r\n" . $location;
    }
 
    header($status);
    header($location);
    exit();
 
  }
 
  /**
   * Sends download headers for anything that is downloadable 
   * 
   * @param array $params Check out the defaults array for available parameters
   */
   public static function download($params = array()) {
 
    $defaults = array(
      'name'     => 'download',
      'size'     => false,
      'mime'     => 'application/force-download',
      'modified' => time()
    );
 
    $options = array_merge($defaults, $params);

 * Helps redirecting to various places in your app
 * Combined with custom handlers of URL::to, this can be really smart and handy
 * 
 * @package   Kirby Toolkit 
 * @author    Bastian Allgeier <bastian@getkirby.com>
 * @link      http://getkirby.com
 * @copyright Bastian Allgeier
 * @license   http://www.opensource.org/licenses/mit-license.php MIT License
 */
class Redirect {
 
  /**
   * Redirects the user to a new URL
   *
   * @param   string    $url The URL to redirect to
   * @param   boolean   $code The HTTP status code, which should be sent (301, 302 or 303)
   * @param   boolean   $send If true, headers will be sent and redirection will take effect
   */
  public static function send($url = false, $code = false, $send = true) {
    return header::redirect($url, $code, $send);
  }
 
  /**
   * Redirects to a specific URL. You can pass either a normal URI
   * a controller path or simply nothing (which redirects home)
   * You can also pass a second param with the HTTP status code
   */
  public static function to() {
    $args = func_get_args();
 
    // if the last element is a number, use it as HTTP status code
    $code = false;
    if(is_int(end($args))) {
      $code = array_pop($args);
    }
 
    return static::send(call_user_func_array(array('url', 'to'), $args), $code);
  }
 
  /**

   */
  public static function send($url = false, $code = false, $send = true) {
    return header::redirect($url, $code, $send);
  }
 
  /**
   * Redirects to a specific URL. You can pass either a normal URI
   * a controller path or simply nothing (which redirects home)
   * You can also pass a second param with the HTTP status code
   */
  public static function to() {
    $args = func_get_args();
 
    // if the last element is a number, use it as HTTP status code
    $code = false;
    if(is_int(end($args))) {
      $code = array_pop($args);
    }
 
    return static::send(call_user_func_array(array('url', 'to'), $args), $code);
  }
 
  /**
   * Redirects to the home page of the app
   */
  public static function home() {
    static::send(url::home());
  }
 
  /**
   * Redirects to the last location of the user
   * 
   * @param string $fallback
   */
  public static function back($fallback = null) {
    // get the last url
    $last = url::last();
    // make sure there's a proper fallback
    if(empty($last)) $last = $fallback ? $fallback : url::home();
    static::send($last);

  return call_user_func_array('url::to', func_get_args());
}
 
/**
 * Even shorter shortcut for url::to()
 *
 * @return string
 */
function u() {
  return call_user_func_array('url::to', func_get_args());
}
 
/**
 * Redirects the user to a new URL
 * This uses the URL::to() method and can be super
 * smart with the custom url::to() handler. Check out
 * the URL class for more information
 */
function go() {
  call_user_func_array('redirect::to', func_get_args());
}
 
/**
 * Shortcut for r::get()
 *
 * @param   mixed    $key The key to look for. Pass false or null to return the entire request array.
 * @param   mixed    $default Optional default value, which should be returned if no element has been found
 * @return  mixed
 */
function get($key = null, $default = null) {
  return r::data($key, $default);
}
 
/**
 * Returns all params from the current url
 *
 * @return array
 */
function params() {
  return url::params();

      }
 
      // get the language code from the route
      $lang = ($kirby->route->lang)? $kirby->route->lang->code() : false;
 
      // visit the currently active page
      $page = ($lang)? $site->visit($path, $lang) : $site->visit($path);
 
      // redirections for files and invalid representations
      if($site->representation !== null) {
 
        // get the filename
        $filename = rawurldecode(basename($path));
        $pagepath = dirname($path);
 
        // check if there's a page for the parent path
        if($parent = $site->find($pagepath)) {
          // check if there's a file for the last element of the path
          if($file = $parent->file($filename)) {
            return go($file->url());
          }
        }
 
        // prevent invalid representation routes
        if($site->representation === '' || $site->representation != $page->representation()) {
          return $site->errorPage();
        }
 
      }
 
      return $page;
 
    };
 
    // tinyurl handling
    $routes['tinyurl'] = $this->component('tinyurl')->route();
 
    // home redirect
    $routes['homeRedirect'] = array(
      'pattern' => $this->options['home'] . '(\..*)?',

 
/**
 * Facepalm typo alias
 * @see csrf()
 */
function csfr() {
  return call('csrf', func_get_args());
}
 
/**
 * Shortcut for call_user_func_array with a better handling of arguments
 *
 * @param mixed $function
 * @param mixed $arguments
 * @return mixed
 */
function call($function, $arguments = array()) {
  if(!is_callable($function)) return false;
  if(!is_array($arguments)) $arguments = array($arguments);
  return call_user_func_array($function, $arguments);
}
 
/**
 * Parses yaml structured text
 *
 * @param $string
 * @return array
 */
function yaml($string) {
  return yaml::decode($string);
}
 
/**
 * Simple email sender helper
 *
 * @param array $params
 * @return Email
 */
function email($params = array()) {
  return new Email($params);

 
    // load all plugins
    $this->plugins();
 
    // start the router
    $this->router = new Router($this->routes());
    $this->route  = $this->router->run($this->path());
 
    // check for a valid route
    if(is_null($this->route)) {
      header::status('500');
      header::type('json');
      die(json_encode(array(
        'status'  => 'error',
        'message' => 'Invalid route or request method'
      )));
    }
 
    // call the router action with all arguments from the pattern
    $response = call($this->route->action(), $this->route->arguments());
 
    // load all language variables
    // this can only be loaded once the router action has been called
    // otherwise the current language is not yet available
    $this->localize();
 
    // build the response
    $this->response = $this->component('response')->make($response);
 
    // store the current language in the session
    if(
        $this->option('language.detect') &&
        $this->site()->multilang() && 
        $this->site()->language()
      ) {      
      s::set('kirby_language', $this->site()->language()->code());
    }
 
    return $this->response;
 

<?php
 
define('DS', DIRECTORY_SEPARATOR);
 
// load kirby
require(__DIR__ . DS . 'kirby' . DS . 'bootstrap.php');
 
// check for a custom site.php
if(file_exists(__DIR__ . DS . 'site.php')) {
  require(__DIR__ . DS . 'site.php');
} else {
  $kirby = kirby();
}
 
// render
echo $kirby->launch();