<?php
/*
 * This file is part of the sfDoctrine package.
 * (c) 2006-2007 Olivier Verdier <Olivier.Verdier@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

/**
 * @package    symfony.plugins
 * @subpackage sfDoctrine
 * @author     Olivier Verdier <Olivier.Verdier@gmail.com>
 * @author     Nathanael D. Noblet <nathanael@gnat.ca>
 * @version    SVN: $Id: sfPakeDoctrine.php 4878 2007-08-17 17:45:54Z Jonathan.Wage $
 */

pake_desc('converts propel schema.*ml into doctrine schema');
pake_task('doctrine-import', 'project_exists');

pake_desc('exports doctrine schemas to sql');
pake_task('doctrine-build-sql', 'project_exists');

pake_desc('insert sql for doctrine schemas in to database');
pake_task('doctrine-insert-sql', 'project_exists');

pake_desc('build Doctrine classes');
pake_task('doctrine-build-model', 'project_exists');

pake_desc('Creates Doctrine CRUD Module');
pake_task('doctrine-generate-crud', 'app_exists');

pake_desc('initialize a new doctrine admin module');
pake_task('doctrine-init-admin', 'app_exists');

pake_desc('dump data to yaml fixtures file');
pake_task('doctrine-dump-data', 'project_exists');

pake_desc('load data from yaml fixtures file');
pake_task('doctrine-load-data', 'project_exists');

pake_desc('load doctrine nested set data from nested set fixtures file');
pake_task('doctrine-load-nested-set', 'project_exists');

pake_desc('doctrine build all - generate model and initialize database, drops current database if exists');
pake_task('doctrine-build-all', 'project_exists');

pake_desc('doctrine build all load - generate model, initialize database, and load data from fixtures. Drops current database if exists');
pake_task('doctrine-build-all-load', 'project_exists');

pake_desc('doctrine build schema - build schema from an existing database');
pake_task('doctrine-build-schema', 'project_exists');

pake_desc('doctrine drop all - drop all database tables');
pake_task('doctrine-drop-all-tables', 'project_exists');

pake_desc('doctrine build database - initialize database, drop current database if exists');
pake_task('doctrine-build-db', 'project_exists');

pake_desc('doctrine drop database - drops database');
pake_task('doctrine-drop-db', 'project_exists');

function run_doctrine_drop_all_tables($task, $args)
{
  if (!count($args))
  {
    throw new Exception('You must provide the app.');
  }

  $app = $args[0];
  
  $env = empty($args[1]) ? 'dev' : $args[1];
  
  _load_application_environment($app, $env);
  
  $sf_root_dir = sfConfig::get('sf_root_dir');
  
  $declared = get_declared_classes();
  
  $directory = sfConfig::get('sf_lib_dir').DIRECTORY_SEPARATOR.'model'.DIRECTORY_SEPARATOR.'doctrine'.DIRECTORY_SEPARATOR;
  if ($directory !== null)
  {
      foreach ((array) $directory as $dir)
      {
        $it = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir),
                                                RecursiveIteratorIterator::LEAVES_ONLY);
                                              
        foreach ($it as $file)
        {
            $e = explode('.', $file->getFileName());
            if (end($e) === 'php' && strpos($file->getFileName(), '.inc') === false)
            {
                require_once $file->getPathName();
            }
        }
    }
    
    $declared = array_diff(get_declared_classes(), $declared);
  }

  $parent = new ReflectionClass('Doctrine_Record');
  
  $sql = array();
  $fks = array();

  // we iterate trhough the diff of previously declared classes 
  // and currently declared classes
  foreach ($declared as $name)
  {
      $class = new ReflectionClass($name);
      $conn  = Doctrine_Manager::getInstance()->getConnectionForComponent($name);

      // check if class is an instance of Doctrine_Record and not abstract
      // class must have method setTableDefinition (to avoid non-Record subclasses like symfony's sfDoctrineRecord)
      if ($class->isSubclassOf($parent) && ! $class->isAbstract() && method_exists($class->getName(), 'setTableDefinition'))
      {
          $record = new $name();
          $table  = $record->getTable();
          
          try {
            pake_echo_action('doctrine', "dropping table '".$table->getTableName()."'");
            
            $table->getConnection()->export->dropTable($table->getTableName());
          } catch(Exception $e) {
            continue;
          }
      }
  }
}

function run_doctrine_load_data($task, $args)
{
  if (!count($args))
  { 
    throw new Exception('You must provide the app.');
  }
 
  $app = $args[0];
 
  if (!is_dir(sfConfig::get('sf_app_dir').DIRECTORY_SEPARATOR.$app))
  { 
    throw new Exception('The app "'.$app.'" does not exist.');
  }
 
  if (count($args) > 1 && $args[count($args) - 1] == 'append')
  { 
    array_pop($args);
    $delete = false;
  }
  else
  { 
    $delete = true;
  }
 
  $env = empty($args[1]) ? 'dev' : $args[1];
 
  _load_application_environment($app, $env);
  
  if (count($args) == 1)
  {
    if (!$pluginDirs = glob(sfConfig::get('sf_root_dir').'/plugins/*/data'))
    {
      $pluginDirs = array();
    }
    $fixtures_dirs = pakeFinder::type('dir')->name('fixtures')->in(array_merge($pluginDirs, array(sfConfig::get('sf_data_dir'))));
  }
  else
  {
    $fixtures_dirs = array_slice($args, 1);
  }
 
  $data = new sfDoctrineData();
  $data->setDeleteCurrentData($delete);
 
  foreach ($fixtures_dirs as $fixtures_dir)
  {
    if (!is_readable($fixtures_dir))
    {
      continue;
    }
 
    pake_echo_action('doctrine', sprintf('load data from "%s"', $fixtures_dir));
 
    $data->loadData($fixtures_dir);
  }
}

function run_doctrine_import($task, $args)
{
  $type = 'xml';
  if (isset($args[0]))
    $type = $args[0];

  $schemas = _doctrine_load('propel', $type, false);
  
  $doctrineSchemasDir = sfConfig::get('sf_config_dir').DIRECTORY_SEPARATOR.'doctrine'.DIRECTORY_SEPARATOR;
  
  pake_mkdirs($doctrineSchemasDir);

  foreach($schemas as $schema)
  {
    $doctrineYml = $schema->asDoctrineYml();
    $classes = $schema->getClasses();
    $class = array_pop($classes);
    $package = $class->getTable()->getPackage();
    $filePath = $package.'.yml';
    
    pake_echo_action('writing', $filePath);
    
    file_put_contents($doctrineSchemasDir.$filePath, $doctrineYml['source']);
  }
}

function run_doctrine_export($task, $args)
{
  $schemas = _doctrine_load('doctrine', 'yml', false);
  
  $configDir = sfConfig::get('sf_config_dir').DIRECTORY_SEPARATOR;
  
  foreach($schemas as $schema)
  {
    $propelXml = $schema->asPropelXml();
    
    // we do some tidying before echoing the xml
    $source = preg_replace(array('#</database#', '#<(/?)table#', '#<column#', '#<(/?)foreign-key#', '#<reference#'), array("\n</database", "\n<\\1table", "\n  <column", "\n  <\\1foreign-key", "\n    <reference",), $propelXml['source']);
    
    $filePath = $propelXml['name'].'-schema.xml';
    
    pake_echo_action('writing', $filePath);
    
    file_put_contents($configDir.$filePath, $source);
  }
}

function run_doctrine_insert_sql($task, $args)
{
  if (!count($args))
  {
    throw new Exception('You must provide the app.');
  }

  $app = $args[0];
  
  $env = empty($args[1]) ? 'dev' : $args[1];
  
  _load_application_environment($app, $env);
  
  $sf_root_dir = sfConfig::get('sf_root_dir');
  
  $directories = sfFinder::type('dir')->maxdepth(0)->ignore_version_control()->in(sfConfig::get('sf_model_lib_dir').'/doctrine');
  
  Doctrine::exportSchema($directories);
  
  pake_echo_action('doctrine', 'sql was inserted successfully');
  
  return;
}

function run_doctrine_build_sql($task,$args)
{
    if(count($args) < 1)
    {
        throw new Exception('You must provide your app name.');
    }
    
    $sf_root_dir = sfConfig::get('sf_root_dir');
    define('SF_APP',         $args[0]);
    $connection = isset($args[1])?$args[1]:'all';
    
    simpleAutoloader::registerCallable(array('Doctrine','autoload'));

    sfConfig::set('sf_app_module_dir',$sf_root_dir.DIRECTORY_SEPARATOR.'apps'.DIRECTORY_SEPARATOR.SF_APP.DIRECTORY_SEPARATOR.'modules'.DIRECTORY_SEPARATOR);

    $doctrineSchemaPathScheme = DIRECTORY_SEPARATOR.'model'.DIRECTORY_SEPARATOR.'doctrine'.DIRECTORY_SEPARATOR;
    $doctrineModelDir = sfConfig::get('sf_lib_dir').$doctrineSchemaPathScheme;
    $generatedDir = $doctrineModelDir.'generated'.DIRECTORY_SEPARATOR;
    
    $tmp_dir = $sf_root_dir.DIRECTORY_SEPARATOR.'cache'.DIRECTORY_SEPARATOR.'tmp'.DIRECTORY_SEPARATOR.md5(uniqid(rand(), true));

    $db_connections = sfYaml::load($sf_root_dir.DIRECTORY_SEPARATOR.'config'.DIRECTORY_SEPARATOR.'databases.yml');
    if(!isset($db_connections[$connection]))
    {
        throw new sfException('Unable to find connection: '.$connection);
    }
    
    $connection = current($db_connections[$connection]);
    $db = new sfDoctrineDatabase();
    $db->initialize($connection['param']);
    
    $directories = sfFinder::type('dir')->maxdepth(0)->ignore_version_control()->in(sfConfig::get('sf_model_lib_dir').'/doctrine');

    foreach ($directories AS $directory)
    {
        $basename = basename($directory);
        $name = $basename == 'generated' ? 'doctrine':'doctrine-'.$basename;
  
        pake_echo_action("Building SQL", $name);
  
        $sql = implode(";\n\n",Doctrine::exportSql($directory)).";\n";
        $sql = str_replace(array(" (",") ",","),array("(\n ",")\n",",\n"),$sql);

        if (!is_dir($sf_root_dir.DIRECTORY_SEPARATOR.'data'.DIRECTORY_SEPARATOR.'sql'))
        {
            mkdir($sf_root_dir.DIRECTORY_SEPARATOR.'data'.DIRECTORY_SEPARATOR.'sql');
        }

        $fd = fopen($sf_root_dir.DIRECTORY_SEPARATOR.'data'.DIRECTORY_SEPARATOR.'sql'.DIRECTORY_SEPARATOR.$name.'.model.sql','w+');
        fwrite($fd,$sql);
        fclose($fd);
    }
    
    return; 
}


function run_doctrine_build_model($task, $args)
{
  $schemas = _doctrine_load('doctrine', 'yml', true);
  $doctrineSchemaPathScheme = DIRECTORY_SEPARATOR.'model'.DIRECTORY_SEPARATOR.'doctrine'.DIRECTORY_SEPARATOR;
  $doctrineModelDir = sfConfig::get('sf_lib_dir').$doctrineSchemaPathScheme;

  $generatedDir = $doctrineModelDir.'generated'.DIRECTORY_SEPARATOR;
  pake_mkdirs($generatedDir);

  foreach($schemas as $db_schema)
  {
    foreach ($db_schema->getClasses() as $class)
    {
      foreach ($class->asPHP() as $cd)
      {
        $path = $doctrineModelDir;

        $package = $class->getTable()->getPackage();
        if ($package)
        {
          if (isset($cd['plugin']))
          {
            $path = sfConfig::get('sf_plugins_dir').DIRECTORY_SEPARATOR.$package.DIRECTORY_SEPARATOR.'lib'.$doctrineSchemaPathScheme;
          }
          else
          {
            $path.= $package.DIRECTORY_SEPARATOR;
          }
        }
        
        if (isset($cd['overwrite']))
        {
          $path .= 'generated'.DIRECTORY_SEPARATOR;
        }
        
        pake_mkdirs($path);

        $filePath = $cd['className'].'.class.php';
          
        // we overwrite only the base classes
        if (isset($cd['overwrite']) || !file_exists($path.$filePath)) 
        {
          pake_echo_action('writing', $filePath);
          file_put_contents($path.$filePath, $cd['source']);
        }
      }
    }
  }
}

function run_doctrine_build_all($task, $args)
{
  run_doctrine_drop_db($task, $args);
  run_doctrine_build_db($task, $args);
  run_doctrine_build_model($task, $args);
  //run_doctrine_insert_sql($task, $args);
}

function run_doctrine_build_all_load($task, $args)
{
  run_doctrine_build_all($task, $args);
  run_doctrine_load_data($task, $args);
}

function run_doctrine_build_schema($task, $args)
{
  // This will build schema from an existing database
  throw new Exception('Not implemented.');
}

function run_doctrine_drop_db($task, $args)
{
  if (!count($args))
  {
    throw new Exception('You must provide the app.');
  }

  $app = $args[0];
  
  $env = empty($args[1]) ? 'dev' : $args[1];
  
  _load_application_environment($app, $env);
  
  $databases = sfYaml::load(sfConfig::get('sf_root_dir').DIRECTORY_SEPARATOR.'config'.DIRECTORY_SEPARATOR.'databases.yml');
  
  $connectionBlockKey = $env;
  
  if(!isset($databases[$connectionBlockKey]))
  {
  	$connectionBlockKey = 'all';
  }

  
  $connections = $databases[$connectionBlockKey];
  
  $manager = Doctrine_Manager::getInstance();
  
  foreach ($connections AS $name => $info)
  {
    $dsnInfo = $manager->parseDsn($info['param']['dsn']);
    $connection = $manager->getConnection($name);
    
    try {
      echo "Drop database '".$dsnInfo['database']."' are you sure Y/N ?";
      $confirmation = strtolower(trim(fgets(STDIN)));
      if ($confirmation!='y') {
        pake_echo_action("cancelled");
        exit(1);
      }

      pake_echo_action('doctrine', "dropping database '".$dsnInfo['database']."'");
      
      $connection->export->dropDatabase($dsnInfo['database']);
    } catch (Exception $e) {
      pake_echo_action('doctrine', "could not drop database '".$dsnInfo['database']."'");
    }
  }
}

function run_doctrine_build_db($task, $args)
{
  $connectionName = isset($args[0]) ? $args[0]:'all';
  
  simpleAutoloader::registerCallable(array('Doctrine','autoload'));
  
  $databases = sfYaml::load(sfConfig::get('sf_root_dir').DIRECTORY_SEPARATOR.'config'.DIRECTORY_SEPARATOR.'databases.yml');
  
  if(!isset($databases[$connectionName]))
  {
  	$connectionName = 'all';
  }
      
  $connections = $databases[$connectionName];
  
  foreach($connections AS $name => $connection)
  {
    $dsn = $connection['param']['dsn'];
    $info = Doctrine_Manager::getInstance()->parseDsn($dsn);
    
    $dsn = $info['scheme'].':host='.$info['host'];
    $user = $info['user'];
    $password = $info['pass'];
    
    $connection = Doctrine_Manager::getInstance()->openConnection(new PDO($dsn, $user, $password), $name.'2');
    
    pake_echo_action('doctrine', "creating database '".$info['database']."'");
  
    try {
      $connection->export->createDatabase($info['database']);
    } catch(Exception $e) {
      pake_echo_action('doctrine', "could not create database '".$info['database']."'");
    }
  }
}

// FIXME: has to be rewritten to avoid code duplication
function run_doctrine_generate_crud($task,$args)
{
  if (count($args) < 2)
  {
    throw new Exception('You must provide your module name.');
  }

  if (count($args) < 3)
  {
    throw new Exception('You must provide your model class name.');
  }

  $app         = $args[0];
  $module      = $args[1];
  $model_class = $args[2];
  $theme = isset($args[3]) ? $args[3] : 'crud';

  // function variables
  $doctrineModelDir = sfConfig::get('sf_lib_dir').DIRECTORY_SEPARATOR.'model'.DIRECTORY_SEPARATOR.'doctrine'.DIRECTORY_SEPARATOR;
  $sf_root_dir = sfConfig::get('sf_root_dir');
  $sf_symfony_lib_dir = sfConfig::get('sf_symfony_lib_dir');
  $pluginDir = realpath(dirname(__FILE__).DIRECTORY_SEPARATOR.'..'.DIRECTORY_SEPARATOR.'..');
  $doctrineLibDir =$pluginDir.DIRECTORY_SEPARATOR.'lib'.DIRECTORY_SEPARATOR.'doctrine'.DIRECTORY_SEPARATOR.'Doctrine'.DIRECTORY_SEPARATOR;
  $tmp_dir = $sf_root_dir.DIRECTORY_SEPARATOR.'cache'.DIRECTORY_SEPARATOR.'tmp'.DIRECTORY_SEPARATOR.md5(uniqid(rand(), true));

  sfConfig::set('sf_module_cache_dir', $tmp_dir);
  sfConfig::set('sf_app_dir', $tmp_dir);
  // add classes to autoload function
  pake_echo_action('PluginDir', $pluginDir);

  simpleAutoloader::registerCallable(array('Doctrine','autoload'));

  // generate module
  $generator_manager = new sfGeneratorManager();
  $generator_manager->initialize();
  $generator_manager->generate('sfDoctrineAdminGenerator', array('model_class' => $model_class, 'moduleName' => $module, 'theme' => $theme));
  $moduleDir = $sf_root_dir.'/'.sfConfig::get('sf_apps_dir_name').'/'.$app.'/'.sfConfig::get('sf_app_module_dir_name').'/'.$module;
  
  // copy our generated module
  $finder = pakeFinder::type('any');
  pake_mirror($finder, $tmp_dir.'/auto'.ucfirst($module), $moduleDir);

  // change module name
  pake_replace_tokens($moduleDir.'/actions/actions.class.php', getcwd(), '', '', array('auto'.ucfirst($module) => $module));

  try
  {
    $author_name = $task->get_property('author', 'symfony');
  }
  catch (pakeException $e)
  {
    $author_name = 'Your name here';
  }

  $constants = array(
    'PROJECT_NAME' => $task->get_property('name', 'symfony'),
    'APP_NAME'     => $app,
    'MODULE_NAME'  => $module,
    'MODEL_CLASS'  => $model_class,
    'AUTHOR_NAME'  => $author_name,
  );

  // customize php files
  $finder = pakeFinder::type('file')->name('*.php');
  pake_replace_tokens($finder, $moduleDir, '##', '##', $constants);

  // delete temp files
  $finder = pakeFinder::type('any');
  pake_remove($finder, $tmp_dir);

  // for some reason the above does not remove the tmp dir as it should.
  // delete temp dir
  @rmdir($tmp_dir);
  
  // delete cache/tmp
  @rmdir(sfConfig::get('sf_cache_dir').'tmp');
}

// FIXME: has to be rewritten to avoid code duplication
function run_doctrine_init_admin($task, $args)
{
  if (count($args) < 2)
  {
    throw new Exception('You must provide your module name.');
  }

  if (count($args) < 3)
  {
    throw new Exception('You must provide your model class name.');
  }
    
  $app         = $args[0];
  $module      = $args[1];
  $model_class = $args[2];
  $theme       = isset($args[3]) ? $args[3] : 'default';

  try
  {
    $author_name = $task->get_property('author', 'symfony');
  }
  catch (pakeException $e)
  {
    $author_name = 'Your name here';
  }

  $constants = array(
    'PROJECT_NAME' => $task->get_property('name', 'symfony'),
    'APP_NAME'     => $app,
    'MODULE_NAME'  => $module,
    'MODEL_CLASS'  => $model_class,
    'AUTHOR_NAME'  => $author_name,
    'THEME'        => $theme,
  );

  $moduleDir = sfConfig::get('sf_root_dir').DIRECTORY_SEPARATOR.sfConfig::get('sf_apps_dir_name').DIRECTORY_SEPARATOR.$app.DIRECTORY_SEPARATOR.sfConfig::get('sf_app_module_dir_name').DIRECTORY_SEPARATOR.$module;
  
  // create module structure
  $finder = pakeFinder::type('any')->ignore_version_control()->discard('.sf');
  $dirs = sfLoader::getGeneratorSkeletonDirs('sfDoctrineAdmin', $theme);
  foreach($dirs as $dir)
  {
    echo $dir;
    if(is_dir($dir))
    {
      pake_mirror($finder, $dir, $moduleDir);
      break;
    }
  }

  // customize php and yml files
  $finder = pakeFinder::type('file')->name('*.php', '*.yml');
  pake_replace_tokens($finder, $moduleDir, '##', '##', $constants);
}


/**
 * run_doctrine_load_nested_set 
 * 
 * @param mixed $task 
 * @param mixed $args 
 * @access public
 * @return void
 */
function run_doctrine_load_nested_set($task, $args)
{
  if (!count($args))
  {
    throw new Exception('You must provide the app.');
  }

  $app = $args[0];

  if (!is_dir(sfConfig::get('sf_app_dir').DIRECTORY_SEPARATOR.$app))
  {
    throw new Exception('The app "'.$app.'" does not exist.');
  }

  if (!isset($args[1]))
  {
    throw new Exception('You must provide a filename.');
  }

  $filename = $args[1];

  $env = empty($args[2]) ? 'dev' : $args[2];
  
  _load_application_environment($app, $env);

  $model = sfInflector::classify($args[1]);
  $ymlName = sfInflector::tableize($args[1]);
  
  $ymlPath = sfConfig::get('sf_data_dir').'/'.$ymlName.'.yml';
  
  pake_echo_action('doctrine', 'loading nested set data for '.$model);
  pake_echo_action('doctrine', 'loading '.$ymlPath);
  
  $nestedSetData = sfYaml::load($ymlPath);

  _doctrine_load_nested_set_data($model, $nestedSetData);
}

/**
 * run_doctrine_dump_data 
 * 
 * @param mixed $task 
 * @param mixed $args 
 * @access public
 * @return void
 */
function run_doctrine_dump_data($task, $args)
{
  if (!count($args))
  {
    throw new Exception('You must provide the app.');
  }

  $app = $args[0];

  if (!is_dir(sfConfig::get('sf_app_dir').DIRECTORY_SEPARATOR.$app))
  {
    throw new Exception('The app "'.$app.'" does not exist.');
  }

  if (!isset($args[1]))
  {
    throw new Exception('You must provide a filename.');
  }

  $filename = $args[1];

  $env = empty($args[2]) ? 'dev' : $args[2];
  
  _load_application_environment($app, $env);

  if (!sfToolkit::isPathAbsolute($filename))
  {
    $dir = sfConfig::get('sf_data_dir').DIRECTORY_SEPARATOR.'fixtures';
    pake_mkdirs($dir);
    $filename = $dir.DIRECTORY_SEPARATOR.$filename;
  }

  pake_echo_action('doctrine', sprintf('dumping data to "%s"', $filename));

  $data = new sfDoctrineData();
  $data->dumpData($filename);
}

/**
 * _doctrine_load_nested_set_data 
 * 
 * @param mixed $model 
 * @param mixed $nestedSetData 
 * @param mixed $parent 
 * @access protected
 * @return void
 */
function _doctrine_load_nested_set_data($model, $nestedSetData, $parent = null)
{
  $manager = Doctrine_Manager::getInstance();

  foreach($nestedSetData AS $name => $data)
  {
    $children = array();
    $setters  = array();
    
    if( array_key_exists('children', $data) )
    {
      $children = $data['children'];
      unset($data['children']);
    }

    if( array_key_exists('setters', $data) )
    {
      $setters = $data['setters'];
      unset($data['setters']);
    }

    $record = new $model();
    
    if( is_array($setters) AND !empty($setters) )
    {
      foreach($setters AS $key => $value)
      {
        $record->set($key, $value);
      }
    }
    
    if( !$parent )
    {
      $manager->getTable($model)->getTree()->createRoot($record);
    } else {
      $parent->getNode()->addChild($record);
    }

    pake_echo_action('doctrine', 'loading '.str_repeat(' ', $record->getNode()->getLevel()).$name);

    if( is_array($children) AND !empty($children) )
    {
      _doctrine_load_nested_set_data($model, $children, $record);
    }
  }
}

function _findPropelSchemas($type)
{
  $preGlob = '*schema';
  $root = 'config';

  $extension = '.'.$type;

  $schemas = pakeFinder::type('file')->name($preGlob.$extension)->in($root);

  $schemasToLoad = array();
  foreach ($schemas as $schema)
  {
    // we store the name of the file as "package"
    $schemasToLoad[$schema] = basename($schema, $extension);
  }

  return $schemasToLoad;
}

function _findDoctrineSchemas()
{
  $schemasToLoad = array();

  // first we try with a connection mapping config file
  $connectionMappingPath = 'config/schemas.yml';
  if (file_exists($connectionMappingPath))
  {
    $connectionMapping = sfYaml::load($connectionMappingPath);

    foreach ($connectionMapping as $connection => $schemas)
    {
      foreach ($schemas as $schema)
      {
        $components = explode('/', $schema);
        $name = array_pop($components);
        $schemaPath = 'config/doctrine/'.$name.'.yml';
        if (!empty($components))
        {
          $packageName = $components[0];
          $schemaPath = sfConfig::get('sf_plugins_dir').DIRECTORY_SEPARATOR.$packageName.DIRECTORY_SEPARATOR.$schemaPath;
        }
        else
          $packageName = null;

        if (file_exists($schemaPath))
        {
          $schemasToLoad[$schemaPath] = $packageName;
        }
      }
    }
  }
  else // otherwise we load all the schemas in the doctrine directories
  {
    $preGlob = '*';
    $root = 'config'.DIRECTORY_SEPARATOR.'doctrine';

    $schemas = pakeFinder::type('file')->name($preGlob.'.yml')->in($root);

    if(count($schemas))
        $schemas = array_combine($schemas, array_fill(0, count($schemas), null));

    // adding the plugin schemas
    $pluginSchemas = array();
    $pluginSchemas = pakeFinder::type('file')->name($preGlob.'.yml')->in(glob('plugins/*/'.$root));
    $schemasToLoad = array();
    foreach ($pluginSchemas as $pluginSchema)
    {
      // we get the plugin name from the path file; not very elegant...
      $pluginName = basename(substr(dirname($pluginSchema), 0, -strlen($root)));
      $schemasToLoad[$pluginSchema] = $pluginName;
    }

    $schemasToLoad = array_merge($schemas, $schemasToLoad);
  }
  return $schemasToLoad;
}

function _doctrine_load($mode, $type, $aggregate)
{
  $schemasToLoad = array();

  if ($mode == 'doctrine')
  {
    $schemasToLoad = _findDoctrineSchemas();
  }
  elseif ($mode == 'propel')
  {
    $schemasToLoad = _findPropelSchemas($type);
  }
    
  if (!count($schemasToLoad))
  {
    throw new Exception('No schemas were found');
  }

  $dbSchemas = array();
  
  // schema loader class
  $schemaClass = 'sfDoctrineSchema'.ucfirst($mode).'Loader';
  
  $db_schema = new $schemaClass();
  $db_schemas = array();

  foreach ($schemasToLoad as $schema => $package)
  {
    if (!$aggregate)
    {
      $db_schema = new $schemaClass();
    }
    $relativeSchema = substr($schema, strlen(sfConfig::get('sf_root_dir'))+1);

    pake_echo_action('loading', 'Class descriptions from "'.$schema.'"');
    $db_schema->load($schema, $package);
    if (!$aggregate)
    {
      $db_schema->process();
      $db_schemas[] = $db_schema;
    }
  }

  if ($aggregate)
  {
    $db_schema->process();
    $db_schemas = array($db_schema);
  }

  return $db_schemas;
}

function _load_application_environment($app, $env)
{
  // define constants
  define('SF_ROOT_DIR',    sfConfig::get('sf_root_dir'));
  define('SF_APP',         $app);
  define('SF_ENVIRONMENT', $env);
  define('SF_DEBUG',       true);

  // get configuration
  require_once SF_ROOT_DIR.DIRECTORY_SEPARATOR.'apps'.DIRECTORY_SEPARATOR.SF_APP.DIRECTORY_SEPARATOR.'config'.DIRECTORY_SEPARATOR.'config.php';
  
  sfContext::getInstance();
}