AutoChainRenderer::render() - Code Metrics - Inspection of "Migrating to 2.0: Mouf agnostic version" - thecodingmachine/html.renderer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 1.2 (#12)

by David

created 2018-08-16 10:56 UTC

AutoChainRenderer::render() A

↳ Parent: AutoChainRenderer

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	8
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	2

<?php
/*
 * Copyright (c) 2013 David Negrier
 *
 * See the file LICENSE.txt for copying permission.
 */

namespace Mouf\Html\Renderer;

use Mouf\Utils\Cache\CacheInterface;
use Mouf\MoufManager;

/**
 * This class is a renderer that renders objects using other renderers.
 * This renderer will automatically detect the renderers to be included.
 * They must extend the ChainableRendererInterface interface.
 *
 * @author David Négrier <[email protected]>
 */
class AutoChainRenderer implements CanSetTemplateRendererInterface
{

    /**
     * @var ChainableRendererInterface
     */
    private $templateRenderer;
    /**
     * @var ChainableRendererInterface[]
     */
    private $packageRenderers = array();
    /**
     * @var ChainableRendererInterface[]
     */
    private $customRenderers = array();

    private $cacheService;

    private $initDone = false;
    /**
     * @var string
     */
    private $uniqueName;

    /**
     *
     * @param CacheInterface $cacheService This service is used to speed up the mapping between the object and the template.
     */
    public function __construct(CacheInterface $cacheService, string $uniqueName = 'autochain-renderer')
    {
        $this->cacheService = $cacheService;
        $this->uniqueName = $uniqueName;
    }

    /**
     * (non-PHPdoc)
     * @see \Mouf\Html\Renderer\RendererInterface::render()
     */
    public function render($object, string $context = null): void
    {
        $renderer = $this->getRenderer($object, $context);
        if ($renderer == null) {
            throw new \Exception("Renderer not found. Unable to find renderer for object of class '".get_class($object)."'. Path tested: ".$this->getRendererDebugMessage($object, $context));
        }
        $renderer->render($object, $context);
    }

    /**
     * Sets the renderer associated to the template.
     * There should be only one if these renderers.
     * It is the role of the template to subscribe to this renderer.
     *
     * @param RendererInterface $templateRenderer
     */
    public function setTemplateRenderer(RendererInterface $templateRenderer): void
    {
        $this->templateRenderer = $templateRenderer;
class Alien {}

class Dalek extends Alien {}

class Plot
{
    /** @var  Dalek */
    public $villain;
}

$alien = new Alien();
$plot = new Plot();
if ($alien instanceof Dalek) {
    $plot->villain = $alien;
}
    }

    private function getRenderer($object, $context = null)
    {
        $cacheKey = "chainRendererByClass_".$this->uniqueName."/".$this->templateRenderer->getUniqueName()."/".$this->getTemplateRendererInstanceName()."/".get_class($object)."/".$context;


        $rendererSource = $this->cacheService->get($cacheKey);
        if ($rendererSource != null) {
            $source = $rendererSource['source'];
            $rendererIndex = $rendererSource['index'];
            switch ($source) {
                case 'customRenderers':
                    return $this->customRenderers[$rendererIndex];
                case 'templateRenderer':
                    return $this->templateRenderer;
                case 'packageRenderers':
                    return $this->packageRenderers[$rendererIndex];
                default:
                    throw new \RuntimeException('Unexpected renderer source: "'.$source.'"');
            }
        }

        $this->initRenderersList();

        $isCachable = true;
        $foundRenderer = null;
        $source = null;
        $rendererIndex = null;

        do {
            foreach ($this->customRenderers as $key => $renderer) {

                /* @var $renderer ChainableRendererInterface */
                $result = $renderer->canRender($object, $context);
                if ($result == ChainableRendererInterface::CAN_RENDER_OBJECT || $result == ChainableRendererInterface::CANNOT_RENDER_OBJECT) {
                    $isCachable = false;
                }
                if ($result == ChainableRendererInterface::CAN_RENDER_OBJECT || $result == ChainableRendererInterface::CAN_RENDER_CLASS) {
                    $foundRenderer = $renderer;
                    $source = 'customRenderers';
                    $rendererIndex = $key;
                    break 2;
                }
            }

            /* @var $renderer ChainableRendererInterface */
            if ($this->templateRenderer) {
                $result = $this->templateRenderer->canRender($object, $context);
                if ($result == ChainableRendererInterface::CAN_RENDER_OBJECT || $result == ChainableRendererInterface::CANNOT_RENDER_OBJECT) {
                    $isCachable = false;
                }
                if ($result == ChainableRendererInterface::CAN_RENDER_OBJECT || $result == ChainableRendererInterface::CAN_RENDER_CLASS) {
                    $foundRenderer = $this->templateRenderer;
                    $source = 'templateRenderer';
                    break;
                }
            }

            foreach ($this->packageRenderers as $key => $renderer) {

                /* @var $renderer ChainableRendererInterface */
                $result = $renderer->canRender($object, $context);
                if ($result == ChainableRendererInterface::CAN_RENDER_OBJECT || $result == ChainableRendererInterface::CANNOT_RENDER_OBJECT) {
                    $isCachable = false;
                }
                if ($result == ChainableRendererInterface::CAN_RENDER_OBJECT || $result == ChainableRendererInterface::CAN_RENDER_CLASS) {
                    $foundRenderer = $renderer;
                    $source = 'packageRenderers';
                    $rendererIndex = $key;
                    break 2;
                }
            }
        } while (false);

        if ($isCachable && $foundRenderer) {
            $this->cacheService->set($cacheKey, [
                'source' => $source,
                'index' => $rendererIndex
            ]);
        }

        return $foundRenderer;
    }

    /**
     * Returns a string explaining the steps done to find the renderer.
     *
     * @param  object $object
     * @param  string $context
     * @return string
     */
    private function getRendererDebugMessage($object, $context = null)
    {
        $debugMessage = '';

        $this->initRenderersList();

        $isCachable = true;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $foundRenderer = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        do {
            foreach ($this->customRenderers as $renderer) {

                /* @var $renderer ChainableRendererInterface */

                $debugMessage .= $renderer->debugCanRender($object, $context);
                $result = $renderer->canRender($object, $context);
                if ($result == ChainableRendererInterface::CAN_RENDER_OBJECT || $result == ChainableRendererInterface::CANNOT_RENDER_OBJECT) {
                    $isCachable = false;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                }
                if ($result == ChainableRendererInterface::CAN_RENDER_OBJECT || $result == ChainableRendererInterface::CAN_RENDER_CLASS) {
                    $foundRenderer = $renderer;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                    break 2;
                }
            }

            /* @var $renderer ChainableRendererInterface */
            if ($this->templateRenderer) {
                $debugMessage .= $this->templateRenderer->debugCanRender($object, $context);
                $result = $this->templateRenderer->canRender($object, $context);
                if ($result == ChainableRendererInterface::CAN_RENDER_OBJECT || $result == ChainableRendererInterface::CANNOT_RENDER_OBJECT) {
                    $isCachable = false;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                }
                if ($result == ChainableRendererInterface::CAN_RENDER_OBJECT || $result == ChainableRendererInterface::CAN_RENDER_CLASS) {
                    $foundRenderer = $this->templateRenderer;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                    break;
                }
            }

            foreach ($this->packageRenderers as $renderer) {

                /* @var $renderer ChainableRendererInterface */

                $debugMessage .= $renderer->debugCanRender($object, $context);
                $result = $renderer->canRender($object, $context);
                if ($result == ChainableRendererInterface::CAN_RENDER_OBJECT || $result == ChainableRendererInterface::CANNOT_RENDER_OBJECT) {
                    $isCachable = false;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                }
                if ($result == ChainableRendererInterface::CAN_RENDER_OBJECT || $result == ChainableRendererInterface::CAN_RENDER_CLASS) {
                    $foundRenderer = $renderer;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                    break 2;
                }
            }

        } while (false);
		
		return $debugMessage;
	}
	
	/**
	 * Initializes the renderers list (from cache if available)
	 */
	private function initRenderersList() {
        if (!$this->initDone) {
            $moufManager = MoufManager::getMoufManager();
            // TODO: suboptimal. findInstanceName is not efficient.
            $instanceName = $this->getInstanceName();

            $renderersList = $this->cacheService->get("chainRenderer_" . $instanceName);
            if ($renderersList === null) {
                $renderersList = $this->queryRenderersList();
                $this->cacheService->set("chainRenderer_" . $instanceName, $renderersList);
            }

            if (isset($renderersList[ChainableRendererInterface::TYPE_CUSTOM])) {

                $this->customRenderers = array_map(function ($name) use ($moufManager) {
                    return $moufManager->getInstance($name);
                }, $renderersList[ChainableRendererInterface::TYPE_CUSTOM]);
            }

            if (isset($renderersList[ChainableRendererInterface::TYPE_PACKAGE])) {

                $this->packageRenderers = array_map(function ($name) use ($moufManager) {
                    return $moufManager->getInstance($name);
                }, $renderersList[ChainableRendererInterface::TYPE_PACKAGE]);
            }

            // Note: We ignore template renderers on purpose.

            $this->initDone = true;
        }
	}
	
	/**
	 * Returns an orderered list of renderers instance name to apply, separated by "type".
	 * 
	 * @return array<string, string[]>

	 */
	private function queryRenderersList() {
		$moufManager = MoufManager::getMoufManager();
		$renderersNames = $moufManager->findInstances('Mouf\\Html\\Renderer\\ChainableRendererInterface');
		
		foreach ($renderersNames as $name) {
			$renderers[$name] = $moufManager->getInstance($name);
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
		}
		
		$renderersByType = array();
		foreach ($renderers as $name => $renderer) {
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
			/* @var $renderer ChainableRendererInterface */
			$renderersByType[$renderer->getRendererType()][] = $name;

		}
		
		// Now, let's sort the renderers by priority (highest first).
		$renderersByType = array_map(function(array $innerArray) use ($renderers) {
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
			usort($innerArray, function($name1, $name2) use ($renderers) {
				$item1 = $renderers[$name1];
				$item2 = $renderers[$name2];
				return $item2->getPriority() - $item1->getPriority();
			});
			return $innerArray;
		}, $renderersByType);
		
		return $renderersByType;
	}
}


Pull Request — 1.2 (#12)

AutoChainRenderer::render() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

1			<?php
2			/*
3			* Copyright (c) 2013 David Negrier
4			*
5			* See the file LICENSE.txt for copying permission.
6			*/
7
8			namespace Mouf\Html\Renderer;
9
10			use Mouf\Utils\Cache\CacheInterface;
11			use Mouf\MoufManager;
12
13			/**
14			* This class is a renderer that renders objects using other renderers.
15			* This renderer will automatically detect the renderers to be included.
16			* They must extend the ChainableRendererInterface interface.
17			*
18			* @author David Négrier <[email protected]>
19			*/
20			class AutoChainRenderer implements CanSetTemplateRendererInterface
21			{
22
23			/**
24			* @var ChainableRendererInterface
25			*/
26			private $templateRenderer;
27			/**
28			* @var ChainableRendererInterface[]
29			*/
30			private $packageRenderers = array();
31			/**
32			* @var ChainableRendererInterface[]
33			*/
34			private $customRenderers = array();
35
36			private $cacheService;
37
38			private $initDone = false;
39			/**
40			* @var string

thecodingmachine / html.renderer

Pull Request — 1.2 (#12)

AutoChainRenderer::render() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like