Zicht\Tool\Container\ContainerCompiler

Complexity

Total Complexity

11

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

0%

Importance

Changes	2
Bugs	1	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getContainer()	0	21	4
A	addPlugin()	0	4	1
A	needsRecompile()	0	8	3
A	compileContainerCode()	0	14	2

<?php
/**
 * For licensing information, please see the LICENSE file accompanied with this file.
 *
 * @author Gerard van Helden <drm@melp.nl>
 * @copyright 2012 Gerard van Helden <http://melp.nl>
 */

namespace Zicht\Tool\Container;

use Zicht\Tool\Script\Buffer;
use Zicht\Tool\PluginInterface;
use Zicht\Util\Mutex;

/**
 * Compiler to compile the entire container into PHP code.
 */
class ContainerCompiler
{
    private $configTree;
    private $plugins;
    private $file;
    private $code;

The property $code is not used and could be removed.

    /**
     * Construct the compiler
     *
     * @param array $configTree
     * @param PluginInterface[] $plugins
     * @param null $file
     */
    public function __construct($configTree, $plugins, $file)
    {
        $this->configTree = $configTree;
        $this->plugins = $plugins;
        $this->file = $file;
    }


    /**
     * Writes the code to a temporary file and returns the resulting Container object.
     *
     * @return mixed
     *
     * @throws \LogicException
     */
    public function getContainer()
    {
        $mutex = new Mutex($this->file . '.lock', true);

        $ret = $mutex->run(
            function () {
                if ($this->needsRecompile()) {
                    file_put_contents($this->file, $this->compileContainerCode());
                }
                return include $this->file;
            }
        );

        if (!($ret instanceof Container)) {
            throw new \LogicException("The container must be returned by the compiler");
        }
        foreach ($this->plugins as $plugin) {
            $ret->addPlugin($plugin);
        }
        return $ret;
    }


    /**
     * Add a plugin
     *
     * @param \Zicht\Tool\PluginInterface $p
     * @return void
     */
    public function addPlugin(PluginInterface $p)
    {
        $this->plugins[] = $p;
    }


    /**
     * Crude check for whether a recompile is needed.
     *
     * @return bool
     */
    protected function needsRecompile()
    {
        clearstatcache();
        return !is_file($this->file) || (
            (!empty($this->configTree['z']['sources'])
            && max(array_map('filemtime', $this->configTree['z']['sources'])) >= filemtime($this->file))
        );
    }


    /**
     * Returns the code for initializing the container.
     *
     * @return string
     */
    public function compileContainerCode()
    {
        $builder = new ContainerBuilder($this->configTree);
        foreach ($this->plugins as $name => $plugin) {
            $plugin->setContainerBuilder($builder);
        }
        $containerNode = $builder->build();
        $buffer = new Buffer();
        $buffer->write('<?php')->eol();
        $containerNode->compile($buffer);
        $buffer->writeln('return $z;');
        $code = $buffer->getResult();
        return $code;
    }
}