The symfony platform: Create your very own framework (PHP Quebec 2008)

The symfony platform

Create your very own framework

Fabien Potencier / Sensio Labs

PHP Quebec 2008 www.symfony-project.com 1 www.sensiolabs.com

Sensio / Me
• Founder of Sensio
– Web Agency
– Founded in 1998
– 45 people
– Open-Source Specialists
• Creator of symfony
– PHP Web framework
– Based on
• 10 years of Sensio experience
• Existing Open-Source projects


Web Framework
« Whatever the application, a framework is build to
ease development by providing tools for recurrent and
boring tasks. »
• Generic components
– Built-in
– Well integrated
– To solve web problems
• Professionalize web development


The symfony Platform
• symfony is made of decoupled classes based on a
small number of core classes
– Event Dispatcher
– Parameter Holder

• Classes with no dependency

cache, command, database, form, i18n, log,
request, response, routing, storage, user,
validator, widget

The symfony Platform

You can use all of those classes by themselves

… to create your own framework


Let’s do it


The Goals
• We won’t create a full stack framework

• We will create a framework customized for YOUR
needs

• The code we will write today can be used as a
bootstrap for your own framework


The Web Workflow

The User asks a Resource in a Browser

The Browser sends a Request to the Server

The Server sends back a Response

The Browser displays the Resource to the User


session_start();

if (isset($_GET['name']))
{
$name = $_GET['name'];
}
else if (isset($_SESSION['name']))
{
$name = $_SESSION['name']; PHP Global arrays
} Built-in PHP functions
else
{
$name = 'World';
}

$_SESSION['name'] = $name;

echo 'Hello '.$name;

User > Resource > Request > Response
Request Response

Move to OOP
• Use objects instead of global arrays and functions
– $_GET, $_POST, getcookie() Request
– echo, header(), setcookie() Response
– $_SESSION User
• Why ?
– To add behaviors to those objects
– To have several requests, users, responses in one PHP
process (functional testing)
– To be able to mock those objects to ease testing

sfWebRequest
PHP Object
$_SERVER[‘REQUEST_METHOD’] >getMethod()
$_GET[‘name’] >getParameter(‘name’)

get_magic_quotes_gpc() ?
>getCookie(‘name’)
stripslashes($_COOKIE[$name]) : $_COOKIE[$name];

(
isset($_SERVER['HTTPS'])
&& (
strtolower($_SERVER ['HTTPS']) == 'on’ >isSecure()
||
strtolower($_SERVER ['HTTPS']) == 1)
)
|| (
isset($_SERVER ['HTTP_X_FORWARDED_PROTO'])
&&
strtolower($_SERVER ['HTTP_X_FORWARDED_PROTO']) == 'https')
)
) Abstract
Parameters
and Headers


sfWebResponse
PHP Object
echo ‘Hello World!’ >setContent(‘Hello World’)

header(‘HTTP/1.0 404 Not Found’) >setStatusCode(404)

setcookie(‘name’, ‘value’) >setCookie(‘name’, ‘value’)

Abstract
Headers
and Cookies


sfUser / sfStorage
PHP Object
$_SESSION[‘name’] = ‘value’ >setAttribute(‘name’, ‘value’)

>setCulture(‘fr’)

>setAuthenticated(true)

Native session storage +
MySQL, PostgreSQL, PDO, …

Abstract
$_SESSION
Add features


sfEventDispatcher
• Allow decoupled objects to communicate
// sfUser
$event = new sfEvent($this, 'user.change_culture', array('culture' => $culture));
$dispatcher->notify($event);

// sfI18N
Based on
$callback = array($this, 'listenToChangeCultureEvent');
Cocoa Notification Center
$dispatcher->connect('user.change_culture', $callback);

• sfI18N and sfUser are decoupled
• « Anybody » can listen to any event
• You can notify existing events or create new ones


session_start();

if (isset($_GET['name']))
{

}
$name = $_GET['name'];
sfWebRequest
{
$name = $_SESSION['name'];
}
else
{ sfUser
$name = 'World';
}


echo 'Hello '.$name; sfWebResponse

Request Response

Install symfony
• Install symfony 1.1 (via PEAR or Subversion)
$ svn co http://svn.symfony-project.com/branches/1.1 symfony

• Core classes are autoloaded
require dirname(__FILE__).'/../symfony/lib/autoload/sfCoreAutoload.class.php';
sfCoreAutoload::register();



$dispatcher = new sfEventDispatcher();
$request = new sfWebRequest($dispatcher);

session_start();

if ($request->hasParameter('name')) if (isset($_GET['name']))
{ {
$name = $request->getParameter('name'); $name = $_GET['name'];
} }
{
}
else
{
$name = 'World';
}



Request Response



session_start();

if (!$name = $request->getParameter('name'))
{
if (isset($_SESSION['name']))
{
}
else
{
$name = 'World';
}
} >getParameter() returns null
if the parameter is not defined

Request Response


session_start();

if (!$name = $request->getParameter('name'))
{
if (isset($_SESSION['name']))
{
}
else
{
$name = 'World';
}
}


$response = new sfWebResponse($dispatcher);
$response->setContent('Hello '.$name); echo 'Hello '.$name;
$response->send();

Request Response


$storage = new sfSessionStorage(); session_start();
$user = new sfUser($dispatcher, $storage);

if (!$name = $request->getParameter('name')) else if (isset($_SESSION['name']))
{ {
if (!$name = $user->getAttribute('name')) $name = $_SESSION['name'];
{ }
$name = 'World';
}
}

$user->setAttribute('name', $name); $_SESSION['name'] = $name;

$response->setContent('Hello '.$name);
$response->send();

Request Response


$storage = new sfSessionStorage();

$name = $request->getParameter('name', $user->getAttribute('name', 'World'));

$user->setAttribute('name', $name);

$response->send();

Request Response

sfRouting
• Clean URLs <> Resources
• Parses PATH_INFO to inject parameters in the
sfRequest object
• Several strategies: PathInfo, Pattern
• Decouples Request and Controller



/step.php?name=Fabien
$routing = new sfPatternRouting($dispatcher);
$routing->connect('hello', '/hello/:name');
$request = new sfWebRequest($dispatcher); /step.php/hello/Fabien

$name = $request->getParameter('name', $user->getAttribute('name', 'World’));


$response->send();

Request Response

The Web Workflow

The User asks a Resource in a Browser

The Browser sends a Request to the Server

The Server sends back a Response

The Browser displays the Resource to the User


Let’s create
a new framework

Code name: fp


$dispatcher = new sfEventDispatcher(); Application
$user = new sfUser($dispatcher, $storage); Resource
$routing->connect('hello', '/hello/:name'); Generic

$name = $request->getParameter('name', $user->getAttribute('name', 'World'));


$response->send();

Request Response

Resource specific code
generic

application

resource

Request
? Response

fp gives You handle the fp wants
resource
you a Request specific code
A Response

• The dispatching logic is the same for every
resource

• The business logic depends on the resource and is
managed by the controller

• The controller responsability is to « convert » the
request to a response



$routing->connect('hello', '/hello/:name');

$controller = new helloController();

$response = $controller->indexAction($dispatcher, $request, $user);

$response->send();


class helloController
{
function indexAction($dispatcher, $request, $user)
{
$name = $request->getParameter('name', $user->getAttribute('name', 'World’));



return $response;
}
}


The framework creation process

• We write code that just works

• We abstract the code to make it generic



$routing->connect('hello', '/hello/:name',
array('controller' => 'hello', 'action' => 'index'));

$class = $request->getParameter('controller').'Controller';
$method = $request->getParameter('action').'Action';
$controller = new $class();

$response = $controller->$method($dispatcher, $request, $user);

$response->send();
sfPatternRouting accepts default
parameter values

Application
Resource
Generic



$response->send();


The Request Handler
• Handles the dispatching of the request

• Calls the Controller

• Has the responsability to return a sfResponse



$response = fpRequestHandler::handle($dispatcher, $request, $user);

$response->send();




class fpRequestHandler
{
static function handle($dispatcher, $request, $user)
{


return $response;
}
}


Application
Resource
Generic

$response = fpRequestHandler::handle($dispatcher, $request, $user);

$response->send();


Abstract object management
• I need a container for my application objects
– The dispatcher
– The user
– The routing
– The i18n
– The database
– …
• These objects are specific to my Application and do not
depend on the Request


$application = new helloApplication($dispatcher);


$response = $application->handle($request);

$response->send();


class helloApplication
{
public $dispatcher, $user, $routing;

function __construct($dispatcher)
{
$this->dispatcher = $dispatcher;

$this->user = new sfUser($this->dispatcher, $storage);

$this->routing = new sfPatternRouting($this->dispatcher);
$this->routing->connect('hello', '/hello/:name',
}

function handle($request)
{
return fpRequestHandler::handle($this->dispatcher, $request, $this-
>user);
}
}


Instead of passing a dispatcher around,
pass the application object


{
// ...

{
return fpRequestHandler::handle($this, $request);
}
}

{
static function handle($application, $request)
{
$method = $request->getParameter('action').'Action'; fpRequestHandler
$response = $controller->$method($application, $request);
is now generic
return $response;
}
}

class helloController
{
function indexAction($application, $request)
{
$name = $request->getParameter('name', $application->user->getAttribute('name', 'World’));

$application->user->setAttribute('name', $name);

$response = new sfWebResponse($application->dispatcher);

return $response;
}
}


{
Application

function __construct($dispatcher) Generic
{

$this->user = new sfUser($this->dispatcher, $storage);

}

{
return fpRequestHandler::handle($this->dispatcher, $request, $this-
>user);
}
}


Create a fpApplication class


abstract class fpApplication
{

{
$this->user = new sfUser($this->dispatcher, new sfSessionStorage());

$this->configure();
}

abstract function configure();

{
}
}

class helloApplication extends fpApplication
{
function configure()
{
}
}


Move the public properties
to accessor methods


{
protected $dispatcher, $storage, $user, $routing;
{
$this->configure();
}
function getDispatcher()
{
return $this->dispatcher;
}
function getStorage()
{
if (is_null($this->storage))
{
$this->storage = new new sfSessionStorage();
}
return $this->storage;
}
function getUser()
{
if (is_null($this->user))
{
$this->user = new sfUser($this->dispatcher, $this->getStorage());
}
return $this->user;
}
function getRouting()
{
if (is_null($this->routing))
{
}
return $this->routing;
}
// ...
}


Sensible defaults
• Most of the time
– The dispatcher is a sfEventDispatcher
– The request is a sfWebRequest object

• Let’s change the Application to take defaults


{
function __construct($dispatcher = null)
{
$this->dispatcher = is_null($dispatcher) ? new sfEventDispatcher() : $dispatcher;

// ...
}

function handle($request = null)
{
$request = is_null($request) ? new sfWebRequest($this->dispatcher) : $request;

}
}

$application = new helloApplication();

$response = $application->handle();

$response->send();


More sensible defaults
• Most of the time
– The controller creates a sfWebResponse object
– … with some content

• Let’s introduce a new Controller abstract class


class fpController
{
function __construct($application)
{
$this->application = $application;
}

function render($content)
{
$response = new sfWebResponse($this->application->dispatcher);
$response->setContent($content);

return $response;
}
}

class helloController extends fpController
{
function indexAction($request)
{
$name = $request->getParameter('name', $this->application->getUser()->getAttribute('name', 'World'));

$this->application->getUser()->setAttribute('name', $name);

return $this->render('Hello '.$name);
}
}


Move the framework
• Move the framework code to its own directory
structure
require dirname(__FILE__).'/../lib/symfony/lib/autoload/sfCoreAutoload.class.php';

require dirname(__FILE__).'/../lib/framework/fpApplication.class.php';
require dirname(__FILE__).'/../lib/framework/fpController.class.php';
require dirname(__FILE__).'/../lib/framework/fpRequestHandler.class.php';

{
// ...
}

{
// ...
}

$application->handle()->send();


Autoload our framework
require dirname(__FILE__).'/../lib/symfony/lib/autoload/sfCoreAutoload.class.php';

$autoload = sfSimpleAutoload::getInstance();
$autoload->addDirectory(dirname(__FILE__).'/../lib/framework');
$autoload->register();

{
// ...
}

{
// ...
}



Create a bootstrap file
require dirname(__FILE__).'/../lib/framework/bootstrap.php';

{
// ...
}

{
// ...
}



Move classes
• Move the application and controller classes to
their own directory structure

require dirname(__FILE__).'/../lib/framework/bootstrap.php';

require dirname(__FILE__).'/../hello/application.class.php';
require dirname(__FILE__).'/../hello/controller/helloController.class.php';



Summary
• 3 generic classes
– fpApplication
– fpController
– fpRequestHandler
• 2 specific classes
– helloApplication
– helloController
• A small boostrap code


Conventions
• We already have some conventions
– Controller class names
– Action method names

• Let’s add some directory name conventions
– Controllers are in the controller directory in the same
directory as applications.class.php
– The controller file is the controller class name suffixed
by .class.php


{
{
$this->dispatcher = is_null($dispatcher) ? new sfEventDispatcher() : $dispatcher;

$r = new ReflectionObject($this);
$this->root = realpath(dirname($r->getFileName()));

// ...
}

// ...
}

{
static function handle($application, $request)
{

require_once $application->root.'/controller/'.$class.'.class.php';

$response = $controller->$method($application, $request);

return $response;
}
}


Let’s add a simple templating
system based on PHP


{
protected $dispatcher, $storage, $user, $routing, $template;

function getTemplate()
{
if (is_null($this->template))
{
$this->template = new fpTemplate();
}

return $this->template;
}

// ...
}

class fpTemplate
{
function render($template, $parameters = array())
{
extract($parameters);

ob_start();
require $template;

return ob_get_clean();
}
}


The directory structure
• Add a template directory


class fpController
{
// ...

{
$template = $this->application->root.'/template/'.$template;
$content = $this->application->getTemplate()->render($template, $parameters);

$response = new sfWebResponse($this->application->getDispatcher());
$response->setContent($content);

return $response;
}
}

{
function indexAction($request)
{
$name = $request->getParameter('name', $this->application->getUser()->getAttribute('name',
'World'));

$this->application->getUser()->setAttribute('name', $name);

return $this->render('hello.php', array('name' => $name));
}
}


Write some tests
• Create a test/ directory to host test classes
• Use PHPUnit to test our controllers
• Change the session storage object


<?php

require_once 'PHPUnit/Framework.php';
require dirname(__FILE__).'/../../lib/framework/bootstrap.php';
require dirname(__FILE__).'/../application.class.php';

class helloApplicationTest extends helloApplication
{
{
parent::__construct($dispatcher);
$this->root = dirname(__FILE__).'/..';
}

function getStorage()
{
return new sfSessionTestStorage(
array('session_path' => '/tmp/quebec_demo', 'session_id' => '123')
);
}
}


class helloControllerTest extends PHPUnit_Framework_TestCase
{
protected function setUp()
{
$this->application = new helloApplicationTest();
}

public function testWithRequestParameter()
{
$_SERVER['PATH_INFO'] = '/hello/Fabien';
$request = new sfWebRequest($this->application->getDispatcher());
$response = $this->application->handle($request);

$this->assertEquals('Hello Fabien', $response->getContent());
}

public function testWithSession()
{
$_SERVER['PATH_INFO'] = '/hello';
$request = new sfWebRequest($this->application->getDispatcher());
$response = $this->application->handle($request);

$this->assertEquals('Hello Fabien', $response->getContent());
}
}


Refactor the code to create
a fpControllerTest class


abstract class fpControllerTest extends PHPUnit_Framework_TestCase
{
protected function setUp()
{
$r = new ReflectionObject($this);
$root = realpath(dirname($r->getFileName()).'/..');

require_once $root.'/application.class.php';

$this->application = $this->getMock(
basename($root).'Application', array('getStorage')
);
$this->application->root = $root;

$storage = new sfSessionTestStorage(
array('session_path' => '/tmp/quebec_demo', 'session_id' => '123')
);

$this->application->
expects($this->any())->
method('getStorage')->
will($this->returnValue($storage))
;
}

// ...
}


Add XSS protection
• Add XSS protection by escaping all template
parameters
• Use sfOutputEscaper symfony classes to do the
job
• Update the tests


{
// ...

function getTemplate()
{
if (is_null($this->template))
{
$this->template = new fpTemplate($this->dispatcher);
}

return $this->template;
}

// ...
}

class fpTemplate
{
{
}

{
$event = $this->dispatcher->filter(new sfEvent($this, 'template.filter_parameters'), $parameters);
$parameters = $event->getReturnValue();

// ...
}
}

{
{
$this->getRouting()->connect('hello', '/hello/:name',

$this->getDispatcher()->connect('template.filter_parameters’,
array($this, 'escapeTemplateParameters'));
}

function escapeTemplateParameters(sfEvent $event, $parameters)
{
$parameters['sf_data'] = sfOutputEscaper::escape(array($this, 'htmlspecialchars'), $parameters);
foreach ($parameters['sf_data'] as $key => $value)
{
$parameters[$key] = $value;
}

return $parameters;
}

function htmlspecialchars($value)
{
return htmlspecialchars($value, ENT_QUOTES, 'UTF-8');
}
}


Move the generic code to fpApplication


{
{
$this->getRouting()->connect('hello', '/hello/:name',
$this->enableOutputEscaping();
}
}
class fpApplication
{
// ...
function enableOutputEscaping()
{
$this->dispatcher->connect('template.filter_parameters’,
array($this, 'escapeTemplateParameters'));
}
function escapeTemplateParameters(sfEvent $event, $parameters)
{
$parameters['sf_data'] = sfOutputEscaper::escape(array($this, 'htmlspecialchars'), $parameters);
foreach ($parameters['sf_data'] as $key => $value)
{
$parameters[$key] = $value;
}
return $parameters;
}
function htmlspecialchars($value)
{
return htmlspecialchars($value, ENT_QUOTES, 'UTF-8');
}
}


Add custom 404, 500
• Allow custom 404 and 500 pages
– 404 pages > sfError404Exception
– 500 pages > Exception

• Change fpRequestHandler


Customization
• Add some events in the RequestHandler
– application.request
– application.controller
– application.response
– application.exception

• They can return a sfResponse and stop the
RequestHandler flow


What for?
• Page caching
– application.request: If I have the page in cache,
unserialize the response from the cache and returns it
– application.response : Serialize the response to the
cache
• Security
– application.controller: Check security and change the
controller if needed


If we have time…
• Add CSS selector support to the test class
• Implement a page cache system
• Implement a security mecanism for controllers
• Improve performance with caching (routing,
framework « compilation », …)
• Add a CLI
• Implement a layout system
• Use symfony Forms
• Use a database/model

SENSIO S.A.
26, rue Salomon de Rothschild
92 286 Suresnes Cedex
FRANCE
Tél. : +33 1 40 99 80 80
Fax : +33 1 40 99 83 34

Contact
Fabien Potencier
fabien.potencier@sensio.com

http://www.sensiolabs.com/ http://www.symfony-project.com/

The symfony platform: Create your very own framework (PHP Quebec 2008)

More Related Content

What's hot (20)

Similar to The symfony platform: Create your very own framework (PHP Quebec 2008) (20)

More from Fabien Potencier (16)

Recently uploaded (20)

The symfony platform: Create your very own framework (PHP Quebec 2008)