GenerateSerializerCommand::generateModel() - Code Metrics - Inspection of "unified internal API and mechanism" - keeko/tools - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f1c264...f58245 )

by Thomas

created 2016-04-18 16:16 UTC

GenerateSerializerCommand::generateModel() B

↳ Parent: GenerateSerializerCommand

Complexity

Conditions	2
Paths	2

Size

Total Lines	38
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	0	Features	1

Metric	Value
c	4
b	0
f	1
dl	0
loc	38
rs	8.8571
cc	2
eloc	25
nc	2
nop	1

<?php
namespace keeko\tools\command;

use gossi\codegen\model\PhpClass;
use gossi\codegen\model\PhpMethod;
use gossi\codegen\model\PhpProperty;
use keeko\tools\generator\serializer\base\ModelSerializerTraitGenerator;
use keeko\tools\generator\serializer\SkeletonSerializerGenerator;
use keeko\tools\helpers\QuestionHelperTrait;
use phootwork\file\File;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Question\ConfirmationQuestion;
use Symfony\Component\Console\Question\Question;
use keeko\tools\utils\NamespaceResolver;
use phootwork\lang\Text;
use keeko\tools\generator\serializer\ModelSerializerGenerator;

class GenerateSerializerCommand extends AbstractGenerateCommand {

	use QuestionHelperTrait;
	
	private $twig;

	protected function configure() {
		$this
			->setName('generate:serializer')
			->setDescription('Generates a serializer')
			->addArgument(
				'name',
				InputArgument::OPTIONAL,
				'The name of the action for which the serializer should be generated.'
			)
			->addOption(
				'model',
				'm',
				InputOption::VALUE_OPTIONAL,
				'The model for which the serializer should be generated, when there is no name argument (if ommited all models will be generated)'
			)
		;
		
		$this->configureGenerateOptions();
		
		parent::configure();
	}

	protected function initialize(InputInterface $input, OutputInterface $output) {
		parent::initialize($input, $output);

		$loader = new \Twig_Loader_Filesystem($this->service->getConfig()->getTemplateRoot() . '/serializer');
		$this->twig = new \Twig_Environment($loader);
	}

	/**
	 * Checks whether actions can be generated at all by reading composer.json and verify
	 * all required information are available
	 */
	private function preCheck() {
		$module = $this->packageService->getModule();
		if ($module === null) {
			throw new \DomainException('No module definition found in composer.json - please run `keeko init`.');
		}
	}
	
	protected function interact(InputInterface $input, OutputInterface $output) {
		$this->preCheck();
		
		// check if the dialog can be skipped
		$name = $input->getArgument('name');
		$model = $input->getOption('model');
		
		if ($model !== null) {
			return;
		} else if ($name !== null) {
			$generateModel = false;
		} else {
			$modelQuestion = new ConfirmationQuestion('Do you want to generate a serializer based off a model?');
			$generateModel = $this->askConfirmation($modelQuestion);
		}
		
		// ask questions for a model
		if ($generateModel) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
			$schema = str_replace(getcwd(), '', $this->modelService->getSchema());
			$allQuestion = new ConfirmationQuestion(sprintf('For all models in the schema (%s)?', $schema));
			$allModels = $this->askConfirmation($allQuestion);

			if (!$allModels) {
				$modelQuestion = new Question('Which model');
				$modelQuestion->setAutocompleterValues($this->modelService->getModelNames());
				$model = $this->askQuestion($modelQuestion);
				$input->setOption('model', $model);
			}
		} 
		
		// ask question for a skeleton
		else if (empty($name)) {
			// ask for classname
			$name = $this->askQuestion(new Question('Classname', $name));
			$input->setArgument('name', $name);
		}
	}

	protected function execute(InputInterface $input, OutputInterface $output) {
		$this->preCheck();
		
		$name = $input->getArgument('name');
		$model = $input->getOption('model');

		// only a specific action
		if ($name) {
			$this->generateSkeleton($name);
		}

		// create action(s) from a model
		else if ($model) {
			$this->generateModel($model);
		}

		// anyway, generate all models
		else {
			foreach ($this->modelService->getModels() as $model) {
				$modelName = $model->getOriginCommonName();
				$input->setOption('model', $modelName);
				$this->generateModel($modelName);
			}
		}
	}

	private function generateModel($modelName) {
		$this->logger->info('Generate Serializer from Model: ' . $modelName);
		$model = $this->modelService->getModel($modelName);
		
		// generate class
		$generator = new ModelSerializerGenerator($this->service);
		$serializer = $generator->generate($model);
		$this->codegenService->dumpStruct($serializer, true);
		
		// generate trait
		$generator = new ModelSerializerTraitGenerator($this->service);
		$trait = $generator->generate($model);
		$this->codegenService->dumpStruct($trait, true);
		
		// add serializer + ApiModelInterface on the model
		$class = new PhpClass(str_replace('\\\\', '\\', $model->getNamespace() . '\\' . $model->getPhpName()));
		$file = $this->codegenService->getFile($class);
		if ($file->exists()) {
			$class = PhpClass::fromFile($this->codegenService->getFilename($class));
			$class
				->addUseStatement($serializer->getQualifiedName())
				->addUseStatement('keeko\\framework\\model\\ApiModelInterface')
				->addInterface('ApiModelInterface')
				->setProperty(PhpProperty::create('serializer')
					->setStatic(true)
					->setVisibility('private')
				)
				->setMethod(PhpMethod::create('getSerializer')
					->setStatic(true)
					->setBody($this->twig->render('get-serializer.twig', [
						'class' => $serializer->getName()
					]))
				)
			;
		
			$this->codegenService->dumpStruct($class, true);
		}
	}
	
	/**
	 * Generates a skeleton serializer
	 *  
	 * @param string $name
	 */
	private function generateSkeleton($name) {
		$this->logger->info('Generate Skeleton Serializer: ' . $name);
		$input = $this->io->getInput();

		$className = NamespaceResolver::getNamespace('src/serializer', $this->package) . '\\' . $name;
		
		if (!Text::create($className)->endsWith('Serializer')) {
			$className .= 'Serializer';
		}

		// generate code
		$generator = new SkeletonSerializerGenerator($this->service);
		$class = $generator->generate($className);
		$this->codegenService->dumpStruct($class, $input->getOption('force'));
	}
	
	

}


1			<?php
2			namespace keeko\tools\command;
3
4			use gossi\codegen\model\PhpClass;
5			use gossi\codegen\model\PhpMethod;
6			use gossi\codegen\model\PhpProperty;
7			use keeko\tools\generator\serializer\base\ModelSerializerTraitGenerator;
8			use keeko\tools\generator\serializer\SkeletonSerializerGenerator;
9			use keeko\tools\helpers\QuestionHelperTrait;
10			use phootwork\file\File;
11			use Symfony\Component\Console\Input\InputArgument;
12			use Symfony\Component\Console\Input\InputInterface;
13			use Symfony\Component\Console\Input\InputOption;
14			use Symfony\Component\Console\Output\OutputInterface;
15			use Symfony\Component\Console\Question\ConfirmationQuestion;
16			use Symfony\Component\Console\Question\Question;
17			use keeko\tools\utils\NamespaceResolver;
18			use phootwork\lang\Text;
19			use keeko\tools\generator\serializer\ModelSerializerGenerator;
20
21			class GenerateSerializerCommand extends AbstractGenerateCommand {
22
23			use QuestionHelperTrait;
24
25			private $twig;
26
27			protected function configure() {
28			$this
29			->setName('generate:serializer')
30			->setDescription('Generates a serializer')
31			->addArgument(
32			'name',
33			InputArgument::OPTIONAL,
34			'The name of the action for which the serializer should be generated.'
35			)
36			->addOption(
37			'model',
38			'm',
39			InputOption::VALUE_OPTIONAL,
40			'The model for which the serializer should be generated, when there is no name argument (if ommited all models will be generated)'
41			)
42			;
43
44			$this->configureGenerateOptions();
45
46			parent::configure();
47			}
48
49			protected function initialize(InputInterface $input, OutputInterface $output) {
50			parent::initialize($input, $output);
51
52			$loader = new \Twig_Loader_Filesystem($this->service->getConfig()->getTemplateRoot() . '/serializer');
53			$this->twig = new \Twig_Environment($loader);
54			}
55
56			/**
57			* Checks whether actions can be generated at all by reading composer.json and verify
58			* all required information are available
59			*/
60			private function preCheck() {
61			$module = $this->packageService->getModule();
62			if ($module === null) {
63			throw new \DomainException('No module definition found in composer.json - please run `keeko init`.');
64			}
65			}
66
67			protected function interact(InputInterface $input, OutputInterface $output) {
68			$this->preCheck();
69
70			// check if the dialog can be skipped
71			$name = $input->getArgument('name');
72			$model = $input->getOption('model');
73
74			if ($model !== null) {
75			return;
76			} else if ($name !== null) {
77			$generateModel = false;
78			} else {
79			$modelQuestion = new ConfirmationQuestion('Do you want to generate a serializer based off a model?');
80			$generateModel = $this->askConfirmation($modelQuestion);
81			}
82
83			// ask questions for a model
84			if ($generateModel) {
			0 ignored issues – show Bug Best Practice introduced 2016-04-15 00:05 UTC by Report Bug Copy Issue Report The expression `$generateModel` of type `false\|string` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== false` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
85			$schema = str_replace(getcwd(), '', $this->modelService->getSchema());
86			$allQuestion = new ConfirmationQuestion(sprintf('For all models in the schema (%s)?', $schema));
87			$allModels = $this->askConfirmation($allQuestion);
88
89			if (!$allModels) {
90			$modelQuestion = new Question('Which model');
91			$modelQuestion->setAutocompleterValues($this->modelService->getModelNames());
92			$model = $this->askQuestion($modelQuestion);
93			$input->setOption('model', $model);
94			}
95			}
96
97			// ask question for a skeleton
98			else if (empty($name)) {
99			// ask for classname
100			$name = $this->askQuestion(new Question('Classname', $name));
101			$input->setArgument('name', $name);
102			}
103			}
104
105			protected function execute(InputInterface $input, OutputInterface $output) {
106			$this->preCheck();
107
108			$name = $input->getArgument('name');
109			$model = $input->getOption('model');
110
111			// only a specific action
112			if ($name) {
113			$this->generateSkeleton($name);
114			}
115
116			// create action(s) from a model
117			else if ($model) {
118			$this->generateModel($model);
119			}
120
121			// anyway, generate all models
122			else {
123			foreach ($this->modelService->getModels() as $model) {
124			$modelName = $model->getOriginCommonName();
125			$input->setOption('model', $modelName);
126			$this->generateModel($modelName);
127			}
128			}
129			}
130
131			private function generateModel($modelName) {
132			$this->logger->info('Generate Serializer from Model: ' . $modelName);
133			$model = $this->modelService->getModel($modelName);
134
135			// generate class
136			$generator = new ModelSerializerGenerator($this->service);
137			$serializer = $generator->generate($model);
138			$this->codegenService->dumpStruct($serializer, true);
139
140			// generate trait
141			$generator = new ModelSerializerTraitGenerator($this->service);
142			$trait = $generator->generate($model);
143			$this->codegenService->dumpStruct($trait, true);
144
145			// add serializer + ApiModelInterface on the model
146			$class = new PhpClass(str_replace('\\\\', '\\', $model->getNamespace() . '\\' . $model->getPhpName()));
147			$file = $this->codegenService->getFile($class);
148			if ($file->exists()) {
149			$class = PhpClass::fromFile($this->codegenService->getFilename($class));
150			$class
151			->addUseStatement($serializer->getQualifiedName())
152			->addUseStatement('keeko\\framework\\model\\ApiModelInterface')
153			->addInterface('ApiModelInterface')
154			->setProperty(PhpProperty::create('serializer')
155			->setStatic(true)
156			->setVisibility('private')
157			)
158			->setMethod(PhpMethod::create('getSerializer')
159			->setStatic(true)
160			->setBody($this->twig->render('get-serializer.twig', [
161			'class' => $serializer->getName()
162			]))
163			)
164			;
165
166			$this->codegenService->dumpStruct($class, true);
167			}
168			}
169
170			/**
171			* Generates a skeleton serializer
172			*
173			* @param string $name
174			*/
175			private function generateSkeleton($name) {
176			$this->logger->info('Generate Skeleton Serializer: ' . $name);
177			$input = $this->io->getInput();
178
179			$className = NamespaceResolver::getNamespace('src/serializer', $this->package) . '\\' . $name;
180
181			if (!Text::create($className)->endsWith('Serializer')) {
182			$className .= 'Serializer';
183			}
184
185			// generate code
186			$generator = new SkeletonSerializerGenerator($this->service);
187			$class = $generator->generate($className);
188			$this->codegenService->dumpStruct($class, $input->getOption('force'));
189			}
190
191
192
193			}
194

keeko / tools

Push — master ( f1c264...f58245 )

GenerateSerializerCommand::generateModel() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like