<?php

/*

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * This software consists of voluntary contributions made by many individuals

 * and is licensed under the LGPL. For more information, see

 * <http://www.doctrine-project.org>.

 */

namespace Doctrine\ORM\Tools;

use Doctrine\ORM\Mapping\ClassMetadataInfo,

    Doctrine\ORM\Mapping\AssociationMapping,

    Doctrine\Common\Util\Inflector;

/**

 * Generic class used to generate PHP5 entity classes from ClassMetadataInfo instances

 *

 *     [php]

 *     $classes = $em->getClassMetadataFactory()->getAllMetadata();

 *

 *     $generator = new \Doctrine\ORM\Tools\EntityGenerator();

 *     $generator->setGenerateAnnotations(true);

 *     $generator->setGenerateStubMethods(true);

 *     $generator->setRegenerateEntityIfExists(false);

 *     $generator->setUpdateEntityIfExists(true);

 *     $generator->generate($classes, '/path/to/generate/entities');

 *

 * @license http://www.opensource.org/licenses/lgpl-license.php LGPL

 * @link    www.doctrine-project.org

 * @since   2.0

 * @version $Revision$

 * @author  Benjamin Eberlei <kontakt@beberlei.de>

 * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>

 * @author  Jonathan Wage <jonwage@gmail.com>

 * @author  Roman Borschel <roman@code-factory.org>

 */

class EntityGenerator

{

    /**

     * @var bool

     */

    private $_backupExisting = true;

    /** The extension to use for written php files */

    private $_extension = '.php';

    /** Whether or not the current ClassMetadataInfo instance is new or old */

    private $_isNew = true;

    private $_staticReflection = array();

    /** Number of spaces to use for indention in generated code */

    private $_numSpaces = 4;

    /** The actual spaces to use for indention */

    private $_spaces = '    ';

    /** The class all generated entities should extend */

    private $_classToExtend;

    /** Whether or not to generation annotations */

    private $_generateAnnotations = false;

    /**

     * @var string

     */

    private $_annotationsPrefix = '';

    /** Whether or not to generated sub methods */

    private $_generateEntityStubMethods = false;

    /** Whether or not to update the entity class if it exists already */

    private $_updateEntityIfExists = false;

    /** Whether or not to re-generate entity class if it exists already */

    private $_regenerateEntityIfExists = false;

    private static $_classTemplate =

'<?php

<namespace>

use Doctrine\ORM\Mapping as ORM;

<entityAnnotation>

<entityClassName>

{

<entityBody>

}';

    private static $_getMethodTemplate =

'/**

 * <description>

 *

 * @return <variableType>

 */

public function <methodName>()

{

<spaces>return $this-><fieldName>;

}';

    private static $_setMethodTemplate =

'/**

 * <description>

 *

 * @param <variableType>$<variableName>

 */

public function <methodName>(<methodTypeHint>$<variableName>)

{

<spaces>$this-><fieldName> = $<variableName>;

}';

    private static $_addMethodTemplate =

'/**

 * <description>

 *

 * @param <variableType>$<variableName>

 */

public function <methodName>(<methodTypeHint>$<variableName>)

{

<spaces>$this-><fieldName>[] = $<variableName>;

}';

    private static $_lifecycleCallbackMethodTemplate =

'/**

 * @<name>

 */

public function <methodName>()

{

<spaces>// Add your code here

}';

    private static $_constructorMethodTemplate =

'public function __construct()

{

<spaces><collections>

}

';

    public function __construct()

    {

        if (version_compare(\Doctrine\Common\Version::VERSION, '3.0.0-DEV', '>=')) {

            $this->_annotationsPrefix = 'ORM\\';

        }

    }

    /**

     * Generate and write entity classes for the given array of ClassMetadataInfo instances

     *

     * @param array $metadatas

     * @param string $outputDirectory

     * @return void

     */

    public function generate(array $metadatas, $outputDirectory)

    {

        foreach ($metadatas as $metadata) {

            $this->writeEntityClass($metadata, $outputDirectory);

        }

    }

    /**

     * Generated and write entity class to disk for the given ClassMetadataInfo instance

     *

     * @param ClassMetadataInfo $metadata

     * @param string $outputDirectory

     * @return void

     */

    public function writeEntityClass(ClassMetadataInfo $metadata, $outputDirectory)

    {

        $path = $outputDirectory . '/' . str_replace('\\', DIRECTORY_SEPARATOR, $metadata->name) . $this->_extension;

        $dir = dirname($path);

        if ( ! is_dir($dir)) {

            mkdir($dir, 0777, true);

        }

        $this->_isNew = !file_exists($path) || (file_exists($path) && $this->_regenerateEntityIfExists);

        if ( ! $this->_isNew) {

            $this->_parseTokensInEntityFile(file_get_contents($path));

        }

        if ($this->_backupExisting && file_exists($path)) {

            $backupPath = dirname($path) . DIRECTORY_SEPARATOR . basename($path) . "~";

            if (!copy($path, $backupPath)) {

                throw new \RuntimeException("Attempt to backup overwritten entitiy file but copy operation failed.");

            }

        }

        // If entity doesn't exist or we're re-generating the entities entirely

        if ($this->_isNew) {

            file_put_contents($path, $this->generateEntityClass($metadata));

        // If entity exists and we're allowed to update the entity class

        } else if ( ! $this->_isNew && $this->_updateEntityIfExists) {

            file_put_contents($path, $this->generateUpdatedEntityClass($metadata, $path));

        }

    }

    /**

     * Generate a PHP5 Doctrine 2 entity class from the given ClassMetadataInfo instance

     *

     * @param ClassMetadataInfo $metadata

     * @return string $code

     */

    public function generateEntityClass(ClassMetadataInfo $metadata)

    {

        $placeHolders = array(

            '<namespace>',

            '<entityAnnotation>',

            '<entityClassName>',

            '<entityBody>'

        );

        $replacements = array(

            $this->_generateEntityNamespace($metadata),

            $this->_generateEntityDocBlock($metadata),

            $this->_generateEntityClassName($metadata),

            $this->_generateEntityBody($metadata)

        );

        $code = str_replace($placeHolders, $replacements, self::$_classTemplate);

        return str_replace('<spaces>', $this->_spaces, $code);

    }

    /**

     * Generate the updated code for the given ClassMetadataInfo and entity at path

     *

     * @param ClassMetadataInfo $metadata

     * @param string $path

     * @return string $code;

     */

    public function generateUpdatedEntityClass(ClassMetadataInfo $metadata, $path)

    {

        $currentCode = file_get_contents($path);

        $body = $this->_generateEntityBody($metadata);

        $body = str_replace('<spaces>', $this->_spaces, $body);

        $last = strrpos($currentCode, '}');

        return substr($currentCode, 0, $last) . $body . (strlen($body) > 0 ? "\n" : ''). "}";

    }

    /**

     * Set the number of spaces the exported class should have

     *

     * @param integer $numSpaces

     * @return void

     */

    public function setNumSpaces($numSpaces)

    {

        $this->_spaces = str_repeat(' ', $numSpaces);

        $this->_numSpaces = $numSpaces;

    }

    /**

     * Set the extension to use when writing php files to disk

     *

     * @param string $extension

     * @return void

     */

    public function setExtension($extension)

    {

        $this->_extension = $extension;

    }

    /**

     * Set the name of the class the generated classes should extend from

     *

     * @return void

     */

    public function setClassToExtend($classToExtend)

    {

        $this->_classToExtend = $classToExtend;

    }

    /**

     * Set whether or not to generate annotations for the entity

     *

     * @param bool $bool

     * @return void

     */

    public function setGenerateAnnotations($bool)

    {

        $this->_generateAnnotations = $bool;

    }

    /**

     * Set an annotation prefix.

     *

     * @param string $prefix

     */

    public function setAnnotationPrefix($prefix)

    {

        if (version_compare(\Doctrine\Common\Version::VERSION, '3.0.0-DEV', '>=')) {

            return;

        }

        $this->_annotationsPrefix = $prefix;

    }

    /**

     * Set whether or not to try and update the entity if it already exists

     *

     * @param bool $bool

     * @return void

     */

    public function setUpdateEntityIfExists($bool)

    {

        $this->_updateEntityIfExists = $bool;

    }

    /**

     * Set whether or not to regenerate the entity if it exists

     *

     * @param bool $bool

     * @return void

     */

    public function setRegenerateEntityIfExists($bool)

    {

        $this->_regenerateEntityIfExists = $bool;

    }

    /**

     * Set whether or not to generate stub methods for the entity

     *

     * @param bool $bool

     * @return void

     */

    public function setGenerateStubMethods($bool)

    {

        $this->_generateEntityStubMethods = $bool;

    }

    /**

     * Should an existing entity be backed up if it already exists?

     */

    public function setBackupExisting($bool)

    {

        $this->_backupExisting = $bool;

    }

    private function _generateEntityNamespace(ClassMetadataInfo $metadata)

    {

        if ($this->_hasNamespace($metadata)) {

            return 'namespace ' . $this->_getNamespace($metadata) .';';

        }

    }

    private function _generateEntityClassName(ClassMetadataInfo $metadata)

    {

        return 'class ' . $this->_getClassName($metadata) .

            ($this->_extendsClass() ? ' extends ' . $this->_getClassToExtendName() : null);

    }

    private function _generateEntityBody(ClassMetadataInfo $metadata)

    {

        $fieldMappingProperties = $this->_generateEntityFieldMappingProperties($metadata);

        $associationMappingProperties = $this->_generateEntityAssociationMappingProperties($metadata);

        $stubMethods = $this->_generateEntityStubMethods ? $this->_generateEntityStubMethods($metadata) : null;

        $lifecycleCallbackMethods = $this->_generateEntityLifecycleCallbackMethods($metadata);

        $code = array();

        if ($fieldMappingProperties) {

            $code[] = $fieldMappingProperties;

        }

        if ($associationMappingProperties) {

            $code[] = $associationMappingProperties;

        }

        $code[] = $this->_generateEntityConstructor($metadata);

        if ($stubMethods) {

            $code[] = $stubMethods;

        }

        if ($lifecycleCallbackMethods) {

            $code[] = $lifecycleCallbackMethods;

        }

        return implode("\n", $code);

    }

    private function _generateEntityConstructor(ClassMetadataInfo $metadata)

    {

        if ($this->_hasMethod('__construct', $metadata)) {

            return '';

        }

        $collections = array();

        foreach ($metadata->associationMappings AS $mapping) {

            if ($mapping['type'] & ClassMetadataInfo::TO_MANY) {

                $collections[] = '$this->'.$mapping['fieldName'].' = new \Doctrine\Common\Collections\ArrayCollection();';

            }

        }

        if ($collections) {

            return $this->_prefixCodeWithSpaces(str_replace("<collections>", implode("\n", $collections), self::$_constructorMethodTemplate));

        }

        return '';

    }

    /**

     * @todo this won't work if there is a namespace in brackets and a class outside of it.

     * @param string $src

     */

    private function _parseTokensInEntityFile($src)

    {

        $tokens = token_get_all($src);

        $lastSeenNamespace = "";

        $lastSeenClass = false;

        $inNamespace = false;

        $inClass = false;

        for ($i = 0; $i < count($tokens); $i++) {

            $token = $tokens[$i];

            if (in_array($token[0], array(T_WHITESPACE, T_COMMENT, T_DOC_COMMENT))) {

                continue;

            }

            if ($inNamespace) {

                if ($token[0] == T_NS_SEPARATOR || $token[0] == T_STRING) {

                    $lastSeenNamespace .= $token[1];

                } else if (is_string($token) && in_array($token, array(';', '{'))) {

                    $inNamespace = false;

                }

            }

            if ($inClass) {

                $inClass = false;

                $lastSeenClass = $lastSeenNamespace . ($lastSeenNamespace ? '\\' : '') . $token[1];

                $this->_staticReflection[$lastSeenClass]['properties'] = array();

                $this->_staticReflection[$lastSeenClass]['methods'] = array();

            }