FrameworkComposer::__construct() - Code Metrics - Corollarium/Formularium - Measure and Improve Code Quality continuously with Scrutinizer

FrameworkComposer::__construct() A
last analyzed 2021-09-29 18:01 UTC

↳ Parent: FrameworkComposer

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php declare(strict_types=1);

namespace Formularium;

use Formularium\Exception\ClassNotFoundException;
use Formularium\Factory\FrameworkFactory;
use Formularium\HTMLNode;

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

    /**
     *
     * @var HTMLNode[]
     */
    protected $headerElements = [];

    /**
     *
     * @var HTMLNode[]
     */
    protected $footerElements = [];

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

    /**
     * @param Framework[]|string[] $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[]|string[] $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 : FrameworkFactory::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('');
        $found = false;
        foreach ($this->getFrameworks() as $framework) {
            try {
                $element = $framework->getElement($elementName, $this);
                $found = true;
                $node = $element->render($parameters, $node);
            } catch (ClassNotFoundException $e) {
                continue; // element default
            }
        }
        if (!$found) {
            throw new ClassNotFoundException("Element $elementName not found");
        }
        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.
     * @return HTMLNode[]
     */
    public function viewableNodes(Model $m, array $modelData): 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(), $this);
                    $html = $r->viewable($value, $field, $html);
                } 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.
     * @return string
     */
    public function viewable(Model $m, array $modelData): string
    {
        $elements = array_merge(
            $this->headerElements,
            $this->viewableNodes($m, $modelData),
            $this->footerElements
        );
        $output = '';
        foreach ($this->getFrameworks() as $framework) {
            $output = $framework->viewableCompose($m, $elements, $output, $this);
        }
        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.
     * @return HTMLNode[]
     */
    public function editableNodes(Model $m, array $modelData): 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(), $this);
                    $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.
     * @return string
     */
    public function editable(Model $m, array $modelData): string
    {
        $elements = array_merge(
            $this->headerElements,
            $this->editableNodes($m, $modelData),
            $this->footerElements
        );

        $output = '';

        foreach ($this->getFrameworks() as $framework) {
            $output = $framework->editableCompose($m, $elements, $output, $this);
        }
        return $output;
    }

    /**
     * Get the value of footerElements
     * @return HTMLNode[]
     */
    public function getFooterElements(): array
    {
        return $this->footerElements;
    }

    /**
     * Set the value of footerElements
     *
     * @param HTMLNode[] $footerElements
     * @return  self
     */
    public function setFooterElements(array $footerElements): self
    {
        $this->footerElements = $footerElements;

        return $this;
    }

    /**
     * Appends an element to the footer
     *
     * @return self
     */
    public function appendFooterElement(HTMLNode $node): self
    {
        $this->footerElements[] = $node;
        return $this;
    }

    /**
     * Get the value of headerElements
     * @return HTMLNode[]
     */
    public function getHeaderElements(): array
    {
        return $this->headerElements;
    }

    /**
     * Set the value of headerElements
     *
     * @param HTMLNode[] $headerElements
     * @return  self
     */
    public function setHeaderElements(array $headerElements)
    {
        $this->headerElements = $headerElements;

        return $this;
    }

    /**
     * Appends an element to the footer
     *
     * @return self
     */
    public function appendHeaderElement(HTMLNode $node): self
    {
        $this->headerElements[] = $node;
        return $this;
    }
}


1		<?php declare(strict_types=1);
2
3		namespace Formularium;
4
5		use Formularium\Exception\ClassNotFoundException;
6		use Formularium\Factory\FrameworkFactory;
7		use Formularium\HTMLNode;
8
9		class FrameworkComposer
10		{
11		/**
12		* @var Framework[]
13		*/
14		protected $frameworks = [];
15
16		/**
17		*
18		* @var HTMLNode[]
19		*/
20		protected $headerElements = [];
21
22		/**
23		*
24		* @var HTMLNode[]
25		*/
26		protected $footerElements = [];
27
28		/**
29		* @param Framework[]\|string[] $frameworks
30		*/
31	6	public function __construct(array $frameworks = [])
32		{
33	6	$this->setFrameworks($frameworks);
34	6	}
35
36		/**
37		* @param Framework[]\|string[] $frameworks
38		*/
39	5	public static function create(array $frameworks = []): FrameworkComposer
40		{
41	5	return new self($frameworks);
42		}
43
44		/**
45		*
46		* @return Framework[]
47		*/
48	5	public function getFrameworks(): array
49		{
50	5	return $this->frameworks;
51		}
52
53		/**
54		*
55		* @return Framework\|null
56		*/
57	2	public function getByName(string $name): ?Framework
58		{
59	2	foreach ($this->frameworks as $f) {
60	2	if ($f->getName() === $name) {
61	2	return $f;
62		}
63		}
64	1	return null;
65		}
66
67		/**
68		* @param Framework[]\|string[] $frameworks
69		* @return void
70		*/
71	6	public function setFrameworks(array $frameworks = [])
72		{
73	6	$this->frameworks = [];
74	6	foreach ($frameworks as $f) {
75	6	$this->append($f);
76		}
77	6	}
78
79		/**
80		* Appends a framework to the queue
81		*
82		* @param string\|Framework $framework
83		* @return void
84		*/
85	6	public function append($framework)
86		{
87	6	$this->frameworks[] = ($framework instanceof Framework ? $framework : FrameworkFactory::factory($framework));
88	5	}
89
90		/**
91		* Returns the html <head> contents for all frameworks.
92		*
93		* @return string
94		*/
95	1	public function htmlHead(): string
96		{
97	1	$head = new HTMLNode('');
98	1	foreach ($this->getFrameworks() as $framework) {
99	1	$framework->htmlHead($head);
100		}
101	1	return $head->getRenderHTML();
102		}
103
104	1	public function htmlFooter(): string
105		{
106	1	$footer = new HTMLNode('');
107	1	foreach ($this->getFrameworks() as $framework) {
108	1	$framework->htmlFooter($footer);
109		}
110	1	return $footer->getRenderHTML();
111		}
112
113		/**
114		* Renders an element
115		*
116		* @param string $elementName
117		* @param array $parameters
118		* @return HTMLNode The element HTMLNode
119		*/
120	1	public function nodeElement(string $elementName, array $parameters = []): HTMLNode
121		{
122	1	$node = new HTMLNode('');
123	1	$found = false;
124	1	foreach ($this->getFrameworks() as $framework) {
125		try {
126	1	$element = $framework->getElement($elementName, $this);
127	1	$found = true;
128	1	$node = $element->render($parameters, $node);
129		} catch (ClassNotFoundException $e) {
130		continue; // element default
131		}
132		}
133	1	if (!$found) {
134		throw new ClassNotFoundException("Element $elementName not found");
135		}
136	1	return $node;
137		}
138
139		/**
140		* Renders an element to a string
141		*
142		* @param string $elementName
143		* @param array $parameters
144		* @return string The rendered HTML
145		*/
146	1	public function element(string $elementName, array $parameters = []): string
147		{
148	1	return $this->nodeElement($elementName, $parameters)->getRenderHTML();
149		}
150
151		/**
152		* Renders a Model with the loaded frameworks.
153		*
154		* @param Model $m
155		* @param array $modelData Actual data for the fields to render. Can be empty.
156		* @return HTMLNode[]
157		*/
158	2	public function viewableNodes(Model $m, array $modelData): array
159		{
160	2	$elements = [];
161	2	foreach ($m->getFields() as $field) {
162	2	$value = $modelData[$field->getName()] ?? $field->getDataType()->getDefault(); // TODO: values?
163	2	$html = new HTMLNode('');
164	2	foreach ($this->getFrameworks() as $framework) {
165		try {
166	2	$r = $framework->getRenderable($field->getDatatype(), $this);
167	2	$html = $r->viewable($value, $field, $html);
168		} catch (ClassNotFoundException $e) {
169		continue; // renderable default
170		}
171		}
172	2	$elements[$field->getName()] = $html;
173		}
174	2	return $elements;
175		}
176
177		/**
178		* Renders a Model with the loaded frameworks.
179		*
180		* @param Model $m
181		* @param array $modelData Actual data for the fields to render. Can be empty.
182		* @return string
183		*/
184	2	public function viewable(Model $m, array $modelData): string
185		{
186	2	$elements = array_merge(
187	2	$this->headerElements,
188	2	$this->viewableNodes($m, $modelData),
189	2	$this->footerElements
190		);
191	2	$output = '';
192	2	foreach ($this->getFrameworks() as $framework) {
193	2	$output = $framework->viewableCompose($m, $elements, $output, $this);
194		}
195	2	return $output;
196		}
197
198		/**
199		* Renders a Model as an editable form with the loaded frameworks.
200		*
201		* @param Model $m
202		* @param array $modelData Actual data for the fields to render. Can be empty.
203		* @return HTMLNode[]
204		*/
205		public function editableNodes(Model $m, array $modelData): array
206		{
207		$elements = [];
208		foreach ($m->getFields() as $field) {
209		$value = $modelData[$field->getName()] ?? $field->getDataType()->getDefault(); // TODO: values?
210		$html = new HTMLNode('');
211		foreach ($this->getFrameworks() as $framework) {
212		try {
213		$r = $framework->getRenderable($field->getDatatype(), $this);
214		$html = $r->editable($value, $field, $html);
215		} catch (ClassNotFoundException $e) {
216		continue; // renderable default
217		}
218		}
219		$elements[$field->getName()] = $html;
220		}
221		return $elements;
222		}
223
224		/**
225		* Renders a Model as an editable form with the loaded frameworks.
226		*
227		* @param Model $m
228		* @param array $modelData Actual data for the fields to render. Can be empty.
229		* @return string
230		*/
231		public function editable(Model $m, array $modelData): string
232		{
233		$elements = array_merge(
234		$this->headerElements,
235		$this->editableNodes($m, $modelData),
236		$this->footerElements
237		);
238
239		$output = '';
240
241		foreach ($this->getFrameworks() as $framework) {
242		$output = $framework->editableCompose($m, $elements, $output, $this);
243		}
244		return $output;
245		}
246
247		/**
248		* Get the value of footerElements
249		* @return HTMLNode[]
250		*/
251		public function getFooterElements(): array
252		{
253		return $this->footerElements;
254		}
255
256		/**
257		* Set the value of footerElements
258		*
259		* @param HTMLNode[] $footerElements
260		* @return self
261		*/
262		public function setFooterElements(array $footerElements): self
263		{
264		$this->footerElements = $footerElements;
265
266		return $this;
267		}
268
269		/**
270		* Appends an element to the footer
271		*
272		* @return self
273		*/
274		public function appendFooterElement(HTMLNode $node): self
275		{
276		$this->footerElements[] = $node;
277		return $this;
278		}
279
280		/**
281		* Get the value of headerElements
282		* @return HTMLNode[]
283		*/
284		public function getHeaderElements(): array
285		{
286		return $this->headerElements;
287		}
288
289		/**
290		* Set the value of headerElements
291		*
292		* @param HTMLNode[] $headerElements
293		* @return self
294		*/
295		public function setHeaderElements(array $headerElements)
296		{
297		$this->headerElements = $headerElements;
298
299		return $this;
300		}
301
302		/**
303		* Appends an element to the footer
304		*
305		* @return self
306		*/
307		public function appendHeaderElement(HTMLNode $node): self
308		{
309		$this->headerElements[] = $node;
310		return $this;
311		}
312		}
313

Corollarium / Formularium

FrameworkComposer::__construct() A last analyzed 2021-09-29 18:01 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

FrameworkComposer::__construct() A
last analyzed 2021-09-29 18:01 UTC