Items renamed to constants and key renamed to constantName

Author: Petr Knap

src/Enum/AbstractEnum.php

@@ -21,36 +21,36 @@ abstract class AbstractEnum
     /**
      * @var mixed[][]
      */
-    private static $items = [];
+    private static $constants = [];
 
     /**
      * @var mixed
      */
-    private $key;
+    private $constantName;
 
     /**
      * @var mixed
      */
-    private $value;
+    private $constantValue;
 
     /**
-     * @param mixed $key
+     * @param mixed $constantName
      * @throws EnumException
      */
-    protected 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,66 @@ 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[] $items
+     * @param mixed[] $constants
      */
-    protected static function setItems(array $items)
+    protected static function setConstants(array $constants)
     {
-        self::$items[get_called_class()] = $items;
+        self::$constants[get_called_class()] = $constants;
     }
 
     /**
-     * @param mixed $key
+     * @param string $constantName
      * @return bool
      */
-    private function exists($key)
+    private function exists($constantName)
     {
-        return array_key_exists($key, self::$items[get_called_class()]);
+        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,
+                    $constantName,
                     get_called_class()
                 ),
                 EnumException::OUT_OF_RANGE
             );
         }
 
-        return self::$items[get_called_class()][$key];
+        return self::$constants[get_called_class()][$constantName];
     }
 }

tests/Enum/EnumTest.php

@@ -19,31 +19,31 @@ public function wrongKeyProvider()
 
     /**
      * @dataProvider goodKeyProvider
-     * @param string $key
-     * @param string $value
+     * @param string $name
+     * @param mixed $value
      */
-    public function testEnumMagicConstruction_GoodKey($key, $value)
+    public function testEnumMagicConstruction_GoodKey($name, $value)
     {
         /** @var EnumMock $enum */
-        $enum = EnumMock::$key();
+        $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 testEnumMagicConstruction_WrongKey($key)
+    public function testEnumMagicConstruction_WrongKey($name)
     {
         $this->setExpectedException(
             get_class(new EnumException()),
             "",
             EnumException::OUT_OF_RANGE
         );
 
-        EnumMock::$key();
+        EnumMock::$name();
     }
 }

tests/Enum/EnumTest/EnumMock.php

@@ -12,7 +12,7 @@ class EnumMock extends AbstractEnum
 {
     protected function __construct($key)
     {
-        self::setItems([
+        self::setConstants([
             "A" => "a",
             "B" => "b"
         ]);