Add Symfony 5 support

.gitignore

@@ -1,4 +1,5 @@
 /vendor/
+.phpunit.result.cache
 composer.lock
 composer.phar
 phpunit.xml

.travis.yml

@@ -8,15 +8,14 @@ cache:
 matrix:
   fast_finish: true
   include:
-    - php: 5.6
+    - php: 7.2
       env:
         - DEPENDENCIES="--prefer-lowest --prefer-stable"
-    - php: 7.0
-    - php: 7.1
-    - php: 7.2
     - php: 7.3
+    - php: 7.4
       env:
         - TEST_COVERAGE=true
+    - php: 8.0
 
 before_script:
   - phpenv config-rm xdebug.ini || true

DependencyInjection/Configuration.php

@@ -19,14 +19,7 @@ public function getConfigTreeBuilder()
     {
         $treeBuilder = new TreeBuilder('biplane_enum');
 
-        if (method_exists($treeBuilder, 'getRootNode')) {
-            $rootNode = $treeBuilder->getRootNode();
-        } else {
-            // BC layer for symfony/config 4.1 and older
-            $rootNode = $treeBuilder->root('doctrine_migrations');
-        }
-
-        $rootNode
+        $treeBuilder->getRootNode()
             ->children()
                 ->arrayNode('serializer')
                     ->addDefaultsIfNotSet()

Form/Type/EnumType.php

@@ -98,7 +98,6 @@ public function configureOptions(OptionsResolver $resolver)
                 array(
                     'enum_class' => $enumClass,
                     'choices' => $choices,
-                    'choices_as_values' => true,
                     'choice_value' => function ($choice) {
                         return $choice;
                     },

Serializer/Handler/EnumHandler.php

@@ -24,13 +24,7 @@ class EnumHandler
      */
     public function serializeEnumToJson(JsonSerializationVisitor $visitor, EnumInterface $data, array $type)
     {
-        $value = $data->getValue();
-
-        if ($visitor->getRoot() === null) {
-            $visitor->setRoot($value);
-        }
-
-        return $value;
+        return $data->getValue();
     }
 
     /**
@@ -44,13 +38,16 @@ public function serializeEnumToJson(JsonSerializationVisitor $visitor, EnumInter
      */
     public function serializeEnumToXml(XmlSerializationVisitor $visitor, EnumInterface $data, array $type)
     {
-        if ($visitor->document === null) {
-            $visitor->document = $visitor->createDocument(null, null, true);
-            $visitor->getCurrentNode()->appendChild($node = $visitor->document->createCDATASection($data->getValue()));
+        $valueNode = $visitor->getDocument()->createCDATASection($data->getValue());
+
+        $currentNode = $visitor->getCurrentNode();
 
-            return $node;
+        if ($currentNode !== null) {
+            $currentNode->appendChild($valueNode);
+        } else {
+            $visitor->setCurrentNode($valueNode);
         }
 
-        return $visitor->document->createCDATASection($data->getValue());
+        return $valueNode;
     }
 }

Serializer/Normalizer/EnumNormalizer.php

@@ -17,55 +17,31 @@ class EnumNormalizer implements NormalizerInterface, DenormalizerInterface
     use SerializerAwareTrait;
 
     /**
-     * Normalizes an object into a set of arrays/scalars
-     *
-     * @param object $object object to normalize
-     * @param string $format format the normalization result will be encoded as
-     * @param array $context Context options for the normalizer
-     *
-     * @return array|string|bool|int|float|null
+     * {@inheritDoc}
      */
     public function normalize($object, $format = null, array $context = array())
     {
         return $object->getValue();
     }
 
     /**
-     * Denormalizes data back into an object of the given class
-     *
-     * @param mixed  $data   data to restore
-     * @param string $class  the expected class to instantiate
-     * @param string $format format the given data was extracted from
-     * @param array  $context options available to the denormalizer
-     *
-     * @return object
+     * {@inheritDoc}
      */
     public function denormalize($data, $class, $format = null, array $context = array())
     {
         return call_user_func(array($class, 'create'), $data);
     }
 
     /**
-     * Checks whether the given class is supported for normalization by this normalizer
-     *
-     * @param mixed  $data   Data to normalize.
-     * @param string $format The format being (de-)serialized from or into.
-     *
-     * @return Boolean
+     * {@inheritDoc}
      */
     public function supportsNormalization($data, $format = null)
     {
         return $data instanceof EnumInterface;
     }
 
     /**
-     * Checks whether the given class is supported for denormalization by this normalizer
-     *
-     * @param mixed  $data   Data to denormalize from.
-     * @param string $type   The class to which the data should be denormalized.
-     * @param string $format The format being deserialized from.
-     *
-     * @return Boolean
+     * {@inheritDoc}
      */
     public function supportsDenormalization($data, $type, $format = null)
     {

Tests/DependencyInjection/BiplaneEnumExtensionTest.php

@@ -5,12 +5,13 @@
 use Biplane\EnumBundle\DependencyInjection\BiplaneEnumExtension;
 use Biplane\EnumBundle\Tests\Fixtures\FlagsEnum;
 use Biplane\EnumBundle\Tests\Fixtures\SimpleEnum;
+use PHPUnit\Framework\TestCase;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 
 /**
  * @author Denis Vasilev <yethee@biplane.ru>
  */
-class BiplaneEnumExtensionTest extends \PHPUnit_Framework_TestCase
+class BiplaneEnumExtensionTest extends TestCase
 {
     /**
      * @var ContainerBuilder
@@ -22,14 +23,14 @@ class BiplaneEnumExtensionTest extends \PHPUnit_Framework_TestCase
      */
     private $extension;
 
-    public function testLoadWithDefaults()
+    public function testLoadWithDefaults(): void
     {
         $this->extension->load(array(), $this->container);
 
-        $this->assertFalse($this->container->hasDefinition('biplane_enum.jms_serializer.enum_handler'));
+        self::assertFalse($this->container->hasDefinition('biplane_enum.jms_serializer.enum_handler'));
     }
 
-    public function testLoadSerializationTypes()
+    public function testLoadSerializationTypes(): void
     {
         $config = array(
             'serializer' => array(
@@ -42,30 +43,30 @@ public function testLoadSerializationTypes()
 
         $this->extension->load(array('biplane_enum' => $config), $this->container);
 
-        $this->assertTrue($this->container->hasDefinition('biplane_enum.jms_serializer.enum_handler'));
+        self::assertTrue($this->container->hasDefinition('biplane_enum.jms_serializer.enum_handler'));
 
         $tagAttributes = $this->container->getDefinition('biplane_enum.jms_serializer.enum_handler')
             ->getTag('jms_serializer.handler');
 
-        $this->assertCount(4, $tagAttributes);
-        $this->assertTagAttributes($tagAttributes[0], SimpleEnum::class, 'json');
-        $this->assertTagAttributes($tagAttributes[1], SimpleEnum::class, 'xml');
-        $this->assertTagAttributes($tagAttributes[2], FlagsEnum::class, 'json');
-        $this->assertTagAttributes($tagAttributes[3], FlagsEnum::class, 'xml');
+        self::assertCount(4, $tagAttributes);
+        self::assertTagAttributes($tagAttributes[0], SimpleEnum::class, 'json');
+        self::assertTagAttributes($tagAttributes[1], SimpleEnum::class, 'xml');
+        self::assertTagAttributes($tagAttributes[2], FlagsEnum::class, 'json');
+        self::assertTagAttributes($tagAttributes[3], FlagsEnum::class, 'xml');
     }
 
-    protected function setUp()
+    protected function setUp(): void
     {
         $this->container = new ContainerBuilder();
         $this->extension = new BiplaneEnumExtension();
     }
 
-    protected function tearDown()
+    protected function tearDown(): void
     {
         unset($this->container, $this->extension);
     }
 
-    private function assertTagAttributes(array $attributes, $type, $format)
+    private static function assertTagAttributes(array $attributes, $type, $format): void
     {
         $expected = array(
             'direction' => 'serialization',
@@ -74,6 +75,6 @@ private function assertTagAttributes(array $attributes, $type, $format)
             'method'    => 'serializeEnumTo' . ucfirst($format),
         );
 
-        $this->assertEquals($expected, $attributes);
+        self::assertEquals($expected, $attributes);
     }
-}
+}

Tests/Enumeration/EnumTest.php

@@ -3,81 +3,80 @@
 namespace Biplane\EnumBundle\Tests\Enumeration;
 
 use Biplane\EnumBundle\Enumeration\Enum;
+use Biplane\EnumBundle\Exception\InvalidEnumArgumentException;
 use Biplane\EnumBundle\Tests\Fixtures\SimpleEnum;
 use Biplane\EnumBundle\Tests\Fixtures\ExtendedSimpleEnum;
+use PHPUnit\Framework\TestCase;
 
 /**
  * @author Denis Vasilev <yethee@biplane.ru>
  */
-class EnumTest extends \PHPUnit_Framework_TestCase
+class EnumTest extends TestCase
 {
     /**
      * @dataProvider enumValuesProvider
      */
-    public function testCreateEnumValue($value, $readableValue)
+    public function testCreateEnumValue($value, $readableValue): void
     {
         $enumValue = SimpleEnum::create($value);
 
-        $this->assertEquals($value, $enumValue->getValue());
-        $this->assertEquals($readableValue, $enumValue->getReadable());
+        self::assertEquals($value, $enumValue->getValue());
+        self::assertEquals($readableValue, $enumValue->getReadable());
     }
 
-    public function testEnumToString()
+    public function testEnumToString(): void
     {
         $enumValue = SimpleEnum::create(SimpleEnum::FIRST);
 
-        $this->assertEquals('First', (string)$enumValue);
+        self::assertEquals('First', (string)$enumValue);
     }
 
-    /**
-     * @expectedException \Biplane\EnumBundle\Exception\InvalidEnumArgumentException
-     */
-    public function testExceptionIsRaisedWhenValueIsNotAcceptable()
+    public function testExceptionIsRaisedWhenValueIsNotAcceptable(): void
     {
+        $this->expectException(InvalidEnumArgumentException::class);
+
         SimpleEnum::create(3);
     }
 
-    /**
-     * @expectedException \Biplane\EnumBundle\Exception\InvalidEnumArgumentException
-     */
-    public function testExceptionIsRaisedWhenValueIsNotAcceptableWithStrictCheck()
+    public function testExceptionIsRaisedWhenValueIsNotAcceptableWithStrictCheck(): void
     {
+        $this->expectException(InvalidEnumArgumentException::class);
+
         SimpleEnum::create('0');
     }
 
-    public function testValueCanBeReadabled()
+    public function testValueCanBeReadabled(): void
     {
-        $this->assertEquals('Second', SimpleEnum::getReadableFor(2));
+        self::assertEquals('Second', SimpleEnum::getReadableFor(2));
     }
 
-    /**
-     * @expectedException \Biplane\EnumBundle\Exception\InvalidEnumArgumentException
-     */
-    public function testExceptionIsRaisedWhenValueCannotBeReadable()
+    public function testExceptionIsRaisedWhenValueCannotBeReadable(): void
     {
+        $this->expectException(InvalidEnumArgumentException::class);
+
         SimpleEnum::getReadableFor(3);
     }
 
-    public function testEnumsForEqualsWithSameClass()
+    public function testEnumsForEqualsWithSameClass(): void
     {
         $enum = SimpleEnum::create(SimpleEnum::FIRST);
 
-        $this->assertTrue($enum->equals(SimpleEnum::create(SimpleEnum::FIRST)));
-        $this->assertFalse($enum->equals(SimpleEnum::create(SimpleEnum::SECOND)));
+        self::assertTrue($enum->equals(SimpleEnum::create(SimpleEnum::FIRST)));
+        self::assertFalse($enum->equals(SimpleEnum::create(SimpleEnum::SECOND)));
     }
 
-    public function testEnumsForEqualsWithExtendedClasses()
+    public function testEnumsForEqualsWithExtendedClasses(): void
     {
         $enum = SimpleEnum::create(SimpleEnum::FIRST);
 
-        $this->assertFalse($enum->equals(ExtendedSimpleEnum::create(ExtendedSimpleEnum::FIRST)));
+        self::assertFalse($enum->equals(ExtendedSimpleEnum::create(ExtendedSimpleEnum::FIRST)));
     }
 
-    public function enumValuesProvider()
+    public function enumValuesProvider(): array
     {
         return array(
             array(1, 'First'),
             array(SimpleEnum::SECOND, 'Second')
         );
     }
-}
+}