PhUml\Code\Summary

Complexity

Total Complexity

23

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	1
A	protectedAttributeCount()	0	3	1
A	protectedFunctionCount()	0	3	1
A	typedAttributeCount()	0	3	1
A	attributesSummary()	0	11	1
A	attributeCount()	0	3	1
A	classCount()	0	3	1
A	publicAttributeCount()	0	3	1
A	attributesPerClass()	0	3	1
A	publicTypedAttributes()	0	3	1
A	publicFunctionCount()	0	3	1
A	privateAttributeCount()	0	3	1
A	from()	0	11	4
A	privateTypedAttributes()	0	3	1
A	functionCount()	0	3	1
A	functionsPerClass()	0	3	1
A	methodsSummary()	0	5	1
A	protectedTypedAttributes()	0	3	1
A	interfaceCount()	0	3	1
A	privateFunctionCount()	0	3	1

<?php
/**
 * PHP version 7.1
 *
 * This source file is subject to the license that is bundled with this package in the file LICENSE.
 */

namespace PhUml\Code;

/**
 * It creates a summary of the classes, interfaces, methods, and attributes of a codebase
 */
class Summary
{
    private $interfaceCount;
    private $classCount;
    private $publicFunctionCount;
    private $publicAttributeCount;
    private $publicTypedAttributes;
    private $protectedFunctionCount;
    private $protectedAttributeCount;
    private $protectedTypedAttributes;
    private $privateFunctionCount;
    private $privateAttributeCount;
    private $privateTypedAttributes;

    public function __construct()
    {
        $this->interfaceCount = 0;
        $this->classCount = 0;
        $this->publicFunctionCount = 0;
        $this->publicAttributeCount = 0;
        $this->publicTypedAttributes = 0;
        $this->protectedFunctionCount = 0;
        $this->protectedAttributeCount = 0;
        $this->protectedTypedAttributes = 0;
        $this->privateFunctionCount = 0;
        $this->privateAttributeCount = 0;
        $this->privateTypedAttributes = 0;
    }

    public function from(Structure $structure): void
    {
        foreach ($structure->definitions() as $definition) {
            if ($definition instanceof InterfaceDefinition) {
                $this->interfaceCount++;
            }
            if ($definition instanceof ClassDefinition) {
                $this->classCount++;
                $this->attributesSummary($definition);
            }
            $this->methodsSummary($definition);
        }
    }

    private function attributesSummary(ClassDefinition $definition): void
    {
        // Attributes count
        $this->publicAttributeCount += $definition->countAttributesByVisibility(Visibility::public());
        $this->protectedAttributeCount += $definition->countAttributesByVisibility(Visibility::protected());
        $this->privateAttributeCount += $definition->countAttributesByVisibility(Visibility::private());

        // Typed attributes count
        $this->publicTypedAttributes += $definition->countTypedAttributesByVisibility(Visibility::public());
        $this->protectedTypedAttributes += $definition->countTypedAttributesByVisibility(Visibility::protected());
        $this->privateTypedAttributes += $definition->countTypedAttributesByVisibility(Visibility::private());
    }

    private function methodsSummary(Definition $definition): void
    {
        $this->publicFunctionCount += $definition->countMethodsByVisibility(Visibility::public());
        $this->protectedFunctionCount += $definition->countMethodsByVisibility(Visibility::protected());
        $this->privateFunctionCount += $definition->countMethodsByVisibility(Visibility::private());
    }

    public function interfaceCount(): int
    {
        return $this->interfaceCount;
    }

    public function classCount(): int
    {
        return $this->classCount;
    }

    public function publicFunctionCount(): int
    {
        return $this->publicFunctionCount;
    }

    public function publicAttributeCount(): int
    {
        return $this->publicAttributeCount;
    }

    public function publicTypedAttributes(): int
    {
        return $this->publicTypedAttributes;
    }

    public function protectedFunctionCount(): int
    {
        return $this->protectedFunctionCount;
    }

    public function protectedAttributeCount(): int
    {
        return $this->protectedAttributeCount;
    }

    public function protectedTypedAttributes(): int
    {
        return $this->protectedTypedAttributes;
    }

    public function privateFunctionCount(): int
    {
        return $this->privateFunctionCount;
    }

    public function privateAttributeCount(): int
    {
        return $this->privateAttributeCount;
    }

    public function privateTypedAttributes(): int
    {
        return $this->privateTypedAttributes;
    }

    public function functionCount(): int
    {
        return $this->publicFunctionCount + $this->protectedFunctionCount + $this->privateFunctionCount;
    }

    public function attributeCount(): int
    {
        return $this->publicAttributeCount + $this->protectedAttributeCount + $this->privateAttributeCount;
    }

    public function typedAttributeCount(): int
    {
        return $this->publicTypedAttributes + $this->protectedTypedAttributes + $this->privateTypedAttributes;
    }

    public function attributesPerClass(): float
    {
        return round($this->attributeCount() / $this->classCount, 2);
    }

    public function functionsPerClass(): float
    {
        return round($this->functionCount() / $this->classCount, 2);
    }
}