SpeckCatalog\Mapper\AbstractMapper

Complexity

Total Complexity

68

Size/Duplication

Total Lines	403
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	14

Test Coverage

Coverage

77.4%

Importance

Changes	15
Bugs	4	Features	5

38 Methods

Rating	Name	Duplication	Size	Complexity
A	getSelect()	0	4	2
A	getPaginatorOptions()	0	4	1
A	getDbAdapter()	0	4	1
A	getTableName()	0	4	1
A	getTableFields()	0	4	1
A	getTableKeyFields()	0	4	1
A	enabledOnly()	0	4	1
A	getAll()	0	5	1
A	find()	0	6	1
A	findMany()	0	6	1
A	findRow()	0	6	1
A	findRows()	0	6	1
A	select()	0	9	2
A	delete()	0	12	2
B	insert()	0	23	5
A	dataToKeyData()	0	10	3
A	update()	0	18	3
A	selectOne()	0	6	1
A	selectMany()	0	14	3
A	selectOneModel()	0	5	1
A	selectManyModels()	0	5	1
A	extract()	0	11	4
B	cleanData()	0	12	5
A	hydrate()	0	7	3
A	initPaginator()	0	14	3
A	getHydrator()	0	8	3
A	setHydrator()	0	5	1
A	getModel()	0	12	4
A	setModel()	0	5	1
A	getSql()	0	8	2
A	setSql()	0	5	1
A	usePaginator()	0	6	1
A	setPaginatorOptions()	0	5	1
A	setDbAdapter()	0	5	1
A	setTableName()	0	5	1
A	setTableFields()	0	5	1
A	setTableKeyFields()	0	5	1
A	setEnabledOnly()	0	5	1

<?php

namespace SpeckCatalog\Mapper;

use SpeckCatalog\Model\AbstractModel;
use Zend\Stdlib\Hydrator\ClassMethods;
use Zend\Stdlib\Hydrator\HydratorInterface;
use SpeckCatalog\Mapper\DbAdapterAwareInterface;
use SpeckCatalog\Adapter\PaginatorDbSelect;
use Zend\ServiceManager\ServiceLocatorAwareInterface;
use Zend\ServiceManager\ServiceLocatorAwareTrait;
use Zend\Db\Adapter\Adapter;
use Zend\Db\Sql\Select;
use Zend\Db\Sql\Sql;
use Zend\Paginator\Paginator;
use Zend\Db\ResultSet;

class AbstractMapper implements
    DbAdapterAwareInterface,
    ServiceLocatorAwareInterface,
    ProvidesTableMetadataInterface
{
    use ServiceLocatorAwareTrait;
    use ProvidesTableMetadataTrait;

    protected $hydrator;
    protected $dbAdapter;
    protected $model;
    protected $tableFields;
    protected $tableName;
    protected $tableKeyFields;
    protected $sql;
    protected $usePaginator;
    protected $paginatorOptions;
    protected $enabledOnly = false;

    public function getSelect($tableName = null)
    {
        return $this->getSql()->select($tableName ?: $this->getTableName());
    }

    public function getAll()
    {
        $select = $this->getSelect();
        return $this->selectManyModels($select);
    }

    public function find(array $data)
    {
        $select = $this->getSelect()
            ->where($data);
        return $this->selectOneModel($select);
    }

    public function findMany(array $data)
    {
        $select = $this->getSelect()
            ->where($data);
        return $this->selectManyModels($select);
    }

    public function findRow(array $data)
    {
        $select = $this->getSelect()
            ->where($data);
        return $this->selectOne($select);
    }

    public function findRows(array $data)
    {
        $select = $this->getSelect()
            ->where($data);
        return $this->select($select);
    }

    //return array or null

58% of this comment could be valid code. Did you maybe forget this after debugging?

    public function select(Select $select, ResultSet\ResultSetInterface $resultSet = null)
    {
        $stmt = $this->getSql()->prepareStatementForSqlObject($select);

        $resultSet = $resultSet ?: new ResultSet\ResultSet(ResultSet\ResultSet::TYPE_ARRAY);
        $resultSet->initialize($stmt->execute());

        return $resultSet;
    }

    //return deleted nuber of rows
    public function delete(array $where, $tableName = null)
    {
        $tableName = $tableName ?: $this->getTableName();
        $sql = $this->getSql();
        $delete = $sql->delete($tableName);

        $delete->where($where);

        $statement = $sql->prepareStatementForSqlObject($delete);

        return $statement->execute();
    }

    //returns lastInsertId or null
    public function insert($dataOrModel, $tableName = null, HydratorInterface $hydrator = null)
    {
        $tableName = $tableName ?: $this->getTableName();
        $data = $this->extract($dataOrModel, $hydrator);

        if ($tableName === $this->getTableName()) {
            $data = $this->cleanData($data);
        }

        if ($tableName === $this->getTableName() && $this->findRow($this->dataToKeyData($data))) {
            throw new \RuntimeException('row already exists');
        }

        $sql = $this->getSql();
        $insert = $sql->insert($tableName);

        $insert->values($data);

        $statement = $sql->prepareStatementForSqlObject($insert);
        $result = $statement->execute();

        return $result->getGeneratedValue();
    }

    public function dataToKeyData($data)
    {
        if (!is_array($this->getTableKeyFields())) {
            throw new \RuntimeException('no key fields for:' . $this->getTableName());
        }
        foreach ($this->getTableKeyFields() as $field) {
            $return[$field] = $data[$field];

$return was never initialized. Although not strictly required by PHP, it is generally a good practice to add $return = array(); before regardless.

        }
        return $return;

The variable $return does not seem to be defined for all execution paths leading up to this point.

    }

    //returns affected number of rows
    public function update($dataOrModel, array $where, $tableName = null, HydratorInterface $hydrator = null)
    {
        $tableName = $tableName ?: $this->getTableName();
        $data = $this->extract($dataOrModel, $hydrator);
        if ($tableName === $this->getTableName()) {
            $data = $this->cleanData($data);
        }

        $sql = $this->getSql();
        $update = $sql->update($tableName);

        $update->set($data)
            ->where($where);

        $statement = $sql->prepareStatementForSqlObject($update);

        return $statement->execute();
    }

    //returns row or null
    public function selectOne(Select $select, ResultSet\ResultSetInterface $resultSet = null)
    {
        $select->limit(1);
        //var_dump($select->getSqlString()); die();

79% of this comment could be valid code. Did you maybe forget this after debugging?

        return $this->select($select, $resultSet)->current();
    }

    //returns array of rows
    public function selectMany(Select $select, ResultSet\ResultSetInterface $resultSet = null)
    {
        if ($this->usePaginator) {
            $this->usePaginator = false;
            $rows = $this->initPaginator($select, $resultSet);
        } else {
            $result = $this->select($select, $resultSet);
            $rows = array();
            foreach ($result as $row) {
                $rows[] = $row;
            }
        }
        return $rows;
    }

    //returns model or null
    public function selectOneModel(Select $select, HydratorInterface $hydrator = null, AbstractModel $model = null)

The parameter $hydrator is not used and could be removed.

The parameter $model is not used and could be removed.

    {
        $resultSet = new ResultSet\HydratingResultSet($this->getHydrator(), $this->getModel());
        return $this->selectOne($select, $resultSet);
    }

    //returns array of models
    public function selectManyModels(Select $select, HydratorInterface $hydrator = null, AbstractModel $model = null)

The parameter $hydrator is not used and could be removed.

The parameter $model is not used and could be removed.

    {
        $resultSet = new ResultSet\HydratingResultSet($this->getHydrator(), $this->getModel());
        return $this->selectMany($select, $resultSet);
    }

    public function extract($dataOrModel, HydratorInterface $hydrator = null)
    {
        if (is_array($dataOrModel)) {
            return $dataOrModel;
        }
        if (!$dataOrModel instanceof AbstractModel) {
            throw new \InvalidArgumentException('need nstance of AbstractModel got: ' . getType($dataOrModel));
        }
        $hydrator = $hydrator ?: $this->getHydrator();
        return $hydrator->extract($dataOrModel);
    }

    public function cleanData($data)
    {
        if (!is_array($this->getTableFields()) || !count($this->getTableFields())) {
            return $data;
        }
        foreach ($data as $key => $val) {
            if (!in_array($key, $this->getTableFields())) {
                unset($data[$key]);
            }
        }
        return $data;
    }

    public function hydrate(array $data, AbstractModel $model = null, HydratorInterface $hydrator = null)
    {
        $hydrator = $hydrator ?: $this->getHydrator();
        $model    = $model    ?: $this->getModel();

        return $hydrator->hydrate($data, $model);
    }

    public function initPaginator($select, ResultSet\ResultSetInterface $resultSet = null)
    {
        $paginator = new Paginator(new PaginatorDbSelect($select, $this->getDbAdapter(), $resultSet));

        $options = $this->getPaginatorOptions();
        if (isset($options['n'])) {
            $paginator->setItemCountPerPage($options['n']);
        }
        if (isset($options['p'])) {
            $paginator->setCurrentPageNumber($options['p']);
        }

        return $paginator;
    }

    /**
     * @return hydrator
     */
    public function getHydrator()
    {
        if (is_string($this->hydrator) && class_exists($this->hydrator)) {
            return new $this->hydrator();
        } else {
            return new ClassMethods();

The class Zend\Stdlib\Hydrator\ClassMethods has been deprecated with message: Use Zend\Hydrator\ClassMethods from zendframework/zend-hydrator instead.

        }
    }

    /**
     * @param $hydrator
     * @return self
     */
    public function setHydrator(HydratorInterface $hydrator)
    {
        $this->hydrator = $hydrator;
        return $this;
    }

    /**
     * @return model
     */
    public function getModel(array $data = null)
    {
        if (is_string($this->model) && class_exists($this->model)) {
            if ($data) {
                $hydrator = $this->getHydrator();
                return $hydrator->hydrate($data, new $this->model);
            }
            return new $this->model;
        } else {
            throw new \RuntimeException('could not instantiate model - ' . $this->model);
        }
    }

    /**
     * @param $model
     * @return self
     */
    public function setModel(AbstractModel $model)
    {
        $this->model = $model;
        return $this;
    }

    /**
     * @return Sql
     */
    protected function getSql()
    {
        if (!$this->sql instanceof Sql) {
            $this->sql = new Sql($this->getDbAdapter());
        }

        return $this->sql;
    }

    /**
     * @param Sql
     * @return AbstractDbMapper
     */
    protected function setSql(Sql $sql)
    {
        $this->sql = $sql;
        return $this;
    }

    public function usePaginator(array $paginatorOptions = array())
    {
        $this->usePaginator = true;
        $this->paginatorOptions = $paginatorOptions;
        return $this;
    }

    /**
     * @return paginatorOptions
     */
    public function getPaginatorOptions()
    {
        return $this->paginatorOptions;
    }

    /**
     * @param $paginatorOptions
     * @return self
     */
    public function setPaginatorOptions($paginatorOptions)
    {
        $this->paginatorOptions = $paginatorOptions;
        return $this;
    }

    /**
     * @return dbAdapter
     */
    public function getDbAdapter()
    {
        return $this->dbAdapter;
    }

    /**
     * @param $dbAdapter
     * @return self
     */
    public function setDbAdapter(Adapter $dbAdapter)
    {
        $this->dbAdapter = $dbAdapter;
        return $this;
    }

    /**
     * @return tableName
     */
    public function getTableName()
    {
        return $this->tableName;
    }

    /**
     * @param $tableName
     * @return self
     */
    public function setTableName($tableName)
    {
        $this->tableName = $tableName;
        return $this;
    }

    /**
     * @return tableFields
     */
    public function getTableFields()
    {
        return $this->tableFields;
    }

    /**
     * @param $tableFields
     * @return self
     */
    public function setTableFields($tableFields)
    {
        $this->tableFields = $tableFields;
        return $this;
    }

    /**
     * @return tableKeyFields
     */
    public function getTableKeyFields()
    {
        return $this->tableKeyFields;
    }

    /**
     * @param $tableKeyFields
     * @return self
     */
    public function setTableKeyFields($tableKeyFields)
    {
        $this->tableKeyFields = $tableKeyFields;
        return $this;
    }

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

    public function setEnabledOnly($bool)
    {
        $this->enabledOnly = $bool;
        return $this;
    }
}