PhpEngine.php

TLDR

The PhpEngine.php file in the Illuminate\View\Engines namespace contains the PhpEngine class. This class implements the Engine interface and is responsible for evaluating the contents of a view file written in PHP.

Methods

__construct(Filesystem $files)

This method is the constructor of the PhpEngine class. It takes a Filesystem instance as a parameter and assigns it to the $files property.

get($path, array $data = [])

This method is defined in the Engine interface and implemented in the PhpEngine class. It takes the path of the view file and an optional array of data. It calls the evaluatePath method passing the path and data, and returns the evaluated contents of the view file as a string.

evaluatePath($path, $data)

This method is a helper method used by the get method to evaluate the contents of the view file. It starts output buffering, loads the view file using the getRequire method of the $files property, and catches any exceptions that occur during the evaluation. It then returns the evaluated contents of the view file.

handleViewException(Throwable $e, $obLevel)

This method is a helper method used by the evaluatePath method to handle any exceptions that occur during the evaluation of the view file. It cleans up any output buffering that may have been started in the evaluatePath method before re-throwing the exception.

Classes

PhpEngine

This class implements the Engine interface and is responsible for evaluating the contents of a view file written in PHP. It contains the $files property, which is an instance of the Filesystem class. The PhpEngine class has a constructor that takes a Filesystem instance and assigns it to the $files property. It also defines the get method, the evaluatePath method, and the handleViewException method, as described in the Methods section above.

<?php

namespace Illuminate\View\Engines;

use Illuminate\Contracts\View\Engine;
use Illuminate\Filesystem\Filesystem;
use Throwable;

class PhpEngine implements Engine
{
    /**
     * The filesystem instance.
     *
     * @var \Illuminate\Filesystem\Filesystem
     */
    protected $files;

    /**
     * Create a new file engine instance.
     *
     * @param  \Illuminate\Filesystem\Filesystem  $files
     * @return void
     */
    public function __construct(Filesystem $files)
    {
        $this->files = $files;
    }

    /**
     * Get the evaluated contents of the view.
     *
     * @param  string  $path
     * @param  array  $data
     * @return string
     */
    public function get($path, array $data = [])
    {
        return $this->evaluatePath($path, $data);
    }

    /**
     * Get the evaluated contents of the view at the given path.
     *
     * @param  string  $path
     * @param  array  $data
     * @return string
     */
    protected function evaluatePath($path, $data)
    {
        $obLevel = ob_get_level();

        ob_start();

        // We'll evaluate the contents of the view inside a try/catch block so we can
        // flush out any stray output that might get out before an error occurs or
        // an exception is thrown. This prevents any partial views from leaking.
        try {
            $this->files->getRequire($path, $data);
        } catch (Throwable $e) {
            $this->handleViewException($e, $obLevel);
        }

        return ltrim(ob_get_clean());
    }

    /**
     * Handle a view exception.
     *
     * @param  \Throwable  $e
     * @param  int  $obLevel
     * @return void
     *
     * @throws \Throwable
     */
    protected function handleViewException(Throwable $e, $obLevel)
    {
        while (ob_get_level() > $obLevel) {
            ob_end_clean();
        }

        throw $e;
    }
}