Phinx\Db\Adapter\MongoMigrationAdapter

Complexity

Total Complexity

70

Size/Duplication

Total Lines	530
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	6

Importance

Changes

0

56 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	getVersions()	0	4	1
A	getVersionLog()	0	9	2
A	setOptions()	0	4	1
A	getOptions()	0	4	1
A	hasOption()	0	4	1
A	getOption()	0	7	2
A	setInput()	0	5	1
A	getInput()	0	4	1
A	setOutput()	0	5	1
A	getOutput()	0	4	1
A	migrated()	0	17	2
A	toggleBreakpoint()	0	4	1
A	resetAllBreakpoints()	0	4	1
A	hasSchemaTable()	0	4	1
A	createSchemaTable()	0	4	1
A	getAdapterType()	0	4	1
A	connect()	0	6	1
A	disconnect()	0	4	1
A	hasTransactions()	0	4	1
A	beginTransaction()	0	4	1
A	commitTransaction()	0	4	1
A	rollbackTransaction()	0	4	1
A	execute()	0	4	1
B	executeActions()	0	34	8
A	getQueryBuilder()	0	4	1
A	query()	0	4	1
A	fetchRow()	0	4	1
A	fetchAll()	0	4	1
A	insert()	0	4	1
A	bulkinsert()	0	4	1
A	quoteTableName()	0	4	1
A	quoteColumnName()	0	4	1
A	hasTable()	0	4	1
A	createTable()	0	3	1
A	truncateTable()	0	4	1
A	getColumns()	0	4	1
A	hasColumn()	0	4	1
A	hasIndex()	0	5	1
A	hasIndexByName()	0	5	1
A	hasPrimaryKey()	0	4	1
A	hasForeignKey()	0	4	1
A	getColumnTypes()	0	10	1
A	isValidColumnType()	0	4	1
A	getSqlType()	0	4	1
A	createDatabase()	0	3	1
A	hasDatabase()	0	4	1
A	dropDatabase()	0	4	1
A	createSchema()	0	4	1
A	dropSchema()	0	4	1
A	castToBool()	0	4	1
A	getMigrationCollection()	0	4	1
A	getDatabase()	0	4	1
A	hasValue()	0	9	3
A	hasValues()	0	9	3
A	getConnection()	0	4	1

<?php

namespace Phinx\Db\Adapter;

use MongoDB\Client;
use MongoDB\Collection;
use MongoDB\Database;
use Phinx\Db\Action\AddIndex;
use Phinx\Db\Action\DropIndex;
use Phinx\Db\Action\DropTable;
use Phinx\Db\Adapter\AdapterInterface as PhinxAdapter;
use Phinx\Db\Table\Column;
use Phinx\Db\Table\Table;
use Phinx\Migration\MigrationInterface;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

class MongoMigrationAdapter implements PhinxAdapter
{

    protected $collectionName = 'phinx_migration';

    /** @var InputInterface $consoleInput */
    protected $consoleInput;

    /** @var OutputInterface $consoleOutput */
    protected $consoleOutput;

    /** @var Client $mongoClient */
    protected $mongoClient;

    /** @var Database $database */
    protected $database;

    /** @var Collection $collection */
    protected $collection;

    /** @var string $databaseName */
    protected $databaseName;

    /** @var string $uri */
    protected $uri;

    protected $session;

    protected $options = [
        'table_prefix' => ''
    ];

    function __construct(array $options)

It is generally recommended to explicitly declare the visibility for methods.

    {
        $this->collectionName = $options['default_migration_table'];
        $this->databaseName = $options['name'];
        $this->uri = $options['uri'];
        $this->options = $options;
        $this->connect();
    }

    /**
     * @return array
     */
    public function getVersions()
    {
        return array_keys($this->getVersionLog());
    }

    /**
     * @return array
     */
    public function getVersionLog()
    {
        $result = [];
        $rows = $this->getMigrationCollection()->find();
        foreach ($rows as $row) {
            $result[$row['version']] = $row;
        }
        return $result;
    }

    /**
     * @param array $options
     * @return $this|PhinxAdapter
     */
    public function setOptions(array $options)
    {
        return $this;
    }

    /**
     * @return array
     */
    public function getOptions()
    {
        return $this->options;
    }

    public function hasOption($name)
    {
        return true;
    }

    /**
     * @param string $name
     * @return mixed|null
     */
    public function getOption($name)
    {
        if (isset($this->options[$name])) {
            return $this->options[$name];
        }
        return null;
    }

    /**
     * @param InputInterface $input
     * @return $this|PhinxAdapter
     */
    public function setInput(InputInterface $input)
    {
        $this->consoleInput = $input;
        return $this;
    }

    /**
     * @return InputInterface
     */
    public function getInput()
    {
        return $this->consoleInput;
    }

    /**
     * @param OutputInterface $output
     * @return PhinxAdapter
     */
    public function setOutput(OutputInterface $output)
    {
        $this->consoleOutput = $output;
        return $this;
    }

    public function getOutput()
    {
        return $this->consoleOutput;
    }

    /**
     * @param MigrationInterface $migration
     * @param string $direction
     * @param int $startTime
     * @param int $endTime
     * @return $this|PhinxAdapter
     */
    public function migrated(MigrationInterface $migration, $direction, $startTime, $endTime)
    {
        if (strcasecmp($direction, MigrationInterface::UP) === 0) {
            $this->getMigrationCollection()->insertOne([
                'name' => $migration->getName(),
                'start_time' => $startTime,
                'end_time' => $endTime,
                'version' => $migration->getVersion(),
                'breakpoint' => false
            ]);
        } else {
            $this->getMigrationCollection()->deleteOne([
                'version' => $migration->getVersion()
            ]);
        }
        return $this;
    }

    /**
     * @param MigrationInterface $migration
     * @return $this|PhinxAdapter
     */
    public function toggleBreakpoint(MigrationInterface $migration)
    {
        return $this;
    }

    public function resetAllBreakpoints()
    {
        throw new \InvalidArgumentException("Not implemented");
    }

    /**
     * @return bool
     */
    public function hasSchemaTable()
    {
        return true;
    }

    public function createSchemaTable()
    {
        throw new \InvalidArgumentException("Not implemented");
    }

    public function getAdapterType()
    {
        return null;
    }

    public function connect()
    {
        $this->mongoClient = new Client($this->uri);
        $this->database = $this->mongoClient->selectDatabase($this->databaseName);
        $this->collection = $this->database->selectCollection($this->collectionName);
    }

    public function disconnect()
    {
        throw new \InvalidArgumentException("Not implemented");
    }

    public function hasTransactions()
    {
        return false;
    }

    public function beginTransaction()
    {
        throw new \InvalidArgumentException("Not implemented");
    }

    public function commitTransaction()
    {
        throw new \InvalidArgumentException("Not implemented");
    }

    public function rollbackTransaction()
    {
        throw new \InvalidArgumentException("Not implemented");
    }

    public function execute($sql)
    {
        throw new \InvalidArgumentException("Don't know how to execute");
    }

    public function executeActions(Table $table, array $actions)
    {
        foreach ($actions as $action) {

            if ($action instanceof AddIndex) {
                $columns = $action->getIndex()->getColumns();
                $options = [];
                $indexName = $action->getIndex()->getName();
                if (!empty($indexName)) {
                    $options['name'] = $indexName;
                }
                $type = $action->getIndex()->getType();
                if ($type == 'unique') {
                    $options['unique'] = true;
                }
                $this->getDatabase()
                    ->selectCollection($action->getTable()->getName())
                    ->createIndex($columns, $options);
            } elseif ($action instanceof DropIndex) {
                $indexName = $action->getIndex()->getName();
                if (!empty($indexName)) {
                    $this->getDatabase()->selectCollection($action->getTable()->getName())
                        ->dropIndex($indexName);
                }
            } elseif ($action instanceof DropTable) {
                $this->getDatabase()
                    ->dropCollection($action->getTable()->getName());
            } else {
                throw new \InvalidArgumentException(
                    sprintf("Don't know how to execute action: '%s'", get_class($action))
                );
            }
        }
    }

    public function getQueryBuilder()
    {
        return null;
    }

    public function query($sql)
    {
        throw new \InvalidArgumentException("Not implemented");
    }

    public function fetchRow($sql)
    {
        throw new \InvalidArgumentException("Not implemented");
    }

    public function fetchAll($sql)
    {
        throw new \InvalidArgumentException("Not implemented");
    }

    /**
     * @param Table $table
     * @param array $row
     */
    public function insert(Table $table, $row)
    {
        $this->getDatabase()->selectCollection($table->getName())->insertOne($row);
    }

    /**
     * @param Table $table
     * @param array $rows
     */
    public function bulkinsert(Table $table, $rows)
    {
        $this->getDatabase()->selectCollection($table->getName())->insertMany($rows);
    }

    /**
     * @param string $tableName
     * @return mixed|string
     */
    public function quoteTableName($tableName)
    {
        return str_replace('.', '`.`', $this->quoteColumnName($tableName));
    }

    /**
     * @param string $columnName
     * @return string
     */
    public function quoteColumnName($columnName)
    {
        return '`' . str_replace('`', '``', $columnName) . '`';
    }

    /**
     * @param string $tableName
     * @return bool
     */
    public function hasTable($tableName)
    {
        return true;
    }

    /**
     * @param Table $table
     * @param array $columns
     * @param array $indexes
     */
    public function createTable(Table $table, array $columns = [], array $indexes = [])
    {
    }

    /**
     * @param string $tableName
     */
    public function truncateTable($tableName)
    {
        $this->getDatabase()->dropCollection($tableName);
    }

    /**
     * @param string $tableName
     * @return array|Column[]
     */
    public function getColumns($tableName)
    {
        return [];
    }

    /**
     * @param string $tableName
     * @param string $columnName
     * @return bool
     */
    public function hasColumn($tableName, $columnName)
    {
        return true;
    }

    /**
     * @param string $tableName
     * @param mixed $columns
     * @return bool|void
     */
    public function hasIndex($tableName, $columns)
    {
        $indexes = $this->getDatabase()->selectCollection($tableName)->listIndexes();
        $this->hasValues($indexes, $columns);

The call to the method Phinx\Db\Adapter\MongoMigrationAdapter::hasValues() seems un-needed as the method has no side-effects.

    }

    /**
     * @param string $tableName
     * @param string $indexName
     * @return bool
     */
    public function hasIndexByName($tableName, $indexName)
    {
        $indexes = $this->getDatabase()->selectCollection($tableName)->listIndexes();
        return $this->hasValue($indexes, $indexName);
    }

    /**
     * @param string $tableName
     * @param string[] $columns
     * @param null $constraint
     * @return bool
     */
    public function hasPrimaryKey($tableName, $columns, $constraint = null)
    {
        return true;
    }

    /**
     * @param string $tableName
     * @param string[] $columns
     * @param null $constraint
     * @return bool
     */
    public function hasForeignKey($tableName, $columns, $constraint = null)
    {
        return false;
    }

    /**
     * @return array
     */
    public function getColumnTypes()
    {
        return [
            self::PHINX_TYPE_BIG_INTEGER,
            self::PHINX_TYPE_BOOLEAN,
            self::PHINX_TYPE_INTEGER,
            self::PHINX_TYPE_STRING,
            self::PHINX_TYPE_FLOAT
        ];
    }

    /**
     * @param Column $column
     * @return bool
     */
    public function isValidColumnType(Column $column)
    {
        return true;
    }

    /**
     * @param string $type
     * @param null $limit
     * @return array|string[]
     */
    public function getSqlType($type, $limit = null)
    {
        return [];
    }

    /**
     * @param string $name
     * @param array $options
     */
    public function createDatabase($name, $options = [])
    {
    }

    /**
     * @param string $name
     * @return bool
     */
    public function hasDatabase($name)
    {
        return true;
    }

    /**
     * @param string $name
     */
    public function dropDatabase($name)
    {
        $this->mongoClient->dropDatabase($name);
    }

    public function createSchema($schemaName = 'public')
    {
        throw new \InvalidArgumentException("Not implemented");
    }

    /**
     * @param string $schemaName
     */
    public function dropSchema($schemaName)
    {
        $this->getDatabase()->dropCollection($schemaName);
    }

    public function castToBool($value)
    {
        throw new \InvalidArgumentException("Not implemented");
    }

    protected function getMigrationCollection()
    {
        return $this->collection;
    }

    /**
     * @return Database
     */
    protected function getDatabase()
    {
        return $this->database;
    }

    /**
     * @param \Iterator $iterator
     * @param $value
     * @return bool
     */
    protected function hasValue(\Iterator $iterator, $value)
    {
        foreach ($iterator as $iteration) {
            if ($iteration == $value) {
                return true;
            }
        }
        return false;
    }

    /**
     * @param \Iterator $iterator
     * @param $values
     * @return bool
     */
    protected function hasValues(\Iterator $iterator, $values)
    {
        foreach ($iterator as $iteration) {
            if ($this->hasValue($iteration, $values)) {
                return true;
            }
        }
        return false;
    }

    /**
     * @return Client|\PDO
     */
    public function getConnection()
    {
        return $this->mongoClient;
    }
}