LayoutLine - Code Metrics - eXpansionPluginPack/eXpansion2 - Measure and Improve Code Quality continuously with Scrutinizer

LayoutLine F
last analyzed 2020-03-13 11:49 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	413
Duplicated Lines	6.54 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

Metric	Value
wmc	61
lcom	1
cbo	3
dl	27
loc	413
rs	3.52
c	0
b	0
f	0

28 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	7	19	4
D	render()	9	57	21
A	getRelativeStartPosition()	0	16	5
A	getStartPosition()	0	13	3
A	getScriptFeatures()	11	11	3
A	setX()	0	6	1
A	setY()	0	6	1
A	getX()	0	4	1
A	getY()	0	4	1
A	getWidth()	0	4	1
A	setWidth()	0	4	1
A	getHeight()	0	4	1
A	setHeight()	0	4	1
A	addChild()	0	8	2
A	getChildren()	0	4	1
A	addClass()	0	4	1
A	add()	0	4	1
A	addChildren()	0	6	2
A	removeAllChildren()	0	8	1
A	removeChildren()	0	4	1
A	getFormat()	0	4	1
A	setFormat()	0	4	1
A	setAlign()	0	7	1
A	setPosition()	0	7	1
A	getId()	0	4	1
A	setId()	0	6	1
A	getHorizontalAlign()	0	4	1
A	setHorizontalAlign()	0	6	1

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 LayoutLine 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 LayoutLine, and based on these observations, apply Extract Interface, too.

<?php

namespace eXpansion\Framework\Gui\Layouts;

use FML\Controls\Control;
use FML\Controls\Frame;
use FML\Elements\Format;
use FML\Script\Features\ScriptFeature;
use FML\Types\Container;
use FML\Types\Renderable;
use FML\Types\ScriptFeatureable;

class LayoutLine implements Renderable, ScriptFeatureable, Container
{
    protected $frameClasses = [];

    protected $frameId = null;

    /** @var float */
    protected $width = 0.;

    /** @var float */
    protected $height = 0.;

    /** @var Control[] */
    protected $elements = [];

    /** @var float */
    private $margin = 2.;
    /**
     * @var float
     */
    protected $startX = 0.;
    /**
     * @var float
     */
    protected $startY = 0.;

    /** @var string */
    protected $hAlign = "left";

    /** @var string */
    protected $vAlign = "top";

    /**
     * layoutLine constructor.
     * @param float    $startX
     * @param float    $startY
     * @param object[] $elements
     * @param float    $margin
     * @throws \Exception
     */
    public function __construct($startX, $startY, $elements = [], $margin = 0.)
    {
        if (!is_array($elements)) {
            throw new \Exception('not an array');
        }
        $this->margin = $margin;
        $this->elements = $elements;
        $this->startX = $startX;
        $this->startY = $startY;
        $sizeY = 0;
        foreach ($this->elements as $idx => $element) {

            $this->width += $element->getWidth() + $this->margin;
            if ((abs($element->getY()) + $element->getHeight()) > $sizeY) {
                $sizeY = abs($element->getY()) + $element->getHeight();
                $this->setHeight($sizeY);
            }
        }

    }

    /**
     * Render the XML element
     *
     * @param \DOMDocument $domDocument DOMDocument for which the XML element should be rendered
     * @return \DOMElement
     */
    public function render(\DOMDocument $domDocument)
    {
        $frame = new Frame();
        $frame->setId($this->frameId);
        $frame->setAlign($this->hAlign, $this->vAlign);
        $frame->setPosition($this->startX, $this->startY);
        $frame->addClasses($this->frameClasses);
        $sizeY = 0;
        $sizeX = 0;
        /** @var Control $oldElement */
        $oldElement = null;
        foreach ($this->elements as $idx => $element) {

            if ($idx === 0) {
                $start = $this->getRelativeStartPosition($element);
            } else {
                $start = $this->getStartPosition($oldElement) + $this->margin;
            }

            if ($oldElement) {

                if ($oldElement->getHorizontalAlign() == "center" && $element->getHorizontalAlign() == "center") {
                    $element->setX($start + $oldElement->getWidth() + ($element->getWidth() / 2));
                } elseif ($oldElement->getHorizontalAlign() == "left" && $element->getHorizontalAlign() == "center") {

                    $element->setX($start + $oldElement->getWidth() + ($element->getWidth() / 2));
                } elseif ($oldElement->getHorizontalAlign() == "center" && $element->getHorizontalAlign() == "left") {
                    $element->setX($start + $oldElement->getWidth());
                } elseif ($oldElement->getHorizontalAlign() == "center" && $element->getHorizontalAlign() == "right") {

                    $element->setX($start + $oldElement->getWidth() + $element->getWidth());
                } elseif ($oldElement->getHorizontalAlign() == "right" && $element->getHorizontalAlign() == "right") {
                    $element->setX($start + $element->getWidth());
                } elseif ($oldElement->getHorizontalAlign() == "right" && $element->getHorizontalAlign() == "center") {

                    $element->setX($start + ($element->getWidth() / 2));
                } elseif ($oldElement->getHorizontalAlign() == "left" && $element->getHorizontalAlign() == "right") {
                    $element->setX($start + $oldElement->getWidth() + $element->getWidth());
                } elseif ($oldElement->getHorizontalAlign() == "right" && $element->getHorizontalAlign() == "left") {
                    $element->setX($start);
                } else {
                    $element->setX($start + $oldElement->getWidth());
                }
            } else {
                $element->setX($start);
            }

            if ((abs($element->getY()) + $element->getHeight()) > $sizeY) {
                $sizeY = abs($element->getY()) + $element->getHeight();
                $this->setHeight($sizeY);
            }
            $frame->addChild($element);
            $oldElement = $element;
            $sizeX += $element->getWidth() + $this->margin;
        }

        $this->setWidth($sizeX);

        return $frame->render($domDocument);
    }

    /**
     * @param Control $element
     * @return double
     */
    private function getRelativeStartPosition($element)
    {
        if (is_null($element)) {
            return 0;
        }
        switch ($element->getHorizontalAlign()) {
            case "left":
                return 0;
            case "center":
                return 0.5 * $element->getWidth();
            case "right":
                return $element->getWidth();
            default:
                return 0;
        }
    }

    /**
     * @param Control $element
     * @return float|int
     */
    private function getStartPosition($element)
    {
        if (is_null($element)) {
            return 0;
        }

        switch ($element->getHorizontalAlign()) {
            case "center":
                return $element->getX() - (0.5 * $element->getWidth());
            default:
                return $element->getX();
        }
    }

    /**
     * Get the Script Features
     *
     * @return ScriptFeature[]
     */
    public function getScriptFeatures()

    {
        $features = [];
        foreach ($this->elements as $element) {
            if ($element instanceof ScriptFeatureable) {
                $features[] = $element->getScriptFeatures();
            }
        }

        return ScriptFeature::collect($features);
    }

    /**
     * @param mixed $startX
     * @return LayoutLine
     */
    public function setX($startX)
    {
        $this->startX = $startX;

        return $this;
    }

    /**
     * @param mixed $startY
     * @return LayoutLine
     */
    public function setY($startY)
    {
        $this->startY = $startY;

        return $this;
    }

    /**
     * @return float
     */
    public function getX()
    {
        return $this->startX;
    }

    /**
     * @return double
     */
    public function getY()
    {
        return $this->startY;
    }

    /**
     * @return float
     */
    public function getWidth()
    {
        return $this->width;
    }

    /**
     * @param float $width
     */
    public function setWidth($width)
    {
        $this->width = $width;
    }

    /**
     * @return float
     */
    public function getHeight()
    {
        return $this->height;
    }

    /**
     * @param float $height
     */
    public function setHeight($height)
    {
        $this->height = $height;
    }

    /**
     * @param Renderable $element
     */
    public function addChild(Renderable $element)
    {
        $this->elements[] = $element;
        $this->width += $element->getWidth() + $this->margin;
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        if ((abs($element->getY()) + $element->getHeight()) > $this->getHeight()) {
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            $this->setHeight(abs($element->getY()) + $element->getHeight());
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        }
    }

    public function getChildren()
    {
        return $this->elements;
    }


    public function addClass($class)
    {
        $this->frameClasses [] = $class;
    }

    /**
     * Add a new child
     *
     * @api
     * @param Renderable $child Child Control to add
     * @return void
     * @deprecated Use addChild()
     * @see        Container::addChild()
     */
    public function add(Renderable $child)
    {
        // do nothing
    }

    /**
     * Add new children
     *
     * @api
     * @param Renderable[] $children Child Controls to add
     * @return void
     */
    public function addChildren(array $children)
    {
        foreach ($children as $child) {
            $this->addChild($child);
        }
    }

    /**
     * Remove all children
     *
     * @api
     * @return static
     */
    public function removeAllChildren()
    {
        $this->width = 0;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
        $this->height = 0;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
        $this->elements = [];

        return $this;
    }

    /**
     * Remove all children
     *
     * @api
     * @return void
     * @deprecated Use removeAllChildren()
     * @see        Container::removeAllChildren()
     */
    public function removeChildren()
    {
        // do nothing
    }

    /**
     * Get the Format
     *
     * @api
     * @param bool $createIfEmpty If the format should be created if it doesn't exist yet
     * @return void
     * @deprecated Use Style
     * @see        Style
     */
    public function getFormat($createIfEmpty = true)
    {

    }

    /**
     * Set the Format
     *
     * @api
     * @param Format $format New Format
     * @return void
     * @deprecated Use Style
     * @see        Style
     */
    public function setFormat(Format $format = null)
    {

    }

    public function setAlign($hAling = "left", $vAlign = "top")
    {
        $this->hAlign = $hAling;
        $this->vAlign = $vAlign;

        return $this;
    }


    public function setPosition($x, $y)
    {
        $this->setX($x);
        $this->setY($y);

        return $this;
    }

    /**
     * @return null|string
     */
    public function getId()
    {
        return $this->frameId;
    }

    /**
     * @param null|string $frameId
     * @return LayoutLine
     */
    public function setId($frameId)
    {
        $this->frameId = $frameId;

        return $this;
    }

    /**
     * @return string
     */
    public function getHorizontalAlign(): string
    {
        return $this->hAlign;
    }

    /**
     * @param string $hAlign
     * @return LayoutLine
     */
    public function setHorizontalAlign(string $hAlign)
    {
        $this->hAlign = $hAlign;

        return $this;
    }

}


LayoutLine F
last analyzed 2020-03-13 11:49 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

28 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

eXpansionPluginPack / eXpansion2

LayoutLine F last analyzed 2020-03-13 11:49 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

28 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

LayoutLine F
last analyzed 2020-03-13 11:49 UTC