FrontendVueGenerator::buildTemplateParameters() - Code Metrics - Inspection of "can frontend fixes" - Corollarium/modelarium - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( ee41eb...972703 )

by Bruno

created 2020-12-23 18:24 UTC

FrontendVueGenerator::buildTemplateParameters() B

↳ Parent: FrontendVueGenerator

Complexity

Conditions	7
Paths	2

Size

Total Lines	54
Code Lines	43

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	7
eloc	43
c	0
b	0
f	0
nc	2
nop	0
dl	0
loc	54
rs	8.2986

How to fix Long Method

<?php declare(strict_types=1);

namespace Modelarium\Frontend;

use Formularium\Datatype;
use Formularium\Element;
use Formularium\Field;
use Formularium\Model;
use Formularium\FrameworkComposer;
use Formularium\Frontend\HTML\Element\Button;
use Formularium\Frontend\HTML\Element\Table;
use Formularium\Frontend\Vue\Element\Pagination as PaginationVue;
use Formularium\Frontend\Vue\Framework as FrameworkVue;
use Modelarium\GeneratedCollection;
use Modelarium\GeneratedItem;

use function Safe\file_get_contents;
use function Safe\json_encode;

class FrontendVueGenerator
{
    /**
     * @var FrontendGenerator
     */
    protected $generator = null;

    public function __construct(FrontendGenerator $generator)
    {
        $this->generator = $generator;
        $this->buildTemplateParameters();
    }

    protected function getCollection(): GeneratedCollection
    {
        return $this->generator->getCollection();
    }

    public function generate(): void
    {
        /**
         * @var FrameworkVue $vue
         */
        $vue = $this->generator->getComposer()->getByName('Vue');
        $vueCode = $vue->getVueCode();

        // set basic data for vue
        $extraprops = [
            [
                'name' => 'id',
                'type' => 'String',
                'required' => true
            ]
        ];
        $vueCode->setExtraProps($extraprops);

        // build basic vue components
        $this->vuePublish();
        $this->makeVuePaginationComponent();

        $this->vueCard($vue);
        $this->vueLink($vue);
        $this->vueTableItem($vue);
        $this->vueTable($vue);

        $this->makeVue($vue, 'List', 'viewable');
        $this->makeVue($vue, 'Show', 'viewable');
        $this->makeVue($vue, 'Edit', 'editable');
        $this->makeVue(
            $vue,
            'Form',
            'editable',
            function (Field $f) {
                if (!$f->getExtradata('modelFillable')) {
                    return false;
                }
                return true;
            }
        );
        $this->makeVueRoutes();
        $this->makeVueIndex();
    }

    public function buildTemplateParameters(): void
    {
        $hasVuex = true; // TODO
        $hasCan = $this->generator->getModel()->getExtradataValue('hasCan', 'value', false);
        $routeBase = $this->generator->getRouteBase();
        $keyAttribute = $this->generator->getKeyAttribute();
        $targetAttribute = $hasVuex ? 'to' : 'href';

        $buttonCreate = $this->generator->getComposer()->nodeElement(
            'Button',
            [
                Button::TYPE => ($hasVuex ? 'router-link' : 'a'),

                Button::ATTRIBUTES => [
                    $targetAttribute => "/{$routeBase}/edit",
                ] + ($hasCan ? [ "v-if" => 'can.create' ]: []),
            ]
        )->setContent(
            '<i class="fa fa-plus"></i> Add new',
            true,
            true
        )->getRenderHTML();

        $buttonEdit = $this->generator->getComposer()->nodeElement(
            'Button',
            [
                Button::TYPE => ($hasVuex ? 'router-link' : 'a'),

                Button::ATTRIBUTES => [
                    $targetAttribute => "'/{$routeBase}/' + model.{$keyAttribute} + '/edit'",
                ] + ($hasCan ? [ "v-if" => 'can.edit' ]: []),
            ]
        )->setContent(
            '<i class="fa fa-pencil"></i> Edit',
            true,
            true
        )->getRenderHTML();

        $buttonDelete = $this->generator->getComposer()->nodeElement(
            'Button',
            [
                Button::TYPE => 'a',
                Button::COLOR => Button::COLOR_WARNING,
                Button::ATTRIBUTES => [
                    'href' => '#',
                    '@click.prevent' => 'remove',
                ] + ($hasCan ? [ "v-if" => 'can.delete' ]: []),
            ]
        )->setContent(
            '<i class="fa fa-trash"></i> Delete',
            true,
            true
        )->getRenderHTML();

        $this->generator->templateParameters['buttonCreate'] = $buttonCreate;
        $this->generator->templateParameters['buttonEdit'] = $buttonEdit;
        $this->generator->templateParameters['buttonDelete'] = $buttonDelete;
    }

    /**
     * Publishes the Vue component dependencies
     *
     * @return void
     */
    protected function vuePublish(): void
    {
        $this->getCollection()->push(
            new GeneratedItem(
                GeneratedItem::TYPE_FRONTEND,
                file_get_contents(__DIR__ . "/Vue/Renderable/RelationshipAutocomplete.vue"),
                "Modelarium/RelationshipAutocomplete.vue"
            )
        );
        $this->getCollection()->push(
            new GeneratedItem(
                GeneratedItem::TYPE_FRONTEND,
                file_get_contents(__DIR__ . "/Vue/Renderable/RelationshipSelect.vue"),
                "Modelarium/RelationshipSelect.vue"
            )
        );
        // $this->getCollection()->push(
        //     new GeneratedItem(
        //         GeneratedItem::TYPE_FRONTEND,
        //         file_get_contents(__DIR__ . "/Vue/Renderable/RelationshipSelectMultiple.vue"),
        //         "Modelarium/RelationshipSelectMultiple.vue"
        //     )
        // );
    }

    protected function makeVuePaginationComponent(): void
    {
        // TODO: this is called once per type
        $pagination = $this->generator->getComposer()->nodeElement(
            'Pagination',
            [
            ]
        );
        $html = $pagination->getRenderHTML();
        $script = PaginationVue::script();

        $this->getCollection()->push(
            new GeneratedItem(
                GeneratedItem::TYPE_FRONTEND,
                "<template>\n$html\n</template>\n<script>\n$script\n</script>\n",
                "Modelarium/Pagination.vue"
            )
        );
    }

    /**
     * Appends computed item
     *
     * @param FrameworkVue $vue
     * @return void
     */
    protected function vueCodeLinkItem(FrameworkVue $vue): void
    {
        $vue->getVueCode()->appendComputed(
            'link',
            'return "/' . $this->generator->getRouteBase() .
                '/" + this.' . $this->generator->getKeyAttribute()
        );
    }

    protected function vueCard(FrameworkVue $vue): void
    {
        $vueCode = $vue->getVueCode();
        // set basic data for vue
        $extraprops = [
            [
                'name' => 'id',
                'type' => 'String',
                'required' => true
            ]
        ];
        $cardFieldNames = array_map(function (Field $f) {
            return $f->getName();
        }, $this->generator->getCardFields());
        $vueCode->setExtraProps($extraprops);
        $this->vueCodeLinkItem($vue);

        foreach ($this->generator->getCardFields() as $f) {
            $vueCode->appendExtraProp([
                'name' => $f->getName(),
                'type' => $vueCode->mapTypeToJs($f->getDatatype()),
                'required' => true
            ]);
        }
        $this->makeVue($vue, 'Card', 'viewable', $cardFieldNames);
    }

    protected function vueLink(FrameworkVue $vue): void
    {
        $vueCode = $vue->getVueCode();
        // set basic data for vue
        $extraprops = [
            [
                'name' => 'id',
                'type' => 'String',
                'required' => true
            ]
        ];
        $vueCode->setExtraProps($extraprops);
        $cardFieldNames = array_map(function (Field $f) {
            return $f->getName();
        }, $this->generator->getCardFields());
        foreach ($this->generator->getCardFields() as $f) {
            $vueCode->appendExtraProp([
                'name' => $f->getName(),
                'type' => $vueCode->mapTypeToJs($f->getDatatype()),
                'required' => true
            ]);
        }
        $this->vueCodeLinkItem($vue);
        $this->makeVue($vue, 'Link', 'viewable', $cardFieldNames);
    }

    public function vueTableItem(FrameworkVue $vue): void
    {
        $vueCode = $vue->getVueCode();
        $tableFieldNames = array_map(function (Field $f) {
            return $f->getName();
        }, $this->generator->getTableFields());
        $extraprops = [
            [
                'name' => 'id',
                'type' => 'String',
                'required' => true
            ]
        ];
        $vueCode->setExtraProps($extraprops);
        foreach ($this->generator->getTableFields() as $f) {
            $vueCode->appendExtraProp([
                'name' => $f->getName(),
                'type' => $vueCode->mapTypeToJs($f->getDatatype()),
                'required' => true
            ]);
        }
        $this->makeVue($vue, 'TableItem', 'viewable', $tableFieldNames);
    }

    public function vueTable(FrameworkVue $vue): void
    {
        $this->makeVue($vue, 'Table', 'viewable');
    }

    /**
     * @param FrameworkVue $vue
     * @param string $component
     * @param string $mode
     * @param string[]|callable $restrictFields
     * @return void
     */
    protected function makeVue(FrameworkVue $vue, string $component, string $mode, $restrictFields = null): void
    {
        $path = $this->generator->getModel()->getName() . '/' .
            $this->generator->getModel()->getName() . $component . '.vue';

        $stub = $this->generator->getStubDir() . "/Vue{$component}.mustache.vue";

        if ($mode == 'editable') {
            $vue->setEditableTemplate(
                function (FrameworkVue $vue, array $data, Model $m) use ($stub) {
                    return $this->generator->templateCallback($stub, $vue, $data, $m);
                }
            );

            $this->getCollection()->push(
                new GeneratedItem(
                    GeneratedItem::TYPE_FRONTEND,
                    $this->generator->getModel()->editable($this->generator->getComposer(), [], $restrictFields),
                    $path
                )
            );
        } else {
            $vue->setViewableTemplate(
                function (FrameworkVue $vue, array $data, Model $m) use ($stub) {
                    return $this->generator->templateCallback($stub, $vue, $data, $m);
                }
            );

            $this->getCollection()->push(
                new GeneratedItem(
                    GeneratedItem::TYPE_FRONTEND,
                    $this->generator->getModel()->viewable($this->generator->getComposer(), [], $restrictFields),
                    $path
                )
            );
        }
        $vue->resetVueCode();
        $vue->getVueCode()->setFieldModelVariable('model.');
    }

    protected function makeVueIndex(): void
    {
        $path = $this->generator->getModel()->getName() . '/index.js';
        $name = $this->generator->getStudlyName();

        $items = [
            'Card',
            'Edit',
            'Link',
            'List',
            'Show',
            'Table',
        ];

        $import = array_map(
            function ($i) use ($name) {
                return "import {$name}$i from './{$name}$i.vue';";
            },
            $items
        );

        $export = array_map(
            function ($i) use ($name) {
                return "    {$name}$i,\n";
            },
            $items
        );

        $this->getCollection()->push(
            new GeneratedItem(
                GeneratedItem::TYPE_FRONTEND,
                implode("\n", $import) . "\n" .
                "export {\n" .
                implode("\n", $export) . "\n};\n",
                $path
            )
        );
    }

    protected function makeVueRoutes(): void
    {
        $path = $this->generator->getModel()->getName() . '/routes.js';

        $this->getCollection()->push(
            new GeneratedItem(
                GeneratedItem::TYPE_FRONTEND,
                $this->generator->templateFile(
                    $this->generator->getStubDir() . "/routes.mustache.js",
                    [
                        'routeName' => $this->generator->getRouteBase(),
                        'keyAttribute' => $this->generator->getKeyAttribute()
                    ]
                ),
                $path
            )
        );
    }
}


1			<?php declare(strict_types=1);
2
3			namespace Modelarium\Frontend;
4
5			use Formularium\Datatype;
6			use Formularium\Element;
7			use Formularium\Field;
8			use Formularium\Model;
9			use Formularium\FrameworkComposer;
10			use Formularium\Frontend\HTML\Element\Button;
11			use Formularium\Frontend\HTML\Element\Table;
12			use Formularium\Frontend\Vue\Element\Pagination as PaginationVue;
13			use Formularium\Frontend\Vue\Framework as FrameworkVue;
14			use Modelarium\GeneratedCollection;
15			use Modelarium\GeneratedItem;
16
17			use function Safe\file_get_contents;
18			use function Safe\json_encode;
19
20			class FrontendVueGenerator
21			{
22			/**
23			* @var FrontendGenerator
24			*/
25			protected $generator = null;
26
27			public function __construct(FrontendGenerator $generator)
28			{
29			$this->generator = $generator;
30			$this->buildTemplateParameters();
31			}
32
33			protected function getCollection(): GeneratedCollection
34			{
35			return $this->generator->getCollection();
36			}
37
38			public function generate(): void
39			{
40			/**
41			* @var FrameworkVue $vue
42			*/
43			$vue = $this->generator->getComposer()->getByName('Vue');
44			$vueCode = $vue->getVueCode();
45
46			// set basic data for vue
47			$extraprops = [
48			[
49			'name' => 'id',
50			'type' => 'String',
51			'required' => true
52			]
53			];
54			$vueCode->setExtraProps($extraprops);
55
56			// build basic vue components
57			$this->vuePublish();
58			$this->makeVuePaginationComponent();
59
60			$this->vueCard($vue);
61			$this->vueLink($vue);
62			$this->vueTableItem($vue);
63			$this->vueTable($vue);
64
65			$this->makeVue($vue, 'List', 'viewable');
66			$this->makeVue($vue, 'Show', 'viewable');
67			$this->makeVue($vue, 'Edit', 'editable');
68			$this->makeVue(
69			$vue,
70			'Form',
71			'editable',
72			function (Field $f) {
73			if (!$f->getExtradata('modelFillable')) {
74			return false;
75			}
76			return true;
77			}
78			);
79			$this->makeVueRoutes();
80			$this->makeVueIndex();
81			}
82
83			public function buildTemplateParameters(): void
84			{
85			$hasVuex = true; // TODO
86			$hasCan = $this->generator->getModel()->getExtradataValue('hasCan', 'value', false);
87			$routeBase = $this->generator->getRouteBase();
88			$keyAttribute = $this->generator->getKeyAttribute();
89			$targetAttribute = $hasVuex ? 'to' : 'href';
			0 ignored issues – show introduced 2020-12-23 18:28 UTC by Report Bug Copy Issue Report The condition `$hasVuex` is always `true`. Loading history...
90			$buttonCreate = $this->generator->getComposer()->nodeElement(
91			'Button',
92			[
93			Button::TYPE => ($hasVuex ? 'router-link' : 'a'),
			0 ignored issues – show introduced 2020-12-23 18:28 UTC by Report Bug Copy Issue Report The condition `$hasVuex` is always `true`. Loading history...
94			Button::ATTRIBUTES => [
95			$targetAttribute => "/{$routeBase}/edit",
96			] + ($hasCan ? [ "v-if" => 'can.create' ]: []),
97			]
98			)->setContent(
99			'<i class="fa fa-plus"></i> Add new',
100			true,
101			true
102			)->getRenderHTML();
103
104			$buttonEdit = $this->generator->getComposer()->nodeElement(
105			'Button',
106			[
107			Button::TYPE => ($hasVuex ? 'router-link' : 'a'),
			0 ignored issues – show introduced 2020-12-23 18:28 UTC by Report Bug Copy Issue Report The condition `$hasVuex` is always `true`. Loading history...
108			Button::ATTRIBUTES => [
109			$targetAttribute => "'/{$routeBase}/' + model.{$keyAttribute} + '/edit'",
110			] + ($hasCan ? [ "v-if" => 'can.edit' ]: []),
111			]
112			)->setContent(
113			'<i class="fa fa-pencil"></i> Edit',
114			true,
115			true
116			)->getRenderHTML();
117
118			$buttonDelete = $this->generator->getComposer()->nodeElement(
119			'Button',
120			[
121			Button::TYPE => 'a',
122			Button::COLOR => Button::COLOR_WARNING,
123			Button::ATTRIBUTES => [
124			'href' => '#',
125			'@click.prevent' => 'remove',
126			] + ($hasCan ? [ "v-if" => 'can.delete' ]: []),
127			]
128			)->setContent(
129			'<i class="fa fa-trash"></i> Delete',
130			true,
131			true
132			)->getRenderHTML();
133
134			$this->generator->templateParameters['buttonCreate'] = $buttonCreate;
135			$this->generator->templateParameters['buttonEdit'] = $buttonEdit;
136			$this->generator->templateParameters['buttonDelete'] = $buttonDelete;
137			}
138
139			/**
140			* Publishes the Vue component dependencies
141			*
142			* @return void
143			*/
144			protected function vuePublish(): void
145			{
146			$this->getCollection()->push(
147			new GeneratedItem(
148			GeneratedItem::TYPE_FRONTEND,
149			file_get_contents(__DIR__ . "/Vue/Renderable/RelationshipAutocomplete.vue"),
150			"Modelarium/RelationshipAutocomplete.vue"
151			)
152			);
153			$this->getCollection()->push(
154			new GeneratedItem(
155			GeneratedItem::TYPE_FRONTEND,
156			file_get_contents(__DIR__ . "/Vue/Renderable/RelationshipSelect.vue"),
157			"Modelarium/RelationshipSelect.vue"
158			)
159			);
160			// $this->getCollection()->push(
161			// new GeneratedItem(
162			// GeneratedItem::TYPE_FRONTEND,
163			// file_get_contents(__DIR__ . "/Vue/Renderable/RelationshipSelectMultiple.vue"),
164			// "Modelarium/RelationshipSelectMultiple.vue"
165			// )
166			// );
167			}
168
169			protected function makeVuePaginationComponent(): void
170			{
171			// TODO: this is called once per type
172			$pagination = $this->generator->getComposer()->nodeElement(
173			'Pagination',
174			[
175			]
176			);
177			$html = $pagination->getRenderHTML();
178			$script = PaginationVue::script();
179
180			$this->getCollection()->push(
181			new GeneratedItem(
182			GeneratedItem::TYPE_FRONTEND,
183			"<template>\n$html\n</template>\n<script>\n$script\n</script>\n",
184			"Modelarium/Pagination.vue"
185			)
186			);
187			}
188
189			/**
190			* Appends computed item
191			*
192			* @param FrameworkVue $vue
193			* @return void
194			*/
195			protected function vueCodeLinkItem(FrameworkVue $vue): void
196			{
197			$vue->getVueCode()->appendComputed(
198			'link',
199			'return "/' . $this->generator->getRouteBase() .
200			'/" + this.' . $this->generator->getKeyAttribute()
201			);
202			}
203
204			protected function vueCard(FrameworkVue $vue): void
205			{
206			$vueCode = $vue->getVueCode();
207			// set basic data for vue
208			$extraprops = [
209			[
210			'name' => 'id',
211			'type' => 'String',
212			'required' => true
213			]
214			];
215			$cardFieldNames = array_map(function (Field $f) {
216			return $f->getName();
217			}, $this->generator->getCardFields());
218			$vueCode->setExtraProps($extraprops);
219			$this->vueCodeLinkItem($vue);
220
221			foreach ($this->generator->getCardFields() as $f) {
222			$vueCode->appendExtraProp([
223			'name' => $f->getName(),
224			'type' => $vueCode->mapTypeToJs($f->getDatatype()),
225			'required' => true
226			]);
227			}
228			$this->makeVue($vue, 'Card', 'viewable', $cardFieldNames);
229			}
230
231			protected function vueLink(FrameworkVue $vue): void
232			{
233			$vueCode = $vue->getVueCode();
234			// set basic data for vue
235			$extraprops = [
236			[
237			'name' => 'id',
238			'type' => 'String',
239			'required' => true
240			]
241			];
242			$vueCode->setExtraProps($extraprops);
243			$cardFieldNames = array_map(function (Field $f) {
244			return $f->getName();
245			}, $this->generator->getCardFields());
246			foreach ($this->generator->getCardFields() as $f) {
247			$vueCode->appendExtraProp([
248			'name' => $f->getName(),
249			'type' => $vueCode->mapTypeToJs($f->getDatatype()),
250			'required' => true
251			]);
252			}
253			$this->vueCodeLinkItem($vue);
254			$this->makeVue($vue, 'Link', 'viewable', $cardFieldNames);
255			}
256
257			public function vueTableItem(FrameworkVue $vue): void
258			{
259			$vueCode = $vue->getVueCode();
260			$tableFieldNames = array_map(function (Field $f) {
261			return $f->getName();
262			}, $this->generator->getTableFields());
263			$extraprops = [
264			[
265			'name' => 'id',
266			'type' => 'String',
267			'required' => true
268			]
269			];
270			$vueCode->setExtraProps($extraprops);
271			foreach ($this->generator->getTableFields() as $f) {
272			$vueCode->appendExtraProp([
273			'name' => $f->getName(),
274			'type' => $vueCode->mapTypeToJs($f->getDatatype()),
275			'required' => true
276			]);
277			}
278			$this->makeVue($vue, 'TableItem', 'viewable', $tableFieldNames);
279			}
280
281			public function vueTable(FrameworkVue $vue): void
282			{
283			$this->makeVue($vue, 'Table', 'viewable');
284			}
285
286			/**
287			* @param FrameworkVue $vue
288			* @param string $component
289			* @param string $mode
290			* @param string[]\|callable $restrictFields
291			* @return void
292			*/
293			protected function makeVue(FrameworkVue $vue, string $component, string $mode, $restrictFields = null): void
294			{
295			$path = $this->generator->getModel()->getName() . '/' .
296			$this->generator->getModel()->getName() . $component . '.vue';
297
298			$stub = $this->generator->getStubDir() . "/Vue{$component}.mustache.vue";
299
300			if ($mode == 'editable') {
301			$vue->setEditableTemplate(
302			function (FrameworkVue $vue, array $data, Model $m) use ($stub) {
303			return $this->generator->templateCallback($stub, $vue, $data, $m);
304			}
305			);
306
307			$this->getCollection()->push(
308			new GeneratedItem(
309			GeneratedItem::TYPE_FRONTEND,
310			$this->generator->getModel()->editable($this->generator->getComposer(), [], $restrictFields),
311			$path
312			)
313			);
314			} else {
315			$vue->setViewableTemplate(
316			function (FrameworkVue $vue, array $data, Model $m) use ($stub) {
317			return $this->generator->templateCallback($stub, $vue, $data, $m);
318			}
319			);
320
321			$this->getCollection()->push(
322			new GeneratedItem(
323			GeneratedItem::TYPE_FRONTEND,
324			$this->generator->getModel()->viewable($this->generator->getComposer(), [], $restrictFields),
325			$path
326			)
327			);
328			}
329			$vue->resetVueCode();
330			$vue->getVueCode()->setFieldModelVariable('model.');
331			}
332
333			protected function makeVueIndex(): void
334			{
335			$path = $this->generator->getModel()->getName() . '/index.js';
336			$name = $this->generator->getStudlyName();
337
338			$items = [
339			'Card',
340			'Edit',
341			'Link',
342			'List',
343			'Show',
344			'Table',
345			];
346
347			$import = array_map(
348			function ($i) use ($name) {
349			return "import {$name}$i from './{$name}$i.vue';";
350			},
351			$items
352			);
353
354			$export = array_map(
355			function ($i) use ($name) {
356			return " {$name}$i,\n";
357			},
358			$items
359			);
360
361			$this->getCollection()->push(
362			new GeneratedItem(
363			GeneratedItem::TYPE_FRONTEND,
364			implode("\n", $import) . "\n" .
365			"export {\n" .
366			implode("\n", $export) . "\n};\n",
367			$path
368			)
369			);
370			}
371
372			protected function makeVueRoutes(): void
373			{
374			$path = $this->generator->getModel()->getName() . '/routes.js';
375
376			$this->getCollection()->push(
377			new GeneratedItem(
378			GeneratedItem::TYPE_FRONTEND,
379			$this->generator->templateFile(
380			$this->generator->getStubDir() . "/routes.mustache.js",
381			[
382			'routeName' => $this->generator->getRouteBase(),
383			'keyAttribute' => $this->generator->getKeyAttribute()
384			]
385			),
386			$path
387			)
388			);
389			}
390			}
391

Corollarium / modelarium

Push — master ( ee41eb...972703 )

FrontendVueGenerator::buildTemplateParameters() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like