Handle types as Map of objects, auto add use statements, and some utility methods

composer.json

@@ -45,4 +45,4 @@
 		"test" : "phpunit",
 		"api" : "sami.php update sami.php"
 	}
-}
+}

docs/model.rst

@@ -126,7 +126,7 @@ We've just learned how to pass a blank method, the constructor to the class. We
           )
           ->setBody('$this->driver = $driver');
       )
-      ->setProperty(PhpProperty::create('driver')
+      ->addProperty(PhpProperty::create('driver')
           ->setVisibility('private')
           ->setType('string')
       )

src/generator/builder/parts/TypeBuilderPart.php

@@ -4,14 +4,16 @@
 namespace gossi\codegen\generator\builder\parts;
 
 use gossi\codegen\model\AbstractModel;
+use gossi\codegen\model\parts\TypePart;
+use phootwork\collection\Map;
 
 trait TypeBuilderPart {
 
 	protected static $noTypeHints = [
 		'string', 'int', 'integer', 'bool', 'boolean', 'float', 'double', 'object', 'mixed', 'resource'
 	];
 
-	protected static $php7typeHints = [
+    protected static $php7typeHints = [
 		'string', 'int', 'integer', 'bool', 'boolean', 'float', 'double'
 	];
 
@@ -27,22 +29,26 @@ trait TypeBuilderPart {
 
 	/**
 	 *
-	 * @param AbstractModel $model
+	 * @param AbstractModel|TypePart $model
 	 * @param bool $allowed
+	 *
 	 * @return string|null
 	 */
 	private function getType(AbstractModel $model, bool $allowed, bool $nullable): ?string {
-		$type = $model->getType();
-		if (!empty($type) && strpos($type, '|') === false
-				&& (!in_array($type, self::$noTypeHints)
-					|| ($allowed && in_array($type, self::$php7typeHints)))
-				) {
-
-			$type = isset(self::$typeHintMap[$type])
-				? self::$typeHintMap[$type]
-				: $type;
-
-			if ($nullable && $model->getNullable()) {
+		$types = $model->getTypes();
+		if ($types->get('iterable')) {
+		    $types = new Map(['iterable' => 'iterable']);
+        }
+		if (!$types || $types->size() !== 1) {
+		    return null;
+        }
+		$type = (string)$types->values()->toArray()[0];
+		if (!in_array($type, self::$noTypeHints, true)
+            || ($allowed && in_array($type, self::$php7typeHints, true))) {
+
+            $type = self::$typeHintMap[$type] ?? $type;
+
+            if ($nullable && $model->getNullable()) {
 				$type = '?' . $type;
 			}
 

src/model/AbstractModel.php

@@ -32,7 +32,9 @@ public function setDescription($description) {
 		if (is_array($description)) {
 			$description = implode("\n", $description);
 		}
-		$this->description = $description;
+		if ($description) {
+            $this->description = $description;
+        }
 		return $this;
 	}
 

src/model/AbstractPhpMember.php

@@ -75,6 +75,7 @@ abstract class AbstractPhpMember extends AbstractModel implements DocblockInterf
 	public function __construct(string $name) {
 		$this->setName($name);
 		$this->docblock = new Docblock();
+		$this->initTypes();
 	}
 
 	/**

src/model/AbstractPhpStruct.php

@@ -21,6 +21,7 @@
 use gossi\codegen\model\parts\DocblockPart;
 use gossi\codegen\model\parts\LongDescriptionPart;
 use gossi\codegen\model\parts\QualifiedNamePart;
+use gossi\codegen\utils\TypeUtils;
 use gossi\docblock\Docblock;
 use phootwork\collection\Map;
 use phootwork\collection\Set;
@@ -37,13 +38,13 @@ abstract class AbstractPhpStruct extends AbstractModel implements NamespaceInter
 	use LongDescriptionPart;
 	use QualifiedNamePart;
 
-	/** @var Map */
+	/** @var Map|string[] */
 	private $useStatements;
 
-	/** @var Set */
+	/** @var Set|string[] */
 	private $requiredFiles;
 
-	/** @var Map */
+	/** @var Map|PhpMethod[] */
 	private $methods;
 
 	/**
@@ -56,6 +57,13 @@ public static function create(?string $name = null) {
 		return new static($name);
 	}
 
+    public static function fromName(string $name): self
+    {
+        $ref = new \ReflectionClass($name);
+
+        return static::fromFile($ref->getFileName());
+    }
+
 	/**
 	 * Creates a new struct
 	 *
@@ -122,11 +130,23 @@ public function setUseStatements(array $useStatements) {
 	/**
 	 * Adds a use statement with an optional alias
 	 *
-	 * @param string $qualifiedName
+	 * @param string|PhpTypeInterface $qualifiedName
 	 * @param null|string $alias
 	 * @return $this
 	 */
-	public function addUseStatement(string $qualifiedName, string $alias = null) {
+	public function addUseStatement($qualifiedName, string $alias = null) {
+        if ($qualifiedName instanceof PhpTypeInterface) {
+            $qualifiedName = $qualifiedName->getQualifiedName();
+        }
+
+        if (TypeUtils::isGlobalQualifiedName($qualifiedName) || TypeUtils::isNativeType($qualifiedName)) {
+            return $this;
+        }
+
+	    if (preg_replace('#\\\\[^\\\\]+$#', '', $qualifiedName) === $this->getNamespace()) {
+	        return $this;
+        }
+
 		if (!is_string($alias)) {
 			if (false === strpos($qualifiedName, '\\')) {
 				$alias = $qualifiedName;
@@ -135,6 +155,7 @@ public function addUseStatement(string $qualifiedName, string $alias = null) {
 			}
 		}
 
+		$qualifiedName = str_replace('[]', '', $qualifiedName);
 		$this->useStatements->set($alias, $qualifiedName);
 
 		return $this;
@@ -236,7 +257,7 @@ public function setMethods(array $methods) {
 
 		$this->methods->clear();
 		foreach ($methods as $method) {
-			$this->setMethod($method);
+			$this->addMethod($method);
 		}
 
 		return $this;
@@ -248,11 +269,28 @@ public function setMethods(array $methods) {
 	 * @param PhpMethod $method
 	 * @return $this
 	 */
-	public function setMethod(PhpMethod $method) {
+	public function addMethod(PhpMethod $method) {
 		$method->setParent($this);
 		$this->methods->set($method->getName(), $method);
-
-		return $this;
+		$types = $method->getTypes();
+        if ($types) {
+            foreach ($types as $type) {
+                $this->addUseStatement($type);
+                $method->addType($type);
+            }
+        }
+
+        foreach ($method->getParameters() as $parameter) {
+            $types = $parameter->getTypes();
+            if ($types) {
+                foreach ($types as $type) {
+                    $this->addUseStatement($type);
+                    $parameter->addType($type);
+                }
+            }
+        }
+
+        return $this;
 	}
 
 	/**
@@ -313,7 +351,7 @@ public function getMethod($nameOrMethod): PhpMethod {
 	/**
 	 * Returns all methods
 	 *
-	 * @return Map collection of methods
+	 * @return Map|PhpMethod[] collection of methods
 	 */
 	public function getMethods(): Map {
 		return $this->methods;

src/model/PhpClass.php

@@ -20,7 +20,7 @@
  *
  * @author Thomas Gossmann
  */
-class PhpClass extends AbstractPhpStruct implements GenerateableInterface, TraitsInterface, ConstantsInterface, PropertiesInterface {
+class PhpClass extends AbstractPhpStruct implements GenerateableInterface, TraitsInterface, ConstantsInterface, PropertiesInterface, PhpTypeInterface {
 
 	use AbstractPart;
 	use ConstantsPart;
@@ -71,16 +71,25 @@ public function getParentClassName(): ?string {
 		return $this->parentClassName;
 	}
 
+    public function getParentClass(): PhpClass {
+	    return class_exists($this->parentClassName) ?
+            self::fromName($this->parentClassName) : PhpClass::create($this->parentClassName);
+    }
+
 	/**
 	 * Sets the parent class name
 	 *
-	 * @param string|null $name the new parent
+	 * @param PhpClass|string|null $name the new parent
 	 * @return $this
 	 */
-	public function setParentClassName(?string $name) {
-		$this->parentClassName = $name;
+	public function setParentClassName($parent) {
+		if ($parent instanceof PhpClass) {
+		    $this->addUseStatement($parent->getQualifiedName());
+		    $parent = $parent->getName();
+        }
+        $this->parentClassName = $parent;
 
-		return $this;
+        return $this;
 	}
 
 	public function generateDocblock(): void {

src/model/PhpConstant.php

@@ -54,6 +54,7 @@ public function __construct($name = null, $value = null, $isExpression = false)
 			$this->setValue($value);
 		}
 		$this->docblock = new Docblock();
+		$this->initTypes();
 	}
 
 	/**

src/model/PhpFunction.php

@@ -93,7 +93,8 @@ public function __construct($name = null) {
 		$this->setQualifiedName($name);
 		$this->docblock = new Docblock();
 		$this->initParameters();
-	}
+        $this->initTypes();
+    }
 
 	/**
 	 * @inheritDoc

src/model/PhpInterface.php

@@ -15,7 +15,7 @@
  *
  * @author Thomas Gossmann
  */
-class PhpInterface extends AbstractPhpStruct implements GenerateableInterface, ConstantsInterface {
+class PhpInterface extends AbstractPhpStruct implements GenerateableInterface, ConstantsInterface, PhpTypeInterface {
 
 	use ConstantsPart;
 	use InterfacesPart;

src/model/PhpParameter.php

@@ -21,6 +21,7 @@
 use gossi\codegen\model\parts\NamePart;
 use gossi\codegen\model\parts\TypePart;
 use gossi\codegen\model\parts\ValuePart;
+use gossi\codegen\utils\TypeUtils;
 use gossi\docblock\tags\ParamTag;
 
 /**
@@ -54,7 +55,8 @@ public static function create($name = null) {
 	 */
 	public function __construct($name = null) {
 		$this->setName($name);
-	}
+        $this->initTypes();
+    }
 
 	/**
 	 * Sets whether this parameter is passed by reference
@@ -83,8 +85,18 @@ public function isPassedByReference(): bool {
 	 * @return ParamTag
 	 */
 	public function getDocblockTag(): ParamTag {
+        $type = '';
+        if ($this->getNullable()) {
+            $type = 'null';
+        }
+        if ($this->getTypes()) {
+            if ($type) {
+                $type .= '|';
+            }
+            $type .= TypeUtils::typesToExpression($this->getTypes());
+        }
 		return ParamTag::create()
-			->setType($this->getType())
+			->setType($type)
 			->setVariable($this->getName())
 			->setDescription($this->getTypeDescription());
 	}

src/model/PhpType.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace gossi\codegen\model;
+
+use gossi\codegen\model\parts\QualifiedNamePart;
+
+class PhpType implements PhpTypeInterface
+{
+    use QualifiedNamePart;
+
+    public function __construct($qualifiedName)
+    {
+        $this->setQualifiedName($qualifiedName);
+    }
+}

src/model/PhpTypeInterface.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace gossi\codegen\model;
+
+interface PhpTypeInterface extends NamespaceInterface
+{
+    public function getName(): ?string;
+
+    public function getQualifiedName(): ?string;
+
+    public function setName(?string $name);
+
+    public function setQualifiedName(?string $qualifiedName);
+
+    public function __toString(): string;
+}

src/model/PropertiesInterface.php

@@ -22,7 +22,7 @@ public function setProperties(array $properties);
 	 * @param PhpProperty $property
 	 * @return $this
 	 */
-	public function setProperty(PhpProperty $property);
+	public function addProperty(PhpProperty $property);
 
 	/**
 	 * Removes a property

src/model/RoutineInterface.php

@@ -35,24 +35,24 @@ public function hasParameter(string $name): bool;
 	 * A quick way to add a parameter which is created from the given parameters
 	 *
 	 * @param string      $name
-	 * @param null|string $type
+	 * @param string[]|PhpTypeInterface[] $types
 	 * @param mixed       $defaultValue omit the argument to define no default value
 	 *
 	 * @return $this
 	 */
-	public function addSimpleParameter(string $name, string $type = null, $defaultValue = null);
+	public function addSimpleParameter(string $name, $type = null, $defaultValue = null);
 
 	/**
 	 * A quick way to add a parameter with description which is created from the given parameters
 	 *
 	 * @param string      $name
-	 * @param null|string $type
+	 * @param string[]|PhpTypeInterface[] $types
 	 * @param null|string $typeDescription
 	 * @param mixed       $defaultValue omit the argument to define no default value
 	 *
 	 * @return $this
 	 */
-	public function addSimpleDescParameter(string $name, string $type = null, string $typeDescription = null, $defaultValue = null);
+	public function addSimpleDescParameter(string $name, $type = null, string $typeDescription = null, $defaultValue = null);
 
 	/**
 	 * Returns a parameter by index or name