3848713348

Build Type

push

github

Committed by Mior Muhammad Zaki

Commit Message

Merge branch '7.x'

Run Details

772 of 799 relevant lines covered (96.62%)

19.07 hits per line

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

98.7

/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/9.x/src/Illuminate/Routing/Console/ControllerMakeCommand.php
 */
class GeneratesControllerCode extends GeneratesCode
{
    /**
     * Build the class with the given name.
     *
     * Remove the base controller import if we are already in base namespace.
     */
    protected function buildClass(string $name): string
    {
        $controllerNamespace = $this->getNamespace($name);

        $rootNamespace = $this->rootNamespace();

        $replace = [];

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

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

        $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), parent::buildClass($name)
        );
    }

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

orchestral / canvas / 3848713348

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