DefaultController::generate() - Code Metrics - Inspection of "Refactor" - yiisoft/yii-gii - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#58)

by Dmitriy

created 2022-10-16 22:53 UTC

DefaultController::generate() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	19
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
eloc	14
c	0
b	0
f	0
dl	0
loc	19
ccs	0
cts	14
cp	0
rs	9.7998
cc	2
nc	2
nop	1
crap	6

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Gii\Controller;

use Psr\Http\Message\ResponseInterface;
use ReflectionClass;
use ReflectionParameter;
use Yiisoft\DataResponse\DataResponse;
use Yiisoft\DataResponse\DataResponseFactoryInterface;
use Yiisoft\Http\Status;
use Yiisoft\RequestModel\Attribute\Query;
use Yiisoft\Validator\RulesDumper;
use Yiisoft\Validator\RulesProvider\AttributesRulesProvider;
use Yiisoft\Yii\Gii\CodeFile;
use Yiisoft\Yii\Gii\CodeFileWriter;
use Yiisoft\Yii\Gii\Exception\InvalidGeneratorCommandException;
use Yiisoft\Yii\Gii\Generator\CommandHydrator;
use Yiisoft\Yii\Gii\GeneratorCommandInterface;
use Yiisoft\Yii\Gii\GeneratorInterface;
use Yiisoft\Yii\Gii\GiiInterface;
use Yiisoft\Yii\Gii\Request\GeneratorRequest;

final class DefaultController
{
    public function __construct(private DataResponseFactoryInterface $responseFactory)
    {
    }

    public function list(GiiInterface $gii): ResponseInterface
    {
        $generators = $gii->getGenerators();

        return $this->responseFactory->createResponse([
            'generators' => array_map($this->serializeGenerator(...), array_values($generators)),

        ]);
    }

    private function serializeGenerator(GeneratorInterface $generator): array
    {
        /**
         * @psalm-var $commandClass class-string<GeneratorCommandInterface>
         */
        $commandClass = $generator::getCommandClass();

        $dataset = new AttributesRulesProvider($commandClass);
        $rules = $dataset->getRules();
        $dumpedRules = (new RulesDumper())->asArray($rules);
        $attributes = $commandClass::getAttributes();
        $hints = $commandClass::getHints();
        $labels = $commandClass::getAttributeLabels();

        $reflection = new ReflectionClass($commandClass);
        $constructorParameters = $reflection->getConstructor()->getParameters();

        $attributesResult = [];
        foreach ($attributes as $attributeName) {
            $reflectionProperty = $reflection->getProperty($attributeName);
            $defaultValue = $reflectionProperty->hasDefaultValue()
                ? $reflectionProperty->getDefaultValue()
                : $this->findReflectionParameter($attributeName, $constructorParameters)?->getDefaultValue();
            $attributesResult[$attributeName] = [
                'defaultValue' => $defaultValue,
                'hint' => $hints[$attributeName] ?? null,
                'label' => $labels[$attributeName] ?? null,
                'rules' => $dumpedRules[$attributeName] ?? [],
            ];
        }

        return [
            'id' => $generator::getId(),
            'name' => $generator::getName(),
            'description' => $generator::getDescription(),
            'commandClass' => $commandClass,
            'attributes' => $attributesResult,
            //            'templatePath' => $generator->getTemplatePath(),
            //            'templates' => $generator->getTemplates(),
            'directory' => $generator->getDirectory(),
        ];
    }

    public function get(GeneratorRequest $request): ResponseInterface
    {
        $generator = $request->getGenerator();

        return $this->responseFactory->createResponse(
            $this->serializeGenerator($generator)
        );
    }

    /**
     * @param ReflectionParameter[] $constructorParameters
     * @return void
     */
    private function findReflectionParameter(string $name, array $constructorParameters): ReflectionParameter|null
    {
        foreach ($constructorParameters as $parameter) {
            if ($parameter->getName() === $name) {
                return $parameter;
            }
        }
        return null;
    }

    public function generate(
        GeneratorRequest $request,
        CodeFileWriter $codeFileWriter,
        CommandHydrator $commandHydrator
    ): ResponseInterface {
        $generator = $request->getGenerator();
        $command = $commandHydrator->hydrate($generator::getCommandClass(), $request->getBody());
        $answers = $request->getAnswers();
        try {
            $files = $generator->generate($command);
        } catch (InvalidGeneratorCommandException $e) {
            return $this->createErrorResponse($e);
        }
        $params = [];
        $results = [];
        // TODO: get answers from the request
        $answers = [];
        foreach ($files as $file) {
            $answers[$file->getId()] = true;
        }
        $params['hasError'] = !$codeFileWriter->write($command, $files, $answers, $results);
        $params['results'] = $results;
        return $this->responseFactory->createResponse($params);
    }

    public function preview(
        GeneratorRequest $request,
        CommandHydrator $commandHydrator,
        #[Query('file')] ?string $file = null
    ): ResponseInterface {
        $generator = $request->getGenerator();
        $command = $commandHydrator->hydrate($generator::getCommandClass(), $request->getBody());

        try {
            $files = $generator->generate($command);
        } catch (InvalidGeneratorCommandException $e) {
            return $this->createErrorResponse($e);
        }
        if ($file === null) {
            return $this->responseFactory->createResponse([
                'files' => array_map($this->serializeCodeFile(...), $files),
                // todo: fix showing operations' keys. they are skipped because of serialization numerical arrays
                'operations' => CodeFile::OPERATIONS_MAP,
            ]);
        }

        foreach ($files as $generatedFile) {
            if ($generatedFile->getId() === $file) {
                $content = $generatedFile->preview();
                return $this->responseFactory->createResponse(
                    ['content' => $content ?: 'Preview is not available for this file type.']
                );
            }
        }

        return $this->responseFactory->createResponse(
            ['message' => "Code file not found: $file"],
            Status::UNPROCESSABLE_ENTITY
        );
    }

    public function diff(
        GeneratorRequest $request,
        CommandHydrator $commandHydrator,
        #[Query('file')] string $file
    ): ResponseInterface {
        $generator = $request->getGenerator();
        $command = $commandHydrator->hydrate($generator::getCommandClass(), $request->getBody());

        try {
            $files = $generator->generate($command);
        } catch (InvalidGeneratorCommandException $e) {
            return $this->createErrorResponse($e);
        }

        foreach ($files as $generatedFile) {
            if ($generatedFile->getId() === $file) {
                return $this->responseFactory->createResponse(['diff' => $generatedFile->diff()]);
            }
        }
        return $this->responseFactory->createResponse(
            ['message' => "Code file not found: $file"],
            Status::UNPROCESSABLE_ENTITY
        );
    }

    private function createErrorResponse(InvalidGeneratorCommandException $e): DataResponse
    {
        return $this->responseFactory->createResponse(
        // TODO: fix
            ['errors' => $e->getResult()->getErrorMessagesIndexedByAttribute()],
            Status::UNPROCESSABLE_ENTITY
        );
    }

    private function serializeCodeFile(CodeFile $file): array
    {
        return [
            'id' => $file->getId(),
            'content' => $file->getContent(),
            'operation' => $file->getOperation(),
            'path' => $file->getPath(),
            'relativePath' => $file->getRelativePath(),
            'type' => $file->getType(),
            'preview' => $file->preview(),
        ];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Yiisoft\Yii\Gii\Controller;
6
7			use Psr\Http\Message\ResponseInterface;
8			use ReflectionClass;
9			use ReflectionParameter;
10			use Yiisoft\DataResponse\DataResponse;
11			use Yiisoft\DataResponse\DataResponseFactoryInterface;
12			use Yiisoft\Http\Status;
13			use Yiisoft\RequestModel\Attribute\Query;
14			use Yiisoft\Validator\RulesDumper;
15			use Yiisoft\Validator\RulesProvider\AttributesRulesProvider;
16			use Yiisoft\Yii\Gii\CodeFile;
17			use Yiisoft\Yii\Gii\CodeFileWriter;
18			use Yiisoft\Yii\Gii\Exception\InvalidGeneratorCommandException;
19			use Yiisoft\Yii\Gii\Generator\CommandHydrator;
20			use Yiisoft\Yii\Gii\GeneratorCommandInterface;
21			use Yiisoft\Yii\Gii\GeneratorInterface;
22			use Yiisoft\Yii\Gii\GiiInterface;
23			use Yiisoft\Yii\Gii\Request\GeneratorRequest;
24
25			final class DefaultController
26			{
27			public function __construct(private DataResponseFactoryInterface $responseFactory)
28			{
29			}
30
31			public function list(GiiInterface $gii): ResponseInterface
32			{
33			$generators = $gii->getGenerators();
34
35			return $this->responseFactory->createResponse([
36			'generators' => array_map($this->serializeGenerator(...), array_values($generators)),
			0 ignored issues – show Bug introduced 2022-10-16 22:55 UTC by Report Bug Copy Issue Report A parse error occurred: Syntax error, unexpected ')' on line 36 at column 67 Loading history...
37			]);
38			}
39
40			private function serializeGenerator(GeneratorInterface $generator): array
41			{
42			/**
43			* @psalm-var $commandClass class-string<GeneratorCommandInterface>
44			*/
45			$commandClass = $generator::getCommandClass();
46
47			$dataset = new AttributesRulesProvider($commandClass);
48			$rules = $dataset->getRules();
49			$dumpedRules = (new RulesDumper())->asArray($rules);
50			$attributes = $commandClass::getAttributes();
51			$hints = $commandClass::getHints();
52			$labels = $commandClass::getAttributeLabels();
53
54			$reflection = new ReflectionClass($commandClass);
55			$constructorParameters = $reflection->getConstructor()->getParameters();
56
57			$attributesResult = [];
58			foreach ($attributes as $attributeName) {
59			$reflectionProperty = $reflection->getProperty($attributeName);
60			$defaultValue = $reflectionProperty->hasDefaultValue()
61			? $reflectionProperty->getDefaultValue()
62			: $this->findReflectionParameter($attributeName, $constructorParameters)?->getDefaultValue();
63			$attributesResult[$attributeName] = [
64			'defaultValue' => $defaultValue,
65			'hint' => $hints[$attributeName] ?? null,
66			'label' => $labels[$attributeName] ?? null,
67			'rules' => $dumpedRules[$attributeName] ?? [],
68			];
69			}
70
71			return [
72			'id' => $generator::getId(),
73			'name' => $generator::getName(),
74			'description' => $generator::getDescription(),
75			'commandClass' => $commandClass,
76			'attributes' => $attributesResult,
77			// 'templatePath' => $generator->getTemplatePath(),
78			// 'templates' => $generator->getTemplates(),
79			'directory' => $generator->getDirectory(),
80			];
81			}
82
83			public function get(GeneratorRequest $request): ResponseInterface
84			{
85			$generator = $request->getGenerator();
86
87			return $this->responseFactory->createResponse(
88			$this->serializeGenerator($generator)
89			);
90			}
91
92			/**
93			* @param ReflectionParameter[] $constructorParameters
94			* @return void
95			*/
96			private function findReflectionParameter(string $name, array $constructorParameters): ReflectionParameter\|null
97			{
98			foreach ($constructorParameters as $parameter) {
99			if ($parameter->getName() === $name) {
100			return $parameter;
101			}
102			}
103			return null;
104			}
105
106			public function generate(
107			GeneratorRequest $request,
108			CodeFileWriter $codeFileWriter,
109			CommandHydrator $commandHydrator
110			): ResponseInterface {
111			$generator = $request->getGenerator();
112			$command = $commandHydrator->hydrate($generator::getCommandClass(), $request->getBody());
113			$answers = $request->getAnswers();
114			try {
115			$files = $generator->generate($command);
116			} catch (InvalidGeneratorCommandException $e) {
117			return $this->createErrorResponse($e);
118			}
119			$params = [];
120			$results = [];
121			// TODO: get answers from the request
122			$answers = [];
123			foreach ($files as $file) {
124			$answers[$file->getId()] = true;
125			}
126			$params['hasError'] = !$codeFileWriter->write($command, $files, $answers, $results);
127			$params['results'] = $results;
128			return $this->responseFactory->createResponse($params);
129			}
130
131			public function preview(
132			GeneratorRequest $request,
133			CommandHydrator $commandHydrator,
134			#[Query('file')] ?string $file = null
135			): ResponseInterface {
136			$generator = $request->getGenerator();
137			$command = $commandHydrator->hydrate($generator::getCommandClass(), $request->getBody());
138
139			try {
140			$files = $generator->generate($command);
141			} catch (InvalidGeneratorCommandException $e) {
142			return $this->createErrorResponse($e);
143			}
144			if ($file === null) {
145			return $this->responseFactory->createResponse([
146			'files' => array_map($this->serializeCodeFile(...), $files),
147			// todo: fix showing operations' keys. they are skipped because of serialization numerical arrays
148			'operations' => CodeFile::OPERATIONS_MAP,
149			]);
150			}
151
152			foreach ($files as $generatedFile) {
153			if ($generatedFile->getId() === $file) {
154			$content = $generatedFile->preview();
155			return $this->responseFactory->createResponse(
156			['content' => $content ?: 'Preview is not available for this file type.']
157			);
158			}
159			}
160
161			return $this->responseFactory->createResponse(
162			['message' => "Code file not found: $file"],
163			Status::UNPROCESSABLE_ENTITY
164			);
165			}
166
167			public function diff(
168			GeneratorRequest $request,
169			CommandHydrator $commandHydrator,
170			#[Query('file')] string $file
171			): ResponseInterface {
172			$generator = $request->getGenerator();
173			$command = $commandHydrator->hydrate($generator::getCommandClass(), $request->getBody());
174
175			try {
176			$files = $generator->generate($command);
177			} catch (InvalidGeneratorCommandException $e) {
178			return $this->createErrorResponse($e);
179			}
180
181			foreach ($files as $generatedFile) {
182			if ($generatedFile->getId() === $file) {
183			return $this->responseFactory->createResponse(['diff' => $generatedFile->diff()]);
184			}
185			}
186			return $this->responseFactory->createResponse(
187			['message' => "Code file not found: $file"],
188			Status::UNPROCESSABLE_ENTITY
189			);
190			}
191
192			private function createErrorResponse(InvalidGeneratorCommandException $e): DataResponse
193			{
194			return $this->responseFactory->createResponse(
195			// TODO: fix
196			['errors' => $e->getResult()->getErrorMessagesIndexedByAttribute()],
197			Status::UNPROCESSABLE_ENTITY
198			);
199			}
200
201			private function serializeCodeFile(CodeFile $file): array
202			{
203			return [
204			'id' => $file->getId(),
205			'content' => $file->getContent(),
206			'operation' => $file->getOperation(),
207			'path' => $file->getPath(),
208			'relativePath' => $file->getRelativePath(),
209			'type' => $file->getType(),
210			'preview' => $file->preview(),
211			];
212			}
213			}
214

yiisoft / yii-gii

Pull Request — master (#58)

DefaultController::generate() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like