/www/slight

<?php

/**
 * Slight: an extension to Flight, in the form of useful configuration changes
 * and extra library code.
 *
 * @copyright Copyright (c) 2015, Tim Marston <tim@ed.am>
 * @licence   MIT
 *
 * Slight brings the following changes to Flight:
 *
 *  1. A global $app object.
 *
 *  2. App directories.
 *
 * It is expected that your app has the following layout, and class and view
 * paths are set up to reflect this:
 *
 *     /
 *     +-- index.php          (see note below)
 *     +-- app/
 *         +-- controllers/
 *         +-- models/
 *         +-- views/
 *
 * Note that index.php MUST go in the top-level directory, or autoloading
 * breaks.  If you want to keep it in the app/ directory, add a shim index.php
 * that just requires app/bootstrap.php (or whatever you want to call it).
 *
 *  3. The route() method now accepts a class name and routes to class methods.
 *
 * The flight route() method now accepts a class name in an array (so, like a
 * callable, except with no method specified) which indicates a class in which
 * the part of the URL beyond the route specified should be looked up as a
 * method and additional URL parts beyond those represented by the name of the
 * method passed as arguments to the method.
 *
 * For example, you could configure routing to a class's methods like this:
 *
 *     $app->route( '/some/path', array( 'MyClass' ) );
 *
 * Then, for example, /some/path/list will route to MyClass::action_list(),
 * assuming it exists.
 *
 * If MyClass::default_action() exists, then /some/path will route to it.  If
 * you don't require default functionality, you might still want to use this to
 * call some other action method.
 *
 * If other URL parts are specified beyond the name of the matched method, for
 * example /some/path/list/1/2, then these are passed as arguments to the
 * action.  You would define the action method as follows:
 *
 *     public static function action_list( $foo = 0, $bar = 0 )
 *
 * NOTE: the use of default values for arguments is REQUIRED, or a PHP error
 * would occur where if they were missing in the HTTP request.
 *
 * You can also write "specialisations" of actions, where an action has a
 * specific argument value.  This is achieved by using a double underscore in
 * the method name to represent the path separator.  For example, using the
 * above routing, /some/path/list/1 will route to MyClass::action_list__1(), if
 * it exists, leaving URLs that have other values in the last part of their path
 * (for example, /some/path/list/2) to still route to MyClass::action_list() as
 * before (passing 2 as the first argument).
 *
 * Also note that hyphens in URLs are converted to underscores (or they wouldn't
 * be usable as method names), and multiple underscores are contracted to a
 * single underscore (so that the path separators can be represented as a
 * double-underscore in method names)
 *
 *  4. Add database connection and classes
 *
 * The new method connect() takes an array of connection parameters, as follows:
 *     type: the database type (defaults to mysql)
 *     host: the database hostname (defaults to localhost)
 *     port: database port number (optional)
 *     dbname: database name
 *     username: authentication user
 *     password: authentication password
 *     prefix: a table prefix
 *
 * This makes a PDO connection available at $app->db().
 *
 * A Model base class is available, for an app to base it's own models on.
 *
 *  5. Helper functions
 *
 * The following helper functions are provided:
 *
 * e()
 *     This is a global function which escapes text for use in HTML.
 * $app->link( 'some/where' )
 *     Constructs and returns links, taking in to account the base_url.
 */


// instantiate global flight app
require 'flight/autoload.php';
$app = new flight\Engine();

// set slight class path
$app->path( __DIR__.'/classes' );

// set app paths
$app->set( 'flight.views.path', 'app/views' );
$app->path( 'app/controllers' );
$app->path( 'app/models' );

// config
$app->set( 'flight.log_errors', true );

// add class method router advice to route() method
$app->before( 'route',
	function( &$params, &$output ) use( &$app )
	{
		// is the callback an array containing only a classname?
		if( count( $params ) >= 2 &&
			is_array( $params[ 1 ] ) &&
			count( $params[ 1 ] ) == 1 )
		{
			$class = $params[ 1 ][ 0 ];

			// fix-up pattern
			$params[ 0 ] = preg_replace( '/\/$/', '', $params[ 0 ] ).'/*';

			// replace callback with method router
			$params[ 1 ] =
				function( $route ) use( &$app, &$class )
				{
					// clean up splat
					$splat = preg_replace(
						array( '/(.)\/$/', '/-/', '/_+/' ),
						array( '\1', '_', '_' ), $route->splat );

					// default action?
					if( $splat === '' ) {
						if( method_exists( $class, 'default_action' ) )
						{
							// set controller url
							$app->set( 'controller', '' );

							// instantiate class and call method
							$obj = new $class();
							return $obj->default_action();
						}
					}
					else {
						// method parts
						$parts = explode( '/', $splat );

						// find method
						$params = array();
						while( count( $parts ) )
						{
							// check to see if combined parts make a method name
							$method = 'action_'.implode( '__', $parts );
							if( method_exists( $class, $method ) )
							{
								// set controller url
								$controller = explode( '/', preg_replace(
									array( '/^\//', '/\/$/' ), '',
									$app->request()->url ) );
								array_splice( $controller, -count( $params ) );
								$app->set( 'controller',
									join( '/', $controller ) );

								// instantiate class and call method
								$obj = new $class();
								return call_user_func_array(
									array( $obj, $method ), $params );
							}

							// discard last part as a param and keep looking
							array_unshift( $params, array_pop( $parts ) );
						}
					}

					// 404
					$app->notFound();
				};

			// pass route to callback
			$params[ 2 ] = true;
		}
	} );

// add $app to global view parameters
$app->view()->set( 'app', $app );

// add connect() method
$app->map( 'connect',
	function( $params ) use( &$app )
	{
		// default values
		$params += array( 'type' => 'mysql', 'host' => 'localhost' );

		// construct pdo string
		$pdostr = $params[ 'type' ].':host='.$params[ 'host' ];
		if( isset( $params[ 'port' ] ) ) $pdostr .= ';port='.$params[ 'port' ];
		$pdostr .= ';dbname='.$params[ 'dbname' ];

		// register DB class
		$app->register( 'db', 'PDO',
			array( $pdostr, $params[ 'username' ], $params[ 'password' ] ) );

		// set variables
		if( isset( $params[ 'prefix' ] ) ) {
			$app->set( 'dbprefix', $params[ 'prefix' ] );
		}
	} );

// add general html escaping function
function e( $text )
{
	return htmlspecialchars( $text, ENT_COMPAT | ENT_HTML5 );
}

// add link helper
$app->map( 'link',
	function( $url = null ) use( &$app )
	{
		if( is_null( $url ) ) $url = $app->get( 'controller' );
		$url = preg_replace( array( '/^\//', '/\/$/' ), '', $url );
		return $app->get( 'base_url' ).'/'.$url;
	} );