PhUml\Processors\GraphvizProcessor

Complexity

Total Complexity

9

Size/Duplication

Total Lines	48
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	name()	0	3	1
A	process()	0	7	2
A	fromConfiguration()	0	10	1
A	extractElements()	0	11	4
A	__construct()	0	6	1

<?php declare(strict_types=1);
/**
 * This source file is subject to the license that is bundled with this package in the file LICENSE.
 */

namespace PhUml\Processors;

use PhUml\Code\ClassDefinition;
use PhUml\Code\Codebase;
use PhUml\Code\Definition;
use PhUml\Code\InterfaceDefinition;
use PhUml\Code\TraitDefinition;
use PhUml\Graphviz\Builders\ClassGraphBuilder;
use PhUml\Graphviz\Builders\InterfaceGraphBuilder;
use PhUml\Graphviz\Builders\TraitGraphBuilder;
use PhUml\Graphviz\Digraph;
use PhUml\Graphviz\DigraphPrinter;
use PhUml\Templates\TemplateEngine;

/**
 * It creates a digraph from a `Structure` and returns it as a string in DOT format
 */
final class GraphvizProcessor implements Processor
{
    public static function fromConfiguration(GraphvizConfiguration $configuration): GraphvizProcessor
    {
        $style = $configuration->digraphStyle();
        $associationsBuilder = $configuration->associationsBuilder();

        return new GraphvizProcessor(
            new ClassGraphBuilder($associationsBuilder),
            new InterfaceGraphBuilder(),
            new TraitGraphBuilder(),
            new DigraphPrinter(new TemplateEngine(), $style)
        );
    }

    private function __construct(
        private readonly ClassGraphBuilder $classBuilder,
        private readonly InterfaceGraphBuilder $interfaceBuilder,
        private readonly TraitGraphBuilder $traitBuilder,
        private readonly DigraphPrinter $printer
    ) {
    }

    public function name(): string
    {
        return 'Graphviz';
    }

    public function process(Codebase $codebase): OutputContent
    {
        $digraph = new Digraph();
        foreach ($codebase->definitions() as $definition) {
            $this->extractElements($definition, $codebase, $digraph);
        }
        return new OutputContent($this->printer->toDot($digraph));
    }

    private function extractElements(
        Definition $definition,
        Codebase $codebase,
        Digraph $digraph
    ): void {
        if ($definition instanceof ClassDefinition) {
            $digraph->add($this->classBuilder->extractFrom($definition, $codebase));
        } elseif ($definition instanceof InterfaceDefinition) {
            $digraph->add($this->interfaceBuilder->extractFrom($definition, $codebase));
        } elseif ($definition instanceof TraitDefinition) {
            $digraph->add($this->traitBuilder->extractFrom($definition, $codebase));
        }
    }
}