Ebi\CompilerBuffer

Complexity

Total Complexity

49

Size/Duplication

Total Lines	308
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	3

Test Coverage

Coverage

91.87%

Importance

Changes

0

31 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	echoLiteral()	0	3	1
A	echoCode()	0	3	1
A	appendCode()	0	3	1
A	indent()	0	3	1
A	depth()	0	3	1
A	depthName()	0	3	1
A	pushScope()	0	3	1
A	popScope()	0	3	1
A	getScopeVariables()	0	3	1
A	flushJoin()	0	6	1
A	px()	0	3	1
A	getStyle()	0	3	1
A	setStyle()	0	4	1
A	getBasename()	0	3	1
A	setBasename()	0	4	1
A	getNodeProp()	0	6	3
A	getIndent()	0	3	1
A	getDepth()	0	3	1
A	getScope()	0	3	1
A	getAllScopes()	0	3	1
A	select()	0	12	2
A	flush()	0	8	2
B	flushArray()	0	22	5
A	setNodeProp()	0	12	3
C	createCompilerException()	0	33	8
A	splitSyntaxError()	0	7	2
A	getSource()	0	3	1
A	setSource()	0	4	1
A	getPath()	0	3	1
A	setPath()	0	4	1

<?php
/**
 * @author Todd Burry <todd@vanillaforums.com>
 * @copyright 2009-2017 Vanilla Forums Inc.
 * @license MIT
 */

namespace Ebi;


use Symfony\Component\ExpressionLanguage\SyntaxError;

class CompilerBuffer {
    const STYLE_JOIN = 'join';
    const STYLE_ARRAY = 'array';

    /**
     * @var ComponentBuffer[]
     */
    private $buffers;

    /**
     * @var ComponentBuffer
     */
    private $current;

    private $currentName;

    private $basename;

    private $style = self::STYLE_JOIN;

    private $source;

    private $path;

    /**
     * @var array
     */
    private $defaults;

    /**
     * @var \SplObjectStorage
     */
    private $nodeProps;

    public function __construct($style = self::STYLE_JOIN, array $defaults = []) {
        $defaults += [
            'baseIndent' => 0
        ];

        $this->buffers = [];

Equals sign not aligned with surrounding assignments; expected 3 spaces but found 1 space

        $this->nodeProps = new \SplObjectStorage();
        $this->style = $style;

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

        $this->defaults = $defaults;
        $this->select('');
    }

    /**
     * Select a specific component buffer.
     * @param $component
     */
    public function select($component) {

The return type could not be reliably inferred; please add a @return annotation.

        $previous = $this->currentName;

Equals sign not aligned with surrounding assignments; expected 10 spaces but found 1 space

        $this->currentName = $component;

        if (!array_key_exists($component, $this->buffers)) {
            $this->buffers[$component] = $buffer = new ComponentBuffer($this->defaults);

$buffer is not used, you could remove the assignment.

        }

        $this->current =& $this->buffers[$component];

        return $previous;
    }

    public function echoLiteral($value) {
        $this->current->echoLiteral($value);
    }

    public function echoCode($php) {
        $this->current->echoCode($php);
    }

    public function appendCode($php) {
        $this->current->appendCode($php);
    }

    public function indent($add) {
        $this->current->indent($add);
    }

    public function depth($add = 1) {
        $this->current->depth($add);
    }

    public function depthName($name, $add = 0) {

The return type could not be reliably inferred; please add a @return annotation.

        return $this->current->depthName($name, $add);
    }

    public function pushScope(array $vars) {
        $this->current->pushScope($vars);
    }

    public function popScope() {
        $this->current->popScope();
    }

    public function getScopeVariables() {
        return $this->current->getScopeVariables();
    }

    public function flush() {
        switch ($this->getStyle()) {
            case self::STYLE_ARRAY:
                return $this->flushArray();
            default:
                return $this->flushJoin();
        }
    }

    private function flushJoin() {
        return implode("\n\n", array_map(function ($buffer) {
            /* @var ComponentBuffer $buffer */
            return $buffer->flush();
        }, $this->buffers));
    }

    private function flushArray() {
        $result = [];

        foreach ($this->buffers as $name => $buffer) {
            $flushed = $buffer->flush();
            if (empty($flushed)) {
                continue;
            }

            if ($name === '') {

The strict comparison === seems to always evaluate to false as the types of $name (integer) and '' (string) can never be identical. Maybe you want to use a loose comparison == instead?

                $result[] = $flushed;
            } else {
                $result[] = var_export($name, true).' => '.$flushed;
            }
        }

        if (empty($result)) {
            return '[]';
        } else {
            return "[\n".implode(",\n\n", $result)."\n".$this->px().']';
        }
    }

    protected function px($add = 0) {
        return str_repeat(' ', ($this->defaults['baseIndent'] + $add) * 4);
    }

    /**
     * Get the style.
     *
     * @return string Returns the style.
     */
    public function getStyle() {
        return $this->style;
    }

    /**
     * Set the style.
     *
     * @param string $style One of the **STYLE_*** constants.
     * @return $this
     */
    public function setStyle($style) {
        $this->style = $style;
        return $this;
    }

    /**
     * Get the basename.
     *
     * @return string Returns the basename.
     */
    public function getBasename() {
        return $this->basename;
    }

    /**
     * Set the basename.
     *
     * @param string $basename
     * @return $this
     */
    public function setBasename($basename) {
        $this->basename = $basename;
        return $this;
    }

    public function getNodeProp(\DOMNode $node, $name, $default = null) {

The return type could not be reliably inferred; please add a @return annotation.

        if (!$this->nodeProps->contains($node) || !array_key_exists($name, $this->nodeProps[$node])) {
            return $default;
        }
        return $this->nodeProps[$node][$name];
    }

    public function setNodeProp(\DOMNode $node = null, $name, $value) {
        if ($node === null) {
            return $this;
        }

        if (!$this->nodeProps->contains($node)) {
            $this->nodeProps->attach($node, [$name => $value]);
        }

        $this->nodeProps[$node] = [$name => $value] + $this->nodeProps[$node];
        return $this;
    }

    public function getIndent() {
        return $this->current->getIndent();
    }

    public function getDepth() {
        return $this->current->getDepth();
    }

    public function getScope() {
        return $this->current->getScope();
    }

    public function getAllScopes() {
        return $this->current->getAllScopes();
    }

    /**
     * Create a new **CompileException** with proper context.
     *
     * @param \DOMNode $node The node that has the error.
     * @param \Exception $ex The exception that represents the low-level error.
     * @param array $context Custom context information for the exception.
     * @return CompileException Returns a new exception that can be thrown.
     */
    public function createCompilerException(\DOMNode $node, \Exception $ex, array $context = []) {
        $result = $context + [

Equals sign not aligned with surrounding assignments; expected 13 spaces but found 1 space

            'path' => $this->getPath(),
            'source' => '',
            'sourcePosition' => null,
            'line' => $line = $node->getLineNo(),
            'lines' => []
        ];
        $message = $ex->getMessage();

Equals sign not aligned with surrounding assignments; expected 12 spaces but found 1 space

        if ($ex instanceof SyntaxError) {
            list($error, $position) = $this->splitSyntaxError($ex);

The assignment to $error is unused. Consider omitting it like so list($first,,$third).

            $result['source'] = $result['source'] ?: ($node instanceof \DOMAttr ? $node->value : $node->nodeValue);

Equals sign not aligned with surrounding assignments; expected 7 spaces but found 1 space

            if (!isset($context['sourcePosition'])) {
                $result['sourcePosition'] = $position;
            }
        }

        if (!empty($this->source)) {
            $allLines = explode("\n", $this->source);

            $lines = [];
            for ($i = max(0, $line - 3); $i < $line + 2; $i++) {
                if (isset($allLines[$i])) {
                    $lines[$i + 1] = $allLines[$i];
                }
            }

            $result['lines'] = $lines;
        }

        return new CompileException($message, $result, $ex);
    }

    private function splitSyntaxError(SyntaxError $ex) {
        if (preg_match('`^(.*) around position (.*)\.$`', $ex->getMessage(), $m)) {
            return [$m[1], $m[2]];
        } else {
            return [$ex->getMessage(), 0];
        }
    }

    /**
     * Get the source.
     *
     * @return mixed Returns the source.
     */
    public function getSource() {
        return $this->source;
    }

    /**
     * Set the source.
     *
     * @param mixed $source
     * @return $this
     */
    public function setSource($source) {
        $this->source = $source;
        return $this;
    }

    /**
     * Get the path.
     *
     * @return mixed Returns the path.
     */
    public function getPath() {
        return $this->path;
    }

    /**
     * Set the path.
     *
     * @param mixed $path
     * @return $this
     */
    public function setPath($path) {
        $this->path = $path;
        return $this;
    }
}