keeko\tools\generator\serializer\base\ModelSerializerTraitGenerator

Complexity

Total Complexity

17

Size/Duplication

Total Lines	216
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	19

Importance

Changes	11
Bugs	2	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	generate()	0	13	1
A	generateIdentifyingMethods()	0	18	1
B	generateAttributeMethods()	0	41	4
B	generateHydrateMethod()	0	47	5
B	generateRelationshipMethods()	0	76	5
A	generateTypeInferencerAccess()	0	8	1

<?php
namespace keeko\tools\generator\serializer\base;

use gossi\codegen\model\PhpMethod;
use gossi\codegen\model\PhpParameter;
use gossi\codegen\model\PhpTrait;
use keeko\framework\utils\NameUtils;
use keeko\tools\generator\serializer\AbstractSerializerGenerator;
use keeko\tools\model\Relationship;
use Propel\Generator\Model\Table;

class ModelSerializerTraitGenerator extends AbstractSerializerGenerator {

	/**
	 *
	 * @param Table $model
	 * @return PhpTrait
	 */
	public function generate(Table $model) {
		$ns = $this->packageService->getNamespace();
		$fqcn = sprintf('%s\\serializer\\base\\%sSerializerTrait', $ns, $model->getPhpName());
		$trait = new PhpTrait($fqcn);

		$this->generateIdentifyingMethods($trait, $model);
		$this->generateAttributeMethods($trait, $model);
		$this->generateHydrateMethod($trait, $model);
		$this->generateRelationshipMethods($trait, $model);
		$this->generateTypeInferencerAccess($trait);

		return $trait;
	}

	protected function generateIdentifyingMethods(PhpTrait $trait, Table $model) {
		$package = $this->packageService->getPackage();
		$type = sprintf('%s/%s', $package->getKeeko()->getModule()->getSlug(), NameUtils::dasherize($model->getOriginCommonName()));

		$trait->setMethod(PhpMethod::create('getId')
			->addParameter(PhpParameter::create('model'))
			->setBody($this->twig->render('getId.twig'))
			->setType('string')
		);

		$trait->setMethod(PhpMethod::create('getType')
			->addParameter(PhpParameter::create('model'))
			->setBody($this->twig->render('getType.twig', [
				'type' => $type
			]))
			->setType('string')
		);
	}

	protected function generateAttributeMethods(PhpTrait $trait, Table $model) {
		$readFields = $this->codegenService->getReadFields($model->getOriginCommonName());
		$attrs = '';

		foreach ($readFields as $field) {
			$col = $model->getColumn($field);
			$param = $col->isTemporalType() ? '\DateTime::ISO8601' : '';
			$attrs .= sprintf("\t'%s' => \$model->get%s(%s),\n",
				NameUtils::dasherize($field), $col->getPhpName(), $param
			);
		}

		if (count($field) > 0) {

The variable $field seems to be defined by a foreach iteration on line 56. Are you sure the iterator is never empty, otherwise this variable is not defined?

			$attrs = substr($attrs, 0, -2);
		}

		$trait->setMethod(PhpMethod::create('getAttributes')
			->addParameter(PhpParameter::create('model'))
			->addParameter(PhpParameter::create('fields')->setType('array')->setDefaultValue(null))

The method gossi\codegen\model\parts\ValuePart::setDefaultValue() has been deprecated with message: use `setValue()` instead

			->setBody($this->twig->render('getAttributes.twig', [
				'attrs' => $attrs
			]))
		);

		$trait->setMethod(PhpMethod::create('getSortFields')
			->setBody($this->twig->render('getFields.twig', [
				'fields' => $this->codegenService->arrayToCode(array_map(function ($field) {
					return NameUtils::dasherize($field);
				}, $readFields))
			]))
		);

		$readFields = $this->codegenService->getReadFields($model->getOriginCommonName());
		$trait->setMethod(PhpMethod::create('getFields')
			->setBody($this->twig->render('getFields.twig', [
				'fields' => $this->codegenService->arrayToCode(array_map(function ($field) {
					return NameUtils::dasherize($field);
				}, $readFields))
			]))
		);
	}

	protected function generateHydrateMethod(PhpTrait $trait, Table $model) {
		if ($model->isReadOnly()) {
			$body = $this->twig->render('hydrate-readonly.twig');
		} else {
			$trait->addUseStatement('keeko\\framework\\utils\\HydrateUtils');
			$modelName = $model->getOriginCommonName();
			$normalizer = $this->codegenService->getCodegen()->getNormalizer($modelName);
			$fields = $this->codegenService->getWriteFields($modelName);
			$code = '';

			foreach ($fields as $field) {
				$code .= sprintf("'%s'", NameUtils::dasherize($field));
				if ($normalizer->has($field)) {
					$code .= $this->twig->render('normalizer.twig', [
						'class' => $normalizer->get($field)
					]);
				}

				$code .= ', ';
			}

			if (strlen($code) > 0) {
				$code = substr($code, 0, -2);
			}

			$code = sprintf('[%s]', $code);
			$body = $this->twig->render('hydrate.twig', [
				'code' => $code,
				'normalizer' => $normalizer->size() > 0
			]);

			$trait->setMethod(PhpMethod::create('hydrateRelationships')
				->addParameter(PhpParameter::create('model'))
				->addParameter(PhpParameter::create('data'))
				->setAbstract(true)
				->setType('void')
				->setVisibility(PhpMethod::VISIBILITY_PROTECTED)
			);
		}

		$trait->setMethod(PhpMethod::create('hydrate')
			->addParameter(PhpParameter::create('model'))
			->addParameter(PhpParameter::create('data'))
			->setBody($body)
			->setType('mixed', 'The model')
		);
	}

	protected function generateRelationshipMethods(PhpTrait $trait, Table $model) {
		if ($model->isReadOnly()) {
			return;
		}

		$fields = [];
		$relationships = $this->modelService->getRelationships($model);

		if ($relationships->size() > 0) {
			$trait->addUseStatement('Tobscure\\JsonApi\\Relationship');
			$trait->setMethod(PhpMethod::create('addRelationshipSelfLink')
				->addParameter(PhpParameter::create('relationship')
					->setType('Relationship')
				)
				->addParameter(PhpParameter::create('model')
					->setType('mixed')
				)
				->addParameter(PhpParameter::create('related')
					->setType('string')
				)
				->setAbstract(true)
				->setVisibility(PhpMethod::VISIBILITY_PROTECTED)
				->setType('Relationship')
			);
		}

		foreach ($relationships->getAll() as $rel) {
			// one-to-one
			if ($rel->getType() == Relationship::ONE_TO_ONE) {
				$foreign = $rel->getForeign();
				$relatedName = $rel->getRelatedName();
				$typeName = $rel->getRelatedTypeName();
				$method = NameUtils::toCamelCase($relatedName);
				$fields[$typeName] = $foreign->getPhpName() . '::getSerializer()->getType(null)';
				$trait->addUseStatement($foreign->getNamespace() . '\\' . $foreign->getPhpName());
				$trait->addUseStatement('Tobscure\\JsonApi\\Resource');

				// read
				$body = $this->twig->render('to-one-read.twig', [
					'class' => $foreign->getPhpName(),
					'related' => $relatedName,
					'related_type' => $typeName
				]);
			}

			// ?-to-many
			else {
				$foreign = $rel->getForeign();
				$typeName = $rel->getRelatedPluralTypeName();
				$method = NameUtils::toCamelCase($rel->getRelatedPluralName());
				$fields[$typeName] = $foreign->getPhpName() . '::getSerializer()->getType(null)';
				$trait->addUseStatement($foreign->getNamespace() . '\\' . $foreign->getPhpName());
				$trait->addUseStatement('Tobscure\\JsonApi\\Collection');

				// read
				$body = $this->twig->render('to-many-read.twig', [
					'class' => $foreign->getPhpName(),
					'related' => $rel->getRelatedPluralName(),
					'related_type' => $rel->getRelatedTypeName()
				]);
			}

			// set read method on class
			$trait->setMethod(PhpMethod::create($method)
				->addParameter(PhpParameter::create('model'))
				->setBody($body)
				->setType('Relationship')
			);
		}

		$trait->setMethod(PhpMethod::create('getRelationships')
			->setBody($this->twig->render('getRelationships.twig', [
				'fields' => $fields
			]))
		);
	}

	protected function generateTypeInferencerAccess(PhpTrait $trait) {
		$namespace = $this->factory->getNamespaceGenerator()->getSerializerNamespace();
		$trait->addUseStatement($namespace . '\\TypeInferencer');
		$trait->setMethod(PhpMethod::create('getTypeInferencer')
			->setVisibility(PhpMethod::VISIBILITY_PROTECTED)
			->setBody($this->twig->render('getTypeInferencer.twig'))
		);
	}
}