Soluble\Schema\Source\AbstractSchemaSource

Complexity

Total Complexity

19

Size/Duplication

Total Lines	157
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

84.44%

Importance

Changes	3
Bugs	1	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	4
A	getColumns()	0	4	1
A	getTableInformation()	0	5	1
A	getTables()	0	4	1
A	hasTable()	0	5	1
A	validateTable()	0	8	2
A	validateSchema()	0	7	3
A	setDefaultSchema()	0	6	1
A	checkTableArgument()	0	8	4
A	setSchemaSignature()	0	6	1

<?php
namespace Soluble\Schema\Source;

use Soluble\Schema\Exception;
use Soluble\DbWrapper\Adapter\AdapterInterface;

abstract class AbstractSchemaSource implements SchemaSourceInterface
{
    /**
     * Default schema name
     * @var string
     */
    protected $schema;


    /**
     * Schema signature
     * @var string
     */
    protected $schemaSignature;


    /**
     * @var AdapterInterface
     */
    protected $adapter;

    /**
     * Constructor
     *
     * @param AdapterInterface $adapter
     * @param string|null $schema default schema, taken from adapter if not given
     * @throws Exception\InvalidArgumentException for invalid connection
     * @throws Exception\InvalidUsageException thrown if no schema can be found.
     */
    public function __construct(AdapterInterface $adapter, $schema = null)
    {
        $this->adapter = $adapter;
        if ($schema === null) {
            $schema = $this->adapter->getConnection()->getCurrentSchema();
            if ($schema === false || $schema == '') {
                $msg = "Database name (schema) parameter missing and no default schema set on connection";
                throw new Exception\InvalidUsageException($msg);
            }
        }
        $this->setDefaultSchema($schema);
        $this->setSchemaSignature();
    }


    /**
     * {@inheritdoc}
     */
    public function getColumns($table)
    {
        return array_keys($this->getColumnsInformation($table));
    }


    /**
     * {@inheritdoc}
     */
    public function getTableInformation($table)
    {
        $infos = $this->getTablesInformation();
        return $infos[$table];
    }

    /**
     * {@inheritdoc}
     */
    public function getTables()
    {
        return array_keys($this->getTablesInformation());
    }


    /**
     * {@inheritdoc}
     */
    public function hasTable($table)
    {
        $tables = $this->getTables();
        return in_array($table, $tables);
    }

    /**
     * Check whether a table parameter is valid and exists
     *
     * @throws Exception\InvalidArgumentException
     * @throws Exception\ErrorException
     * @throws Exception\ExceptionInterface
     * @throws Exception\TableNotFoundException
     *
     * @param string $table
     * @return AbstractSource
    */
    protected function validateTable($table)
    {
        $this->checkTableArgument($table);
        if (!$this->hasTable($table)) {
            throw new Exception\TableNotFoundException(__METHOD__ . ": Table '$table' does not exists in database '{$this->schema}'");
        }
        return $this;
    }


    /**
     * Check whether a schema parameter is valid
     *
     * @throws Exception\InvalidArgumentException

     * @param string $schema
     * @return AbstractSource
     */
    protected function validateSchema($schema)
    {
        if (!is_string($schema) || trim($schema) == '') {
            throw new Exception\InvalidArgumentException(__METHOD__ . ": Schema name must be a valid string or an empty string detected");
        }
        return $this;
    }

    /**
     * Set default schema
     *
     * @throws Exception\InvalidArgumentException
     * @param string $schema
     * @return AbstractSource
     */
    protected function setDefaultSchema($schema)
    {
        $this->validateSchema($schema);
        $this->schema = $schema;
        return $this;
    }

    /**
     *
     * @param string $table
     * @throws Exception\InvalidArgumentException
     */
    protected function checkTableArgument($table = null)
    {
        if ($table !== null) {
            if (!is_string($table) || trim($table) == '') {
                throw new Exception\InvalidArgumentException(__METHOD__ . " Table name must be a valid string or an empty string detected");
            }
        }
    }

    /**
     * Return current schema signature for caching
     *
     * @return void
     */
    protected function setSchemaSignature()
    {
        $host   = $this->adapter->getConnection()->getHost();
        $schema = $this->schema;
        $this->schemaSignature = "$host:$schema";
    }
}