Starting your new Symfony2 project

Starting your new
project with
Symfony2
Ryan Weaver
@weaverryan

Thursday, August 18, 11

Who is this dude?
• Co-author of the Symfony2 Docs
• Core Symfony2 contributor
• Co-owner of KnpLabs US
• Fiancee of the much more
talented @leannapelham

http://www.knplabs.com/en
http://www.github.com/weaverryan


KnpLabs
Quality. Innovation. Excitement.

• Training
• Coaching / Consulting
• Fun, high-quality custom dev


Act 1:

Downloading the Symfony
Standard Edition

http://bit.ly/sf2-install


The “Standard Distribution”
• Symfony offers “distributions” (think Ubuntu)

• The “Standard Distribution” is a fully-functional
skeleton web application

• The Standard Distribution *is* the starting
point for your new project: download it and
begin developing your new application


Step 1: Get it!

http://symfony.com/download


Step 2: Unzip it!

$ cd /path/to/webroot

$ tar zxvf /path/to/Symfony_Standard_2.0.0.tgz


Step 3: Download the vendors
• Run the following command:
php bin/vendors install

• ...which should fill up your vendor/ directory


Step 3: Explained
• The “standard edition” project itself is just a
few directories and a few files

• But it relies a group of 3rd-party libraries
• The Standard edition packages a script that
downloads these libraries into your vendor/
directory by reading the “deps” file

php bin/vendors install


The “deps” file
[symfony]
git=http://github.com/symfony/symfony.git
version=v2.0.0

[twig]
git=http://github.com/fabpot/Twig.git
version=v1.1.1

[monolog]
git=http://github.com/Seldaek/monolog.git
version=1.0.0

[doctrine]
git=http://github.com/doctrine/doctrine2.git
version=2.1.0

[swiftmailer]
git=http://github.com/swiftmailer/swiftmailer.git
version=v4.1.0

Step 4: Check your conﬁg

http://localhost/Symfony/web/conﬁg.php


Tend to your Garden

• Fix any major problems (e.g. missing libraries,
permissions issues) that Symfony reports


Cache and log permissions

• The app/cache and app/logs directories must
be writable by your web server

• There are several ways to do this depending
on your setup and platform

D o cs
T he http://bit.ly/sf2-perms

Head to the homepage!

This *is* your
ﬁrst Symfony2
page!!!

http://localhost/Symfony/web/app_dev.php


End of Act1
• So far we’ve:

‣ Downloaded the Standard Distribution
‣ Downloaded the vendor libraries
‣ Setup any pre-reqs needed for Symfony

‣ Navigated to the homepage of our project:
a sample page packaged with the distribution


Act 2:

Storing the new project in git

http://bit.ly/sf2-git


Version Control
• The Standard Distribution *is* the starting
point for your new project

• We’ll use “git” as our version control tool

• Initialize a new git repository inside your
project:
git init

git status


Ignore Some Files
• Most of the files are *your* files: you’ll edit
them and commit them to git

• Some files, however, shouldn’t be shared:
‣ database configuration files
• Others simply don’t need to be committed
‣ 3rd party libraries (each developer can
download them via “bin/vendors install”)
‣ cache files


Ignore Some Files
• To ignore certain files in git, create a .gitignore
file at the root of your project and specify file
patterns that shouldn’t be stored in git


Recommended “.gitignore” file

{
/web/bundles/
/app/bootstrap*
“generated” /app/cache/*
files
/app/logs/*
/vendor/
db config { /app/config/parameters.ini


Initial Commit
• Once you’ve created the .gitignore ﬁle, you
can create an initial commit

• This commit represents the starting point of
your project: a fresh project with Symfony

git add .

git commit -m “Initial commit of the project”


Database Configuration
• By convention, database (and other server-
specific) configuration is stored in the app/
config/parameters.ini file

• We’ve placed this file in our .gitignore

• Every new developer that downloads the
project will need to create this file


Database Configuration
• To make the creation of the parameters.ini file
easy, create a parameters.ini.dist sample file that
we *will* commit to git

cp app/config/parameters.ini app/config/parameters.ini.dist

git add app/config/parameters.ini.dist

git commit -m “adding a sample parameters file”


Removing demo pages
• The Standard Distribution comes with some
sample pages inside a demo bundle

• Remove these before developing your own
application

https://github.com/symfony/symfony-standard


Finishing up Act 2
• Where are we now?

‣ The new project is stored in git

‣ Certain files are set to be ignored by git

‣ A database configuration “template” file
was created to help when the project is
cloned by new developers


Act 3:

What Symfony does...
in exactly 3 slides

http://bit.ly/sf2-http


Your job: turn a request into a response

the request
/foo
Client
Your App
(e.g. browser)
<h1>Foo!</h1>
the response

But as your app grows, staying organized is
tough, wheels are reinvented and code tends
towards spaghetti

Request to Response Structure
• Symfony gives you structure for reading each
request and creating the appropriate response

e.g. app.php

1) a request executes 2) matches a route 3) executes a PHP function
the front controller that you write

Tools for Development
• In addition to basic structure, Symfony is full of
optional tools that you can choose to use when
developing your application:

‣ security
‣ render templates
‣ send emails
‣ work with the database
‣ handle HTML forms
‣ validation
‣ caching


Act 4:

Creating your app

http://bit.ly/sf2-page-creation


Bundles!
• A standard Symfony project looks like this:

app/ app conﬁg - nothing too heavy
src/ your bundles!
vendor/ third-party libraries
web/ front controllers, CSS, JS, etc


Bundles: first-class plugins
• A bundle is a directory that holds *everything*
for a single “feature” - from routing files to PHP
classes to JS files

• A bundle is like a plugin, except that
everything (including the core Symfony2 files)
exists in a bundle

(this means you could replace the core framework libraries
with your own...)


Creating the MainBundle
• Symfony can generate a nice bundle skeleton
on your behalf:

php app/console generate:bundle

Answer the prompts:
• Acme/MainBundle
• MainBundle
• ... enter the defaults for the rest


Initialize the bundle
• The following was added by the task to your
app/AppKernel.php file:
public function registerBundles()
{
$bundles = array(
// ...
new AcmeMainBundleMainBundle(),
);
}


Where now?
• Now that you have a bundle, you can start
creating your app page-by-page:

‣ create a route
‣ create a controller
‣ create and return a Response object
(usually via a template)

• As you develop more features, you may
create more bundles, but it’s up to you


Open Source Bundles
• Lots of 3rd-party bundles are also available
to help you:

‣ FOSUserBundle - user management
‣ KnpMenuBundle - really smart menus
‣ DoctrineFixturesBundle
‣ StofDoctrineExtensionsBundle - easy doctrine
behaviors
‣ AvalancheImagineBundle - image manipulation
‣ KnpPaginatorBundle
... and many more...

http://symfony2bundles.org/


Act 5:

Playing with Behat

http://behat.org


What is Behat
• Behat is a tool that lets you focus on
developing to the intended behavior of your
application

• You write scenarios that describe the behavior
of the features needed, which are then executed
as tests against your application


Example Behat Feature

Feature: Registration
In order to have an account with the system
As an unauthenticated user
I can register for a new account

Scenario: Navigate to the registration page
Given I am on "/"
When I follow "Register"
Then the response status code should be 200
And the "h1" element should contain "Register"


Installing Behat
• To use behat to test the functionality of your
application, you’ll need to install both Behat and
Mink

• Behat is a command-line executable that you
install via pear

• Details: behat.org


Installing Behat
• To use behat to test the functionality of your
application, you’ll need to install both Behat and
Mink

• Behat is a command-line executable that you
install via pear

pear channel-discover pear.behat.org
pear channel-discover pear.symfony.com
pear install behat/behat
pear install behat/mink


Integrating into your project
• To use Behat and Mink in your project, install
BehatBundle and MinkBundle

1. Add the deps file
2. Configure the autoloader
3. Enable the bundles
4. Configure the bundles
5. Start describing your features!

http://bit.ly/mink-bundle

Behavior-Driven Development
• Remember that the goal of Behat is to let you
describe the behavior of your application as
human-readable sentences

• This allows you to describe the behavior of
each feature in a common language, which is
executed as tests against your application

• Develop a feature until the test passes,
then move on


registration.feature
Describes your feature, but This “format” is called
not executed by Behat “Gherkin”


{ In order to have an account with the system


{
Given I am on "/"
Each Scenario is actually
executed as a test against
your application

http://bit.ly/gherkin-docs

Behind-the-scenes
• Behind the scenes, each line of the scenario is
executed against a collection of “definitions”

• A definition is a regular expression pattern and
a function

• When a line in your scenario matches a
definition’s regular expression, that definition is
executed

• Mink comes with a great list of
built-in definitions


Testing Javascript
• By default, tests are run in a “headless” or
command-line-only browser

• This means that your testing your application
as if Javascript were off

• You can also do in-browser testing by
leveraging another library called Sahi


In-browser testing

In order to have an account with the system

Activates Sahi
@javascript
Given I am on "/"


Testing Javascript
• By adding “@javascript”, the test will be run
through Sahi

• Sahi will physically open up a browser and
execute the test

• You can use headless browsers for some tests
and Sahi for others that require Javascript
functionality


After dinner mint:

The HTTP Lifecycle


HTTP is Simple

• HTTP is a text language that allows two
machines to communicate with each other

• Communication on the web is always a two-
step process:

1) The client sends an HTTP request
2) The server send back an HTTP response


HTTP Communication - from space

the request
/foo
Client
Your App
(e.g. browser)
<h1>Foo!</h1>
the response


The Request

• The actual request looks something like this:
GET /foo HTTP/1.1
Host: knplabs.com
Accept: text/html
User-Agent: Mozilla/5.0 (Macintosh)


This simple message
communicates everything
necessary about exactly which
resource the client is requesting


The Request

• The first line contains the two most important
pieces of information:

HTTP method URI

GET /foo HTTP/1.1
Host: knplabs.com
Accept: text/html
User-Agent: Mozilla/5.0 (Macintosh)


The Request

URI The unique address or location that
identifies the resource the client wants

HTTP method

The “verb” of the request: what action
you would like to perform with the
resource


Request Methods
Retrieve the resource
GET
from the server
Create a resource on
POST
the server
Update the resource on
PUT
the server
Delete the resource
DELETE
from the server


The Response

• And the response looks like this:
HTTP/1.1 200 OK
Date: Tue, 04 Jun 2011 21:05:05 GMT
Server: lighttpd/1.4.19
Content-Type: text/html

<html>
<h1>Foo!</h1>
</html>


The Response
HTTP Status code
HTTP/1.1 200 OK
Date: Tue, 04 Jun 2011 21:05:05 GMT
Server: lighttpd/1.4.19

{
<html>
Request <h1>Foo!</h1>
body </html>


HTTP Request-Response

• In every application, and every language, you
always have the same goal:

To read the HTTP request and create the
appropriate HTTP response


Request Response in PHP

• So how do you interact with HTTP requests
and responses in PHP?

<?php

$uri = $_SERVER['REQUEST_URI'];
$foo = $_GET['foo'];

header('Content-type: text/html');
echo 'The URI requested is: '.$uri;
echo 'The "foo" parameter is: '.$foo;


Request Response in PHP

• PHP gives you access to the HTTP request
via several “superglobal” arrays

• To create the HTTP response, use the the
header() method to set the header lines and
print content to populate the request body


The user sends the HTTP request...

• http://knplabs.com/testing.php?foo=symfony

<?php
// this is testing.php

$uri = $_SERVER['REQUEST_URI'];
$foo = $_GET['foo'];

header('Content-type: text/html');
echo 'The URI requested is: '.$uri;
echo 'The "foo" parameter is: '.$foo;

... and PHP sends back the HTTP response

• http://knplabs.com/testing.php?foo=symfony
HTTP/1.1 200 OK
Date: Sat, 03 Apr 2011 02:14:33 GMT
Server: Apache/2.2.17 (Unix)

The URI requested is: /testing?
foo=symfony
The "foo" parameter is: symfony


Request and Responses in Symfony

• Symfony offers a Request and Response
objects that abstract the HTTP text messages
into an object-oriented format


use SymfonyComponentHttpFoundationRequest;
use SymfonyComponentHttpFoundationResponse;

$request = Request::createFromGlobals();
$c = 'URI: '.$request->getPathInfo();
$c .= '”foo”: '.$request->query->get('foo');

$response = new Response();
$response->setContent($c);
$response->setStatusCode(200);
$response->headers->set('Content-Type', 'text/
html')

//sets the headers and then prints the content
$response->send();


Thanks!
Questions?

Ryan Weaver
@weaverryan


Starting your new Symfony2 project

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (11)

Ähnlich wie Starting your new Symfony2 project

Ähnlich wie Starting your new Symfony2 project (20)

Mehr von Ryan Weaver

Mehr von Ryan Weaver (12)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Starting your new Symfony2 project