PhpToZephir\Converter\Converter

Complexity

Total Complexity

13

Size/Duplication

Total Lines	107
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

97.62%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	nodeToZephir()	0	13	1
A	implementsExist()	0	6	2
B	implementExist()	0	19	5
A	findAdditionalClasses()	0	19	4

<?php

namespace PhpToZephir\Converter;

use PhpToZephir\Logger;
use PhpToZephir\NodeFetcher;
use PhpParser\Node\Expr;
use PhpParser\Node\Stmt;
use PhpToZephir\Converter\Printer\Expr\ClosurePrinter;
use PhpToZephir\ClassCollector;

class Converter
{
    /**
     * @var Dispatcher
     */
    private $dispatcher = null;
    /**
     * @var NodeFetcher
     */
    private $nodeFetcher = null;

    /**
     * @param Dispatcher  $dispatcher
     * @param NodeFetcher $nodeFetcher
     */
    public function __construct(Dispatcher $dispatcher, NodeFetcher $nodeFetcher)
    {
        $this->dispatcher = $dispatcher;

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

        $this->nodeFetcher = $nodeFetcher;
    }

    /**
     * @param array          $stmts
     * @param ClassCollector $classCollector
     * @param Logger         $logger
     * @param string         $fileName
     * @param array          $classCollected
     *
     * @return array
     */
    public function nodeToZephir(array $stmts, ClassCollector $classCollector, Logger $logger, $fileName = null, array $classCollected = array())

This line exceeds maximum limit of 120 characters; contains 145 characters

    {
        $classInformation = ClassInformationFactory::getInstance();
        $metadata = $classInformation->getClassesMetdata($stmts);

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

        $this->implementsExist($metadata, $classCollector);

        return array(
            'code' => $this->dispatcher->convert($stmts, $metadata, $classCollector, $logger),
            'namespace' => $metadata->getNamespace(),
            'additionalClass' => $this->findAdditionalClasses($stmts, $logger),
        );
    }

    /**
     * @param ClassMetadata $metadata
     * @param ClassCollector $classCollector
     */
    private function implementsExist(ClassMetadata $metadata, ClassCollector $classCollector)
    {
        foreach ($metadata->getImplements() as $implements) {
            $this->implementExist($metadata, $classCollector, $implements);
        }
    }

    /**
     * @param ClassMetadata $metadata
     * @param ClassCollector $classCollector
     * @param string $implements
     * @throws \Exception
     * @return boolean
     */
    private function implementExist(ClassMetadata $metadata, ClassCollector $classCollector, $implements)
    {
        // Class is in actual namespace
        if (array_key_exists($metadata->getNamespace() . '\\' . $implements, $classCollector->getCollected())) {
            return true;
        }

        foreach ($metadata->getClasses() as $use) {
            if (substr(strrchr($use, "\\"), 1) === $implements) {

The string literal \\ does not require double quotes, as per coding-style, please use single quotes.

                return true;
            }
        }

        if (interface_exists($implements)) {
            return true;
        }

        throw new \Exception(sprintf('interface %s does not exist', $implements));
    }

    /**
     * @param array $stmts
     *
     * @return array
     */
    private function findAdditionalClasses(array $stmts, Logger $logger)
    {
        $closurePrinter = new ClosurePrinter($this->dispatcher, $logger);
        $lastMethod = null;

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

        $aditionalClass = array();
        $number = 0;

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

        foreach ($this->nodeFetcher->foreachNodes($stmts) as $nodeData) {
            $node = $nodeData['node'];
            if ($node instanceof Stmt\ClassMethod) {
                $lastMethod = $node->name;
            } elseif ($node instanceof Expr\Closure) {
                $aditionalClass[] = $closurePrinter->createClosureClass($node, $lastMethod, $number);
                ++$number;
            }
        }

        return $aditionalClass;
    }
}