6047542927

Committed 01 Sep 2023 09:03AM UTC coverage: 94.11% (-0.2%) from 94.316%

Build # 6047542927

Build Type

push

github

Committed by

crynobone

Commit Message

Merge remote-tracking branch 'origin/master'

Signed-off-by: Mior Muhammad Zaki <crynobone@gmail.com>

Run Details

751 of 798 relevant lines covered (94.11%)

22.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.72

/src/Processors/GeneratesControllerCode.php

<?php

namespace Orchestra\Canvas\Processors;

use Illuminate\Support\Str;
use InvalidArgumentException;
use Orchestra\Canvas\Core\GeneratesCode;

/**
 * @property \Orchestra\Canvas\Commands\Routing\Controller $listener
 *
 * @see https://github.com/laravel/framework/blob/10.x/src/Illuminate/Routing/Console/ControllerMakeCommand.php
 */
class GeneratesControllerCode extends GeneratesCode
{
    /**
     * Handle generating code.
     */
    protected function generatingCode(string $stub, string $name): string
    {
        $stub = parent::generatingCode($stub, $name);

        $controllerNamespace = $this->getNamespace($name);

        $rootNamespace = $this->rootNamespace();

        $replace = [];

        if ($this->options['parent']) {
            $replace = $this->buildParentReplacements();
        }

        if ($this->options['model']) {
            $replace = $this->buildModelReplacements($replace);
        }

        // Remove the base controller import if we are already in base namespace.
        $replace = array_merge($replace, [
            "use {$controllerNamespace}\Controller;\n" => '',
            "use {$rootNamespace}\Http\Controllers\Controller;" => "use {$rootNamespace}Http\Controllers\Controller;",
        ]);

        return str_replace(
            array_keys($replace), array_values($replace), $stub
        );
    }

    /**
     * Build the replacements for a parent controller.
     *
     * @return array<string, string>
     */
    protected function buildParentReplacements(): array
    {
        $parentModelClass = $this->parseModel($this->options['parent']);

        if (! class_exists($parentModelClass) && method_exists($this->listener, 'createModel')) {
            $this->listener->createModel($parentModelClass);
        }

        return [
            'ParentDummyFullModelClass' => $parentModelClass,
            '{{ namespacedParentModel }}' => $parentModelClass,
            '{{namespacedParentModel}}' => $parentModelClass,
            'ParentDummyModelClass' => class_basename($parentModelClass),
            '{{ parentModel }}' => class_basename($parentModelClass),
            '{{parentModel}}' => class_basename($parentModelClass),
            'ParentDummyModelVariable' => lcfirst(class_basename($parentModelClass)),
            '{{ parentModelVariable }}' => lcfirst(class_basename($parentModelClass)),
            '{{parentModelVariable}}' => lcfirst(class_basename($parentModelClass)),
        ];
    }

    /**
     * Build the model replacement values.
     *
     * @param  array<string, string>  $replace
     * @return array<string, string>
     */
    protected function buildModelReplacements(array $replace): array
    {
        $modelClass = $this->parseModel($this->options['model']);

        if (! class_exists($modelClass) && method_exists($this->listener, 'createModel')) {
            $this->listener->createModel($modelClass);
        }

        $replace = $this->buildFormRequestReplacements($replace, $modelClass);

        return array_merge($replace, [
            'DummyFullModelClass' => $modelClass,
            '{{ namespacedModel }}' => $modelClass,
            '{{namespacedModel}}' => $modelClass,
            'DummyModelClass' => class_basename($modelClass),
            '{{ model }}' => class_basename($modelClass),
            '{{model}}' => class_basename($modelClass),
            'DummyModelVariable' => lcfirst(class_basename($modelClass)),
            '{{ modelVariable }}' => lcfirst(class_basename($modelClass)),
            '{{modelVariable}}' => lcfirst(class_basename($modelClass)),
        ]);
    }

    /**
     * Get the fully-qualified model class name.
     *
     * @throws \InvalidArgumentException
     */
    protected function parseModel(string $model): string
    {
        if (preg_match('([^A-Za-z0-9_/\\\\])', $model)) {
            throw new InvalidArgumentException('Model name contains invalid characters.');
        }

        $model = trim(str_replace('/', '\\', $model), '\\');

        if (! Str::startsWith($model, $rootNamespace = $this->preset->modelNamespace())) {
            $model = $rootNamespace.'\\'.$model;
        }

        return $model;
    }

    /**
     * Build the model replacement values.
     *
     * @param  string  $modelClass
     * @return array<string, string>
     */
    protected function buildFormRequestReplacements(array $replace, $modelClass)
    {
        [$namespace, $storeRequestClass, $updateRequestClass] = [
            'Illuminate\\Http', 'Request', 'Request',
        ];

        if ($this->options['requests']) {
            $namespace = 'App\\Http\\Requests';

            [$storeRequestClass, $updateRequestClass] = $this->generateFormRequests(
                $modelClass, $storeRequestClass, $updateRequestClass
            );
        }

        $namespacedRequests = $namespace.'\\'.$storeRequestClass.';';

        if ($storeRequestClass !== $updateRequestClass) {
            $namespacedRequests .= PHP_EOL.'use '.$namespace.'\\'.$updateRequestClass.';';
        }

        return array_merge($replace, [
            '{{ storeRequest }}' => $storeRequestClass,
            '{{storeRequest}}' => $storeRequestClass,
            '{{ updateRequest }}' => $updateRequestClass,
            '{{updateRequest}}' => $updateRequestClass,
            '{{ namespacedStoreRequest }}' => $namespace.'\\'.$storeRequestClass,
            '{{namespacedStoreRequest}}' => $namespace.'\\'.$storeRequestClass,
            '{{ namespacedUpdateRequest }}' => $namespace.'\\'.$updateRequestClass,
            '{{namespacedUpdateRequest}}' => $namespace.'\\'.$updateRequestClass,
            '{{ namespacedRequests }}' => $namespacedRequests,
            '{{namespacedRequests}}' => $namespacedRequests,
        ]);
    }

    /**
     * Generate the form requests for the given model and classes.
     *
     * @param  string  $modelClass
     * @param  string  $storeRequestClass
     * @param  string  $updateRequestClass
     * @return array<int, string>
     */
    protected function generateFormRequests($modelClass, $storeRequestClass, $updateRequestClass)
    {
        $storeRequestClass = 'Store'.class_basename($modelClass).'Request';
        $updateRequestClass = 'Update'.class_basename($modelClass).'Request';

        $this->listener->createRequest($storeRequestClass);
        $this->listener->createRequest($updateRequestClass);

        return [$storeRequestClass, $updateRequestClass];
    }
}

1	<?php
2
3	namespace Orchestra\Canvas\Processors;
4
5	use Illuminate\Support\Str;
6	use InvalidArgumentException;
7	use Orchestra\Canvas\Core\GeneratesCode;
8
9	/**
10	* @property \Orchestra\Canvas\Commands\Routing\Controller $listener
11	*
12	* @see https://github.com/laravel/framework/blob/10.x/src/Illuminate/Routing/Console/ControllerMakeCommand.php
13	*/
14	class GeneratesControllerCode extends GeneratesCode
15	{
16	/**
17	* Handle generating code.
18	*/
19	protected function generatingCode(string $stub, string $name): string
20	{
21	$stub = parent::generatingCode($stub, $name);	16✔
22
23	$controllerNamespace = $this->getNamespace($name);	16✔
24
25	$rootNamespace = $this->rootNamespace();	16✔
26
27	$replace = [];	16✔
28
29	if ($this->options['parent']) {	16✔
30	$replace = $this->buildParentReplacements();	2✔
31	}
32
33	if ($this->options['model']) {	16✔
34	$replace = $this->buildModelReplacements($replace);	9✔
35	}
36
37	// Remove the base controller import if we are already in base namespace.
38	$replace = array_merge($replace, [	16✔
39	"use {$controllerNamespace}\Controller;\n" => '',	16✔
40	"use {$rootNamespace}\Http\Controllers\Controller;" => "use {$rootNamespace}Http\Controllers\Controller;",	16✔
41	]);	16✔
42
43	return str_replace(	16✔
44	array_keys($replace), array_values($replace), $stub	16✔
45	);	16✔
46	}
47
48	/**
49	* Build the replacements for a parent controller.
50	*
51	* @return array<string, string>
52	*/
53	protected function buildParentReplacements(): array
54	{
55	$parentModelClass = $this->parseModel($this->options['parent']);	2✔
56
57	if (! class_exists($parentModelClass) && method_exists($this->listener, 'createModel')) {	2✔
58	$this->listener->createModel($parentModelClass);	2✔
59	}
60
61	return [	2✔
62	'ParentDummyFullModelClass' => $parentModelClass,	2✔
63	'{{ namespacedParentModel }}' => $parentModelClass,	2✔
64	'{{namespacedParentModel}}' => $parentModelClass,	2✔
65	'ParentDummyModelClass' => class_basename($parentModelClass),	2✔
66	'{{ parentModel }}' => class_basename($parentModelClass),	2✔
67	'{{parentModel}}' => class_basename($parentModelClass),	2✔
68	'ParentDummyModelVariable' => lcfirst(class_basename($parentModelClass)),	2✔
69	'{{ parentModelVariable }}' => lcfirst(class_basename($parentModelClass)),	2✔
70	'{{parentModelVariable}}' => lcfirst(class_basename($parentModelClass)),	2✔
71	];	2✔
72	}
73
74	/**
75	* Build the model replacement values.
76	*
77	* @param array<string, string> $replace
78	* @return array<string, string>
79	*/
80	protected function buildModelReplacements(array $replace): array
81	{
82	$modelClass = $this->parseModel($this->options['model']);	9✔
83
84	if (! class_exists($modelClass) && method_exists($this->listener, 'createModel')) {	9✔
85	$this->listener->createModel($modelClass);	9✔
86	}
87
88	$replace = $this->buildFormRequestReplacements($replace, $modelClass);	9✔
89
90	return array_merge($replace, [	9✔
91	'DummyFullModelClass' => $modelClass,	9✔
92	'{{ namespacedModel }}' => $modelClass,	9✔
93	'{{namespacedModel}}' => $modelClass,	9✔
94	'DummyModelClass' => class_basename($modelClass),	9✔
95	'{{ model }}' => class_basename($modelClass),	9✔
96	'{{model}}' => class_basename($modelClass),	9✔
97	'DummyModelVariable' => lcfirst(class_basename($modelClass)),	9✔
98	'{{ modelVariable }}' => lcfirst(class_basename($modelClass)),	9✔
99	'{{modelVariable}}' => lcfirst(class_basename($modelClass)),	9✔
100	]);	9✔
101	}
102
103	/**
104	* Get the fully-qualified model class name.
105	*
106	* @throws \InvalidArgumentException
107	*/
108	protected function parseModel(string $model): string
109	{
110	if (preg_match('([^A-Za-z0-9_/\\\\])', $model)) {	9✔
111	throw new InvalidArgumentException('Model name contains invalid characters.');	×
112	}
113
114	$model = trim(str_replace('/', '\\', $model), '\\');	9✔
115
116	if (! Str::startsWith($model, $rootNamespace = $this->preset->modelNamespace())) {	9✔
117	$model = $rootNamespace.'\\'.$model;	5✔
118	}
119
120	return $model;	9✔
121	}
122
123	/**
124	* Build the model replacement values.
125	*
126	* @param string $modelClass
127	* @return array<string, string>
128	*/
129	protected function buildFormRequestReplacements(array $replace, $modelClass)
130	{
131	[$namespace, $storeRequestClass, $updateRequestClass] = [	9✔
132	'Illuminate\\Http', 'Request', 'Request',	9✔
133	];	9✔
134
135	if ($this->options['requests']) {	9✔
136	$namespace = 'App\\Http\\Requests';	1✔
137
138	[$storeRequestClass, $updateRequestClass] = $this->generateFormRequests(	1✔
139	$modelClass, $storeRequestClass, $updateRequestClass	1✔
140	);	1✔
141	}
142
143	$namespacedRequests = $namespace.'\\'.$storeRequestClass.';';	9✔
144
145	if ($storeRequestClass !== $updateRequestClass) {	9✔
146	$namespacedRequests .= PHP_EOL.'use '.$namespace.'\\'.$updateRequestClass.';';	1✔
147	}
148
149	return array_merge($replace, [	9✔
150	'{{ storeRequest }}' => $storeRequestClass,	9✔
151	'{{storeRequest}}' => $storeRequestClass,	9✔
152	'{{ updateRequest }}' => $updateRequestClass,	9✔
153	'{{updateRequest}}' => $updateRequestClass,	9✔
154	'{{ namespacedStoreRequest }}' => $namespace.'\\'.$storeRequestClass,	9✔
155	'{{namespacedStoreRequest}}' => $namespace.'\\'.$storeRequestClass,	9✔
156	'{{ namespacedUpdateRequest }}' => $namespace.'\\'.$updateRequestClass,	9✔
157	'{{namespacedUpdateRequest}}' => $namespace.'\\'.$updateRequestClass,	9✔
158	'{{ namespacedRequests }}' => $namespacedRequests,	9✔
159	'{{namespacedRequests}}' => $namespacedRequests,	9✔
160	]);	9✔
161	}
162
163	/**
164	* Generate the form requests for the given model and classes.
165	*
166	* @param string $modelClass
167	* @param string $storeRequestClass
168	* @param string $updateRequestClass
169	* @return array<int, string>
170	*/
171	protected function generateFormRequests($modelClass, $storeRequestClass, $updateRequestClass)
172	{
173	$storeRequestClass = 'Store'.class_basename($modelClass).'Request';	1✔
174	$updateRequestClass = 'Update'.class_basename($modelClass).'Request';	1✔
175
176	$this->listener->createRequest($storeRequestClass);	1✔
177	$this->listener->createRequest($updateRequestClass);	1✔
178
179	return [$storeRequestClass, $updateRequestClass];	1✔
180	}
181	}

orchestral / canvas / 6047542927

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous