1:   2:   3:   4:   5:   6:   7:   8:   9:  10:  11:  12:  13:  14:  15:  16:  17:  18:  19:  20:  21:  22:  23:  24:  25:  26:  27:  28:  29:  30:  31:  32:  33:  34:  35:  36:  37:  38:  39:  40:  41:  42:  43:  44:  45:  46:  47:  48:  49:  50:  51:  52:  53:  54:  55:  56:  57:  58:  59:  60:  61:  62:  63:  64:  65:  66:  67:  68:  69:  70:  71:  72:  73:  74:  75:  76:  77:  78:  79:  80:  81:  82:  83:  84:  85:  86:  87:  88:  89:  90:  91:  92:  93:  94:  95:  96:  97:  98:  99: 100: 101: 102: 103: 104: 105: 106: 107: 108: 109: 110: 111: 112: 113: 114: 115: 116: 117: 118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163: 164: 165: 166: 167: 168: 169: 170: 171: 172: 173: 174: 175: 176: 177: 178: 179: 180: 181: 182: 183: 184: 185: 186: 187: 188: 189: 190: 191: 192: 193: 194: 195: 196: 197: 198: 199: 200: 201: 202: 203: 204: 205: 206: 207: 208: 209: 210: 211: 212: 213: 214: 215: 216: 217: 218: 219: 220: 221: 222: 223: 224: 225: 226: 227: 228: 229: 230: 231: 232: 233: 234: 235: 236: 237: 238: 239: 240: 241: 242: 243: 244: 245: 246: 247: 248: 249: 250: 251: 252: 253: 254: 255: 256: 257: 258: 259: 260: 261: 262: 263: 264: 265: 266: 267: 268: 269: 270: 271: 272: 273: 274: 275: 276: 277: 278: 279: 280: 281: 282: 283: 284: 285: 286: 287: 288: 289: 290: 291: 292: 293: 294: 295: 296: 297: 298: 299: 300: 301: 302: 303: 304: 305: 306: 307: 308: 309: 310: 311: 312: 313: 314: 315: 316: 317: 318: 319: 320: 321: 322: 323: 324: 325: 326: 327: 328: 329: 330: 331: 332: 333: 334: 335: 336: 337: 338: 339: 340: 341: 342: 343: 344: 345: 346: 347: 348: 349: 350: 351: 352: 353: 354: 355: 356: 357: 358: 359: 360: 361: 362: 363: 364: 365: 366: 367: 368: 369: 370: 371: 372: 373: 374: 375: 376: 377: 378: 379: 380: 381: 382: 383: 384: 385: 386: 387: 388: 389: 390: 391: 392: 393: 394: 395: 396: 397: 398: 399: 400: 401: 402: 403: 404: 405: 406: 407: 408: 409: 410: 411: 412: 413: 414: 415: 416: 417: 418: 419: 420: 421: 422: 423: 424: 425: 426: 427: 428: 429: 430: 431: 432: 433: 434: 435: 436: 437: 438: 439: 440: 441: 

<?php

    namespace Inlm\SchemaGenerator\Extractors;

    use CzProject\SqlSchema;
    use Inlm\SchemaGenerator\DataType;
    use Inlm\SchemaGenerator\IExtractor;
    use Inlm\SchemaGenerator\EmptyException;
    use Inlm\SchemaGenerator\InvalidArgumentException;
    use Inlm\SchemaGenerator\MissingException;
    use Inlm\SchemaGenerator\Utils\Generator;
    use Inlm\SchemaGenerator\Utils\DataTypeParser;
    use Inlm\SchemaGenerator\Utils\DataTypeProcessor;
    use Nette;
    use LeanMapper\IMapper;
    use LeanMapper\Reflection;
    use LeanMapper\Reflection\AnnotationsParser;
    use LeanMapper\Relationship;


    class LeanMapperExtractor implements IExtractor
    {
        /** @var IMapper */
        protected $mapper;

        /** @var string|string[] */
        protected $directories;

        /** @var array  [name => DataType] */
        protected $customTypes;

        /** @var string|NULL */
        protected $databaseType;

        /** @var Generator */
        protected $generator;


        /**
         * @param  string|string[]
         * @param  IMapper
         */
        public function __construct($directories, IMapper $mapper)
        {
            $this->directories = $directories;
            $this->mapper = $mapper;
        }


        /**
         * @return SqlSchema\Schema
         */
        public function generateSchema(array $options = array(), array $customTypes = array(), $databaseType = NULL)
        {
            $this->generator = new Generator($options, $databaseType);
            $this->customTypes = $customTypes;
            $this->databaseType = $databaseType;
            $entities = $this->findEntities();

            foreach ($entities as $entity) {
                $this->generateEntity($entity);
            }

            $schema = $this->generator->finalize();
            $this->generator = NULL;
            return $schema;
        }


        protected function generateEntity($entityClass)
        {
            $reflection = call_user_func(array($entityClass, 'getReflection'), $this->mapper);
            $properties = $reflection->getEntityProperties();

            if (empty($properties) || $this->isEntityIgnored($reflection->getDocComment())) {
                return;
            }

            $tableName = $this->mapper->getTable($entityClass);
            $tablePrimaryColumn = $this->mapper->getPrimaryKey($tableName);
            $this->generator->createTable($tableName, $tablePrimaryColumn);

            foreach ($this->getFamilyLine($reflection) as $member) {
                $docComment = $member->getDocComment();
                $this->extractTableComment($tableName, $docComment);
                $this->extractTableOption($tableName, $docComment);
                $this->extractTableIndexes($tableName, $member, 'primary', $entityClass);
                $this->extractTableIndexes($tableName, $member, 'unique', $entityClass);
                $this->extractTableIndexes($tableName, $member, 'index', $entityClass);

                $memberClass = $member->getName();
                $memberProperties = array_keys($member->getEntityProperties());
            }

            // hack - primary column must be always first (@property-read is always last)
            if (isset($properties[$tablePrimaryColumn])) {
                $properties = array($tablePrimaryColumn => $properties[$tablePrimaryColumn]) + $properties;
            }

            foreach ($properties as $property) {
                if ($property->hasRelationship()) {
                    $relationship = $property->getRelationship();

                    if ($relationship instanceof Relationship\HasMany) {
                        $this->addHasManyRelationship($relationship, $tableName);
                        continue; // virtual column

                    } elseif ($relationship instanceof Relationship\HasOne) {
                        $this->generator->addRelationship($tableName, $relationship->getColumnReferencingTargetTable(), $relationship->getTargetTable());

                    } elseif ($relationship instanceof Relationship\BelongsTo) {
                        $this->generator->addRelationship($relationship->getTargetTable(), $relationship->getColumnReferencingSourceTable(), $tableName);
                        continue; // virtual column

                    } else {
                        throw new \RuntimeException('Unknow relationship ' . (is_object($relationship) ? get_class($relationship) : gettype($relationship))); // TODO
                    }
                }

                $propertyName = $property->getName();
                $columnName = $property->getColumn();
                $isPrimaryColumn = $columnName === $tablePrimaryColumn;
                $columnType = NULL;

                if (!$property->hasRelationship()) {
                    $columnType = $this->extractColumnType($property, $isPrimaryColumn, $entityClass);
                }

                $this->generator->addColumn($tableName, $columnName, $columnType);
                $this->generator->setColumnNullable($tableName, $columnName, $property->isNullable());

                $this->extractColumnComment($tableName, $columnName, $property);
                $this->extractColumnAutoIncrement($tableName, $columnName, $property, $isPrimaryColumn);
                $this->extractColumnIndex($property, 'primary', $tableName, $columnName);
                $this->extractColumnIndex($property, 'unique', $tableName, $columnName);
                $this->extractColumnIndex($property, 'index', $tableName, $columnName);
            }
        }


        /**
         * @param  string
         * @return bool
         */
        protected function isEntityIgnored($docComment)
        {
            // @schema-ignore
            // @schemaIgnore
            $annotations = array(
                'schema-ignore',
                'schemaIgnore',
            );

            foreach ($annotations as $annotation) {
                if (AnnotationsParser::parseSimpleAnnotationValue($annotation, $docComment) !== NULL) {
                    return TRUE;
                }
            }

            return FALSE;
        }


        /**
         * @return void
         */
        protected function extractTableComment($tableName, $docComment)
        {
            // @schema-comment comment
            // @schemaComment comment
            $annotations = array(
                'schema-comment',
                'schemaComment',
            );

            foreach ($annotations as $annotation) {
                foreach (AnnotationsParser::parseAnnotationValues($annotation, $docComment) as $comment) {
                    $this->generator->setTableComment($tableName, $comment);
                }
            }
        }


        /**
         * @return void
         */
        protected function extractTableOption($tableName, $docComment)
        {
            // @schema-option option value
            // @schemaOption option value
            $annotations = array(
                'schema-option',
                'schemaOption',
            );

            foreach ($annotations as $annotation) {
                foreach (AnnotationsParser::parseAnnotationValues($annotation, $docComment) as $definition) {
                    $definition = trim($definition);

                    if ($definition === '*/') { // fix for bug in AnnotationsParser::parseAnnotationValues
                        $definition = '';
                    }

                    if ($definition === '') {
                        throw new EmptyException("Empty definition of '@{$annotation}'.");
                    }

                    $option = $definition;
                    $value = NULL;

                    if (strpos($definition, ' ') !== FALSE) {
                        list($option, $value) = explode(' ', $definition, 2);
                        $option = trim($option);
                        $value = trim($value);
                    }

                    if ($option === '') {
                        throw new MissingException("Missing option name in '@{$annotation}'.");
                    }

                    $this->generator->setTableOption($tableName, $option, $value);
                }
            }
        }


        /**
         * @return void
         */
        protected function extractTableIndexes($tableName, Reflection\EntityReflection $reflection, $indexType, $entityClass)
        {
            // @schema-<type> property1, property2
            // @schema<Type> property, property2
            $annotations = array(
                'schema-' . $indexType,
                'schema' . ucfirst($indexType),
            );

            foreach ($annotations as $annotation) {
                foreach (AnnotationsParser::parseAnnotationValues($annotation, $reflection->getDocComment()) as $definition) {
                    $properties = array_map('trim', explode(',', $definition));
                    $columns = array();

                    foreach ($properties as $property) {
                        $columns[] = $this->mapper->getColumn($entityClass, $property);
                    }

                    $this->addIndexByType($indexType, $tableName, $columns);
                }
            }
        }


        /**
         * @return DataType
         */
        protected function extractColumnType(Reflection\Property $property, $isPrimaryColumn, $entityClass)
        {
            $datatype = NULL;

            if ($property->hasCustomFlag('schema-type')) {
                $datatype = $this->parseTypeFlag($property, 'schema-type');

            } elseif ($property->hasCustomFlag('schemaType')) {
                $datatype = $this->parseTypeFlag($property, 'schemaType');
            }

            try {
                return DataTypeProcessor::process($property->getType(), $datatype, $isPrimaryColumn, $this->customTypes, $this->databaseType);

            } catch (MissingException $e) {
                throw new MissingException("Missing type for property '{$property->getName()}' in entity '{$entityClass}'.", 0, $e);
            }
        }


        /**
         * @param  Reflection\Property
         * @param  string
         * @return DataType
         * @throws InvalidArgumentException
         */
        protected function parseTypeFlag(Reflection\Property $property, $flagName)
        {
            $s = $property->getCustomFlagValue($flagName);
            try {
                return DataTypeParser::parse($s, DataTypeParser::SYNTAX_ALTERNATIVE);

            } catch (\Exception $e) { // TODO
                throw new InvalidArgumentException("Malformed m:{$flagName} definition for property '{$property->getName()}' in entity ''.");
            }
        }


        /**
         * @param  string
         * @param  string
         * @return void
         */
        protected function extractColumnComment($tableName, $columnName, Reflection\Property $property)
        {
            if ($property->hasCustomFlag('schema-comment')) {
                $this->generator->setColumnComment($tableName, $columnName, $property->getCustomFlagValue('schema-comment'));

            } elseif ($property->hasCustomFlag('schemaComment')) {
                $this->generator->setColumnComment($tableName, $columnName, $property->getCustomFlagValue('schemaComment'));
            }
        }


        /**
         * @param  string
         * @param  string
         * @return void
         */
        protected function extractColumnAutoIncrement($tableName, $columnName, Reflection\Property $property, $isPrimaryColumn)
        {
            if ($property->hasCustomFlag('schema-autoIncrement') || $property->hasCustomFlag('schemaAutoIncrement')) {
                $this->generator->setColumnAutoIncrement($tableName, $columnName, TRUE);

            } else { // auto-detect
                $this->generator->setColumnAutoIncrement($tableName, $columnName, $isPrimaryColumn && $property->getType() === 'integer');
            }
        }


        /**
         * @return void
         */
        protected function extractColumnIndex(Reflection\Property $property, $type, $tableName, $columnName)
        {
            $flags = array(
                'schema-' . $type,
                'schema' . ucfirst($type),
            );

            foreach ($flags as $flag) {
                if ($property->hasCustomFlag($flag)) {
                    $this->addIndexByType($type, $tableName, $columnName);
                    return;
                }
            }
        }


        protected function addIndexByType($indexType, $tableName, $columns)
        {
            if ($indexType === 'index') {
                $this->generator->addIndex($tableName, $columns);

            } elseif ($indexType === 'unique') {
                $this->generator->addUniqueIndex($tableName, $columns);

            } elseif ($indexType === 'primary') {
                $this->generator->addPrimaryIndex($tableName, $columns);

            } else {
                throw new InvalidArgumentException("Unknow index type '$indexType'.");
            }
        }


        protected function addHasManyRelationship(Relationship\HasMany $relationship, $sourceTable)
        {
            $relationshipTable = $relationship->getRelationshipTable();
            $sourceColumn = $relationship->getColumnReferencingSourceTable();
            $targetTable = $relationship->getTargetTable();
            $targetColumn = $relationship->getColumnReferencingTargetTable();

            if ($this->mapper->getRelationshipTable($sourceTable, $targetTable) === $relationshipTable) {
                $this->generator->addHasManyTable(
                    $relationshipTable,
                    $sourceTable,
                    $sourceColumn,
                    $targetTable,
                    $targetColumn
                );

            } else {
                $this->generator->addHasManyTable(
                    $relationshipTable,
                    $targetTable,
                    $targetColumn,
                    $sourceTable,
                    $sourceColumn
                );
            }
        }


        /**
         * Returns list of FQN class names.
         * @return string[]
         */
        protected function findEntities()
        {
            $robot = new Nette\Loaders\RobotLoader;
            $robot->addDirectory($this->directories);
            $robot->acceptFiles = '*.php';
            $robot->rebuild();
            $classes = array_keys($robot->getIndexedClasses());
            $entities = array();

            foreach ($classes as $class) {
                if (!class_exists($class) && !interface_exists($class)) {
                    $robot->tryLoad($class);
                }

                $accept = class_exists($class)
                    && ($rc = new \ReflectionClass($class))
                    && $rc->isSubclassOf('LeanMapper\\Entity')
                    && !$rc->isAbstract();

                if ($accept) {
                    $entities[] = $class;
                }
            }

            return $entities;
        }


        /**
         * @return Reflection\EntityReflection[]
         */
        protected function getFamilyLine(Reflection\EntityReflection $reflection)
        {
            $line = array($member = $reflection);

            while ($member = $member->getParentClass()) {
                if ($member === NULL || $member->name === 'LeanMapper\Entity') {
                    break;
                }

                $line[] = $member;
            }

            return array_reverse($line);
        }
    }