Skip to content

Commit

Permalink
Fix that #[Polyglot\Translatable] may be used on unmapped fields (#68)
Browse files Browse the repository at this point in the history
It may be useful to use the `#[Polyglot\Translatable]` attribute (or the
corresponding annotation) on properties that are not configured as
mapped Doctrine ORM fields. For example, the property value might be set
by entity lifecycle callbacks or Doctrine listeners.

It was possible to do so until #28 changed
`\Webfactory\Bundle\PolyglotBundle\Doctrine\TranslatableClassMetadata::findTranslatedProperties`
to work based on Doctrine ORM `ClassMetadata` information and fields.
This was done to simplify detection of whether a particular property
belongs to a given class or needs to be mapped through base class
translations. Obviously, `ClassMetadata` does not know about unmapped
properties.

This PR changes the code to work on PHP reflection data instead,
restoring functionality.
  • Loading branch information
mpdude authored Apr 25, 2024
1 parent edb88a6 commit 9c3420b
Show file tree
Hide file tree
Showing 2 changed files with 155 additions and 9 deletions.
23 changes: 14 additions & 9 deletions src/Doctrine/TranslatableClassMetadata.php
Original file line number Diff line number Diff line change
Expand Up @@ -187,16 +187,23 @@ private function findTranslatedProperties(ClassMetadataInfo $cm, Reader $reader,
return;
}

$reflectionService = $classMetadataFactory->getReflectionService();
$translationClassMetadata = $classMetadataFactory->getMetadataFor($this->translationClass->getName());

foreach ($cm->fieldMappings as $fieldName => $mapping) {
if (isset($mapping['declared'])) {
// The association is inherited from a parent class
/* Iterate all properties of the class, not only those mapped by Doctrine */
foreach ($cm->getReflectionClass()->getProperties() as $reflectionProperty) {
$propertyName = $reflectionProperty->name;

/*
If the property is inherited from a parent class, and our parent entity class
already contains that declaration, we need not include it.
*/
$declaringClass = $reflectionProperty->getDeclaringClass()->name;
if ($declaringClass !== $cm->name && $cm->parentClasses && is_a($cm->parentClasses[0], $declaringClass, true)) {
continue;
}

$foundAttributeOrAnnotation = null;
$reflectionProperty = $cm->getReflectionProperty($fieldName);
$attributes = $reflectionProperty->getAttributes(Attribute\Translatable::class);

if ($attributes) {
Expand All @@ -210,11 +217,9 @@ private function findTranslatedProperties(ClassMetadataInfo $cm, Reader $reader,
}

if ($foundAttributeOrAnnotation) {
$translationFieldname = $foundAttributeOrAnnotation->getTranslationFieldname() ?: $fieldName;
$translationFieldReflectionProperty = $translationClassMetadata->getReflectionProperty($translationFieldname);

$this->translatedProperties[$fieldName] = $reflectionProperty;
$this->translationFieldMapping[$fieldName] = $translationFieldReflectionProperty;
$this->translatedProperties[$propertyName] = $reflectionService->getAccessibleProperty($cm->name, $propertyName);
$translationFieldname = $foundAttributeOrAnnotation->getTranslationFieldname() ?: $propertyName;
$this->translationFieldMapping[$propertyName] = $reflectionService->getAccessibleProperty($translationClassMetadata->name, $translationFieldname);
}
}
}
Expand Down
141 changes: 141 additions & 0 deletions tests/Functional/TranslatingUnmappedPropertiesTest.php
Original file line number Diff line number Diff line change
@@ -0,0 +1,141 @@
<?php

namespace Webfactory\Bundle\PolyglotBundle\Tests\Functional;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
use Webfactory\Bundle\PolyglotBundle\Attribute as Polyglot;
use Webfactory\Bundle\PolyglotBundle\Translatable;

/**
* This test covers that also properties which are not mapped Doctrine fields
* can be marked as translatable and will be handled by the PolyglotListener.
*
* This is useful when these fields are managed or updated by e. g. lifecycle callbacks
* or other Doctrine event listeners.
*/
class TranslatingUnmappedPropertiesTest extends FunctionalTestBase
{
protected function setUp(): void
{
parent::setUp();
$this->setupOrmInfrastructure([
TranslatingUnmappedPropertiesTest_Entity::class,
TranslatingUnmappedPropertiesTest_Translation::class,
]);
}

public function testPersistAndReloadEntity(): void
{
$entity = new TranslatingUnmappedPropertiesTest_Entity();
$entity->text = new Translatable('base text');
$entity->text->setTranslation('Basistext', 'de_DE');

$this->infrastructure->import($entity);

$loaded = $this->infrastructure->getEntityManager()->find(TranslatingUnmappedPropertiesTest_Entity::class, $entity->id);

self::assertSame('Basistext', $loaded->text->translate('de_DE'));
self::assertSame('base text', $loaded->text->translate('en_GB'));
}
}

/**
* @ORM\Entity
*
* @ORM\HasLifecycleCallbacks
*/
#[Polyglot\Locale(primary: 'en_GB')]
class TranslatingUnmappedPropertiesTest_Entity
{
/**
* @ORM\Column(type="integer")
*
* @ORM\Id
*
* @ORM\GeneratedValue
*/
public ?int $id = null;

/**
* @ORM\OneToMany(targetEntity="TranslatingUnmappedPropertiesTest_Translation", mappedBy="entity")
*/
#[Polyglot\TranslationCollection]
protected Collection $translations;

/**
* @ORM\Column(type="string")
*/
public $mappedText;

// (!) This field is unmapped from the ORM point of view
#[Polyglot\Translatable]
public $text;

public function __construct()
{
$this->translations = new ArrayCollection();
$this->text = new Translatable();
}

/** @ORM\PreFlush() */
public function copyToMappedField(): void
{
$this->mappedText = $this->text;
}

/** @ORM\PostLoad() */
public function copyFromMappedField(): void
{
$this->text = $this->mappedText;
}
}

/**
* @ORM\Entity
*
* @ORM\HasLifecycleCallbacks
*/
class TranslatingUnmappedPropertiesTest_Translation
{
/**
* @ORM\Id
*
* @ORM\GeneratedValue
*
* @ORM\Column(type="integer")
*/
private ?int $id = null;

/**
* @ORM\Column
*/
#[Polyglot\Locale]
private string $locale;

/**
* @ORM\ManyToOne(targetEntity="TranslatingUnmappedPropertiesTest_Entity", inversedBy="translations")
*/
private TranslatingUnmappedPropertiesTest_Entity $entity;

/**
* @ORM\Column
*/
private $mappedText;

// (!) This field is unmapped from the ORM point of view
private $text;

/** @ORM\PreFlush() */
public function copyToMappedField(): void
{
$this->mappedText = $this->text;
}

/** @ORM\PostLoad() */
public function copyFromMappedField(): void
{
$this->text = $this->mappedText;
}
}

0 comments on commit 9c3420b

Please sign in to comment.