<form method="POST">
    <h3>Editing: EntityPopulator.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace Faker\ORM\Doctrine;

use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;

/**
 * Service class for populating a table through a Doctrine Entity class.
 */
class EntityPopulator
{
    /**
     * @var ClassMetadata
     */
    protected $class;
    /**
     * @var array
     */
    protected $columnFormatters = array();
    /**
     * @var array
     */
    protected $modifiers = array();

    /**
     * Class constructor.
     *
     * @param ClassMetadata $class
     */
    public function __construct(ClassMetadata $class)
    {
        $this-&gt;class = $class;
    }

    /**
     * @return string
     */
    public function getClass()
    {
        return $this-&gt;class-&gt;getName();
    }

    /**
     * @param $columnFormatters
     */
    public function setColumnFormatters($columnFormatters)
    {
        $this-&gt;columnFormatters = $columnFormatters;
    }

    /**
     * @return array
     */
    public function getColumnFormatters()
    {
        return $this-&gt;columnFormatters;
    }

    public function mergeColumnFormattersWith($columnFormatters)
    {
        $this-&gt;columnFormatters = array_merge($this-&gt;columnFormatters, $columnFormatters);
    }

    /**
     * @param array $modifiers
     */
    public function setModifiers(array $modifiers)
    {
        $this-&gt;modifiers = $modifiers;
    }

    /**
     * @return array
     */
    public function getModifiers()
    {
        return $this-&gt;modifiers;
    }

    /**
     * @param array $modifiers
     */
    public function mergeModifiersWith(array $modifiers)
    {
        $this-&gt;modifiers = array_merge($this-&gt;modifiers, $modifiers);
    }

    /**
     * @param \Faker\Generator $generator
     * @return array
     */
    public function guessColumnFormatters(\Faker\Generator $generator)
    {
        $formatters = array();
        $nameGuesser = new \Faker\Guesser\Name($generator);
        $columnTypeGuesser = new ColumnTypeGuesser($generator);
        foreach ($this-&gt;class-&gt;getFieldNames() as $fieldName) {
            if ($this-&gt;class-&gt;isIdentifier($fieldName) || !$this-&gt;class-&gt;hasField($fieldName)) {
                continue;
            }

            $size = isset($this-&gt;class-&gt;fieldMappings[$fieldName]['length']) ? $this-&gt;class-&gt;fieldMappings[$fieldName]['length'] : null;
            if ($formatter = $nameGuesser-&gt;guessFormat($fieldName, $size)) {
                $formatters[$fieldName] = $formatter;
                continue;
            }
            if ($formatter = $columnTypeGuesser-&gt;guessFormat($fieldName, $this-&gt;class)) {
                $formatters[$fieldName] = $formatter;
                continue;
            }
        }

        foreach ($this-&gt;class-&gt;getAssociationNames() as $assocName) {
            if ($this-&gt;class-&gt;isCollectionValuedAssociation($assocName)) {
                continue;
            }

            $relatedClass = $this-&gt;class-&gt;getAssociationTargetClass($assocName);

            $unique = $optional = false;
            if ($this-&gt;class instanceof \Doctrine\ORM\Mapping\ClassMetadata) {
                $mappings = $this-&gt;class-&gt;getAssociationMappings();
                foreach ($mappings as $mapping) {
                    if ($mapping['targetEntity'] == $relatedClass) {
                        if ($mapping['type'] == \Doctrine\ORM\Mapping\ClassMetadata::ONE_TO_ONE) {
                            $unique = true;
                            $optional = isset($mapping['joinColumns'][0]['nullable']) ? $mapping['joinColumns'][0]['nullable'] : false;
                            break;
                        }
                    }
                }
            } elseif ($this-&gt;class instanceof \Doctrine\ODM\MongoDB\Mapping\ClassMetadata) {
                $mappings = $this-&gt;class-&gt;associationMappings;
                foreach ($mappings as $mapping) {
                    if ($mapping['targetDocument'] == $relatedClass) {
                        if ($mapping['type'] == \Doctrine\ODM\MongoDB\Mapping\ClassMetadata::ONE &amp;&amp; $mapping['association'] == \Doctrine\ODM\MongoDB\Mapping\ClassMetadata::REFERENCE_ONE) {
                            $unique = true;
                            $optional = isset($mapping['nullable']) ? $mapping['nullable'] : false;
                            break;
                        }
                    }
                }
            }

            $index = 0;
            $formatters[$assocName] = function ($inserted) use ($relatedClass, &amp;$index, $unique, $optional) {

                if (isset($inserted[$relatedClass])) {
                    if ($unique) {
                        $related = null;
                        if (isset($inserted[$relatedClass][$index]) || !$optional) {
                            $related = $inserted[$relatedClass][$index];
                        }

                        $index++;

                        return $related;
                    }

                    return $inserted[$relatedClass][mt_rand(0, count($inserted[$relatedClass]) - 1)];
                }

                return null;
            };
        }

        return $formatters;
    }

    /**
     * Insert one new record using the Entity class.
     * @param ObjectManager $manager
     * @param bool $generateId
     * @return EntityPopulator
     */
    public function execute(ObjectManager $manager, $insertedEntities, $generateId = false)
    {
        $obj = $this-&gt;class-&gt;newInstance();

        $this-&gt;fillColumns($obj, $insertedEntities);
        $this-&gt;callMethods($obj, $insertedEntities);

        if ($generateId) {
            $idsName = $this-&gt;class-&gt;getIdentifier();
            foreach ($idsName as $idName) {
                $id = $this-&gt;generateId($obj, $idName, $manager);
                $this-&gt;class-&gt;reflFields[$idName]-&gt;setValue($obj, $id);
            }
        }

        $manager-&gt;persist($obj);

        return $obj;
    }

    private function fillColumns($obj, $insertedEntities)
    {
        foreach ($this-&gt;columnFormatters as $field =&gt; $format) {
            if (null !== $format) {
                // Add some extended debugging information to any errors thrown by the formatter
                try {
                    $value = is_callable($format) ? $format($insertedEntities, $obj) : $format;
                } catch (\InvalidArgumentException $ex) {
                    throw new \InvalidArgumentException(sprintf(
                        &quot;Failed to generate a value for %s::%s: %s&quot;,
                        get_class($obj),
                        $field,
                        $ex-&gt;getMessage()
                    ));
                }
                // Try a standard setter if it's available, otherwise fall back on reflection
                $setter = sprintf(&quot;set%s&quot;, ucfirst($field));
                if (is_callable(array($obj, $setter))) {
                    $obj-&gt;$setter($value);
                } else {
                    $this-&gt;class-&gt;reflFields[$field]-&gt;setValue($obj, $value);
                }
            }
        }
    }

    private function callMethods($obj, $insertedEntities)
    {
        foreach ($this-&gt;getModifiers() as $modifier) {
            $modifier($obj, $insertedEntities);
        }
    }

    /**
     * @param ObjectManager $manager
     * @return int|null
     */
    private function generateId($obj, $column, ObjectManager $manager)
    {
        /* @var $repository \Doctrine\Common\Persistence\ObjectRepository */
        $repository = $manager-&gt;getRepository(get_class($obj));
        $result = $repository-&gt;createQueryBuilder('e')
                -&gt;select(sprintf('e.%s', $column))
                -&gt;getQuery()
                -&gt;execute();
        $ids = array_map('current', $result-&gt;toArray());

        $id = null;
        do {
            $id = mt_rand();
        } while (in_array($id, $ids));

        return $id;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>