Views

Views are the presentational part of web applications in Aurora.

They are rendered from templates. Now, you may be wondering:

"But isn't PHP a template-centric language, why do we need another layer of templating?"

And the answer is: Yes, while PHP is a language that can be used as some sort of templating engine (for example by echoing things out), sometimes you need better security, simpler coding and reusability.

For example, to check a variable and the iterating its contents you can do the following with pure PHP:

<div class="list">
    <?php if ($collection): ?>
        <?php foreach ($collection as $item): ?>
            <div class="item">
                <h3><?php echo htmlspecialchars($item->name, ENT_QUOTES, 'UTF-8'); ?></h3>
                <p><?php echo htmlspecialchars($item->details, ENT_QUOTES, 'UTF-8'); ?></p>
            </div>
        <?php endif; ?>
    <?php else: ?>
        <div class="text-muted">No items</div>
    <?php endif; ?>
</div>

Or with Twig you can do it like this:

<div class="list">
    {% if collection %}
        {% for item in collection %}
            <div class="item">
                <h3>{{ item.name }}</h3>
                <p>{{ item.details }}</p>
            </div>
        {% endfor %}
    {% else %}
        <div class="text-muted">No items</div>
    {% endif %}
</div>

It does look cleaner, doesn't it? Also, its automatically escaped, so if name or details have a dangerous content, it will be sanitized before printing it out. Also your designers can learn the templating language (which is simpler) and offload a bit of work from the developers.

And don't forget reusability. With a lot of modern templating languages you can reuse blocks of code, which can really improve the maintainability of your templates.

Also, templates normally are compiled and cached, so performance is top-notch.

Template engines

Aurora supports three templating engines out-of-the-box:

• Twig
• Latte
• Blade

Also, Aurora comes with its own templating micro-engine, Glow, which is enabled by default.

Glow incorporates the best from the other three engines while being lightweight and dependency free, but it's up to you what engine you want to use.

Adding a new adapter

If you want to use another engine, you just have to write a adapter to support it, for example, let's write a Plates adapter in app/View/Adapter/PlatesAdapter.php:

namespace App\View\Adapter;

use League\Plates\Engine;
use Aurora\Web\View\Adapter\AdapterInterface;

class PlatesAdapter implements AdapterInterface {

    /**
     * Templates directory
     * @var string
     */
    protected $templateDir;

    /**
     * Constructor
     * @param string $templateDir Templates directory
     */
    public function __construct(string $templateDir) {
        $this->templateDir = $templateDir;
    }

    /**
     * Render template
     * @param  string $template Template name
     * @param  array  $data     Template data
     * @return string
     */
    public function render(string $template, array $data): string {
        if ( class_exists(Engine::class) ) {
            $templates = new Engine($this->templateDir);
            return $templates->render($template, $data);
        } else {
            throw new RuntimeException('Plates package not found');
        }
    }
}

And register it in settings/web.php:

return [
    'templates' => [
        'engines' => [
            'glow' => [
                'adapter' => Aurora\Web\View\Adapter\GlowAdapter::class,
                'arguments' => [
                    'templateDir' => base_dir('/resources/templates'),
                    'cacheDir' => base_dir('/storage/cache')
                ]
            ],
            'blade' => [
                'adapter' => Aurora\Web\View\Adapter\BladeAdapter::class,
                'arguments' => [
                    'templateDir' => base_dir('/resources/templates'),
                    'cacheDir' => base_dir('/storage/cache')
                ]
            ],
            'latte' => [
                'adapter' => Aurora\Web\View\Adapter\LatteAdapter::class,
                'arguments' => [
                    'templateDir' => base_dir('/resources/templates'),
                    'cacheDir' => base_dir('/storage/cache')
                ]
            ],
            'twig' => [
                'adapter' => Aurora\Web\View\Adapter\TwigAdapter::class,
                'arguments' => [
                    'templateDir' => base_dir('/resources/templates'),
                    'cacheDir' => base_dir('/storage/cache')
                ]
            ],
            'plates' => [
                'adapter' => App\View\Adapter\PlatesAdapter::class,
                'arguments' => [
                    'templateDir' => base_dir('/resources/templates')
                ]
            ]
        ],
        'default' => 'plates'
    ]
];

It is really that easy.

Changing the default engine

Just open up settings/web.php and change the default one under templates.

Rendering templates

Now that you've chosen your template engine, it's time to render some templates.

The quick way is by using the view() function to get a new View instance, just pass a template name:

$content = view('page-index')->render();
$response->getBody()->write($content);

However, you may also pass some data to the template, for example:

$user = User::get($current_user); # Say $current_user holds the current user ID
$content = view('page-profile')->with('user', $user)->render();
$response->getBody()->write($content);

That way you can use the $user variable in your template (using Twig):

<input type="text" name="nicename" value="{{ user.nicename }}">

You can also pass multiple data in a single call:

$user = User::get($current_user); # Say $current_user holds the current user ID
$bookmarks = Bookmark::where('id_user', $user->id)->sort('name', 'asc')->all();
$content = view('page-bookmarks')->with(['user' => $user, 'bookmarks' => $bookmarks])->render();
$response->getBody()->write($content);

Now, if you aren't going to pass any data to the view and just need a static page attached to a route you can use the view() method:

class App extends WebApp {

    function start() {
        router()->view('/about', 'page-about');
    }
}

Next up, Glow templates.