simplify

Author: MartkCz

src/Enum.php

@@ -2,9 +2,18 @@
 
 namespace Utilitte\Enum;
 
-abstract class Enum extends EnumAbstract
+use Utilitte\Enum\Exceptions\InvalidArgumentException;
+use Utilitte\Enum\Storage\EnumStorage;
+
+/**
+ * @internal
+ */
+abstract class Enum
 {
 
+	/** @var EnumStorage[] */
+	private static array $storages = [];
+
 	private string $value;
 
 	final protected function __construct(string $value)
@@ -17,6 +26,36 @@ public function value(): string
 		return $this->value;
 	}
 
+	/**
+	 * @return string[]
+	 */
+	abstract protected static function getEnums(): array;
+
+	/**
+	 * @param mixed[] $arguments
+	 */
+	final public static function __callStatic(string $name, array $arguments)
+	{
+		if ($name !== strtoupper($name)) {
+			throw new InvalidArgumentException(sprintf('Called static class must be uppercase, %s given', $name));
+		}
+
+		return self::getStorage()->getEntry($name)->getEnum();
+	}
+
+	private static function getStorage(): EnumStorage
+	{
+		if (!isset(self::$storages[static::class])) {
+			self::$storages[static::class] = new EnumStorage(
+				static::class,
+				fn(string $value) => new static($value),
+				new EnumMapping(static::getEnums())
+			);
+		}
+
+		return self::$storages[static::class];
+	}
+
 	public function __toString(): string
 	{
 		return $this->value;

src/EnumAbstract.php

@@ -5,38 +5,22 @@
 final class EnumMapping
 {
 
-	/** @var string[] */
+	/** @var bool[] */
 	private array $mapping = [];
 
-	private string $class;
-
 	/**
-	 * @param bool[] $mapping
+	 * @param string[] $mapping
 	 */
-	public function __construct(string $class, array $mapping)
+	public function __construct(array $mapping)
 	{
-		$this->class = $class;
-		foreach ($mapping as $key => $bool) {
-			$this->mapping[strtoupper($key)] = $key;
+		foreach ($mapping as $key) {
+			$this->mapping[strtoupper($key)] = true;
 		}
 	}
 
-	public function getClass(): string
-	{
-		return $this->class;
-	}
-
-	public function callableGetter(): callable
-	{
-		return [$this->getClass(), 'get'];
-	}
-
-	/**
-	 * @return string[]
-	 */
-	public function getMapping(): array
+	public function has(string $key): bool
 	{
-		return $this->mapping;
+		return isset($this->mapping[$key]);
 	}
 
 }

src/EnumMapping.php

@@ -0,0 +1,15 @@
+<?php declare(strict_types = 1);
+
+namespace Utilitte\Enum\Exceptions;
+
+use Exception;
+
+class EnumNotExistsException extends Exception
+{
+
+	public function __construct(string $class, string $key)
+	{
+		parent::__construct(sprintf('Enum %s::%s not exists', $class, $key));
+	}
+
+}

src/Exceptions/EnumNotExistsException.php

@@ -0,0 +1,46 @@
+<?php declare(strict_types = 1);
+
+namespace Utilitte\Enum\Storage;
+
+use Utilitte\Enum\Enum;
+use Utilitte\Enum\Exceptions\EnumNotExistsException;
+
+final class EnumEntry
+{
+
+	private string $key;
+
+	private string $value;
+
+	private string $class;
+
+	private bool $isset;
+
+	/** @var callable */
+	private $factory;
+
+	private Enum $enum;
+
+	public function __construct(string $key, string $value, string $class, bool $isset, callable $factory)
+	{
+		$this->key = $key;
+		$this->value = $value;
+		$this->isset = $isset;
+		$this->factory = $factory;
+		$this->class = $class;
+	}
+
+	public function getEnum(): Enum
+	{
+		if (!$this->isset) {
+			throw new EnumNotExistsException($this->class, $this->key);
+		}
+
+		if (!isset($this->enum)) {
+			$this->enum = ($this->factory)($this->value);
+		}
+
+		return $this->enum;
+	}
+
+}

src/Storage/EnumEntry.php

@@ -3,6 +3,7 @@
 namespace Utilitte\Enum\Storage;
 
 use Utilitte\Enum\Enum;
+use Utilitte\Enum\EnumMapping;
 use Utilitte\Enum\Exceptions\InvalidArgumentException;
 use Utilitte\Enum\Exceptions\UnexpectedValueException;
 
@@ -12,11 +13,33 @@ class EnumStorage
 	/** @var Enum[] */
 	private array $storage = [];
 
+	/** @var EnumEntry[] */
+	private array $entries = [];
+
 	private string $class;
 
-	public function __construct(string $class)
+	/** @var callable */
+	private $factory;
+
+	private EnumMapping $mapping;
+
+	public function __construct(string $class, callable $factory, EnumMapping $mapping)
 	{
 		$this->class = $class;
+		$this->factory = $factory;
+		$this->mapping = $mapping;
+	}
+
+	public function getEntry(string $name): EnumEntry
+	{
+		$key = strtoupper($name);
+		$value = strtolower($name);
+
+		if (!isset($this->entries[$key])) {
+			$this->entries[$key] = new EnumEntry($key, $value, $this->class, $this->mapping->has($key), $this->factory);
+		}
+
+		return $this->entries[$key];
 	}
 
 	public function has(string $name): bool

src/Storage/EnumStorage.php

@@ -3,6 +3,7 @@
 namespace Tests;
 
 use Codeception\Test\Unit;
+use Utilitte\Enum\Exceptions\EnumNotExistsException;
 use Utilitte\Enum\Exceptions\InvalidArgumentException;
 use Utilitte\Tests\TestEnum;
 
@@ -12,9 +13,7 @@ class EnumTest extends Unit
 	public function testEnum()
 	{
 		$this->assertSame(TestEnum::GET_ENUM(), TestEnum::GET_ENUM());
-		$this->assertSame(TestEnum::get('get_enum'), TestEnum::GET_ENUM());
 		$this->assertEquals('get_enum', TestEnum::GET_ENUM()->value());
-		$this->assertEquals('get_enum', TestEnum::get('get_enum')->value());
 	}
 
 	public function testInvalidCase()
@@ -26,7 +25,7 @@ public function testInvalidCase()
 
 	public function testInvalidMethod()
 	{
-		$this->expectException(InvalidArgumentException::class);
+		$this->expectException(EnumNotExistsException::class);
 
 		TestEnum::GET_ENUMS();
 	}