WidgetMapManager - Code Metrics - Victoire/victoire - Measure and Improve Code Quality continuously with Scrutinizer

WidgetMapManager B
last analyzed 2017-05-22 12:29 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	300
Duplicated Lines	2 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

Metric	Value
wmc	40
lcom	1
cbo	8
dl	6
loc	300
rs	8.2608
c	0
b	0
f	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
B	insert()	0	32	3
D	move()	6	33	9
C	delete()	0	49	8
A	overwrite()	0	12	1
B	moveChildren()	0	18	7
A	cloneWidgetMap()	0	13	1
C	moveWidgetMap()	0	24	7
A	getChildrenByView()	0	21	3

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like WidgetMapManager often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use WidgetMapManager, and based on these observations, apply Extract Interface, too.

<?php

namespace Victoire\Bundle\WidgetMapBundle\Manager;

use Doctrine\Orm\EntityManager;
use Victoire\Bundle\CoreBundle\Entity\View;
use Victoire\Bundle\WidgetBundle\Entity\Widget;
use Victoire\Bundle\WidgetMapBundle\Builder\WidgetMapBuilder;
use Victoire\Bundle\WidgetMapBundle\Entity\WidgetMap;
use Victoire\Bundle\WidgetMapBundle\Helper\WidgetMapHelper;
use Victoire\Bundle\WidgetMapBundle\Resolver\WidgetMapChildrenResolver;

class WidgetMapManager

{
    private $em;
    private $builder;
    private $resolver;

    /**
     * WidgetMapManager constructor.
     *
     * @param EntityManager             $em
     * @param WidgetMapBuilder          $builder
     * @param WidgetMapChildrenResolver $resolver
     */
    public function __construct(
        EntityManager $em,
function someFunction(ManagerRegistry $registry) {
    $em = $registry->getManager();
    $em->getConnection()->beginTransaction();
    try {
        // Do something.
        $em->getConnection()->commit();
    } catch (\Exception $ex) {
        $em->getConnection()->rollback();
        $em->close();

        throw $ex;
    }
}
        WidgetMapBuilder $builder,
        WidgetMapChildrenResolver $resolver
    ) {
        $this->em = $em;
        $this->builder = $builder;
        $this->resolver = $resolver;
    }

    /**

     * Insert a WidgetMap in a view at given position.
     *
     * @param string $slotId

     */
    public function insert(Widget $widget, View $view, $slotId, $position, $widgetReference)
    {
        $quantum = $this->em->getRepository('VictoireWidgetMapBundle:WidgetMap')->findOneBy([
            'view'     => $view,
            'slot'     => $slotId,
            'position' => $position,
            'parent'   => $widgetReference,
            'action'   => [
                WidgetMap::ACTION_CREATE,
                WidgetMap::ACTION_OVERWRITE,
            ],
        ]);

        if ($quantum) {
            $widget->setWidgetMap($quantum);
            $view->addWidgetMap($quantum);
        } else {
            $parent = null;
            if ($widgetReference) {
                $parent = $this->em->getRepository('VictoireWidgetMapBundle:WidgetMap')->find($widgetReference);
            }
            //create the new widget map
            $widgetMapEntry = new WidgetMap();
            $widgetMapEntry->setAction(WidgetMap::ACTION_CREATE);
            $widgetMapEntry->setSlot($slotId);
            $widgetMapEntry->setPosition($position);
            $widgetMapEntry->setParent($parent);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $widget->setWidgetMap($widgetMapEntry);

            $view->addWidgetMap($widgetMapEntry);
        }
    }

    /**
     * moves a widget in a view.
     *
     * @param View  $view
     * @param array $sortedWidget
     */
    public function move(View $view, $sortedWidget)
    {
        /** @var WidgetMap $parentWidgetMap */
        $parentWidgetMap = $this->em->getRepository('VictoireWidgetMapBundle:WidgetMap')->find((int) $sortedWidget['parentWidgetMap']);
        $position = $sortedWidget['position'];
        $slot = $sortedWidget['slot'];
        /** @var WidgetMap $widgetMap */
        $widgetMap = $this->em->getRepository('VictoireWidgetMapBundle:WidgetMap')->find((int) $sortedWidget['widgetMap']);

        $originalParent = $widgetMap->getParent();
        $originalPosition = $widgetMap->getPosition();

        $children = $this->resolver->getChildren($widgetMap, $view);
        $beforeChild = !empty($children[WidgetMap::POSITION_BEFORE]) ? $children[WidgetMap::POSITION_BEFORE] : null;
        $afterChild = !empty($children[WidgetMap::POSITION_AFTER]) ? $children[WidgetMap::POSITION_AFTER] : null;

        $parentWidgetMapChildren = $this->getChildrenByView($parentWidgetMap);

        $widgetMap = $this->moveWidgetMap($view, $widgetMap, $parentWidgetMap, $position, $slot);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->moveChildren($view, $beforeChild, $afterChild, $originalParent, $originalPosition);

        foreach ($parentWidgetMapChildren['views'] as $_view) {
            if ($_view !== $view) {
                if (isset($parentWidgetMapChildren['before'][$_view->getId()]) && $parentWidgetMapChildren['before'][$_view->getId()]->getPosition() == $widgetMap->getPosition()) {

                    $parentWidgetMapChildren['before'][$_view->getId()]->setParent($widgetMap);
                }
                if (isset($parentWidgetMapChildren['after'][$_view->getId()]) && $parentWidgetMapChildren['after'][$_view->getId()]->getPosition() == $widgetMap->getPosition()) {

                    $parentWidgetMapChildren['after'][$_view->getId()]->setParent($widgetMap);
                }
            }
        }
    }

    /**
     * Delete the widget from the view.
     *
     * @param View   $view
     * @param Widget $widget
     *
     * @throws \Exception Widget map does not exists
     */
    public function delete(View $view, Widget $widget)
    {
        $this->builder->build($view);

        $widgetMap = WidgetMapHelper::getWidgetMapByWidgetAndView($widget, $view);
        $slot = $widgetMap->getSlot();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $originalParent = $widgetMap->getParent();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $originalPosition = $widgetMap->getPosition();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $children = $this->resolver->getChildren($widgetMap, $view);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $beforeChild = !empty($children[WidgetMap::POSITION_BEFORE]) ? $children[WidgetMap::POSITION_BEFORE] : null;
        $afterChild = !empty($children[WidgetMap::POSITION_AFTER]) ? $children[WidgetMap::POSITION_AFTER] : null;

        //we remove the widget from the current view
        if ($widgetMap->getView() === $view) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            // If the widgetMap has substitutes, delete them or transform them in create mode
            if (count($widgetMap->getAllSubstitutes()) > 0) {
                foreach ($widgetMap->getAllSubstitutes() as $substitute) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                    if ($substitute->getAction() === WidgetMap::ACTION_OVERWRITE) {
                        $substitute->setAction(WidgetMap::ACTION_CREATE);
                        $substitute->setReplaced(null);
                    } else {
                        $view->removeWidgetMap($widgetMap);
                    }
                }
            }
            //remove the widget map from the slot
            $view->removeWidgetMap($widgetMap);
        } else {
            //the widget is owned by another view (a parent)
            //so we add a new widget map that indicates we delete this widget
            $replaceWidgetMap = new WidgetMap();
            $replaceWidgetMap->setAction(WidgetMap::ACTION_DELETE);
            $replaceWidgetMap->setWidget($widget);

            $replaceWidgetMap->setSlot($slot);
            $replaceWidgetMap->setReplaced($widgetMap);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

            $view->addWidgetMap($replaceWidgetMap);
        }

        //Move children for current WidgetMap View
        $this->moveChildren($view, $beforeChild, $afterChild, $originalParent, $originalPosition);

        //Move children WidgetMap for children from other View
        foreach ($widgetMap->getChildren() as $child) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $this->moveWidgetMap($child->getView(), $child, $originalParent, $originalPosition);
        }
    }

    /**
     * the widget is owned by another view (a parent)
     * so we add a new widget map that indicates we delete this widget.
     *
     * @param View      $view
     * @param WidgetMap $originalWidgetMap
     * @param Widget    $widgetCopy
     *
     * @throws \Exception
     */
    public function overwrite(View $view, WidgetMap $originalWidgetMap, Widget $widgetCopy)
    {
        $widgetMap = new WidgetMap();
        $widgetMap->setAction(WidgetMap::ACTION_OVERWRITE);
        $widgetMap->setReplaced($originalWidgetMap);
        $widgetCopy->setWidgetMap($widgetMap);
        $widgetMap->setSlot($originalWidgetMap->getSlot());
        $widgetMap->setPosition($originalWidgetMap->getPosition());
        $widgetMap->setParent($originalWidgetMap->getParent());

        $view->addWidgetMap($widgetMap);
    }

    /**

     * If the moved widgetMap has someone at both his before and after, arbitrary move UP the before side
     * and find the first place after the before widgetMap hierarchy to place the after widgetMap.
     *
     * @param View $view

     * @param $beforeChild

     * @param $afterChild

     * @param $originalParent

     * @param $originalPosition

     */
    public function moveChildren(View $view, $beforeChild, $afterChild, $originalParent, $originalPosition)
    {
        if ($beforeChild && $afterChild) {
            $this->moveWidgetMap($view, $beforeChild, $originalParent, $originalPosition);

            $child = $beforeChild;
            while ($child->getChild(WidgetMap::POSITION_AFTER)) {
                $child = $child->getChild(WidgetMap::POSITION_AFTER);
            }
            if ($afterChild->getId() !== $child->getId()) {
                $this->moveWidgetMap($view, $afterChild, $child);
            }
        } elseif ($beforeChild) {
            $this->moveWidgetMap($view, $beforeChild, $originalParent, $originalPosition);
        } elseif ($afterChild) {
            $this->moveWidgetMap($view, $afterChild, $originalParent, $originalPosition);
        }
    }

    /**
     * Create a copy of a WidgetMap in "overwrite" mode and insert it in the given view.
     *
     * @param WidgetMap $widgetMap
     * @param View      $view
     *
     * @throws \Exception
     *
     * @return WidgetMap
     */
    protected function cloneWidgetMap(WidgetMap $widgetMap, View $view)
    {
        $originalWidgetMap = $widgetMap;
        $widgetMap = clone $widgetMap;
        $widgetMap->setId(null);
        $widgetMap->setAction(WidgetMap::ACTION_OVERWRITE);
        $widgetMap->setReplaced($originalWidgetMap);
        $widgetMap->setView($view);
        $view->addWidgetMap($widgetMap);
        $this->em->persist($widgetMap);

        return $widgetMap;
    }

    /**
     * Move given WidgetMap as a child of given parent at given position and slot.
     *
     * @param View      $view
     * @param WidgetMap $widgetMap
     * @param bool      $parent
     * @param bool      $position
     * @param bool      $slot
     *
     * @return WidgetMap
     */
    protected function moveWidgetMap(View $view, WidgetMap $widgetMap, $parent = false, $position = false, $slot = false)
    {
        if ($widgetMap->getView() !== $view) {
            $widgetMap = $this->cloneWidgetMap($widgetMap, $view);
        }

        if ($parent !== false) {
            if ($oldParent = $widgetMap->getParent()) {
                $oldParent->removeChild($widgetMap);
            }
            $widgetMap->setParent($parent);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            if ($parent) {
                $parent->addChild($widgetMap);
            }
        }
        if ($position !== false) {
            $widgetMap->setPosition($position);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }
        if ($slot !== false) {
            $widgetMap->setSlot($slot);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        return $widgetMap;
    }

    /**
     * Find return all the given WidgetMap children for each view where it's related.
     *
     * @param WidgetMap $widgetMap
     *
     * @return mixed
     */
    protected function getChildrenByView(WidgetMap $widgetMap)
    {
        $beforeChilds = $widgetMap->getContextualChildren(WidgetMap::POSITION_BEFORE);
        $afterChilds = $widgetMap->getContextualChildren(WidgetMap::POSITION_AFTER);

        $childrenByView['views'] = [];
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

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

    // do something with $myArray
}
        $childrenByView['before'] = [];
        $childrenByView['after'] = [];
        foreach ($beforeChilds as $beforeChild) {
            $view = $beforeChild->getView();
            $childrenByView['views'][] = $view;
            $childrenByView['before'][$view->getId()] = $beforeChild;
        }
        foreach ($afterChilds as $afterChild) {
            $view = $afterChild->getView();
            $childrenByView['views'][] = $view;
            $childrenByView['after'][$view->getId()] = $afterChild;
        }

        return $childrenByView;
    }
}


WidgetMapManager B
last analyzed 2017-05-22 12:29 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

9 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Victoire / victoire

WidgetMapManager B last analyzed 2017-05-22 12:29 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

9 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

WidgetMapManager B
last analyzed 2017-05-22 12:29 UTC