AbstractEnum 0.2

Author: Petr Knap

src/Enum/AbstractEnum.php

@@ -8,7 +8,7 @@
  * @author  Petr Knap <dev@petrknap.cz>
  * @since   2016-01-23
  * @package PetrKnap\Php\Enum
- * @version 0.1
+ * @version 0.2
  * @license https://github.com/petrknap/php-enum/blob/master/LICENSE MIT
  */
 abstract class AbstractEnum
@@ -19,38 +19,38 @@ abstract class AbstractEnum
     private static $instances;
 
     /**
-     * @var mixed[]
+     * @var mixed[][]
      */
-    private $items = [];
+    private static $constants = [];
 
     /**
      * @var mixed
      */
-    private $key;
+    private $constantName;
 
     /**
      * @var mixed
      */
-    private $value;
+    private $constantValue;
 
     /**
-     * @param mixed $key
+     * @param mixed $constantName
      * @throws EnumException
      */
-    public function __construct($key)
+    protected function __construct($constantName)
     {
-        $this->key = $key;
-        $this->value = $this->get($key);
+        $this->constantName = $constantName;
+        $this->constantValue = $this->get($constantName);
     }
 
     /**
      * Creates magical factories for easier access to enum
      *
-     * @param mixed $key enum key
+     * @param mixed $constantName enum key
      * @param array $args ignored
      * @return mixed
      */
-    public static function __callStatic($key, array $args)
+    public static function __callStatic($constantName, array $args)
     {
         $className = get_called_class();
 
@@ -60,66 +60,74 @@ public static function __callStatic($key, array $args)
             $instances = [];
         }
 
-        $instance = &$instances[$key];
+        $instance = &$instances[$constantName];
 
         if (!($instance instanceof $className)) {
-            $instance = new $className($key);
+            $instance = new $className($constantName);
         }
 
         return $instance;
     }
 
     /**
-     * @return mixed
+     * @return string
      */
-    public function getKey()
+    public function getName()
     {
-        return $this->key;
+        return $this->constantName;
     }
 
     /**
      * @return mixed
      */
     public function getValue()
     {
-        return $this->value;
+        return $this->constantValue;
+    }
+
+    /**
+     * @param mixed[] $constants
+     */
+    protected static function setConstants(array $constants)
+    {
+        self::$constants[get_called_class()] = $constants;
     }
 
     /**
-     * @param mixed[] $items
+     * @return mixed[]
      */
-    protected function setItems(array $items)
+    public static function getConstants()
     {
-        $this->items = $items;
+        return self::$constants[get_called_class()];
     }
 
     /**
-     * @param mixed $key
+     * @param string $constantName
      * @return bool
      */
-    private function exists($key)
+    private function exists($constantName)
     {
-        return array_key_exists($key, $this->items);
+        return array_key_exists($constantName, self::$constants[get_called_class()]);
     }
 
     /**
-     * @param mixed $key
+     * @param string $constantName
      * @return mixed
      * @throws EnumException
      */
-    private function get($key)
+    private function get($constantName)
     {
-        if (!$this->exists($key)) {
+        if (!$this->exists($constantName)) {
             throw new EnumException(
                 sprintf(
-                    "%s does not exists in %s",
-                    $key,
+                    "%s does not exist in %s",
+                    $constantName,
                     get_called_class()
                 ),
                 EnumException::OUT_OF_RANGE
             );
         }
 
-        return $this->items[$key];
+        return self::$constants[get_called_class()][$constantName];
     }
 }

tests/Enum/EnumTest.php

@@ -19,60 +19,45 @@ public function wrongKeyProvider()
 
     /**
      * @dataProvider goodKeyProvider
-     * @param string $key
-     * @param string $value
+     * @param string $name
+     * @param mixed $value
      */
-    public function testEnumDirectConstruction_GoodKey($key, $value)
+    public function testEnumMagicConstruction_GoodKey($name, $value)
     {
-        $enum = new EnumMock($key);
+        /** @var EnumMock $enum */
+        $enum = EnumMock::$name();
 
         $this->assertInstanceOf(EnumMock::getClass(), $enum);
-        $this->assertSame($key, $enum->getKey());
+        $this->assertSame($name, $enum->getName());
         $this->assertSame($value, $enum->getValue());
     }
 
     /**
      * @dataProvider wrongKeyProvider
-     * @param string $key
+     * @param string $name
      */
-    public function testEnumDirectConstruction_WrongKey($key)
+    public function testEnumMagicConstruction_WrongKey($name)
     {
         $this->setExpectedException(
             get_class(new EnumException()),
             "",
             EnumException::OUT_OF_RANGE
         );
 
-        new EnumMock($key);
+        EnumMock::$name();
     }
 
     /**
      * @dataProvider goodKeyProvider
-     * @param string $key
-     * @param string $value
-     */
-    public function testEnumMagicConstruction_GoodKey($key, $value)
-    {
-        /** @var EnumMock $enum */
-        $enum = EnumMock::$key();
-
-        $this->assertInstanceOf(EnumMock::getClass(), $enum);
-        $this->assertSame($key, $enum->getKey());
-        $this->assertSame($value, $enum->getValue());
-    }
-
-    /**
-     * @dataProvider wrongKeyProvider
-     * @param string $key
+     * @param string $name
+     * @param mixed $value
      */
-    public function testEnumMagicConstruction_WrongKey($key)
+    public function testGetConstants($name, $value)
     {
-        $this->setExpectedException(
-            get_class(new EnumException()),
-            "",
-            EnumException::OUT_OF_RANGE
-        );
+        $constants = EnumMock::getConstants();
 
-        EnumMock::$key();
+        $this->assertInternalType("array", $constants);
+        $this->assertArrayHasKey($name, $constants);
+        $this->assertEquals($value, $constants[$name]);
     }
 }

tests/Enum/EnumTest/EnumMock.php

@@ -10,9 +10,9 @@
  */
 class EnumMock extends AbstractEnum
 {
-    public function __construct($key)
+    protected function __construct($key)
     {
-        $this->setItems([
+        self::setConstants([
             "A" => "a",
             "B" => "b"
         ]);