Flight - An Extensible Micro-framework for PHP2

  • Published on

  • View

  • Download


tentang mikro framerok


  • 3/10/2014 Flight - An extensible micro-framework for PHP

    http://flightphp.com/learn#methods 1/13

    FlightAn extensible micro-framework for PHP

    about install learn code

    User Guide







    Error Handling



    HTTP Caching



    Framework Methods


    Routing in Flight is done by matching a URL pattern with a callback function.

    Flight::route('/', function(){ echo 'hello world!';});

    The callback can be any object that is callable. So you can use a regular function:

    function hello(){ echo 'hello world!';}

    Flight::route('/', 'hello');

    Or a class method:

    class Greeting { public static function hello() { echo 'hello world!'; }}

  • 3/10/2014 Flight - An extensible micro-framework for PHP

    http://flightphp.com/learn#methods 2/13

    Flight::route('/', array('Greeting','hello'));

    Routes are matched in the order they are defined. The first route to match a request will be invoked.

    Method Routing

    By default, route patterns are matched against all request methods. You can respond to specific methods

    by placing an identifier before the URL.

    Flight::route('GET /', function(){ echo 'I received a GET request.';});

    Flight::route('POST /', function(){ echo 'I received a POST request.';});

    You can also map multiple methods to a single callback by using a | delimiter:

    Flight::route('GET|POST /', function(){ echo 'I received either a GET or a POST request.';});

    Regular Expressions

    You can use regular expressions in your routes:

    Flight::route('/user/[0-9]+', function(){ // This will match /user/1234});

    Named Parameters

    You can specify named parameters in your routes which will be passed along to your callback function.

    Flight::route('/@name/@id', function($name, $id){ echo "hello, $name ($id)!";});

    You can also include regular expressions with your named parameters by using the : delimiter:

    Flight::route('/@name/@id:[0-9]{3}', function($name, $id){ // This will match /bob/123 // But will not match /bob/12345});

    Optional Parameters

    You can specify named parameters that are optional for matching by wrapping segments in parentheses.

    Flight::route('/blog(/@year(/@month(/@day)))', function($year, $month, $day){ // This will match the following URLS: // /blog/2012/12/10

  • 3/10/2014 Flight - An extensible micro-framework for PHP

    http://flightphp.com/learn#methods 3/13

    // /blog/2012/12 // /blog/2012 // /blog});

    Any optional parameters that are not matched will be passed in as NULL.


    Matching is only done on individual URL segments. If you want to match multiple segments you can use

    the * wildcard.

    Flight::route('/blog/*', function(){ // This will match /blog/2000/02/01});

    To route all requests to a single callback, you can do:

    Flight::route('*', function(){ // Do something});


    You can pass execution on to the next matching route by returning true from your callback function.

    Flight::route('/user/@name', function($name){ // Check some condition if ($name != "Bob") { // Continue to next route return true; }});

    Flight::route('/user/*', function(){ // This will get called});


    Flight is designed to be an extensible framework. The framework comes with a set of default methods

    and components, but it allows you to map your own methods, register your own classes, or even override

    existing classes and methods.

    Mapping Methods

    To map your own custom method, you use the map function:

    // Map your methodFlight::map('hello', function($name){ echo "hello $name!";});

    // Call your custom method

  • 3/10/2014 Flight - An extensible micro-framework for PHP

    http://flightphp.com/learn#methods 4/13


    Registering Classes

    To register your own class, you use the register function:

    // Register your classFlight::register('user', 'User');

    // Get an instance of your class$user = Flight::user();

    The register method also allows you to pass along parameters to your class constructor. So when you

    load your custom class, it will come pre-initialized. You can define the constructor parameters by passing

    in an additional array. Here's an example of loading a database connection:

    // Register class with constructor parametersFlight::register('db', 'PDO', array('mysql:host=localhost;dnbname=test','user','pass'));

    // Get an instance of your class// This will create an object with the defined parameters//// new PDO('mysql:host=localhost;dnbname=test','user','pass');//$db = Flight::db();

    If you pass in an additional callback parameter, it will be executed immediately after class construction.

    This allows you to perform any set up procedures for your new object. The callback function takes one

    parameter, an instance of the new object.

    // The callback will be passed the object that was constructedFlight::register('db', 'PDO', array('mysql:host=localhost;dnbname=test','user','pass'), function($db){ $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);});

    By default, every time you load your class you will get a shared instance. To get a new instance of a class,

    simply pass in false as a parameter:

    // Shared instance of the class$shared = Flight::db();

    // New instance of the class$new = Flight::db(false);

    Keep in mind that mapped methods have precedence over registered classes. If you declare both using

    the same name, only the mapped method will be invoked.


    Flight allows you to override its default functionality to suit your own needs, without having to modify any


    For example, when Flight cannot match a URL to a route, it invokes the notFound method which sends a

  • 3/10/2014 Flight - An extensible micro-framework for PHP

    http://flightphp.com/learn#methods 5/13

    generic HTTP 404 response. You can override this behavior by using the map method:

    Flight::map('notFound', function(){ // Display custom 404 page include 'errors/404.html';});

    Flight also allows you to replace core components of the framework. For example you can replace the

    default Router class with your own custom class:

    // Register your custom classFlight::register('router', 'MyRouter');

    // When Flight loads the Router instance, it will load your class$myrouter = Flight::router();

    Framework methods like map and register however cannot be overridden. You will get an error if you try

    to do so.


    Flight allows you to filter methods before and after they are called. There are no predefined hooks you

    need to memorize. You can filter any of the default framework methods as well as any custom methods

    that you've mapped.

    A filter function looks like this:

    function(&$params, &$output) { // Filter code}

    Using the passed in variables you can manipulate the input parameters and/or the output.

    You can have a filter run before a method by doing:

    Flight::before('start', function(&$params, &$output){ // Do something});

    You can have a filter run after a method by doing:

    Flight::after('start', function(&$params, &$output){ // Do something});

    You can add as many filters as you want to any method. They will be called in the order that they are


    Here's an example of the filtering process:

  • 3/10/2014 Flight - An extensible micro-framework for PHP

    http://flightphp.com/learn#methods 6/13

    // Map a custom methodFlight::map('hello', function($name){ return "Hello, $name!";});

    // Add a before filterFlight::before('hello', function(&$params, &$output){ // Manipulate the parameter $params[0] = 'Fred';});

    // Add an after filterFlight::after('hello', function(&$params, &$output){ // Manipulate the output $output .= " Have a nice day!";}

    // Invoke the custom methodecho Flight::hello('Bob');

    This should display:

    Hello Fred! Have a nice day!

    If you have defined multiple filters, you can break the chain by returning false in any of your filter


    Flight::before('start', function(&$params, &$output){ echo 'one';});

    Flight::before('start', function(&$params, &$output){ echo 'two';

    // This will end the chain return false;});

    // This will not get calledFlight::before('start', function(&$params, &$output){ echo 'three';});

    Note, core methods such as map and register cannot be filtered because they are called directly and not

    invoked dynamically.


    Flight allows you to save variables so that they can be used anywhere in your application.

    // Save your variableFlight::set('id', 123);

    // Elsewhere in your application$id = Flight::get('id');

    To see if a variable has been set you can do:

  • 3/10/2014 Flight - An extensible micro-framework for PHP

    http://flightphp.com/learn#methods 7/13

    if (Flight::has('id')) { // Do something}

    You can clear a variable by doing:

    // Clears the id variableFlight::clear('id');

    // Clears all variablesFlight::clear();

    Flight also uses variables for configuration purposes.

    Flight::set('flight.log_errors', true);


    Flight provides some basic templating functionality by default. To display a view template call the render

    method with the name of the template file and optional template data:

    Flight::render('hello.php', array('name' => 'Bob'));

    The template data you pass in is automatically injected into the template and can be reference like a

    local variable. Template files are simply PHP files. If the content of the hello.php template file is:

    Hello, ''!

    The output would be:

    Hello, Bob!

    You can also manually set view variables by using the set method:

    Flight::view()->set('name', 'Bob');

    The variable name is now available across all your views. So you can simply do:


    Note that when specifying the name of the template in the render method, you can leave out the .php


    By default Flight will look for a views directory for template files. You can set an alternate path for your

    templates by setting the following config:

  • 3/10/2014 Flight - An extensible micro-framework for PHP

    http://flightphp.com/learn#methods 8/13

    Flight::set('flight.views.path', '/path/to/views');


    It is common for websites to have a single layout template file with interchanging content. To render

    content to be used in a layout, you can pass in an optional parameter to the render method.

    Flight::render('header', array('heading' => 'Hello'), 'header_content');Flight::render('body', array('body' => 'World'), 'body_content');

    Your view will then have saved variables called header_content and body_content. You can then render

    your layout by doing:

    Flight::render('layout', array('title' => 'Home Page'));

    If the template files looks like this:




    The output would be:

    Home Page


    Custom Views

    Flight allows you to swap out the default view engine simply by registering your own view class. Here's

  • 3/10/2014 Flight - An extensible micro-framework for PHP

    http://flightphp.com/learn#methods 9/13

    how you would use the Smarty template engine for your views:

    // Load Smarty libraryrequire './Smarty/libs/Smarty.class.php';

    // Register Smarty as the view class// Also pass a callback function to configure Smarty on loadFlight::register('view', 'Smarty', array(), function($smarty){ $smarty->template_dir = './templates/'; $smarty->compile_dir = './templates_c/'; $smarty->config_dir = './config/'; $smarty->cache_dir = './cache/';});

    // Assign template dataFlight::view()->assign('name', 'Bob');

    // Display the templateFlight::view()->display('hello.tpl');

    For completeness, you should also override Flight's default render method:

    Flight::map('render', function($template, $data){ Flight::view()->assign($data); Flight::view()->display($template);});

    Error Handling

    Errors and Exceptions

    All errors and exceptions are caught by Flight and passed to the error method. The default behavior is to

    send a generic HTTP 500 Internal Server Error response with some error information.

    You can override this behavior for your own needs:

    Flight::map('error', function(Exception $ex){ // Handle error echo $ex->getTraceAsString();});

    By default errors are not logged to the web server. You can enable this by changing the config:

    Flight::set('flight.log_errors', true);

    Not Found

    When a URL can't be found, Flight calls the notFound method. The default behavior is to send an HTTP

    404 Not Found response with a simple message.

    You can override this behavior for your own needs:

    Flight::map('notFound', function(){ // Handle not found

  • 3/10/2014 Flight - An extensible micro-framework for PHP

    http://flightphp.com/learn#methods 10/13



    You can redirect the current request by using the redirect method and passing in a new URL:


    By default Flight sends a HTTP 303 status code. You can optionally set a custom code:

    Flight::redirect('/new/location', 401);


    Flight encapsulates the HTTP request into a single object, which can be accessed by doing:

    $request = Flight::request();

    The request object provides the following properties:

    url - The URL being requestedbase - The parent subdirectory of the URLmethod - The request method (GET, POST, PUT, DELETE)referrer - The referrer URLip - IP address of the clientajax - Whether the request is an AJAX requestscheme - The server protocol (http, https)user_agent - Browser informationbody - Raw data from the request bodytype - The content typelength - The content lengthquery - Query string parametersdata - Post parameterscookies - Cookie parametersfiles - Uploaded filessecure - Whether the connection is secureaccept - HTTP accept parametersproxy_ip - Proxy IP address of the client

    You can access the query, data, cookies, and files properties as arrays or objects.

    So, to get a query string parameter, you can do:

    $id = Flight::request()->query['id'];

    Or you can do:

    $id = Flight::request()->query->id;

  • 3/10/2014 Flight - An extensible micro-framework for PHP

    http://flightphp.com/learn#methods 11/13

    HTTP Caching

    Flight provides built-in support for HTTP level caching. If the caching condition is met, Flight will return

    an HTTP 304 Not Modified response. The next time the client requests the same resource, they will be

    prompted to use their locally cached version.


    You can use the lastModified method and pass in a UNIX timestamp to set the date and time a page

    was last modified. The client will continue to use their cache until the last modified value is changed.

    Flight::route('/news', function(){ Flight::lastModified(1234567890); echo 'This content will be cached.';});


    ETag caching is similar to Last-Modified, except you can specify any id you want for the resource:

    Flight::route('/news', function(){ Flight::etag('my-unique-id'); echo 'This content will be cached.';});

    Keep in mind that calling either lastModified or etag will both set and check the cache value. If the

    cache value is the same between requests, Flight will immediately send an HTTP 304 response and stop



    You can stop the framework at any point by calling the halt method:


    You can also specify an optional HTTP status code and message:

    Flight::halt(200, 'Be right back...');

    Calling halt will discard any response content up to that point. If you want to stop the framework and

    output the current response, use the stop method:



    Flight provides support for sending JSON and JSONP responses. To send a JSON response you pass some

  • 3/10/2014 Flight - An extensible micro-framework for PHP

    http://flightphp.com/learn#methods 12/13

    data to be JSON encoded:

    Flight::json(array('id' => 123));

    For JSONP requests you would use the jsonp method. You can optionally pass in the query parameter

    name you are using to define your callback function:

    Flight::jsonp(array('id' => 123), 'q');

    So, when making a GET request using ?q=my_func, you should receive the output:


    If you don't pass in a query parameter name it will default to jsonp.


    You can customize certain behaviors of Flight by setting configuration values through the set method.

    Flight::set('flight.log_errors', true);

    The following is a list of all the available configuration settings.

    flight.base_url - Override the base url of the request. (default: null)flight.handle_errors - Allow Flight to handle all errors internally. (default: true)flight.log_errors - Log errors to the web server's error log file. (default: false)flight.views.path - Directory containing view template files (default: ./views)

    Framework Methods

    Flight is designed to be easy to use and understand. The following is the complete set of methods for the

    framework. It consists of core methods, which are regular static methods, and extensible methods, which

    can be filtered or overridden.

    Core Methods

    Flight::map($name, $callback) // Creates a custom framework method.Flight::register($name, $class, [$params], [$callback]) // Registers a class to a framework method.Flight::before($name, $callback) // Adds a filter before a framework method.Flight::after($name, $callback) // Adds a filter after a framework method.Flight::path($path) // Adds a path for autoloading classes.Flight::get($key) // Gets a variable.Flight::set($key, $value) // Sets a variable.Flight::has($key) // Checks if a variable is set.Flight::clear([$key]) // Clears a variable.

    Extensible Methods

  • 3/10/2014 Flight - An extensible micro-framework for PHP

    http://flightphp.com/learn#methods 13/13

    Flight::start() // Starts the framework.Flight::stop() // Stops the framework and sends a response.Flight::halt([$code], [$message]) // Stop the framework with an optional status code and message.Flight::route($pattern, $callback) // Maps a URL pattern to a callback.Flight::redirect($url, [$code]) // Redirects to another URL.Flight::render($file, [$data], [$key]) // Renders a template file.Flight::error($exception) // Sends an HTTP 500 response.Flight::notFound() // Sends an HTTP 404 response.Flight::etag($id, [$type]) // Performs ETag HTTP caching.Flight::lastModified($time) // Performs last modified HTTP caching.Flight::json($data, [$code], [$encode]) // Sends a JSON response.Flight::jsonp($data, [$param], [$code], [$encode]) // Sends a JSONP response.

    Any custom methods added with map and register can also be filtered.

    Framework Instance

    Instead of running Flight as a global static class, you can optionally run it as an object instance.

    require 'flight/autoload.php';

    use flight\Engine;

    $app = new Engine();

    $app->route('/', function(){ echo 'hello world!';});


    All of the existing static methods are available as regular class methods.

    Copyright 2013 Mike Cao

    Powered by Flight


View more >