AbstractEnum 0.3

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.2
+ * @version 0.3
  * @license https://github.com/petrknap/php-enum/blob/master/LICENSE MIT
  */
 abstract class AbstractEnum
@@ -21,36 +21,38 @@ abstract class AbstractEnum
     /**
      * @var mixed[][]
      */
-    private static $constants = [];
+    private static $members = [];
 
     /**
-     * @var mixed
+     * @var string
      */
-    private $constantName;
+    private $memberName;
 
     /**
      * @var mixed
      */
-    private $constantValue;
+    private $memberValue;
 
     /**
-     * @param mixed $constantName
+     * @param string $memberName
      * @throws EnumException
      */
-    protected function __construct($constantName)
+    protected function __construct($memberName)
     {
-        $this->constantName = $constantName;
-        $this->constantValue = $this->get($constantName);
+        if(!($memberName === null && !$this->exists(null))) {
+            $this->memberName = $memberName;
+            $this->memberValue = $this->get($memberName);
+        }
     }
 
     /**
      * Creates magical factories for easier access to enum
      *
-     * @param mixed $constantName enum key
+     * @param string $memberName enum key
      * @param array $args ignored
      * @return mixed
      */
-    public static function __callStatic($constantName, array $args)
+    public static function __callStatic($memberName, array $args)
     {
         $className = get_called_class();
 
@@ -60,10 +62,10 @@ public static function __callStatic($constantName, array $args)
             $instances = [];
         }
 
-        $instance = &$instances[$constantName];
+        $instance = &$instances[$memberName];
 
         if (!($instance instanceof $className)) {
-            $instance = new $className($constantName);
+            $instance = new $className($memberName);
         }
 
         return $instance;
@@ -74,60 +76,68 @@ public static function __callStatic($constantName, array $args)
      */
     public function getName()
     {
-        return $this->constantName;
+        return $this->memberName;
     }
 
     /**
      * @return mixed
      */
     public function getValue()
     {
-        return $this->constantValue;
+        return $this->memberValue;
     }
 
     /**
-     * @param mixed[] $constants
+     * @param mixed[] $members
      */
-    protected static function setConstants(array $constants)
+    protected static function setMembers(array $members)
     {
-        self::$constants[get_called_class()] = $constants;
+        self::$members[get_called_class()] = $members;
     }
 
     /**
      * @return mixed[]
      */
-    public static function getConstants()
+    public static function getMembers()
     {
-        return self::$constants[get_called_class()];
+        $className = get_called_class();
+
+        $members = &self::$members[$className];
+
+        if(empty($members)) {
+            new $className(null);
+        }
+
+        return $members;
     }
 
     /**
-     * @param string $constantName
+     * @param string $memberName
      * @return bool
      */
-    private function exists($constantName)
+    private function exists($memberName)
     {
-        return array_key_exists($constantName, self::$constants[get_called_class()]);
+        return array_key_exists($memberName, self::$members[get_called_class()]);
     }
 
     /**
-     * @param string $constantName
+     * @param string $memberName
      * @return mixed
      * @throws EnumException
      */
-    private function get($constantName)
+    private function get($memberName)
     {
-        if (!$this->exists($constantName)) {
+        if (!$this->exists($memberName)) {
             throw new EnumException(
                 sprintf(
                     "%s does not exist in %s",
-                    $constantName,
+                    $memberName,
                     get_called_class()
                 ),
                 EnumException::OUT_OF_RANGE
             );
         }
 
-        return self::$constants[get_called_class()][$constantName];
+        return self::$members[get_called_class()][$memberName];
     }
 }

tests/Enum/EnumTest.php

@@ -18,11 +18,13 @@ public function wrongKeyProvider()
     }
 
     /**
+     * @covers       EnumMock::__callStatic
      * @dataProvider goodKeyProvider
+     *
      * @param string $name
      * @param mixed $value
      */
-    public function testEnumMagicConstruction_GoodKey($name, $value)
+    public function testMagicConstruction_GoodKey($name, $value)
     {
         /** @var EnumMock $enum */
         $enum = EnumMock::$name();
@@ -33,10 +35,12 @@ public function testEnumMagicConstruction_GoodKey($name, $value)
     }
 
     /**
+     * @covers       EnumMock::__callStatic
      * @dataProvider wrongKeyProvider
+     *
      * @param string $name
      */
-    public function testEnumMagicConstruction_WrongKey($name)
+    public function testMagicConstruction_WrongKey($name)
     {
         $this->setExpectedException(
             get_class(new EnumException()),
@@ -48,16 +52,30 @@ public function testEnumMagicConstruction_WrongKey($name)
     }
 
     /**
-     * @dataProvider goodKeyProvider
-     * @param string $name
-     * @param mixed $value
+     * @covers EnumMock::__callStatic
+     */
+    public function testComparable()
+    {
+        $this->assertSame(EnumMock::A(), EnumMock::A());
+        $this->assertNotSame(EnumMock::A(), EnumMock::B());
+
+        $this->assertTrue(EnumMock::A() == EnumMock::A());
+        $this->assertFalse(EnumMock::A() == EnumMock::B());
+    }
+
+    /**
+     * @covers EnumMock::getMembers
+     * @runInSeparateProcess
      */
-    public function testGetConstants($name, $value)
+    public function testGetMembers()
     {
-        $constants = EnumMock::getConstants();
+        $members = EnumMock::getMembers();
 
-        $this->assertInternalType("array", $constants);
-        $this->assertArrayHasKey($name, $constants);
-        $this->assertEquals($value, $constants[$name]);
+        $this->assertInternalType("array", $members);
+        $this->assertCount(2, $members);
+        $this->assertArrayHasKey("A", $members);
+        $this->assertEquals("a", $members["A"]);
+        $this->assertArrayHasKey("B", $members);
+        $this->assertEquals("b", $members["B"]);
     }
 }

tests/Enum/EnumTest/EnumMock.php

@@ -10,14 +10,14 @@
  */
 class EnumMock extends AbstractEnum
 {
-    protected function __construct($key)
+    protected function __construct($memberName)
     {
-        self::setConstants([
+        self::setMembers([
             "A" => "a",
             "B" => "b"
         ]);
 
-        parent::__construct($key);
+        parent::__construct($memberName);
     }
 
     /**