FrameworkComposer::editableNodes() - Code Metrics - Inspection of "restriction on viewable/editable" - Corollarium/Formularium - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( a03165...951dea )

by Bruno
created 2020-08-07 15:17 UTC
FrameworkComposer::editableNodes() B

↳ Parent: FrameworkComposer
Complexity

Conditions	8
Paths	7
Size

Total Lines	23
Code Lines	16
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	72
Importance

Changes
Metric	Value
cc	8
eloc	16
c	0
b	0
f	0
nc	7
nop	3
dl	0
loc	23
ccs	0
cts	0
cp	0
crap	72
rs	8.4444
<?php declare(strict_types=1);

namespace Formularium;

use Formularium\Exception\ClassNotFoundException;
use Formularium\HTMLNode;

class FrameworkComposer
{
    /**
     * @var Framework[]
     */
    protected $frameworks = [];

    /**
     * @param Framework[] $frameworks
     */
    public function __construct(array $frameworks = [])
    {
        $this->setFrameworks($frameworks);
    }

    /**
     * @param Framework[] $frameworks
     */
    public static function create(array $frameworks = []): FrameworkComposer
    {
        return new self($frameworks);
    }

    /**
     *
     * @return Framework[]
     */
    public function getFrameworks(): array
    {
        return $this->frameworks;
    }

    /**
     *
     * @return Framework|null
     */
    public function getByName(string $name): ?Framework
    {
        foreach ($this->frameworks as $f) {
            if ($f->getName() === $name) {
                return $f;
            }
        }
        return null;
    }

    /**
     * @param Framework[] $frameworks
     * @return void
     */
    public function setFrameworks(array $frameworks = [])
    {
        $this->frameworks = [];
        foreach ($frameworks as $f) {
            $this->append($f);
        }
    }

    /**
     * Appends a framework to the queue
     *
     * @param string|Framework $framework
     * @return void
     */
    public function append($framework)
    {
        $this->frameworks[] = ($framework instanceof Framework ? $framework : Framework::factory($framework));
    }

    /**
     * Returns the html <head> contents for all frameworks.
     *
     * @return string
     */
    public function htmlHead(): string
    {
        $head = new HTMLNode('');
        foreach ($this->getFrameworks() as $framework) {
            $framework->htmlHead($head);
        }
        return $head->getRenderHTML();
    }

    public function htmlFooter(): string
    {
        $footer = new HTMLNode('');
        foreach ($this->getFrameworks() as $framework) {
            $framework->htmlFooter($footer);
        }
        return $footer->getRenderHTML();
    }

    /**
     * Renders an element
     *
     * @param string $elementName
     * @param array $parameters
     * @return HTMLNode The element HTMLNode
     */
    public function nodeElement(string $elementName, array $parameters = []): HTMLNode
    {
        $node = new HTMLNode('');
        foreach ($this->getFrameworks() as $framework) {
            try {
                $element = $framework->getElement($elementName);
                $node = $element->render($parameters, $node);
            } catch (ClassNotFoundException $e) {
                continue; // element default
            }
        }
        return $node;
    }

    /**
     * Renders an element to a string
     *
     * @param string $elementName
     * @param array $parameters
     * @return string The rendered HTML
     */
    public function element(string $elementName, array $parameters = []): string
    {
        return $this->nodeElement($elementName, $parameters)->getRenderHTML();
    }

    /**
     * Renders a Model with the loaded frameworks.
     *
     * @param Model $m
     * @param array $modelData Actual data for the fields to render. Can be empty.
     * @param string[]|callable $restrictFields If present, restrict rendered fields. Can either
     * be an array of strings (field names) or a callback which is called for each field.
     * Callable signature: (Field $field, Model $m, array $modelData): boolean
     * @return HTMLNode[]
     */
    public function viewableNodes(Model $m, array $modelData, $restrictFields = null): array
    public function viewableNodes(Model $m, array $modelData, /** @scrutinizer ignore-unused */ $restrictFields = null): array
    {
        $elements = [];
        foreach ($m->getFields() as $field) {
            $value = $modelData[$field->getName()] ?? $field->getDataType()->getDefault(); // TODO: values?
            $html = new HTMLNode('');
            foreach ($this->getFrameworks() as $framework) {
                try {
                    $r = $framework->getRenderable($field->getDatatype());
                    $x = $r->viewable($value, $field, $html);
                    $html = $x;
                } catch (ClassNotFoundException $e) {
                    continue; // renderable default
                }
            }
            $elements[$field->getName()] = $html;
        }
        return $elements;
    }

    /**
     * Renders a Model with the loaded frameworks.
     *
     * @param Model $m
     * @param array $modelData Actual data for the fields to render. Can be empty.
     * @param string[]|callable $restrictFields If present, restrict rendered fields. Can either
     * be an array of strings (field names) or a callback which is called for each field.
     * Callable signature: (Field $field, Model $m, array $modelData): boolean
     * @return string
     */
    public function viewable(Model $m, array $modelData, $restrictFields = null): string
    {
        $elements = $this->viewableNodes($m, $modelData, $restrictFields);
        $output = '';
        foreach ($this->getFrameworks() as $framework) {
            $output = $framework->viewableCompose($m, $elements, $output);
        }
        return $output;
    }

    /**
     * Renders a Model as an editable form with the loaded frameworks.
     *
     * @param Model $m
     * @param array $modelData Actual data for the fields to render. Can be empty.
     * @param string[]|callable $restrictFields If present, restrict rendered fields. Can either
     * be an array of strings (field names) or a callback which is called for each field.
     * Callable signature: (Field $field, Model $m, array $modelData): boolean
     * @return HTMLNode[]
     */
    public function editableNodes(Model $m, array $modelData, $restrictFields = null): array
    {
        $elements = [];
        foreach ($m->getFields() as $field) {
            if (is_array($restrictFields) && !in_array($field->getName(), $restrictFields)) {
                continue;
            } elseif (is_callable($restrictFields) && !$restrictFields($field, $m, $modelData)) {
                continue;
            }

            $value = $modelData[$field->getName()] ?? $field->getDataType()->getDefault(); // TODO: values?
            $html = new HTMLNode('');
            foreach ($this->getFrameworks() as $framework) {
                try {
                    $r = $framework->getRenderable($field->getDatatype());
                    $html = $r->editable($value, $field, $html);
                } catch (ClassNotFoundException $e) {
                    continue; // renderable default
                }
            }
            $elements[$field->getName()] = $html;
        }
        return $elements;
    }

    /**
     * Renders a Model as an editable form with the loaded frameworks.
     *
     * @param Model $m
     * @param array $modelData Actual data for the fields to render. Can be empty.
     * @param string[]|callable $restrictFields If present, restrict rendered fields. Can either
     * be an array of strings (field names) or a callback which is called for each field.
     * Callable signature: (Field $field, Model $m, array $modelData): boolean
     * @return string
     */
    public function editable(Model $m, array $modelData, $restrictFields = null): string
    {
        $elements = $this->editableNodes($m, $modelData, $restrictFields);
        $output = '';
        foreach ($this->getFrameworks() as $framework) {
            $output = $framework->editableCompose($m, $elements, $output);
        }
        return $output;
    }
}

Corollarium / Formularium

Push — master ( a03165...951dea )

FrameworkComposer::editableNodes() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
