Add fromMethod operation

README.md

@@ -81,6 +81,11 @@ class Employee
  {
  return $this->id;
  }
+
+ public function getFullName()
+ {
+ return $this->firstName .' '. $this->lastName;
+ }
 
  // And so on...
 }
@@ -92,6 +97,7 @@ class EmployeeDto
  public $firstName;
  public $lastName;
  public $age;
+ public $fullName;
 }
 ```
 
@@ -219,6 +225,7 @@ The following operations are provided:
 | Ignore | Ignores the property. |
 | MapTo | Maps the property to another class. Allows for [nested mappings](#dealing-with-nested-mappings). Supports both single values and collections. |
 | FromProperty | Use this to explicitly state the source property name. |
+| FromMethod | Use this to map your value from a **public** method. This Operation does not support reverse mapping |
 | DefaultMappingOperation | Simply transfers the property, taking into account the provided naming conventions (if there are any). |
 | SetTo | Always sets the property to the given value |
 
@@ -243,7 +250,9 @@ $mapping->forMember('id', Operation::ignore());
 $mapping->forMember('employee', Operation::mapTo(EmployeeDto::class));
 // Explicitly state what the property name is of the source object.
 $mapping->forMember('name', Operation::fromProperty('unconventially_named_property'));
-// The `FromProperty` operation can be chained with `MapTo`, allowing a
+// Map property from given method name of the source object.
+$mapping->forMember('fullName', Operation::fromMethod('getFullName'));
+// The `FromProperty` and `FromMethod` operations can be chained with `MapTo`, allowing a
 // differently named property to be mapped to a class.
 $mapping->forMember(
  'address',

src/Configuration/Options.php

@@ -8,6 +8,7 @@
 use AutoMapperPlus\NameConverter\NamingConvention\NamingConventionInterface;
 use AutoMapperPlus\NameResolver\NameResolver;
 use AutoMapperPlus\NameResolver\NameResolverInterface;
+use AutoMapperPlus\PropertyAccessor\MethodReaderInterface;
 use AutoMapperPlus\PropertyAccessor\PropertyAccessor;
 use AutoMapperPlus\PropertyAccessor\PropertyAccessorInterface;
 use AutoMapperPlus\PropertyAccessor\PropertyReaderInterface;
@@ -50,6 +51,11 @@ class Options
  */
  private $propertyReader;
 
+ /**
+ * @var MethodReaderInterface
+ */
+ private $methodReader;
+
  /**
  * @var NameResolverInterface
  */
@@ -177,6 +183,7 @@ public function setPropertyAccessor(PropertyAccessorInterface $propertyAccessor)
  $this->propertyReader = $propertyAccessor;
  $this->propertyWriter = $propertyAccessor;
  $this->propertyAccessor = $propertyAccessor;
+ $this->methodReader = $propertyAccessor;
  }
 
  /**
@@ -211,6 +218,22 @@ public function setPropertyReader(PropertyReaderInterface $propertyReader): void
  $this->propertyReader = $propertyReader;
  }
 
+ /**
+ * @return MethodReaderInterface
+ */
+ public function getMethodReader(): MethodReaderInterface
+ {
+ return $this->methodReader ?: $this->propertyAccessor;
+ }
+
+ /**
+ * @param MethodReaderInterface $methodReader
+ */
+ public function setMethodReader(MethodReaderInterface $methodReader): void
+ {
+ $this->methodReader = $methodReader;
+ }
+
  /**
  * @return MappingOperationInterface
  */

src/MappingOperation/DefaultMappingOperation.php

@@ -4,6 +4,7 @@
 
 use AutoMapperPlus\Configuration\Options;
 use AutoMapperPlus\NameResolver\NameResolverInterface;
+use AutoMapperPlus\PropertyAccessor\MethodReaderInterface;
 use AutoMapperPlus\PropertyAccessor\PropertyReaderInterface;
 use AutoMapperPlus\PropertyAccessor\PropertyWriterInterface;
 
@@ -34,6 +35,11 @@ class DefaultMappingOperation implements MappingOperationInterface
  */
  protected $propertyReader;
 
+ /**
+ * @var MethodReaderInterface
+ */
+ protected $methodReader;
+
  /**
  * @var PropertyWriterInterface
  */
@@ -60,6 +66,7 @@ public function setOptions(Options $options): void
  $this->options = $options;
  $this->nameResolver = $options->getNameResolver();
  $this->propertyReader = $options->getPropertyReader();
+ $this->methodReader = $options->getMethodReader();
  $this->propertyWriter = $options->getPropertyWriter();
  }
 
@@ -126,6 +133,14 @@ protected function getPropertyReader(): PropertyReaderInterface
  return $this->propertyReader;
  }
 
+ /**
+ * @return MethodReaderInterface
+ */
+ protected function getMethodReader(): MethodReaderInterface
+ {
+ return $this->methodReader;
+ }
+
  /**
  * @return PropertyWriterInterface
  */

src/MappingOperation/Implementations/FromMethod.php

@@ -0,0 +1,125 @@
+<?php
+
+namespace AutoMapperPlus\MappingOperation\Implementations;
+
+use AutoMapperPlus\AutoMapperInterface;
+use AutoMapperPlus\MappingOperation\AlternativePropertyProvider;
+use AutoMapperPlus\MappingOperation\DefaultMappingOperation;
+use AutoMapperPlus\MappingOperation\MapperAwareOperation;
+use AutoMapperPlus\MappingOperation\MappingOperationInterface;
+use AutoMapperPlus\NameResolver\CallbackNameResolver;
+
+/**
+ * Class FromMethod
+ * @package AutoMapperPlus\MappingOperation\Implementations
+ */
+class FromMethod extends DefaultMappingOperation implements
+ AlternativePropertyProvider,
+ MapperAwareOperation
+{
+ /**
+ * @var MappingOperationInterface|null
+ */
+ private $nextOperation;
+
+ /**
+ * @var string
+ */
+ private $methodName;
+
+ /**
+ * FromMethod constructor.
+ * @param string $methodName
+ */
+ public function __construct(string $methodName)
+ {
+ $this->methodName = $methodName;
+ }
+
+ /**
+ * @inheritdoc
+ */
+ public function mapProperty(string $propertyName, $source, $destination): void {
+ if ($this->nextOperation === null) {
+ parent::mapProperty($propertyName, $source, $destination);
+ return;
+ }
+
+ $this->mapPropertyWithNextOperation(
+ $propertyName,
+ $source,
+ $destination
+ );
+ }
+
+ /**
+ * @inheritdoc
+ */
+ protected function canMapProperty(string $propertyName, $source): bool
+ {
+ $sourcePropertyName = $this->getSourcePropertyName($propertyName);
+
+ return $this->getMethodReader()->hasMethod($source, $sourcePropertyName);
+ }
+
+ /**
+ * @inheritdoc
+ */
+ protected function getSourceValue($source, string $propertyName)
+ {
+ return $this->getMethodReader()->getMethod(
+ $source,
+ $this->getSourcePropertyName($propertyName)
+ );
+ }
+
+ /**
+ * @param string $propertyName
+ * @param $source
+ * @param $destination
+ */
+ protected function mapPropertyWithNextOperation(
+ string $propertyName,
+ $source,
+ $destination
+ ): void {
+ // We have to make the overridden property available to the next
+ // operation. To do this, we create a "one-time use" name resolver
+ // to pass to the operation.
+ $options = clone $this->options;
+ $options->setNameResolver(new CallbackNameResolver(function () {
+ return $this->methodName;
+ }));
+ $this->nextOperation->setOptions($options);
+
+ // The chained operation will now use the property name assigned to
+ // FromProperty, so we can go ahead and call it.
+ $this->nextOperation->mapProperty($propertyName, $source, $destination);
+ }
+
+ /**
+ * @inheritdoc
+ */
+ public function getSourcePropertyName(string $propertyName): string
+ {
+ return $this->methodName;
+ }
+
+ /**
+ * @inheritdoc
+ */
+ public function getAlternativePropertyName(): string
+ {
+ return $this->methodName;
+ }
+
+ /**
+ * @inheritdoc
+ */
+ public function setMapper(AutoMapperInterface $mapper): void
+ {
+ if ($this->nextOperation instanceof MapperAwareOperation) {
+ $this->nextOperation->setMapper($mapper);
+ }
+ }
+}

src/PropertyAccessor/MethodReaderInterface.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace AutoMapperPlus\PropertyAccessor;
+
+/**
+ * Interface PropertyReaderInterface
+ *
+ * @package AutoMapperPlus\PropertyAccessor
+ */
+interface MethodReaderInterface
+{
+ /**
+ * @param $object
+ * @param string $methodName
+ * @return bool
+ */
+ public function hasMethod($object, string $methodName): bool;
+
+ /**
+ * @param $object
+ * @param string $methodName
+ * @return mixed
+ */
+ public function getMethod($object, string $methodName);
+}

src/PropertyAccessor/PropertyAccessor.php

@@ -2,9 +2,10 @@
 
 namespace AutoMapperPlus\PropertyAccessor;
 
+use ReflectionMethod;
+
 /**
  * Class PropertyAccessor
- *
  * @package AutoMapperPlus\PropertyAccessor
  */
 class PropertyAccessor implements PropertyAccessorInterface
@@ -151,4 +152,19 @@ private function getReflectionProperty($object, string $propertyName): ?\Reflect
 
  return null;
  }
+
+ public function hasMethod($object, string $methodName): bool
+ {
+ return method_exists($object, $methodName) && $this->isMethodPublic($object, $methodName);
+ }
+
+ public function getMethod($object, string $methodName)
+ {
+ return $object->{$methodName}();
+ }
+
+ protected function isMethodPublic($object, string $methodName): bool
+ {
+ return (new ReflectionMethod($object, $methodName))->isPublic();
+ }
 }

src/PropertyAccessor/PropertyAccessorInterface.php

@@ -7,7 +7,7 @@
  *
  * @package AutoMapperPlus\PropertyAccessor
  */
-interface PropertyAccessorInterface extends PropertyWriterInterface, PropertyReaderInterface
+interface PropertyAccessorInterface extends PropertyWriterInterface, PropertyReaderInterface, MethodReaderInterface
 {
  //
 }

test/Configuration/OptionsTest.php

@@ -2,6 +2,7 @@
 
 namespace AutoMapperPlus\Configuration;
 
+use AutoMapperPlus\PropertyAccessor\MethodReaderInterface;
 use AutoMapperPlus\PropertyAccessor\PropertyAccessorInterface;
 use AutoMapperPlus\PropertyAccessor\PropertyReaderInterface;
 use AutoMapperPlus\PropertyAccessor\PropertyWriterInterface;
@@ -48,6 +49,18 @@ public function testPropertyReaderCanBeOverridden()
  $this->assertEquals($reader, $options->getPropertyReader());
  }
 
+ public function testMethodReaderCanBeOverridden()
+ {
+ $options = new Options();
+ $accessor = $this->createMock(PropertyAccessorInterface::class);
+ $reader = $this->createMock(MethodReaderInterface::class);
+ $options->setPropertyAccessor($accessor);
+ $options->setMethodReader($reader);
+
+ $this->assertEquals($accessor, $options->getPropertyAccessor());
+ $this->assertEquals($reader, $options->getMethodReader());
+ }
+
  public function testPropertyWriterDefaultsToAccessor()
  {
  $options = new Options();
@@ -65,4 +78,13 @@ public function testPropertyReaderDefaultsToAccessor()
 
  $this->assertEquals($accessor, $options->getPropertyReader());
  }
+
+ public function testMethodReaderDefaultsToAccessor()
+ {
+ $options = new Options();
+ $accessor = $this->createMock(PropertyAccessorInterface::class);
+ $options->setPropertyAccessor($accessor);
+
+ $this->assertEquals($accessor, $options->getMethodReader());
+ }
 }

test/MappingOperation/Implementations/FromMethodTest.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace AutoMapperPlus\MappingOperation\Implementations;
+
+use AutoMapperPlus\Configuration\Options;
+use AutoMapperPlus\Test\Models\SimpleProperties\Destination;
+use AutoMapperPlus\Test\Models\Visibility\Visibility;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Class FromMethodTest
+ * @package AutoMapperPlus\MappingOperation\Implementations
+ */
+class FromMethodTest extends TestCase
+{
+ public function testItMapsAMethod()
+ {
+ $operation = new FromMethod('getMethodValue');
+ $operation->setOptions(Options::default());
+
+ $source = new Visibility();
+ $destination = new Destination();
+
+ $operation->mapProperty('name', $source, $destination);
+
+ $this->assertSame('foo', $destination->name);
+ }
+}