PhpToZephir\Converter\Printer\Expr\ClosurePrinter

Complexity

Total Complexity

18

Size/Duplication

Total Lines	165
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

92%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getType()	0	4	1
A	convert()	0	19	2
A	createClosureClass()	0	17	1
B	createClass()	0	30	4
B	convertUseToMemberAttribute()	0	16	5
B	N2L()	0	27	4

<?php

namespace PhpToZephir\Converter\Printer\Expr;

use PhpToZephir\Converter\Dispatcher;
use PhpToZephir\Logger;
use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpToZephir\NodeFetcher;

class ClosurePrinter
{
    /**
     * @var Dispatcher
     */
    private $dispatcher = null;
    /**
     * @var Logger
     */
    private $logger = null;

    private static $converted = array();

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

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

    }

    /**
     * @return string
     */
    public static function getType()
    {
        return 'pExpr_Closure';
    }

    /**
     * @param Expr\Closure $node
     *
     * @return string
     */
    public function convert(Expr\Closure $node)
    {
        $methodName = $this->dispatcher->getMetadata()->getClass().$this->dispatcher->getLastMethod();
        if (isset(self::$converted[$methodName])) {
            ++self::$converted[$methodName];
        } else {
            self::$converted[$methodName] = 1;
        }

        $name = $methodName.'Closure'.$this->N2L(count(self::$converted[$methodName]));

        $this->logger->logNode(
            sprintf('Closure does not exist in Zephir, class "%s" with __invoke is created', $name),
            $node,
            $this->dispatcher->getMetadata()->getFullQualifiedNameClass()
        );

        return 'new '.$name.'('.$this->dispatcher->pCommaSeparated($node->uses).')';
    }

    /**
     * @param null|string $lastMethod
     * @param int         $number
     */
    public function createClosureClass(Expr\Closure $node, $lastMethod, $number)
    {
        $this->logger->trace(__METHOD__.' '.__LINE__, $node, $this->dispatcher->getMetadata()->getFullQualifiedNameClass());

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

        $name = $this->dispatcher->getMetadata()->getClass().$lastMethod.'Closure'.$this->N2L($number);

        $this->logger->logNode(
            sprintf('Closure does not exist in Zephir, class "%s" with __invoke is created', $name),
            $node,
            $this->dispatcher->getMetadata()->getFullQualifiedNameClass()
        );

        return array(
         'name' => $name,
         'code' => $this->createClass($name, $this->dispatcher->getMetadata()->getNamespace(), $node),
        );
    }

    /**
     * @param string $name
     * @param string $namespace
     */
    private function createClass($name, $namespace, Expr\Closure $node)
    {
        $class = "namespace $namespace;

As per coding-style, please use concatenation or sprintf for the variable $namespace instead of interpolation.

As per coding-style, please use concatenation or sprintf for the variable $name instead of interpolation.

class $name
{
";

        foreach ($node->uses as $use) {
            $class .= '    private '.$use->var.";\n";
        }

        $class .= '
    public function __construct('.(!empty($node->uses) ? ''.$this->dispatcher->pCommaSeparated($node->uses) : '').')
    {
        ';
        foreach ($node->uses as $use) {
            $class .= '        let this->'.$use->var.' = '.$use->var.";\n";
        }
        $class .= '
    }

    public function __invoke('.$this->dispatcher->pCommaSeparated($node->params).')
    {'.$this->dispatcher->pStmts($this->convertUseToMemberAttribute($node->stmts, $node->uses)).'
    }
}
    ';

        return $class;
    }

    /**
     * @param Node[]            $node
     * @param Expr\ClosureUse[] $uses
     */
    private function convertUseToMemberAttribute($node, $uses)
    {
        $noFetcher = new NodeFetcher();
        
        foreach ($noFetcher->foreachNodes($node) as &$stmt) {

The expression $noFetcher->foreachNodes($node) cannot be used as a reference.

            if ($stmt['node'] instanceof Expr\Variable) {
                foreach ($uses as $use) {
                    if ($use->var === $stmt['node']->name) {
                        $stmt['node']->name = 'this->'.$stmt['node']->name;
                    }
                }
            }
        }

        return $node;
    }

    /**
     * @param int $number
     */
    private function N2L($number)

This method is not in camel caps format.

    {
        $result = array();
        $tens = floor($number / 10);

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

        $units = $number % 10;

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

        $words = array(
            'units' => array('', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten', 'Eleven', 'Twelve', 'Thirteen', 'Fourteen', 'Fifteen', 'Sixteen', 'Seventeen', 'Eightteen', 'Nineteen'),

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

            'tens' => array('', '', 'Twenty', 'Thirty', 'Fourty', 'Fifty', 'Sixty', 'Seventy', 'Eigthy', 'Ninety'),
        );

        if ($tens < 2) {
            $result[] = $words['units'][$tens * 10 + $units];
        } else {
            $result[] = $words['tens'][$tens];

            if ($units > 0) {
                $result[count($result) - 1] .= '-'.$words['units'][$units];
            }
        }

        if (empty($result[0])) {
            $result[0] = 'Zero';
        }

        return trim(implode(' ', $result));
    }
}