├── .gitignore
├── ORM
    ├── NullableEmbeddable
    │   ├── ClosureNullator.php
    │   ├── EvaluatorInterface.php
    │   ├── NullatorInterface.php
    │   └── PropertyAccessor.php
    ├── NullableEmbeddableInterface.php
    ├── NullableEmbeddableListener.php
    └── NullableEmbeddableListenerFactory.php
├── README.md
├── Tests
    ├── EntityWithoutSetter.php
    ├── NullableEmbeddable.php
    └── NullableEmbeddable
    │   ├── ClosureNullatorTest.php
    │   └── NullableEmbeddableListenerTest.php
├── composer.json
└── phpunit.xml.dist


/.gitignore:
--------------------------------------------------------------------------------
1 | composer.lock
2 | /vendor/
3 | 


--------------------------------------------------------------------------------
/ORM/NullableEmbeddable/ClosureNullator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tarifhaus\Doctrine\ORM\NullableEmbeddable;
 6 | 
 7 | final class ClosureNullator implements NullatorInterface
 8 | {
 9 |     public function setNull(&$object, $property)
10 |     {
11 |         $nullator = \Closure::bind(function ($property) {
12 |             $this->{$property} = null;
13 |         }, $object, $object);
14 | 
15 |         $nullator($property);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/ORM/NullableEmbeddable/EvaluatorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tarifhaus\Doctrine\ORM\NullableEmbeddable;
 6 | 
 7 | interface EvaluatorInterface
 8 | {
 9 |     public function isNull($object, $property): bool;
10 | }
11 | 


--------------------------------------------------------------------------------
/ORM/NullableEmbeddable/NullatorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tarifhaus\Doctrine\ORM\NullableEmbeddable;
 6 | 
 7 | interface NullatorInterface
 8 | {
 9 |     public function setNull(&$object, $property);
10 | }
11 | 


--------------------------------------------------------------------------------
/ORM/NullableEmbeddable/PropertyAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tarifhaus\Doctrine\ORM\NullableEmbeddable;
 6 | 
 7 | use Symfony\Component\PropertyAccess\PropertyAccessor as DefaultPropertyAccessor;
 8 | use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
 9 | use Tarifhaus\Doctrine\ORM\NullableEmbeddableInterface;
10 | 
11 | final class PropertyAccessor implements EvaluatorInterface, NullatorInterface
12 | {
13 |     private $propertyAccessor;
14 | 
15 |     public function __construct(PropertyAccessorInterface $propertyAccessor)
16 |     {
17 |         $this->propertyAccessor = $propertyAccessor;
18 |     }
19 | 
20 |     public static function createWithDefault()
21 |     {
22 |         return new self(new DefaultPropertyAccessor());
23 |     }
24 | 
25 |     public function isNull($object, $property): bool
26 |     {
27 |         $embeddable = $this->propertyAccessor->getValue($object, $property);
28 |         if ($embeddable instanceof NullableEmbeddableInterface) {
29 |             return $embeddable->isNull();
30 |         }
31 | 
32 |         return false;
33 |     }
34 | 
35 |     public function setNull(&$object, $property)
36 |     {
37 |         $this->propertyAccessor->setValue($object, $property, null);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/ORM/NullableEmbeddableInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tarifhaus\Doctrine\ORM;
 6 | 
 7 | interface NullableEmbeddableInterface
 8 | {
 9 |     public function isNull(): bool;
10 | }
11 | 


--------------------------------------------------------------------------------
/ORM/NullableEmbeddableListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tarifhaus\Doctrine\ORM;
 6 | 
 7 | use Tarifhaus\Doctrine\ORM\NullableEmbeddable\NullatorInterface;
 8 | use Tarifhaus\Doctrine\ORM\NullableEmbeddable\EvaluatorInterface;
 9 | 
10 | /**
11 |  * @see https://github.com/doctrine/doctrine2/issues/4568
12 |  * @see https://github.com/doctrine/doctrine2/pull/1275
13 |  */
14 | final class NullableEmbeddableListener
15 | {
16 |     private $evaluator;
17 |     private $nullator;
18 | 
19 |     /**
20 |      * @var string[][]
21 |      */
22 |     private $propertyMap = [];
23 | 
24 |     public function __construct(EvaluatorInterface $evaluator, NullatorInterface $nullator)
25 |     {
26 |         $this->evaluator = $evaluator;
27 |         $this->nullator = $nullator;
28 |     }
29 | 
30 |     public function addMapping(string $entity, string $propertyPath)
31 |     {
32 |         if (empty($this->propertyMap[$entity])) {
33 |             $this->propertyMap[$entity] = [];
34 |         }
35 | 
36 |         $this->propertyMap[$entity][] = $propertyPath;
37 |     }
38 | 
39 |     public function postLoad($object)
40 |     {
41 |         $entity = get_class($object);
42 |         if (empty($this->propertyMap[$entity])) {
43 |             return;
44 |         }
45 | 
46 |         $entries = $this->propertyMap[$entity];
47 |         foreach ($entries as $property) {
48 |             if ($this->evaluator->isNull($object, $property)) {
49 |                 $this->nullator->setNull($object, $property);
50 |             }
51 |         }
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/ORM/NullableEmbeddableListenerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tarifhaus\Doctrine\ORM;
 6 | 
 7 | use Tarifhaus\Doctrine\ORM\NullableEmbeddable\ClosureNullator;
 8 | use Tarifhaus\Doctrine\ORM\NullableEmbeddable\PropertyAccessor;
 9 | 
10 | final class NullableEmbeddableListenerFactory
11 | {
12 |     public static function createWithPropertyAccessor(): NullableEmbeddableListener
13 |     {
14 |         $default = PropertyAccessor::createWithDefault();
15 | 
16 |         return new NullableEmbeddableListener($default, $default);
17 |     }
18 | 
19 |     public static function createWithClosureNullator(): NullableEmbeddableListener
20 |     {
21 |         $evaluator = PropertyAccessor::createWithDefault();
22 |         $nullator = new ClosureNullator();
23 | 
24 |         return new NullableEmbeddableListener($evaluator, $nullator);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Doctrine: nullable embeddable
 2 | 
 3 | This listener enables you to have truly `null` values for your [Doctrine embeddables](http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/tutorials/embeddables.html).
 4 | The listener hooks into the `postLoad` [lifecycle callback](http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/events.html#postload) and replaces embeddable values that are null.
 5 | 
 6 | It implements a workaround for this open issue:
 7 | 
 8 | * https://github.com/doctrine/doctrine2/issues/4568
 9 | * https://github.com/doctrine/doctrine2/pull/1275
10 | 
11 | The listener depends on an `evaluator` to check whether to instruct a `nullator` to actually replace the embeddable with `null`.
12 | This helper library ships with different implementations and respective interfaces to roll your own.
13 | 
14 | The default `evaluator` requires the `embeddable` class to implement the `Tarifhaus\Doctrine\ORM\NullableEmbeddableInterface`.
15 | It contains a method `isNull(): bool` which tells the evaluator, whether the loaded embeddable should be treated as and therefore replaced with `null`.
16 | 
17 | The `nullator` actually replaces the embeddable with `null` in a specific way.
18 | 
19 | ## Configuration
20 | 
21 | There are two things you have to do, in order to have this listener working correctly.
22 | 
23 | 1. An entry to the property map has to be made.
24 |    This is done by calling the `\Tarifhaus\Doctrine\ORM\NullableEmbeddableListener::addMapping`.
25 |    It receives the FQCN (fully qualified class name) of the entity and the name of the property the embeddable resides in.
26 | 
27 |    For example:
28 |    ```php
29 |    <?php
30 | 
31 |    use Tarifhaus\Doctrine\ORM\NullableEmbeddableListenerFactory;
32 | 
33 |    $listener = NullableEmbeddableListenerFactory::createWithClosureNullator();
34 |    $listener->addMapping('App\Domain\User\Model\UserProfile', 'address');
35 |    ```
36 | 
37 | 2. Now the listener needs to be registered with the Doctrine `EventManager`.
38 |    ```php
39 |    <?php
40 | 
41 |    use Doctrine\Common\EventManager;
42 |    use Doctrine\ORM\Events;
43 |    use Tarifhaus\Doctrine\ORM\NullableEmbeddableListenerFactory;
44 | 
45 |    $listener = NullableEmbeddableListenerFactory::createWithClosureNullator();
46 |    $listener->addMapping('App\Domain\User\Model\UserProfile', 'address');
47 | 
48 |    $evm = new EventManager();
49 |    $evm->addEventListener([Events::postLoad], $listener);
50 |    ```
51 | 
52 | **Tip:** It's highly recommended to use Doctrine [entity listener](http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/events.html#entity-listeners) when configuring the listener, so it is only executed for the entities it actually applies to.
53 | 
54 | ### Symfony
55 | 
56 | In case you are using Symfony with Doctrine, you can register the listener as a service.
57 | 
58 | ```yaml
59 | services:
60 |     tarifhaus.doctrine.nullable_embeddable.property_accessor:
61 |         public: false
62 |         class: Tarifhaus\Doctrine\ORM\NullableEmbeddable\PropertyAccessor
63 |         arguments:
64 |             - '@property_accessor'
65 | 
66 |     tarifhaus.doctrine.nullable_embeddable_closure_nullator:
67 |         public: false
68 |         class: Tarifhaus\Doctrine\ORM\NullableEmbeddable\ClosureNullator
69 | 
70 |     tarifhaus.doctrine.nullable_embeddable_listener:
71 |         public: false
72 |         class: Tarifhaus\Doctrine\ORM\NullableEmbeddableListener
73 |         arguments:
74 |             - '@tarifhaus.doctrine.nullable_embeddable.property_accessor'
75 |             - '@tarifhaus.doctrine.nullable_embeddable_closure_nullator'
76 |         calls:
77 |             - ['addMapping', ['App\Domain\User\Model\UserProfile', 'address']]
78 |         tags:
79 |             - { name: 'doctrine.orm.entity_listener', entity: '\App\Domain\User\Model\UserProfile', event: 'postLoad' }
80 | ```
81 | 


--------------------------------------------------------------------------------
/Tests/EntityWithoutSetter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tarifhaus\Doctrine\Tests;
 6 | 
 7 | use Tarifhaus\Doctrine\ORM\NullableEmbeddableInterface;
 8 | 
 9 | final class EntityWithoutSetter
10 | {
11 |     private $property;
12 | 
13 |     public function __construct(NullableEmbeddableInterface $embeddable)
14 |     {
15 |         $this->property = $embeddable;
16 |     }
17 | 
18 |     public function getProperty()
19 |     {
20 |         return $this->property;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/Tests/NullableEmbeddable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tarifhaus\Tests\Doctrine\ORM;
 6 | 
 7 | use Tarifhaus\Doctrine\ORM\NullableEmbeddableInterface;
 8 | 
 9 | final class NullableEmbeddable implements NullableEmbeddableInterface
10 | {
11 |     private $isNull;
12 | 
13 |     public function __construct(bool $isNull)
14 |     {
15 |         $this->isNull = $isNull;
16 |     }
17 | 
18 |     public function isNull(): bool
19 |     {
20 |         return $this->isNull;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/Tests/NullableEmbeddable/ClosureNullatorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tarifhaus\Doctrine\Tests\NullableEmbeddable;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tarifhaus\Doctrine\ORM\NullableEmbeddableListenerFactory;
 9 | use Tarifhaus\Doctrine\ORM\NullableEmbeddableListener;
10 | use Tarifhaus\Doctrine\Tests\EntityWithoutSetter;
11 | use Tarifhaus\Tests\Doctrine\ORM\NullableEmbeddable;
12 | 
13 | /**
14 |  * @covers \Tarifhaus\Doctrine\ORM\NullableEmbeddable\ClosureNullator
15 |  * @covers \Tarifhaus\Doctrine\ORM\NullableEmbeddableListenerFactory
16 |  */
17 | final class ClosureNullatorTest extends TestCase
18 | {
19 |     /**
20 |      * @var NullableEmbeddableListener
21 |      */
22 |     private $listener;
23 | 
24 |     protected function setUp()
25 |     {
26 |         $this->listener = NullableEmbeddableListenerFactory::createWithClosureNullator();
27 |     }
28 | 
29 |     public function test_it_nullates_without_using_setter()
30 |     {
31 |         $embeddable = new NullableEmbeddable(true);
32 |         $object = new EntityWithoutSetter($embeddable);
33 | 
34 |         $this->listener->addMapping(get_class($object), 'property');
35 |         $this->listener->postLoad($object);
36 | 
37 |         static::assertNull($object->getProperty());
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/Tests/NullableEmbeddable/NullableEmbeddableListenerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tarifhaus\Tests\Doctrine\ORM\NullableEmbeddable;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tarifhaus\Doctrine\ORM\NullableEmbeddableListenerFactory;
 9 | use Tarifhaus\Doctrine\ORM\NullableEmbeddableListener;
10 | use Tarifhaus\Tests\Doctrine\ORM\NullableEmbeddable;
11 | 
12 | /**
13 |  * @covers \Tarifhaus\Doctrine\ORM\NullableEmbeddable\PropertyAccessor
14 |  * @covers \Tarifhaus\Doctrine\ORM\NullableEmbeddableListener
15 |  * @covers \Tarifhaus\Doctrine\ORM\NullableEmbeddableListenerFactory
16 |  */
17 | final class NullableEmbeddableListenerTest extends TestCase
18 | {
19 |     /**
20 |      * @var NullableEmbeddableListener
21 |      */
22 |     private $listener;
23 | 
24 |     protected function setUp()
25 |     {
26 |         $this->listener = NullableEmbeddableListenerFactory::createWithPropertyAccessor();
27 |     }
28 | 
29 |     public function test_it_replaces_nullable_embeddable_with_null()
30 |     {
31 |         $embeddable = new NullableEmbeddable(true);
32 | 
33 |         $object = new \stdClass();
34 |         $object->property = $embeddable;
35 | 
36 |         $this->listener->addMapping(get_class($object), 'property');
37 |         $this->listener->postLoad($object);
38 | 
39 |         static::assertNull($object->property);
40 |     }
41 | 
42 |     public function test_it_does_not_replace_values()
43 |     {
44 |         $embeddable = new NullableEmbeddable(false);
45 | 
46 |         $object = new \stdClass();
47 |         $object->property = $embeddable;
48 | 
49 |         $this->listener->addMapping(get_class($object), 'property');
50 |         $this->listener->postLoad($object);
51 | 
52 |         static::assertSame($embeddable, $object->property);
53 |     }
54 | 
55 |     public function test_it_does_not_alter_unmapped_properties()
56 |     {
57 |         $embeddable = new \stdClass();
58 | 
59 |         $object = new \stdClass();
60 |         $object->property = $embeddable;
61 | 
62 |         $this->listener->postLoad($object);
63 | 
64 |         static::assertSame($embeddable, $object->property);
65 |     }
66 | 
67 |     public function test_it_does_not_alter_unsupported_values()
68 |     {
69 |         $embeddable = new \stdClass();
70 | 
71 |         $object = new \stdClass();
72 |         $object->property = $embeddable;
73 | 
74 |         $this->listener->addMapping(get_class($object), 'property');
75 |         $this->listener->postLoad($object);
76 | 
77 |         static::assertSame($embeddable, $object->property);
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "tarifhaus/doctrine-nullable-embeddable",
 3 |     "description": "A workaround implementation for nullable embeddables in Doctrine entities.",
 4 |     "license": "MIT",
 5 | 
 6 |     "autoload": {
 7 |         "psr-4": { "Tarifhaus\\Doctrine\\": "" },
 8 |         "exclude-from-classmap": [ "/Tests/" ]
 9 |     },
10 | 
11 |     "autoload-dev": {
12 |         "psr-4": { "Tarifhaus\\Tests\\Doctrine\\ORM\\": "Tests" }
13 |     },
14 | 
15 |     "minimum-stability": "stable",
16 |     "require": {
17 |         "php": "^7.0",
18 |         "symfony/property-access": "^3.2|^4.0"
19 |     },
20 |     "require-dev": {
21 |         "phpunit/phpunit": "^5.7"
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/phpunit.xml.dist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | 
 3 | <!-- https://phpunit.de/documentation.html -->
 4 | <phpunit
 5 |         backupGlobals               = "false"
 6 |         backupStaticAttributes      = "false"
 7 |         colors                      = "true"
 8 |         convertErrorsToExceptions   = "true"
 9 |         convertNoticesToExceptions  = "true"
10 |         convertWarningsToExceptions = "true"
11 |         processIsolation            = "false"
12 |         stopOnFailure               = "true"
13 |         stopOnError                 = "true"
14 |         syntaxCheck                 = "false"
15 |         forceCoversAnnotation       = "true"
16 |         bootstrap                   = "./vendor/autoload.php">
17 | 
18 |     <testsuites>
19 |         <testsuite>
20 |             <directory>./Tests</directory>
21 |         </testsuite>
22 |     </testsuites>
23 | 
24 |     <filter>
25 |         <whitelist>
26 |             <directory>.</directory>
27 |             <exclude>
28 |                 <directory>./Tests</directory>
29 |                 <directory suffix="Interface.php">./*</directory>
30 |             </exclude>
31 |         </whitelist>
32 |     </filter>
33 | </phpunit>
34 | 


--------------------------------------------------------------------------------