fixes #47: Handle inherited enumerations as different onces

Author: marc-mabe

src/MabeEnum/Enum.php

@@ -32,14 +32,14 @@ abstract class Enum
     /**
      * An array of available constants by class
      *
-     * @var array ["$class" => ["$const" => $value, ...], ...]
+     * @var array ["$class" => ["$name" => $value, ...], ...]
      */
     private static $constants = array();
 
     /**
      * Already instantiated enumerators
      *
-     * @var array ["$class" => ["$const" => $instance, ...], ...]
+     * @var array ["$class" => ["$name" => $instance, ...], ...]
      */
     private static $instances = array();
 
@@ -139,41 +139,27 @@ final public function getOrdinal()
     }
 
     /**
-     * Compare this enumerator against another enumerator and check if it's the same
+     * Compare this enumerator against another and check if it's the same.
      *
      * @param mixed $enum
      * @return bool
      */
     final public function is($enum)
     {
-        return $this->value === $enum
-            || (($enum instanceof static || $this instanceof $enum) && $this->value === $enum->getValue());
+        return $this === $enum || $this->value === $enum;
     }
 
     /**
-     * Instantiate an enumerator of the given value or instance
-     *
-     * On passing an extended instance the instance will be returned if the value
-     * is inherited by the called class or if $tradeExtendedAsUnknown is disabled
-     * else an InvalidArgumentException will be thrown.
+     * Get an enumerator instance of the given value or instance
      *
      * @param static|null|bool|int|float|string $value
-     * @param bool                              $tradeExtendedAsUnknown
      * @return static
      * @throws InvalidArgumentException On an unknwon or invalid value
      * @throws LogicException           On ambiguous constant values
      */
     final public static function get($value, $tradeExtendedAsUnknown = true)
     {
-        if ($value instanceof static) {
-            if ($tradeExtendedAsUnknown && !defined('static::' . $value->getName())) {
-                throw new InvalidArgumentException(sprintf(
-                    "%s::%s is not inherited from %s",
-                    get_class($value),
-                    $value->getName(),
-                    get_called_class()
-                ));
-            }
+        if ($value instanceof static && get_class($value) === get_called_class()) {
             return $value;
         }
 
@@ -184,19 +170,22 @@ final public static function get($value, $tradeExtendedAsUnknown = true)
             if (is_scalar($value)) {
                 throw new InvalidArgumentException('Unknown value ' . var_export($value, true));
             } else {
-                throw new InvalidArgumentException('Invalid value of type ' . gettype($value));
+                throw new InvalidArgumentException(sprintf(
+                    'Invalid value of type %s',
+                    is_object($value) ? get_class($value) : gettype($value)
+                ));
             }
         }
 
-        if (isset(self::$instances[$class][$name])) {
-            return self::$instances[$class][$name];
+        if (!isset(self::$instances[$class][$name])) {
+            self::$instances[$class][$name] = new $class($constants[$name]);
         }
 
-        return self::$instances[$class][$name] = new $class($constants[$name]);
+        return self::$instances[$class][$name];
     }
 
     /**
-     * Instantiate an enumarator by the given name
+     * Get an enumarator instance by the given name
      *
      * @param string $name The name of the enumerator
      * @return static
@@ -220,7 +209,7 @@ final public static function getByName($name)
     }
 
     /**
-     * Instantiate an enumeration by the given ordinal number
+     * Get an enumeration instance by the given ordinal number
      *
      * @param int $ordinal The ordinal number or the enumerator
      * @return static
@@ -314,7 +303,7 @@ private static function detectConstants($class)
     }
 
     /**
-     * Instantiate an enumarator by the given name.
+     * Get an enumarator instance by the given name.
      *
      * This will be called automatically on calling a method
      * with the same name of a defined enumerator.

tests/MabeEnumTest/EnumTest.php

@@ -101,29 +101,6 @@ public function testGetByInstance()
     public function testGetByExtendedInstanceOfKnownValue()
     {
         $enum = EnumInheritance::get(EnumInheritance::ONE);
-        $this->assertSame($enum, EnumBasic::get($enum));
-    }
-
-    public function testGetByExtendedInstanceOfUnknownValueExplicitAllowed()
-    {
-        $enum = EnumInheritance::get(EnumInheritance::INHERITANCE);
-        $this->assertSame($enum, EnumBasic::get($enum, false));
-    }
-
-    public function testGetByExtendedInstanceOfUnknownValueThrowsInvalidArgumentException()
-    {
-        $enum = EnumInheritance::get(EnumInheritance::INHERITANCE);
-
-        $this->setExpectedException(
-            'InvalidArgumentException',
-            'MabeEnumTest\TestAsset\EnumInheritance::INHERITANCE is not inherited from MabeEnumTest\TestAsset\EnumBasic'
-        );
-        EnumBasic::get($enum, true);
-    }
-
-    public function testGetByInstanceOfDifferentBaseThrowsInvalidArgumentException()
-    {
-        $enum = EnumBasic2::get(EnumBasic2::ONE);
 
         $this->setExpectedException('InvalidArgumentException');
         EnumBasic::get($enum);
@@ -148,25 +125,9 @@ public function testIsBasic()
         $this->assertFalse($enum->is('1'));             // wrong value by strict comparison
 
         // by instance
-        $this->assertTrue($enum->is(EnumBasic::ONE()));       // same
-        $this->assertFalse($enum->is(EnumBasic::TWO()));      // not the same
-        $this->assertTrue($enum->is(EnumInheritance::ONE())); // same by extended instance
-        $this->assertFalse($enum->is(EnumBasic2::ONE()));     // same value but different instance
-    }
-
-    public function testIsExtended()
-    {
-        $enum1Basic     = EnumBasic::ONE();
-        $enum1Inherited = EnumInheritance::ONE();
-        $enumExtended   = EnumInheritance::INHERITANCE();
-
-        $this->assertTrue($enum1Basic->is($enum1Inherited));
-        $this->assertTrue($enum1Inherited->is($enum1Basic));
-
-        $this->assertFalse($enumExtended->is($enum1Basic));
-        $this->assertFalse($enumExtended->is($enum1Inherited));
-        $this->assertFalse($enum1Basic->is($enumExtended));
-        $this->assertFalse($enum1Inherited->is($enumExtended));
+        $this->assertTrue($enum->is(EnumBasic::ONE()));        // same
+        $this->assertFalse($enum->is(EnumBasic::TWO()));       // different enumerators
+        $this->assertFalse($enum->is(EnumInheritance::ONE())); // different enumeration type
     }
 
     public function testCallingGetOrdinalTwoTimesWillResultTheSameValue()