Manager.php

<?php
class ZendDbSchema_Db_Migration_Manager implements IteratorAggregate
{
    protected $_adapter;

    protected $_changes = array();

    protected $_currentVersion;

    public function __construct($version, array $files = array(), array $options = array())
    {
        $this->_currentVersion = (string) $version;

        foreach ($files as $file) {
            $this->addChange($file);
        }

        if (empty($options['directory'])) {
            foreach (new DirectoryIterator($options['directory']) as $file) {
                if ($file->isFile() && substr($file->getBasename(), -4) == '.php') {
                    $this->addChange($file);
                }
            }
        }

        if ($this->_currentVersion && !array_key_exists($this->_currentVersion, $this->_changes)) {
            throw new ZendDbSchema_Db_Migration_Exception(
                "Current change '{$this->_currentVersion}' in not exists"
            );
        }

        $prev = null;
        foreach ($this->_changes as $version => $instance) {
            $this->_changes[$version]['previous'] = $prev;
            if ($prev) {
                $this->_changes[$prev]['next'] = $version;
            }
            $prev = $version;
        }

        $this->init();
    }

    public function addChange($change)
    {
        if (!$change instanceof ZendDbSchema_Db_Migration_Change) {
            $change = ZendDbSchema_Db_Migration_Change::fromFile($change);
        }
        $this->_changes[$change->getVersion()] = array('instance' => $change);

        foreach ($this->_changes as $change) {
            if ($change->compareVersion($change, '=')) {
                break;
            }
        }
        $next = next($this->_changes);
        $this->_changes[$change->getVersion()]['next'] = key($next);

        $prev = prev(prev($this->_changes));

        $this->_changes[$prev]['next'] = $change->getVersion();

        return $this;
    }

    public function init()
    {
    }

    public function getIterator()
    {
        ksort($this->_changes);

        return $this->_changes;
    }

    public function getList()
    {
        return array_keys($this->getIterator());
    }

    public function getVersion()
    {
        return $this->_currentVersion;
    }

    public function getChange($version = null)
    {
        if (!$version) {
            $version = $this->getVersion();
        }

        if ($this->hasChange($version)) {
            return $this->_changes[$version]['instance'];
        }
        return null;
    }

    public function getNext($version = null)
    {
        if (!$version) {
            $version = $this->getVersion();
        }
        if ($this->hasChange($version)) {
            return $this->_changes[$version]['next'];
        }
        return key($this->getIterator());
    }

    public function hasChange($change)
    {
        return array_key_exists((string) $change, $this->_changes);
    }

    public function getPrevious($version = null)
    {
        if (!$version) {
            $version = $this->getVersion();
        }
        if ($this->hasChange($version)) {
            return $this->_changes[$version]['prev'];
        }
        return null;
    }

    public function rollup()
    {
        $next = $this->getNext();
        if (!$next) {
            throw new ZendDbSchema_Db_Migration_Exception('No migration to rollup');
        }

        $change = $this->getChange($next);
        foreach ($change->getTablesConfig() as $name => $config) {
            $schema = new ZendDbSchema_Db_Schema_Table($name);
            $schema->setFromArray($config);
            $schema->save();
        }
        $change->up();

        $this->_currentVersion = $next;
    }

    public function rolldown()
    {
        if (!$this->getChange()) {
            throw new ZendDbSchema_Db_Migration_Exception('No migration to rolldown');
        }
        $prev = $this->getPrevious();
        if (!$prev) {
            throw new ZendDbSchema_Db_Migration_Exception('Current migration is initial');
        }

        if (!$this->getChange()->isDowngradable()) {
            throw new ZendDbSchema_Db_Migration_Exception($this->getVersion() . ' migration is not downgradable');
        }

        $change = $this->getChange($prev);
        foreach ($change->getTablesConfig() as $name => $config) {
            $schema = new ZendDbSchema_Db_Schema_Table($name);
            $schema->setFromArray($config);
            $schema->save();
        }
        $change->down();

        $this->_currentVersion = $prev;
    }

    public function up($version = null)
    {
        if ($this->compareVersion($version, '=')) {
            throw new ZendDbSchema_Db_Migration_Exception("Nothing to migrate");
        }
        if ($this->compareVersion($version, '<')) {
            throw new ZendDbSchema_Db_Migration_Exception("'{$version}' is less then current");
        }

        while ($this->compareVersion($version, '>')) {
            $this->rollup();
        }
    }

    public function down($version)
    {
        if ($this->compareVersion($version, '=')) {
            throw new ZendDbSchema_Db_Migration_Exception("Nothing to migrate");
        }
        if ($this->compareVersion($version, '>')) {
            throw new ZendDbSchema_Db_Migration_Exception("'{$version}' is greater then current");
        }

        while ($this->compareVersion($version, '<')) {
            $this->rolldown();
        }
    }

    public function compareVersion($change, $operator = null)
    {
        if (!$this->hasChange($change)) {
            throw new ZendDbSchema_Db_Migration_Exception("Change '{$change}' is not found");
        }
        if (!$change instanceof ZendDbSchema_Db_Migration_Change) {
            $change = $this->getChange($change);
        }

        $result = $change->compareVersion($this->getVersion(), $operator);

        return is_bool($result) ? !$result : -$result;
    }

    public function isDirty()
    {
        $change = $this->getChange();

        foreach ($change->getTablesConfig() as $name => $config) {
            $schema = new ZendDbSchema_Db_Schema_Table($name);
            $schema->setFromArray($config);
            if ($schema->isDirty()) {
                return true;
            }
        }

        foreach ($change->getDatabasesConfig() as $name => $config) {
            $schema = new ZendDbSchema_Db_Schema_Table($name);
            $schema->setFromArray($config);
            if ($schema->isDirty()) {
                return true;
            }
        }
        return false;
    }
}