PHP Doctrine::filterInvalidModels方法代码示例

 /**
  * Provides a array with all model names
  *
  * @return array
  */
 public function loadModels()
 {
     $models = Doctrine::loadModels($this->modelDir, Doctrine::MODEL_LOADING_CONSERVATIVE);
     $models = Doctrine::initializeModels($models);
     $this->models = Doctrine::filterInvalidModels($models);
     return $this->models;
 }

 public function testAggressiveModelLoading()
 {
     $path = realpath('ModelLoadingTest/Aggressive');
     $models = Doctrine::loadModels($path, Doctrine::MODEL_LOADING_AGGRESSIVE);
     // Ensure the correct model names were returned
     $this->assertTrue(isset($models['AggressiveModelLoadingUser']) && $models['AggressiveModelLoadingUser'] == 'AggressiveModelLoadingUser');
     $this->assertTrue(isset($models['AggressiveModelLoadingProfile']) && $models['AggressiveModelLoadingProfile'] == 'AggressiveModelLoadingProfile');
     $this->assertTrue(isset($models['AggressiveModelLoadingContact']) && $models['AggressiveModelLoadingContact'] == 'AggressiveModelLoadingContact');
     // Make sure it does not include the base classes
     $this->assertTrue(!isset($models['BaseAggressiveModelLoadingUser']));
     $filteredModels = Doctrine::filterInvalidModels($models);
     // Make sure filterInvalidModels filters out base abstract classes
     $this->assertTrue(!isset($models['BaseAggressiveModelLoadingUser']));
 }

 /**
  * buildSchema
  * 
  * Build schema array that can be dumped to file
  *
  * @param string $directory 
  * @return void
  */
 public function buildSchema($directory = null, $models = array())
 {
     if ($directory !== null) {
         $loadedModels = Doctrine::filterInvalidModels(Doctrine::loadModels($directory));
     } else {
         $loadedModels = Doctrine::getLoadedModels();
     }
     $array = array();
     $parent = new ReflectionClass('Doctrine_Record');
     $sql = array();
     $fks = array();
     // we iterate through the diff of previously declared classes
     // and currently declared classes
     foreach ($loadedModels as $className) {
         if (!empty($models) && !in_array($className, $models)) {
             continue;
         }
         $recordTable = Doctrine::getTable($className);
         $data = $recordTable->getExportableFormat();
         $table = array();
         $remove = array('ptype', 'ntype', 'alltypes');
         // Fix explicit length in schema, concat it to type in this format: type(length)
         foreach ($data['columns'] as $name => $column) {
             if (isset($column['length']) && $column['length'] && isset($column['scale']) && $column['scale']) {
                 $data['columns'][$name]['type'] = $column['type'] . '(' . $column['length'] . ', ' . $column['scale'] . ')';
                 unset($data['columns'][$name]['length'], $data['columns'][$name]['scale']);
             } else {
                 $data['columns'][$name]['type'] = $column['type'] . '(' . $column['length'] . ')';
                 unset($data['columns'][$name]['length']);
             }
             // Strip out schema information which is not necessary to be dumped to the yaml schema file
             foreach ($remove as $value) {
                 if (isset($data['columns'][$name][$value])) {
                     unset($data['columns'][$name][$value]);
                 }
             }
             // If type is the only property of the column then lets abbreviate the syntax
             // columns: { name: string(255) }
             if (count($data['columns'][$name]) === 1 && isset($data['columns'][$name]['type'])) {
                 $type = $data['columns'][$name]['type'];
                 unset($data['columns'][$name]);
                 $data['columns'][$name] = $type;
             }
         }
         $table['tableName'] = $data['tableName'];
         $table['columns'] = $data['columns'];
         $relations = $recordTable->getRelations();
         foreach ($relations as $key => $relation) {
             $relationData = $relation->toArray();
             $relationKey = $relationData['alias'];
             if (isset($relationData['refTable']) && $relationData['refTable']) {
                 $table['relations'][$relationKey]['refClass'] = $relationData['refTable']->getComponentName();
             }
             if (isset($relationData['class']) && $relationData['class'] && $relation['class'] != $relationKey) {
                 $table['relations'][$relationKey]['class'] = $relationData['class'];
             }
             $table['relations'][$relationKey]['local'] = $relationData['local'];
             $table['relations'][$relationKey]['foreign'] = $relationData['foreign'];
             if ($relationData['type'] === Doctrine_Relation::ONE) {
                 $table['relations'][$relationKey]['type'] = 'one';
             } else {
                 if ($relationData['type'] === Doctrine_Relation::MANY) {
                     $table['relations'][$relationKey]['type'] = 'many';
                 } else {
                     $table['relations'][$relationKey]['type'] = 'one';
                 }
             }
         }
         $array[$className] = $table;
     }
     return $array;
 }

 /**
  * purge
  * 
  * Purge all data for loaded models or for the passed array of Doctrine_Records
  *
  * @param string $models 
  * @return void
  */
 public function purge($models = array())
 {
     $models = Doctrine::filterInvalidModels($models);
     foreach ($models as $model) {
         $model = new $model();
         $model->getTable()->createQuery()->delete($model)->execute();
     }
 }

 /**
  * Loads all Doctrine builders.
  */
 protected function loadModels()
 {
     Doctrine::loadModels($this->generatorManager->getConfiguration()->getModelDirs(), Doctrine::MODEL_LOADING_CONSERVATIVE);
     $models = Doctrine::getLoadedModels();
     $models = Doctrine::initializeModels($models);
     $this->models = Doctrine::filterInvalidModels($models);
     return $this->models;
 }

 /**
  * purge
  * 
  * Purge all data for loaded models or for the passed array of Doctrine_Records
  *
  * @param string $models 
  * @return void
  */
 public function purge($models = null)
 {
     if ($models) {
         $models = Doctrine::filterInvalidModels($models);
     } else {
         $models = Doctrine::getLoadedModels();
     }
     foreach ($models as $model) {
         $model = new $model();
         $model->getTable()->createQuery()->delete($model)->execute();
     }
 }

 /**
  * generateMigrationsFromModels
  *
  * @param string $modelsPath 
  * @return void
  */
 public function generateMigrationsFromModels($modelsPath = null, $modelLoading = null)
 {
     if ($modelsPath !== null) {
         $models = Doctrine::filterInvalidModels(Doctrine::loadModels($modelsPath, $modelLoading));
     } else {
         $models = Doctrine::getLoadedModels();
     }
     $models = Doctrine::initializeModels($models);
     $foreignKeys = array();
     foreach ($models as $model) {
         $export = Doctrine::getTable($model)->getExportableFormat();
         $foreignKeys[$export['tableName']] = $export['options']['foreignKeys'];
         $up = $this->buildCreateTable($export);
         $down = $this->buildDropTable($export);
         $className = 'Add' . Doctrine_Inflector::classify($export['tableName']);
         $this->generateMigrationClass($className, array(), $up, $down);
     }
     if (!empty($foreignKeys)) {
         $className = 'ApplyForeignKeyConstraints';
         $up = '';
         $down = '';
         foreach ($foreignKeys as $tableName => $definitions) {
             $tableForeignKeyNames[$tableName] = array();
             foreach ($definitions as $definition) {
                 $definition['name'] = $tableName . '_' . implode('_', (array) $definition['local']);
                 $up .= $this->buildCreateForeignKey($tableName, $definition);
                 $down .= $this->buildDropForeignKey($tableName, $definition);
             }
         }
         $this->generateMigrationClass($className, array(), $up, $down);
     }
     return true;
 }

 /**
  * exportSql
  * returns the sql for exporting Doctrine_Record classes to a schema
  *
  * if the directory parameter is given this method first iterates
  * recursively trhough the given directory in order to find any model classes
  *
  * Then it iterates through all declared classes and creates tables for the ones
  * that extend Doctrine_Record and are not abstract classes
  *
  * @throws Doctrine_Connection_Exception    if some error other than Doctrine::ERR_ALREADY_EXISTS
  *                                          occurred during the create table operation
  * @param string $directory     optional directory parameter
  * @return void
  */
 public function exportSql($directory = null)
 {
     if ($directory !== null) {
         $models = Doctrine::filterInvalidModels(Doctrine::loadModels($directory));
     } else {
         $models = Doctrine::getLoadedModels();
     }
     return $this->exportSortedClassesSql($models, false);
 }

 /**
  * Generate a set of migrations from a set of models
  *
  * @param  string $modelsPath    Path to models
  * @param  string $modelLoading  What type of model loading to use when loading the models
  * @return boolean
  */
 public function generateMigrationsFromModels($modelsPath = null, $modelLoading = null)
 {
     if ($modelsPath !== null) {
         $models = Doctrine::filterInvalidModels(Doctrine::loadModels($modelsPath, $modelLoading));
     } else {
         $models = Doctrine::getLoadedModels();
     }
     $models = Doctrine::initializeModels($models);
     $foreignKeys = array();
     foreach ($models as $model) {
         $table = Doctrine::getTable($model);
         if ($table->getTableName() !== $this->migration->getTableName()) {
             $export = $table->getExportableFormat();
             $foreignKeys[$export['tableName']] = $export['options']['foreignKeys'];
             $up = $this->buildCreateTable($export);
             $down = $this->buildDropTable($export);
             $className = 'Add' . Doctrine_Inflector::classify($export['tableName']);
             $this->generateMigrationClass($className, array(), $up, $down);
         }
     }
     if (!empty($foreignKeys)) {
         $className = 'AddFks';
         $up = array();
         $down = array();
         foreach ($foreignKeys as $tableName => $definitions) {
             $tableForeignKeyNames[$tableName] = array();
             foreach ($definitions as $definition) {
                 $up[] = $this->buildCreateForeignKey($tableName, $definition);
                 $down[] = $this->buildDropForeignKey($tableName, $definition);
             }
         }
         $up = implode("\n", $up);
         $down = implode("\n", $down);
         if ($up || $down) {
             $this->generateMigrationClass($className, array(), $up, $down);
         }
     }
     return true;
 }

/*
 * This file is part of sfDoctrineGraphvizPlugin
 * (c) 2009 David PHAM-VAN
 * (c) 2009 Dejan Spasic <spasic.dejan@yahoo.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
require_once dirname(__FILE__) . '/../../../bootstrap.php';
require_once dirname(__FILE__) . '/../../../../lib/generator/doctrineGraphvizMcdGenerator.class.php';
// path to model directory
$modelDir = dirname(__FILE__) . '/../../../_files/model';
// retrieve modelnames
$modelNames = Doctrine::loadModels($modelDir, Doctrine::MODEL_LOADING_CONSERVATIVE);
$modelNames = Doctrine::initializeModels($modelNames);
$modelNames = Doctrine::filterInvalidModels($modelNames);
$subject = new doctrineGraphvizMcdGenerator();
$t = new lime_test(8, new lime_output_color());
$t->ok("" === $subject->getBuffer(), "Test if ->getBuffer() is empty");
$t->ok($subject->generate($modelNames) instanceof doctrineGraphvizMcdGenerator, "Test if generate return a object from type doctrineGraphvizMcdGenerator");
$t->ok(is_string($subject->getBuffer()) && "" !== $subject->getBuffer(), "Test if the current buffer is form type string and not empty");
$t->ok($subject->flushBuffer($modelNames) instanceof doctrineGraphvizMcdGenerator, "Test if ->flushBuffer() return a object from type doctrineGraphvizMcdGenerator");
$t->ok("" === $subject->getBuffer(), "Test if ->flushBuffer() flushed the buffer");
$t->ok($subject->generate($modelNames)->getBuffer() === file_get_contents(dirname(__FILE__) . '/../../../_files/expected/mcd.schema.dot'), "Test the generated graphviz");
try {
    $subject->generate('foo');
    $t->fail('Generate did not throw a exception');
} catch (Exception $e) {
    $t->ok($e instanceof InvalidArgumentException, '->generate throw a InvalidArgumentException');
    $t->ok($e->getMessage() === "First Argument must be from type array. [string] given.", "Test the messsage from exception");
}

 /**
  * purge
  * 
  * Purge all data for loaded models or for the passed array of Doctrine_Records
  *
  * @param string $models 
  * @return void
  */
 public function purge($models = null)
 {
     if ($models) {
         $models = Doctrine::filterInvalidModels($models);
     } else {
         $models = Doctrine::getLoadedModels();
     }
     $connections = array();
     foreach ($models as $model) {
         $connections[Doctrine::getTable($model)->getConnection()->getName()][] = $model;
     }
     foreach ($connections as $connection => $models) {
         $models = Doctrine_Manager::getInstance()->getConnection($connection)->unitOfWork->buildFlushTree($models);
         $models = array_reverse($models);
         foreach ($models as $model) {
             Doctrine::getTable($model)->createQuery()->delete()->execute();
         }
     }
 }

 /**
  * exportClassesSql
  * method for exporting Doctrine_Record classes to a schema
  *
  * @throws Doctrine_Connection_Exception    if some error other than Doctrine::ERR_ALREADY_EXISTS
  *                                          occurred during the create table operation
  * @param array $classes
  * @return void
  */
 public function exportClassesSql(array $classes)
 {
     $models = Doctrine::filterInvalidModels($classes);
     $sql = array();
     foreach ($models as $name) {
         $record = new $name();
         $table = $record->getTable();
         $parents = $table->getOption('joinedParents');
         foreach ($parents as $parent) {
             $data = $table->getConnection()->getTable($parent)->getExportableFormat();
             $query = $this->conn->export->createTableSql($data['tableName'], $data['columns'], $data['options']);
             $sql = array_merge($sql, (array) $query);
         }
         $data = $table->getExportableFormat();
         $query = $this->conn->export->createTableSql($data['tableName'], $data['columns'], $data['options']);
         if (is_array($query)) {
             $sql = array_merge($sql, $query);
         } else {
             $sql[] = $query;
         }
         if ($table->getAttribute(Doctrine::ATTR_EXPORT) & Doctrine::EXPORT_PLUGINS) {
             $sql = array_merge($sql, $this->exportPluginsSql($table));
         }
     }
     $sql = array_unique($sql);
     rsort($sql);
     return $sql;
 }