$ sudo apt-get install php5-common libapache2-mod-php5 php5-cli

$ curl -s http://php-osx.liip.ch/install.sh | bash -s 7.0

$ curl -s http://php-osx.liip.ch/install.sh | bash -s 5.6

// so, this is a PHP variable
$a = 5;

// compare value; return true
var_dump($a == 5);

// compare value (ignore type); return true
var_dump($a == '5');

// compare type/value (integer vs. integer); return true
var_dump($a === 5);

// compare type/value (integer vs. string); return false
var_dump($a === '5');

$a++; // or: ++$a;

$b--; // or: --$b;

$a && $b;   // AND
$a || $b;   // OR

! $a;       // `true` if $a is not `true`

$a . 'foo'; // concatenation

2 ** 3 = 8 // exponentiation (PHP 5.6+)

$a  = 'foo';
$a .= 'bar';
// $a => 'foobar'

$b  = 0;
$b += 1;    // $b = 1
$b -= 1;    // $b = 0

$c = 2;
$c **= 3;   // $c = 8

// Fetches the value of $_GET['user'] and returns 'nobody'
// if it does not exist.
$username = $_GET['user'] ?? 'nobody';

// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';

echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1

class Foo
{
}

abstract class AbstractFoo
{
    abstract public function doSomething();
}

$foo = new Foo();
// $foo = new Foo;

// can also be done with a variable
$class = 'Foo';
$foo   = new $class();

echo get_class($foo);
=> Foo

if ($foo instanceof Foo) {
    // do something
}

new class {
    public function foo() {
        return 'foo';
    }
}

interface Logger {
    public function log($msg);
}

$logger = new class implements Logger {
    public function log($msg) {
        // ...
    }
};

$logger->log('Hello, Anonymous Class');

class Foo
{
    const VALUE = 123;
    // PHP 5.6+
    const SENTENCE        = 'The value of VALUE is ' . self::VALUE;
    const ARRAY_OF_VALUES = ['a', 'b'];
    // PHP 7.1+
    private const IMPLEMENTATION_VALUE = 42;

    /** @var int */
    public static $count = 0;

    /** @var Iterator */
    public $iterator;

    /** @var array */
    protected $values = [];

    /** @var string|null */
    private $language = null;
}

class Foo
{
    public function doSomething()
    {
    }
}

public function doSomething(Foo $foo);

public function doSomething(Traversable $iterator);

public function doSomething(array $values);

public function doSomething(iterable $values); // accepts array + Traversable

public function doSomething(callable $callback);

public function doSomething(Closure $closure);

function sumOfInts(int $a, int $b) {
    return $a + $b;
}

function sumOfInts(int $a, int $b): int {
    return $a + $b;
}

function foo(?string $bar): ?string {
    var_dump($bar);
    return $bar;
}
foo('baz'); // string(3) "baz"
foo(null); // NULL
foo(); // Uncaught Error: Too few arguments to function foo(), 0 passed

function log(string $message): void {
    fprintf(stderr, '>> '.$message);
}

function log(string $message): void {
    fprintf(stderr, '>> '.$message);
    return true; // Fatal error: A void function must not return a value
}

$foo = new Foo();
$foo->doSomething();

// >= PHP 5.4
(new Foo())->doSomething();

// can also be done with a variable
$method = 'doSomething';
$foo->$method();

$foo->{$method . 'Else'}();
// will call 'doSomethingElse()'; curly braces are required.

public function doSomething()
{
    // method call
    $this->doSomethingElse();

    // parent method call (inheritance)
    parent::doSomething();

    // accessing a constant
    self::VALUE;

    // accessing a constant from another class
    Bar::ANOTHER_VALUE;

    // accessing an attribute
    return $this->attribute;
}

class Foo
{
    public static $value;

    public static function doThings()
    {
        // accessing a static attribute
        // don't forget the dollar sign!
        self::$value;
    }
}

class A
{
    public static function who() { echo __CLASS__; }

    public static function testSelf()
    {
        self::who();
    }

    public static function testStatic()
    {
        static::who();
    }
}

class B extends A
{
    public static function who() { echo __CLASS__; }
}

B::testSelf();
// A

B::testStatic();
// B

$foo = new Foo();

// accessing the attribute from an instance
$foo::$value = 123;

// accessing the attribute directly from the class
echo Foo::$value;
=> 123

function sum(...$numbers)
{
    return array_sum($numbers);
}

echo sum(1, 2);
// 3

$numbers = [ 2, 3 ];
echo sum(1, ...$numbers);
// 6

function sum(int ...$numbers): int
{
    return array_sum($numbers);
}

echo sum(1, 2);
// 3

$numbers = [ 2, 3 ];
echo sum(1, ...$numbers);
// 6

interface Fooable
{
    const VALUE = 123;

    // it's always public anyway
    public function doSomething();
}

// Interface may extend several other interfaces.
// This is not possible with classes though!
interface MyTraversable extends Traversable, Countable
{
}

// a class may implement several interfaces, but may extend only one class!
class Foo implements Fooable, MyTraversable {}

namespace Vendor\Model;
// ...

namespace MyNamespace {
    // ...
}

namespace My\Namespace;

// Pre PHP 7 code
use some\namespace\ClassA;
use some\namespace\ClassB;

use function some\namespace\fn_a;
use function some\namespace\fn_b;

// PHP 7+ code
use some\namespace\{ClassA, ClassB};

use function some\namespace\{fn_a, fn_b};

class MyClass
{
    public function __construct(ClassA $a, ClassB $b) {
        // ...
    }
}

namespace My\Namespace;

class ClassName
{
}

echo ClassName::class;
// My\namespace\ClassName

trait Hello                         trait World
{                                   {
    public function sayHello()          public function sayWorld()
    {                                    {
        echo 'Hello ';                       echo 'World';
    }                                    }
}                                   }

class MyHelloWorld
{
    use Hello, World;
}

$obj = new MyHelloWorld();
$obj->sayHello();
$obj->sayWorld();

$greet = function ($name) {
    printf("Hello %s\n", $name);
};

$greet('World');
=> Hello World

$fibonacci = function ($n) use (&$fibonacci) {
    if (0 === $n || 1 === $n) {
        return $n;
    }

    return $fibonacci($n - 1) + $fibonacci($n - 2);
};

echo (int) $fibonacci(6);
=> 8

__construct() { /* ... */ }

__toString() { /* ... */ }

// src/Model/Octopus.php
class Octopus
{
    public function scream()
    {
        echo "o o O O  ° °";
    }
}

// src/Application.php
$paul = new Octopus();
$paul->scream();

Fatal error: Class 'Octopus' not found in […]/src/Application.php

require __DIR__ . '/Model/Octopus.php';

$paul = new Octopus();
$paul->scream();

// somewhere further in your application
require __DIR__ . '/Model/Octopus.php';

class Squid extends Octopus
{
}

Fatal error: Cannot redeclare class Octopus in /path/to/file.php

require_once __DIR__ . '/Model/Octopus.php';

$paul = new Octopus();
$paul->scream();

// somewhere further in your application
require_once __DIR__ . '/Model/Octopus.php';

class Squid extends Octopus
{
}

/**
 * lib/Model/Location.php
 */
require_once __DIR__ . '/../../common.php';
require_once DOCROOT . '/lib/Model/ModelRepresentation.php';
require_once DOCROOT . '/lib/Model/User.php';
require_once DOCROOT . '/lib/Validator/Email.php';
require_once DOCROOT . '/lib/Validator/Username.php';
require_once DOCROOT . '/lib/Validator/Url.php';

class Location implements ModelRepresentation
{
    /* ... */
}

function __autoload($className)
{
    require_once __DIR__ . DIRECTORY_SEPARATOR . $className . '.php';
}

function my_autoload($className)
{
    require_once __DIR__ . DIRECTORY_SEPARATOR . $className . '.php';
}

spl_autoload_register('my_autoload');

spl_autoload_unregister('my_autoload');

new Foo();

1. Does the 'Foo' class exist?
    => Yes
        Go on

    => No
         Do you have registered autoload functions?
            => Yes
                Call each function with 'Foo' as parameter
                until the class gets included

            => No
                Is there a `__autoload()` method?
                    => Yes
                        Call `__autoload('Foo')`

2. Does the 'Foo' class exist?
    => Yes
        Continue
    => No
        Fatal Error

\Zend\Mail\Message
// => /path/to/project/lib/vendor/Zend/Mail/Message.php

Zend_Mail_Message
// => /path/to/project/lib/vendor/Zend/Mail/Message.php

$ php -r 'echo "Hello, World\n"'
Hello, World

$ php -a
Interactive Shell

php > echo "Hello, World\n";
Hello, World

$ wget https://git.io/psysh
$ chmod +x psysh
$ ./psysh

$ php -l my/script.php
No syntax errors detected in my/script.php

$ php -S localhost:8000

#!/usr/bin/env php
<?php

if (2 !== $argc) {
    echo "Usage: php $argv[0] [name]\n";
    exit(1);
}

$name = $argv[1];
echo "Hello, $name!\n";

$ ./hello.php
Usage: ./hello.php [name]

$ php hello.php
Usage: php hello.php [name]

$ php hello.php World
Hello, World!

GET /my/simple/uri?with-query-string HTTP/1.1
Host: example.org
Content-Type: text/plain; charset=utf-8
Content-Length: 17

This is a content

HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 76

<!DOCTYPE HTML>
<html>
    <head>
    </head>
    <body>
        <h1>Hello world !</h1>
    </body>
</html>

GET /my/simple/uri?a=1&id=2&c=42 HTTP/1.1
Host: example.org
Content-Type: text/plain; charset=utf-8
Content-Length: 14

b=3&city=paris

$_GET     = [ "a" => 1, "id" => 2 ];

$_POST    = [ "b" => 3, "city" => 'paris' ];

$_REQUEST = [ "a" => 1, "id" => 2, "b" => 3, "city" => 'paris' ];

$_SERVER['QUERY_STRING'] = "a=1&id=2";

$HTTP_RAW_POST_DATA      = "b=3&city=paris";

Accept: application/json, application/xml;q=0.9, text/html;q=0.8,
    text/*;q=0.7, */*;q=0.5

<?xml version="1.0" encoding="UTF-8"?>
<collection page="1" limit="10" pages="1">
    <user id="123"></user>
    <user id="456"></user>

    <link rel="self" href="/api/users?page=1&amp;limit=10" />
    <link rel="first" href="/api/users?page=1&amp;limit=10" />
    <link rel="last" href="/api/users?page=1&amp;limit=10" />
</collection>

$tom = new MyObject();
$tom['name'] = 'Tom';

/** A comment */
class MyClass
{
    public function hello() { printf("Hello %s", $this->getName()); }

    protected function getName() { return 'foo'; }
}

$reflClass = new ReflectionClass('MyClass');

// access comments
var_dump($reflClass->getDocComment());
// string(16) "/** A comment */"

// get all methods
$reflClass->getMethods();

// get all public methods
$reflClass->getMethods(ReflectionMethod::IS_PUBLIC);

class MyClass
{
    public function hello() { printf("Hello %s", $this->getName()); }

    private function getName() { return 'foo'; }
}

$reflClass = new ReflectionClass('MyClass');

// access private method
$method = $reflClass->getMethod('getName');
$method->setAccessible(true);

$method->invoke(new MyClass());
// 'foo'

class Subject implements SplSubject
{
    /* ... */
}

class Observer implements SplObserver
{
    /* ... */
}

$subject = new Subject();

$observer1 = new Observer();

$subject->attach($observer1);

$subject->notify();

use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\EventDispatcher\Event;

$dispatcher = new EventDispatcher();

$dispatcher->addListener('event_name', function (Event $event) {
    // ...
});

$dispatcher->dispatch('event_name');

try {
    throw new ResourceNotFound();
} catch (RuntimeException $e) {
    // do something
} catch (Exception $e) {
    // do something else
}

class SomethingWentWrong extends RuntimeException
{
}

class ErrorWhileDoingSomething extends Exception implements ExceptionInterface
{
}

try {
    // ...
} catch (RuntimeException | LogicException $e) {
    // do something
} catch (Exception $e) {
    // do something else
}

try {
    // ..
} catch (Exception $e) {
    // do something
} finally {
    // the code here will always be executed
}

function foo(): string
{
    try {
        return 'bar';
    } finally {
        return 'baz';
    }
}
var_dump(foo()); // ?

$passwordHash = password_hash('secret-password', PASSWORD_DEFAULT);

if (password_verify('bad-password', $passwordHash)) {
    // Correct Password
} else {
    // Wrong password
}

$ curl -sS https://getcomposer.org/installer | php

{
    "require": {
        "willdurand/geocoder": "~2.0"
    }
}

$ php composer.phar require willdurand/geocoder

$ php composer.phar install

<?php

require 'vendor/autoload.php';

// your PHP code

{
    "require": {
        "symfony/console": "~2.4"
    }
}

console-app
├── app
│   └── console
├── composer.json
├── src
├── tests
└── vendor

class GreetCommand extends Command
{
    protected function configure()
    {
        // configure the name, arguments, options, etc.
    }

    protected function execute(InputInterface $in, OutputInterface $out) {
        // do greet
    }
}

$this
    ->setName('demo:greet')
    ->addArgument(
        'name',
        InputArgument::OPTIONAL,
        'Who do you want to greet?'
    );

if (null === $name = $input->getArgument('name')) {
    $name = 'World';
}

$output->writeln('Hello, ' . $name);

#!/usr/bin/env php
# app/console
<?php

// require the Composer autoloader
require __DIR__ . '/../vendor/autoload.php';

$application = new Application();
$application->add(new GreetCommand());
$application->run();

$ app/console demo:greet
Hello, World
$ app/console demo:greet William
Hello, William

class PhpTemplateEngine implements TemplateEngine
{
    private $templateDir;

    public function __construct($templateDir)
    {
        $this->templateDir = $templateDir;
    }

    public function render($template, array $parameters = [])
    {
        extract($parameters);

        ob_start();
        include $this->templateDir . DIRECTORY_SEPARATOR . $template;

        return ob_get_clean();
    }
}

<!-- my_template.html -->
<p>Hello, <?php echo $name; ?>!</p>

<p>Hello, <?= $name ?>!</p>

$engine = new PhpTemplateEngine('/path/to/templates');

echo $engine->render('my_template.html', [
    'name' => 'World',
]);
=> <p>Hello, World!</p>

{# my_template.html #}
<p>Hello, {{ name }}!</p>

$loader = new Twig_Loader_Filesystem('/path/to/templates');
$engine = new Twig_Environment($loader, [
    'cache' => '/path/to/compilation_cache',
]);

echo $engine->render('my_template.html', [
    'name' => 'World',
]);
=> <p>Hello, World!</p>

class BananaController
{
    public function __construct(
        BananaRepository $repository,
        TemplateEngine $engine
    ) {
        $this->repository = $repository;
        $this->engine = $engine;
    }

    public function listAction()
    {
        $bananas = $this->repository->findAll();

        return $this->engine->render('list.html', [
            'bananas' => $bananas,
        ]);
    }
}

web/
├ trees/
│ └ pineapple.php
└ tree.php

$dsn = 'mysql:host=localhost;dbname=test';
// or for postgresql → $dsn = 'pgsql:host=localhost;dbname=test';
// or for oracle → $dsn = 'oci:host=localhost;dbname=test';

$options = [
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
    PDO::ATTR_EMULATE_PREPARES => false,
];

$con = new PDO($dsn, $user, $password, $options);

// Prepared statement
$stmt = $con->prepare($query);
$stmt->execute();

/* @var PDOStatement $stmt */
$stmt = $conn->prepare('SELECT name FROM users WHERE email = :email');
$stmt->execute(['email' => $email]);

/* @var array $user */
while ($user = $stmt->fetch()) {
    echo $user['name'] . "\n";
}

class Connection extends PDO
{
}

$con = new Connection($dsn, $user, $password);

class Connection extends PDO
{
    /**
     * @param string $query
     * @param array  $parameters
     *
     * @return bool Returns `true` on success, `false` otherwise
     */
    public function executeQuery($query, array $parameters = [])
    {
        $stmt = $this->prepare($query);

        return $stmt->execute($parameters);
    }
}

$conn->executeQuery('INSERT INTO users (name, email) VALUES (:name, :email)', [
    ':name' => $name,
    ':email' => $email,
])

// This is the implementation of `BananaGateway`
class Banana
{
    private $id;

    private $name;

    public function getId()
    {
        return $this->id;
    }

    public function getName()
    {
        return $this->name;
    }

    public function setName($name)
    {
        $this->name = $name;
    }
}

$con = new Connection('...');

$banana = new Banana();
$banana->setName('Super Banana');

// Save the banana
$banana->insert($con);

// Update it
$banana->setName('New name for my banana');
$banana->update($con);

// Delete it
$banana->delete($con);

class Banana
{
    // …

    public function insert(Connection $con)
    {
        // Prepared statement
        $stmt = $this->con->prepare('INSERT INTO bananas VALUES (:name)');

        $stmt->execute([':name' => $this->name]);

        // Set the id for this banana
        //
        // It becomes easy to know whether the banana is new or not,
        // you just need to check if id is defined.
        $this->id = $this->con->lastInsertId();
    }
}

$table = new BananaGateway(new Connection('...'));

// Insert a new record
$id = $table->insert('My favorite banana');

// Update it
$table->update($id, 'THE banana');

// Delete it
$table->delete($id);

class BananaGateway
{
    private $con;

    public function __construct(Connection $con)
    {
        $this->con = $con;
    }

    public function insert($name) {}

    public function update($id, $name) {}

    public function delete($id);
}

/**
 * @param string $name The name of the banana you want to create
 *
 * @return int The id of the banana
 */
public function insert($name)
{
    // Prepared statement
    $stmt = $this->con->prepare('INSERT INTO bananas VALUES (:name)');

    $stmt->execute([':name' => $name]);

    return $this->con->lastInsertId();
}

/**
 * @param int    $id   The id of the banana to update
 * @param string $name The new name of the banana
 *
 * @return bool Returns `true` on success, `false` otherwise
 */
public function update($id, $name)
{
    $stmt = $this->con->prepare(<<<SQL
UPDATE bananas
SET name = :name
WHERE id = :id
SQL
    );

    return $stmt->execute([':id' => $id, ':name' => $name]);
}

/**
 * @param int $id The id of the banana to delete
 *
 * @return bool Returns `true` on success, `false` otherwise
 */
public function delete($id)
{
    $stmt = $this->con->prepare('DELETE FROM bananas WHERE id = :id');

    return $stmt->execute([':id' => $id]);
}

// Retrieve all bananas
$bananas = $table->findAll();

// Find bananas by name matching 'THE %'
$bananas = $table->findByName('THE %');

// Retrieve a given banana using its id
$banana = $table->find(123);

// Find one banana by name matching 'THE %'
$banana = $table->findOneByName('THE %');

$con = new Connection('...');

$banana = new Banana();
$banana->setName('Another banana');
$banana->save($con);

// Call a method that is part of the domain logic
// What can a banana do anyway?
$banana->grow();

// Smart `save()` method
// use `isNew()` under the hood
$banana->save($con);

class Banana
{
    private $height = 1;

    public function grow()
    {
        $this->height++;
    }

    public function save(Connection $con)
    {
        if ($this->isNew()) {
            // issue an INSERT query
        } else {
            // issue an UPDATE query
        }
    }

    public function isNew()
    {
        return $this->id === null;
    }
}

class BananaMapper
{
    private $con;

    public function __construct(Connection $con)
    {
        $this->con = $con;
    }

    public function persist(Banana $banana)
    {
        // code to save the banana
    }

    public function remove(Banana $banana)
    {
        // code to delete the banana
    }
}

$banana = new Banana();
$banana->setName('Fantastic Banana');

$con    = new Connection('...');
$mapper = new BananaMapper($con);

$mapper->persist($banana);

$mapper->remove($banana);

class Finder
{
    private $identityMap = [];

    public function find($id)
    {
        if (!isset($this->identityMap[$id])) {
            // fetch the object for the given id
            $this->identityMap[$id] = ...;
        }

        return $this->identityMap[$id];
    }
}

class Customer
{
    private $id;

    private $name;

    public function __construct($id, Name $name)
    {
        $this->id   = $id;
        $this->name = $name;
    }

    public function getId()
    {
        return $this->id;
    }

    public function getName()
    {
        return $this->name;
    }
}

class Name
{
    private $firstName;

    private $lastName;

    public function __construct($firstName, $lastName)
    {
        $this->firstName = $firstName;
        $this->lastName  = $lastName;
    }

    public function getFirstName()
    {
        return $this->firstName;
    }

    public function getLastName()
    {
        return $this->lastName;
    }
}

interface CustomerRepository
{
    /**
     * @return Customer
     */
    public function find($customerId);

    /**
     * @return Customer[]
     */
    public function findAll();

    public function add(Customer $user);

    public function remove(Customer $user);
}

interface CustomerSpecification
{
    /**
     * @return boolean
     */
    public function isSatisfiedBy(Customer $customer);
}

class CustomerIsPremium implements CustomerSpecification
{
    /**
     * {@inheritDoc}
     */
    public function isSatisfiedBy(Customer $customer)
    {
        // figure out if the customer is indeed premium,
        // and return true or false.
    }
}

interface CustomerRepository
{
    ...

    /**
     * @return Customer[]
     */
    public function findSatisfying(CustomerSpecification $specification);
}

$specification = new CustomerIsPremium();
$customers     = $repository->findSatisfying($specification);

class OrSpecification implements CustomerSpecification
{
    public function __construct(
        CustomerSpecification $s1,
        CustomerSpecification $s2
    ) {
        $this->s1 = $s1;
        $this->s2 = $s2;
    }

    public function isSatisfiedBy(Customer $c)
    {
        return $this->s1->isSatisfiedBy($c) || $this->s2->isSatisfiedBy($c);
    }
}

class AndSpecification implements CustomerSpecification
{
    ...

    public function isSatisfiedBy(Customer $c)
    {
        return $this->s1->isSatisfiedBy($c) && $this->s2->isSatisfiedBy($c);
    }
}

class NotSpecification implements CustomerSpecification
{
    public function __construct(CustomerSpecification $s)
    {
        $this->s = $s;
    }

    public function isSatisfiedBy(Customer $c)
    {
        return !$this->s->isSatisfiedBy($c);
    }
}

// Find customers who have ordered exactly three times,
// but who are not premium customers (yet?)
$specification = new AndSpecification(
    new CustomerHasOrderedThreeTimes(),
    new NotSpecification(
        new CustomerIsPremium()
    )
);

$customers = $repository->findSatisfying($specification);

class AwesomeOfferSender
{
    private $specification;

    public function __construct(CustomerIsPremium $specification)
    {
        $this->specification = $specification;
    }

    public function sendOffersTo(Customer $customer)
    {
        if ($this->specification->isSatisfiedBy($customer)) {
            // send offers
        }
    }
}

// Initalize session
session_start();

// Regenerate identifier
session_regenerate_id();

// Assign "key" to `$value`
$_SESSION['key'] = $value;

// Retrieve "key"
$_SESSION['key'];

// Terminate session
session_destroy();

; Helps mitigate XSS by telling the browser not to expose the cookie to
; client side scripting such as JavaScript
session.cookie_httponly = 1

; Prevents session fixation by making sure that PHP only uses cookies for
; sessions and disallow session ID passing as a GET parameter
session.use_only_cookies = 1

; Better entropy source
; Evades insufficient entropy vulnerabilities
session.entropy_file = "/dev/urandom"
; `session.entropy_length` might help too!

; Smaller exploitation window for XSS/CSRF/Clickjacking...
session.cookie_lifetime = 0

; Ensures session cookies are only sent over secure connections (it requires
; a valid SSL certificate)
; Related to OWASP 2013-A6-Sensitive Data Exposure
session.cookie_secure = 1

trait EventDispatcherTrait
{
    private $events = [];

    public function addListener($name, $callable)
    {
        $this->events[$name][] = $callable;
    }

    public function dispatch($name, array $arguments = [])
    {
        foreach ($this->events[$name] as $callable) {
            call_user_func_array($callable, $arguments);
        }
    }
}

class App
{
    use EventDispatcherTrait;

    ...

    private function process(Request $request, Route $route)
    {
        $this->dispatch('process.before', [ $request ]);

        ...
    }
}

$app->addListener('process.before', function (Request $request) {
    // code to execute
});

$app->addListener('process.before', function (Request $request) use ($app) {
    if ($request->guessBestFormat() !== 'application/json') {
        return;
    }

    if (empty($_SERVER['PHP_AUTH_USER'])) {
        header('WWW-Authenticate: Basic realm="Super secure app"');
        throw new \Exception\HttpException(401);
    }

    if ($_SERVER['PHP_AUTH_USER'] !== 'admin'
     || $_SERVER['PHP_AUTH_PW'] !== 'not-so-secure') {
        throw new \Exception\HttpException(401);
    }
});

$allowed = [
    '/login'     => [ Request::GET, Request::POST ],
    '/locations' => [ Request::GET ],
];

session_start();

if (isset($_SESSION['is_authenticated'])
    && true === $_SESSION['is_authenticated']) {
    return;
}

$app->addListener('process.before', function(Request $req) use ($app) {
    if ($req->guessBestFormat() === 'application/json') {
        return;
    }

    session_start();

    $allowed = [
        '/login' => [ Request::GET, Request::POST ],
    ];

    if (isset($_SESSION['is_authenticated'])
        && $_SESSION['is_authenticated'] === true) {
        return;
    }

    foreach ($allowed as $pattern => $methods) {
        if (preg_match(sprintf('#^%s$#', $pattern), $req->getUri())
            && in_array($req->getMethod(), $methods)) {
            return;
        }
    }

    return $app->redirect('/login');
});

$app->get('/login', function () use ($app) {
    return $app->render('login.php');
});

$app->post('/login', function (Request $request) use ($app) {
    $user = $request->getParameter('user');
    $pass = $request->getParameter('password');

    if ($user === 'root' && $pass === 'quarante-deux') {
        $_SESSION['is_authenticated'] = true;

        return $app->redirect('/');
    }

    return $app->render('login.php', [ 'user' => $user ]);
});

$app->get('/logout', function (Request $request) use ($app) {
    session_destroy();

    return $app->redirect('/');
});

<?php

namespace Vendor\Model;

class Foo
{
    const VERSION = '1.0';

    public $bar = null;

    protected $opts;

    private $var3 = 123;

    public function __construct(BarInterface $bar, array $opts = [])
    {
        $this->bar  = $bar;
        $this->opts = $opts;
    }
}

$ wget http://cs.sensiolabs.org/get/php-cs-fixer.phar

$ php php-cs-fixer.phar fix /path/to/dir/or/file

interface TemplateEngine
{
    /**
     * @param string $template
     * @param array  $parameters
     *
     * @return string
     */
    public function render($template, array $parameters = []);
}

class Foo
{
    private $bar;

    // **NOT** DI
    public function __construct()
    {
        $this->bar = new Bar();
    }
}

// DI!
public function __construct(Bar $bar)
{
    $this->bar = $bar;
}

class ServiceLocator
{
    public static function getBar()
    {
        return new Bar();
    }
}

class Foo
{
    private $bar;

    public function __construct()
    {
        $this->bar = ServiceLocator::getBar();
    }
}

class Foo
{
    private $bar;

    public function __construct(BarInterface $bar)
    {
        $this->bar = $bar;
    }
}

class Foo
{
    private $bar;

    public function setBar(BarInterface $bar)
    {
        $this->bar = $bar;
    }
}

interface BarAware
{
    public function setBar(BarInterface $bar);
}

class Foo implements BarAware
{
    private $bar;

    public function setBar(BarInterface $bar)
    {
        $this->bar = $bar;
    }
}

// It's an instance of `TemplateEngine`, but you don't know
// anything about its internal implementation.
// Is it the raw PHP implementation or Twig?
$engine = $container->get('template_engine');

class Container {
    protected $s = [];
    function __set($k, $c) { $this->s[$k] = $c; }
    function __get($k) { return $this->s[$k]($this); }
}

$c = new Container();
$c->mailer_config = ['smtp' => '…', 'port' => 25];
$c->mailer = function ($c) { return new Mailer($c->mailer_config); };

{
    "require-dev": {
        "phpunit/phpunit": "~5.7"
    }
}

$ wget http://pear.phpunit.de/get/phpunit.phar
$ chmod +x phpunit.phar

class TestCase extends PHPUnit_Framework_TestCase {}

class ClassTest extends TestCase
{
    public function testFoo()
    {
        $object = new MyClass();
        $this->assertEquals('foo', $object->foo(), 'optional comment');
    }
}