added support for enums

Author: iggyvolz

composer.json

@@ -1,6 +1,6 @@
 {
 	"name": "nette/php-generator",
-	"description": "🐘 Nette PHP Generator: generates neat PHP code for you. Supports new PHP 8.0 features.",
+	"description": "🐘 Nette PHP Generator: generates neat PHP code for you. Supports new PHP 8.1 features.",
 	"keywords": ["nette", "php", "code", "scaffolding"],
 	"homepage": "https://nette.org",
 	"license": ["BSD-3-Clause", "GPL-2.0-only", "GPL-3.0-only"],

ecs.php

@@ -15,6 +15,7 @@
 
 	$parameters->set('skip', [
 		'fixtures*/*',
+		'tests/PhpGenerator/Dumper.dump().enum.phpt', // enum
 
 		// constant NULL, FALSE
 		PhpCsFixer\Fixer\Casing\LowercaseConstantsFixer::class => [

readme.md

@@ -227,6 +227,43 @@ $trait = Nette\PhpGenerator\ClassType::trait('MyTrait');
 // in a similar way $class = Nette\PhpGenerator\ClassType::class('MyClass');
 ```
 
+Enums
+-----
+
+You can easily create the enums that PHP 8.1 brings:
+
+```php
+$enum = Nette\PhpGenerator\ClassType::enum('Suit');
+$enum->addCase('Clubs');
+$enum->addCase('Diamonds');
+$enum->addCase('Hearts');
+$enum->addCase('Spades');
+
+echo $enum;
+```
+
+Result:
+
+```php
+enum Suit
+{
+        case Clubs;
+        case Diamonds;
+        case Hearts;
+        case Spades;
+}
+```
+
+You can also define scalar equivalents for cases to create a backed enum:
+
+```php
+$enum->addCase('Clubs', '♣');
+$enum->addCase('Diamonds', '♦');
+```
+
+It is possible to add a comment or [attributes](#attributes) to each case using `addComment()` or `addAttribute()`.
+
+
 Literals
 --------
 

src/PhpGenerator/ClassType.php

@@ -13,7 +13,7 @@
 
 
 /**
- * Class/Interface/Trait description.
+ * Class/Interface/Trait/Enum description.
  *
  * @property Method[] $methods
  * @property Property[] $properties
@@ -27,7 +27,8 @@ final class ClassType
 	public const
 		TYPE_CLASS = 'class',
 		TYPE_INTERFACE = 'interface',
-		TYPE_TRAIT = 'trait';
+		TYPE_TRAIT = 'trait',
+		TYPE_ENUM = 'enum';
 
 	public const
 		VISIBILITY_PUBLIC = 'public',
@@ -67,6 +68,9 @@ final class ClassType
 	/** @var Method[] name => Method */
 	private $methods = [];
 
+	/** @var EnumCase[] name => EnumCase */
+	private $cases = [];
+
 
 	public static function class(string $name = null, PhpNamespace $namespace = null): self
 	{
@@ -86,6 +90,12 @@ public static function trait(string $name = null, PhpNamespace $namespace = null
 	}
 
 
+	public static function enum(string $name = null, PhpNamespace $namespace = null): self
+	{
+		return (new self($name, $namespace))->setType(self::TYPE_ENUM);
+	}
+
+
 	/**
 	 * @param  string|object  $class
 	 */
@@ -191,11 +201,17 @@ public function isTrait(): bool
 	}
 
 
+	public function isEnum(): bool
+	{
+		return $this->type === self::TYPE_ENUM;
+	}
+
+
 	/** @return static */
 	public function setType(string $type): self
 	{
-		if (!in_array($type, [self::TYPE_CLASS, self::TYPE_INTERFACE, self::TYPE_TRAIT], true)) {
-			throw new Nette\InvalidArgumentException('Argument must be class|interface|trait.');
+		if (!in_array($type, [self::TYPE_CLASS, self::TYPE_INTERFACE, self::TYPE_TRAIT, self::TYPE_ENUM], true)) {
+			throw new Nette\InvalidArgumentException('Argument must be class|interface|trait|enum.');
 		}
 		$this->type = $type;
 		return $this;
@@ -351,7 +367,7 @@ public function removeTrait(string $name): self
 
 
 	/**
-	 * @param  Method|Property|Constant  $member
+	 * @param  Method|Property|Constant|EnumCase  $member
 	 * @return static
 	 */
 	public function addMember($member): self
@@ -368,8 +384,11 @@ public function addMember($member): self
 		} elseif ($member instanceof Constant) {
 			$this->consts[$member->getName()] = $member;
 
+		} elseif ($member instanceof EnumCase) {
+			$this->cases[$member->getName()] = $member;
+
 		} else {
-			throw new Nette\InvalidArgumentException('Argument must be Method|Property|Constant.');
+			throw new Nette\InvalidArgumentException('Argument must be Method|Property|Constant|EnumCase.');
 		}
 
 		return $this;
@@ -414,6 +433,44 @@ public function removeConstant(string $name): self
 	}
 
 
+	/**
+	 * Sets cases to enum
+	 * @param  EnumCase[]  $consts
+	 * @return static
+	 */
+	public function setCases(array $cases): self
+	{
+		(function (EnumCase ...$cases) {})(...$cases);
+		$this->cases = [];
+		foreach ($cases as $case) {
+			$this->cases[$case->getName()] = $case;
+		}
+		return $this;
+	}
+
+
+	/** @return EnumCase[] */
+	public function getCases(): array
+	{
+		return $this->cases;
+	}
+
+
+	/** Adds case to enum */
+	public function addCase(string $name, $value = null): EnumCase
+	{
+		return $this->cases[$name] = (new EnumCase($name))->setValue($value);
+	}
+
+
+	/** @return static */
+	public function removeCase(string $name): self
+	{
+		unset($this->cases[$name]);
+		return $this;
+	}
+
+
 	/**
 	 * @param  Property[]  $props
 	 * @return static
@@ -540,6 +597,9 @@ public function validate(): void
 		if ($this->abstract && $this->final) {
 			throw new Nette\InvalidStateException('Class cannot be abstract and final.');
 
+		} elseif ($this->isEnum() && ($this->abstract || $this->final || $this->extends || $this->properties)) {
+			throw new Nette\InvalidStateException('Enum cannot be abstract or final or extends class or have properties.');
+
 		} elseif (!$this->name && ($this->abstract || $this->final)) {
 			throw new Nette\InvalidStateException('Anonymous class cannot be abstract or final.');
 		}
@@ -559,6 +619,7 @@ private function validateNames(array $names): void
 	public function __clone()
 	{
 		$clone = function ($item) { return clone $item; };
+		$this->cases = array_map($clone, $this->cases);
 		$this->consts = array_map($clone, $this->consts);
 		$this->properties = array_map($clone, $this->properties);
 		$this->methods = array_map($clone, $this->methods);

src/PhpGenerator/Dumper.php

@@ -123,6 +123,9 @@ private function dumpObject(&$var, array $parents, int $level): string
 		if ($var instanceof \Serializable) {
 			return 'unserialize(' . $this->dumpString(serialize($var)) . ')';
 
+		} elseif ($var instanceof \UnitEnum) {
+			return '\\' . get_class($var) . '::' . $var->name;
+
 		} elseif ($var instanceof \Closure) {
 			throw new Nette\InvalidArgumentException('Cannot dump closure.');
 		}

src/PhpGenerator/EnumCase.php

@@ -0,0 +1,41 @@
+<?php
+
+/**
+ * This file is part of the Nette Framework (https://nette.org)
+ * Copyright (c) 2004 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Nette\PhpGenerator;
+
+use Nette;
+
+
+/**
+ * Enum case.
+ */
+final class EnumCase
+{
+	use Nette\SmartObject;
+	use Traits\NameAware;
+	use Traits\CommentAware;
+	use Traits\AttributeAware;
+
+	/** @var mixed */
+	private $value;
+
+
+	/** @return static */
+	public function setValue($val): self
+	{
+		$this->value = $val;
+		return $this;
+	}
+
+
+	public function getValue()
+	{
+		return $this->value;
+	}
+}

src/PhpGenerator/Factory.php

@@ -27,9 +27,17 @@ public function fromClassReflection(\ReflectionClass $from, bool $withBodies = f
 		$class = $from->isAnonymous()
 			? new ClassType
 			: new ClassType($from->getShortName(), new PhpNamespace($from->getNamespaceName()));
-		$class->setType($from->isInterface() ? $class::TYPE_INTERFACE : ($from->isTrait() ? $class::TYPE_TRAIT : $class::TYPE_CLASS));
-		$class->setFinal($from->isFinal() && $class->isClass());
-		$class->setAbstract($from->isAbstract() && $class->isClass());
+
+		if (PHP_VERSION_ID >= 80100 && $from->isEnum()) {
+			$class->setType($class::TYPE_ENUM);
+			$from = new \ReflectionEnum($from->getName());
+			$enumIface = $from->isBacked() ? \BackedEnum::class : \UnitEnum::class;
+		} else {
+			$class->setType($from->isInterface() ? $class::TYPE_INTERFACE : ($from->isTrait() ? $class::TYPE_TRAIT : $class::TYPE_CLASS));
+			$class->setFinal($from->isFinal() && $class->isClass());
+			$class->setAbstract($from->isAbstract() && $class->isClass());
+			$enumIface = null;
+		}
 
 		$ifaces = $from->getInterfaceNames();
 		foreach ($ifaces as $iface) {
@@ -40,6 +48,7 @@ public function fromClassReflection(\ReflectionClass $from, bool $withBodies = f
 		if ($from->isInterface()) {
 			$class->setExtends($ifaces);
 		} else {
+			$ifaces = array_diff($ifaces, [$enumIface]);
 			$class->setImplements($ifaces);
 		}
 
@@ -49,20 +58,25 @@ public function fromClassReflection(\ReflectionClass $from, bool $withBodies = f
 			$class->setExtends($from->getParentClass()->name);
 			$class->setImplements(array_diff($class->getImplements(), $from->getParentClass()->getInterfaceNames()));
 		}
-		$props = $methods = $consts = [];
+
+		$props = [];
 		foreach ($from->getProperties() as $prop) {
 			if ($prop->isDefault()
 				&& $prop->getDeclaringClass()->name === $from->name
 				&& (PHP_VERSION_ID < 80000 || !$prop->isPromoted())
+				&& !$class->isEnum()
 			) {
 				$props[] = $this->fromPropertyReflection($prop);
 			}
 		}
 		$class->setProperties($props);
 
-		$bodies = [];
+		$methods = $bodies = [];
 		foreach ($from->getMethods() as $method) {
-			if ($method->getDeclaringClass()->name === $from->name) {
+			if (
+				$method->getDeclaringClass()->name === $from->name
+				&& (!$enumIface || !method_exists($enumIface, $method->name))
+			) {
 				$methods[] = $m = $this->fromMethodReflection($method);
 				if ($withBodies) {
 					$srcMethod = Nette\Utils\Reflection::getMethodDeclaringMethod($method);
@@ -76,12 +90,16 @@ public function fromClassReflection(\ReflectionClass $from, bool $withBodies = f
 		}
 		$class->setMethods($methods);
 
+		$consts = $cases = [];
 		foreach ($from->getReflectionConstants() as $const) {
-			if ($const->getDeclaringClass()->name === $from->name) {
+			if ($class->isEnum() && $from->hasCase($const->name)) {
+				$cases[] = $this->fromCaseReflection($const);
+			} elseif ($const->getDeclaringClass()->name === $from->name) {
 				$consts[] = $this->fromConstantReflection($const);
 			}
 		}
 		$class->setConstants($consts);
+		$class->setCases($cases);
 
 		return $class;
 	}
@@ -185,6 +203,16 @@ public function fromConstantReflection(\ReflectionClassConstant $from): Constant
 	}
 
 
+	public function fromCaseReflection(\ReflectionClassConstant $from): EnumCase
+	{
+		$const = new EnumCase($from->name);
+		$const->setValue($from->getValue()->value ?? null);
+		$const->setComment(Helpers::unformatDocComment((string) $from->getDocComment()));
+		$const->setAttributes(self::getAttributes($from));
+		return $const;
+	}
+
+
 	public function fromPropertyReflection(\ReflectionProperty $from): Property
 	{
 		$defaults = $from->getDeclaringClass()->getDefaultProperties();

src/PhpGenerator/PhpFile.php

@@ -56,6 +56,14 @@ public function addTrait(string $name): ClassType
 	}
 
 
+	public function addEnum(string $name): ClassType
+	{
+		return $this
+			->addNamespace(Helpers::extractNamespace($name))
+			->addEnum(Helpers::extractShortName($name));
+	}
+
+
 	/** @param  string|PhpNamespace  $namespace */
 	public function addNamespace($namespace): PhpNamespace
 	{

src/PhpGenerator/PhpNamespace.php

@@ -189,6 +189,12 @@ public function addTrait(string $name): ClassType
 	}
 
 
+	public function addEnum(string $name): ClassType
+	{
+		return $this->addClass($name)->setType(ClassType::TYPE_ENUM);
+	}
+
+
 	/** @return ClassType[] */
 	public function getClasses(): array
 	{