/**
* @test
* @dataProvider convertCallsCanConvertFromWithTheFullNormalizedTargetTypeDataProvider
*/
public function convertCallsCanConvertFromWithTheFullNormalizedTargetType($source, $fullTargetType)
{
$mockTypeConverter = $this->getMockTypeConverter();
$mockTypeConverter->expects($this->atLeastOnce())->method('canConvertFrom')->with($source, $fullTargetType);
$truncatedTargetType = TypeHandling::truncateElementType($fullTargetType);
$mockTypeConverters = [gettype($source) => [$truncatedTargetType => [1 => $mockTypeConverter]]];
$propertyMapper = $this->getAccessibleMock(PropertyMapper::class, ['dummy']);
$propertyMapper->_set('typeConverters', $mockTypeConverters);
$mockConfiguration = $this->getMockBuilder(PropertyMappingConfiguration::class)->disableOriginalConstructor()->getMock();
$propertyMapper->convert($source, $fullTargetType, $mockConfiguration);
// dummy assertion to avoid PHPUnit warning
$this->assertTrue(true);
}
/**
* @test
* @dataProvider compositeTypes
*/
public function extractCollectionTypeReturnsOnlyTheMainType($type, $expectedResult)
{
$this->assertEquals($expectedResult, TypeHandling::truncateElementType($type), 'Failed for ' . $type);
}
/**
* Tries to find a suitable type converter for the given source and target type.
*
* @param string $source The actual source value
* @param string $sourceType Type of the source to convert from
* @param string $targetType Name of the target type to find a type converter for
* @return mixed Either the matching object converter or NULL
* @throws Exception\InvalidTargetException
*/
protected function findFirstEligibleTypeConverterInObjectHierarchy($source, $sourceType, $targetType)
{
$targetClass = TypeHandling::truncateElementType($targetType);
if (!class_exists($targetClass) && !interface_exists($targetClass)) {
throw new Exception\InvalidTargetException(sprintf('Could not find a suitable type converter for "%s" because no such the class/interface "%s" does not exist.', $targetType, $targetClass), 1297948764);
}
if (!isset($this->typeConverters[$sourceType])) {
return null;
}
$convertersForSource = $this->typeConverters[$sourceType];
if (isset($convertersForSource[$targetClass])) {
$converter = $this->findEligibleConverterWithHighestPriority($convertersForSource[$targetClass], $source, $targetType);
if ($converter !== null) {
return $converter;
}
}
foreach (class_parents($targetClass) as $parentClass) {
if (!isset($convertersForSource[$parentClass])) {
continue;
}
$converter = $this->findEligibleConverterWithHighestPriority($convertersForSource[$parentClass], $source, $targetType);
if ($converter !== null) {
return $converter;
}
}
$converters = $this->getConvertersForInterfaces($convertersForSource, class_implements($targetClass));
$converter = $this->findEligibleConverterWithHighestPriority($converters, $source, $targetType);
if ($converter !== null) {
return $converter;
}
if (isset($convertersForSource['object'])) {
return $this->findEligibleConverterWithHighestPriority($convertersForSource['object'], $source, $targetType);
} else {
return null;
}
}
/**
* @param mixed $propertyValue
* @param string $dataType
* @return mixed
* @throws PropertyException
*/
protected function convertValue($propertyValue, $dataType)
{
$rawType = TypeHandling::truncateElementType($dataType);
// This hardcoded handling is to circumvent rewriting PropertyMappers that convert objects. Usually they expect the source to be an object already and break if not.
if (!TypeHandling::isSimpleType($rawType) && !is_object($propertyValue) && !is_array($propertyValue)) {
return null;
}
if ($rawType === 'array') {
$conversionTargetType = 'array<string>';
} elseif (TypeHandling::isSimpleType($rawType)) {
$conversionTargetType = TypeHandling::normalizeType($rawType);
} else {
$conversionTargetType = 'array';
}
$propertyMappingConfiguration = $this->createConfiguration($dataType);
$convertedValue = $this->propertyMapper->convert($propertyValue, $conversionTargetType, $propertyMappingConfiguration);
if ($convertedValue instanceof \Neos\Error\Messages\Error) {
throw new PropertyException($convertedValue->getMessage(), $convertedValue->getCode());
}
return $convertedValue;
}
