Bdf\Prime\Repository\EntityRepository

Complexity

Total Complexity

102

Size/Duplication

Total Lines	1023
Duplicated Lines	0 %

Test Coverage

Coverage

95.04%

Importance

Changes	1
Bugs	0	Features	0

67 Methods

Rating	Name	Duplication	Size	Complexity
A	mapper()	0	3	1
A	extractOne()	0	3	1
A	repository()	0	3	1
A	collectionFactory()	0	3	1
A	entity()	0	3	1
A	transaction()	0	21	3
A	__construct()	0	12	1
A	hydrateOne()	0	3	1
A	connection()	0	3	1
A	entityName()	0	3	1
A	metadata()	0	3	1
A	entityClass()	0	3	1
A	collection()	0	3	1
A	isReadOnly()	0	3	1
A	on()	0	13	2
A	criteria()	0	3	1
A	with()	0	3	1
A	where()	0	3	1
A	replace()	0	9	3
A	delete()	0	3	1
A	findOne()	0	3	1
A	wrapAs()	0	3	1
A	withoutConstraints()	0	5	1
A	saved()	0	9	2
A	inserted()	0	9	2
A	save()	0	20	4
A	updateBy()	0	3	1
A	reset()	0	9	2
A	onConnectionClosed()	0	3	1
A	updated()	0	9	2
A	schema()	0	7	3
A	constraints()	0	18	5
A	deleteAll()	0	12	2
A	onRelation()	0	3	1
A	changeActiveConnection()	0	11	1
A	exists()	0	3	1
A	getSubscribedEvents()	0	3	1
A	scopes()	0	3	1
A	update()	0	3	1
A	isWithoutConstraints()	0	3	1
A	builder()	0	3	1
A	queries()	0	3	1
A	deleteBy()	0	3	1
A	loadRelations()	0	7	2
A	isNew()	0	15	4
A	saveAll()	0	12	2
A	by()	0	3	1
A	relation()	0	7	2
A	deleting()	0	9	2
A	loaded()	0	9	2
A	insert()	0	3	1
A	count()	0	3	1
A	refresh()	0	9	2
A	reloadRelations()	0	7	2
A	find()	0	3	1
A	saving()	0	9	2
A	deleted()	0	9	2
A	insertIgnore()	0	3	1
A	updating()	0	9	2
A	free()	0	4	2
A	__call()	0	3	1
A	duplicate()	0	5	1
A	without()	0	3	1
A	destroy()	0	16	2
A	filters()	0	3	1
A	inserting()	0	9	2
A	writer()	0	3	1

<?php

namespace Bdf\Prime\Repository;

use Bdf\Event\EventNotifier;
use Bdf\Prime\Cache\CacheInterface;
use Bdf\Prime\Collection\CollectionFactory;
use Bdf\Prime\Collection\EntityCollection;
use Bdf\Prime\Collection\Indexer\SingleEntityIndexer;
use Bdf\Prime\Connection\Event\ConnectionClosedListenerInterface;
use Bdf\Prime\Entity\Criteria;
use Bdf\Prime\Events;
use Bdf\Prime\Mapper\Mapper;
use Bdf\Prime\Query\QueryInterface;

Unused use statement

use Bdf\Prime\Query\QueryRepositoryExtension;

Unused use statement

use Bdf\Prime\Relations\EntityRelation;
use Bdf\Prime\Relations\Relation;
use Bdf\Prime\Relations\RelationInterface;

Unused use statement

use Bdf\Prime\Repository\Write\Writer;
use Bdf\Prime\Repository\Write\WriterInterface;

Unused use statement

use Bdf\Prime\Schema\NullResolver;
use Bdf\Prime\Schema\Resolver;
use Bdf\Prime\ServiceLocator;
use Doctrine\Common\EventSubscriber;

/**
 * Db repository
 * 
 * implementation de l'abstraction d'un dépot de données.

Doc comment long description must start with a capital letter

 * 
 * @todo fix: il est possible de desactiver temporairement le cache sur des methodes d ecriture

Comment refers to a TODO task

@todo tag is not allowed in class comment

 *
 * @package Bdf\Prime\Repository

@package tag is not allowed in class comment

 *
 * @mixin RepositoryQueryFactory

@mixin tag is not allowed in class comment

 */
class EntityRepository implements RepositoryInterface, EventSubscriber, ConnectionClosedListenerInterface
{
    use EventNotifier;
    
    /**
     * @var Mapper 

Expected "Mapper" but found "Mapper " for @var tag in member variable comment

     */
    protected $mapper;
    
    /**
     * @var ServiceLocator 

Expected "ServiceLocator" but found "ServiceLocator " for @var tag in member variable comment

     */
    protected $serviceLocator;
    
    /**
     * Query result cache
     * 
     * @var CacheInterface
     */
    protected $resultCache;
    
    /**
     * Disable the global constraints for one query
     * 
     * @var bool

Expected "boolean" but found "bool" for @var tag in member variable comment

     */
    protected $withoutConstraints = false;
    
    /**
     * Cache of relation instance
     * 
     * @var RelationInterface[]
     */
    protected $relations = [];

    /**
     * The collection factory
     *
     * @var CollectionFactory
     */
    protected $collectionFactory;

    /**
     * @var RepositoryQueryFactory
     */
    protected $queries;

    /**
     * @var WriterInterface
     */
    protected $writer;


    /**
     * Constructor
     * 
     * @param Mapper         $mapper
     * @param ServiceLocator $serviceLocator
     * @param CacheInterface $cache
     */
    public function __construct(Mapper $mapper, ServiceLocator $serviceLocator, CacheInterface $cache = null)

Expected 1 blank line before function; 2 found

    {
        $this->resultCache = $cache;
        $this->mapper = $mapper;
        $this->serviceLocator = $serviceLocator;

        $this->collectionFactory = CollectionFactory::forRepository($this);
        $this->queries = new RepositoryQueryFactory($this, $cache);
        $this->writer = new Writer($this, $serviceLocator);

        $this->mapper->events($this);
        $this->connection()->getEventManager()->addEventSubscriber($this);
    }
    
    /**

Parameter $entity should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function repository($entity)
    {
        return $this->serviceLocator->repository($entity);
    }
    
    /**
     * {@inheritdoc}
     */
    public function mapper()
    {
        return $this->mapper;
    }
    
    /**
     * {@inheritdoc}
     */
    public function metadata()
    {
        return $this->mapper->metadata();
    }
    
    /**
     * {@inheritdoc}
     */
    public function isReadOnly()
    {
        return $this->mapper->isReadOnly();
    }
    
    /**

Parameter $criteria should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function criteria(array $criteria = [])
    {
        return new Criteria($criteria);
    }
    
    /**

Parameter $data should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function entity(array $data = [])
    {
        return $this->mapper->entity($data);
    }
    
    /**
     * {@inheritdoc}
     */
    public function entityName()
    {
        return $this->mapper->metadata()->entityName;
    }

    /**
     * {@inheritdoc}
     */
    public function entityClass()
    {
        return $this->mapper->metadata()->entityClass;
    }

    /**

Parameter $entities should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function collection(array $entities = [])
    {
        return new EntityCollection($this, $entities);
    }

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

    /**

Parameter $entity should have a doc-comment as per coding-style.

Parameter $property should have a doc-comment as per coding-style.

Parameter $value should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function hydrateOne($entity, $property, $value)
    {
        $this->mapper->hydrateOne($entity, $property, $value);
    }

    /**

Parameter $entity should have a doc-comment as per coding-style.

Parameter $property should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function extractOne($entity, $property)
    {
        return $this->mapper->extractOne($entity, $property);
    }

    /**
     * {@inheritdoc}
     */
    public function connection()
    {
        return $this->serviceLocator->connection($this->mapper->metadata()->connection);
    }
    
    /**
     * Set the new connection for next queries
     * 
     * If work is set, the connection will be available only for the work content
     * Else the repository will be linked with this new connection

Doc comment long description must end with a full stop

     * 
     * @param string   $connection
     * @param \Closure $work
     * 
     * @return $this|mixed  Returns the work result if set or the instance if not set
     */
    public function on($connection, \Closure $work = null)
    {
        $original = $this->changeActiveConnection($connection);

        if ($work !== null) {
            try {
                return $work($this);
            } finally {
                $this->changeActiveConnection($original);
            }
        }
        
        return $this;
    }
    
    /**
     * Launch transactionnal queries
     * 
     * @param \Closure $work

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @return mixed

Tag @return cannot be grouped with parameter tags in a doc comment

Separate the @param and @return sections by a blank line.

     * 
     * @throws \Exception

Comment missing for @throws tag in function comment

     */
    public function transaction(\Closure $work)
    {
        $connection = $this->connection();
        
        try {
            $connection->beginTransaction();

The method beginTransaction() does not exist on Bdf\Prime\Connection\ConnectionInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Bdf\Prime\Connection\ConnectionInterface.

            
            $result = $work($this);
            
            if ($result === false) {
                $connection->rollback();

The method rollback() does not exist on Bdf\Prime\Connection\ConnectionInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Bdf\Prime\Connection\ConnectionInterface.

            } else {
                $connection->commit();

The method commit() does not exist on Bdf\Prime\Connection\ConnectionInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Bdf\Prime\Connection\ConnectionInterface.

            }
        } catch (\Exception $e) {
            $connection->rollback();
            
            throw $e;
        }
        
        return $result;
    }
    
    /**
     * Load relations on given entity
     * If the relation is already loaded, the relation will not be reloaded
     * Use reloadRelation for force loading

Doc comment short description must be on a single line, further text should be a separate paragraph

     * 
     * @param object          $entity
     * @param string|array    $relations
     *
     * @return void

If there is no return value for a function, there must not be a @return tag.

     *
     * @see EntityRepository::reloadRelations() For force load relations

The @see reference should not contain any additional text

     */
    public function loadRelations($entity, $relations)
    {
        foreach (Relation::sanitizeRelations((array)$relations) as $relationName => $meta) {

Expected 1 space(s) after cast statement; 0 found

            $this->relation($relationName)->loadIfNotLoaded(
                new SingleEntityIndexer($this->mapper, $entity),
                $meta['relations'],
                $meta['constraints']
            );
        }
    }

    /**
     * Force loading relations on given entity
     *
     * @param object          $entity
     * @param string|array    $relations
     *
     * @return void

If there is no return value for a function, there must not be a @return tag.

     *
     * @see EntityRepository::loadRelations() For loading relation only if not yet loaded

The @see reference should not contain any additional text

     */
    public function reloadRelations($entity, $relations)
    {
        foreach (Relation::sanitizeRelations((array)$relations) as $relationName => $meta) {

Expected 1 space(s) after cast statement; 0 found

            $this->relation($relationName)->load(
                new SingleEntityIndexer($this->mapper, $entity),
                $meta['relations'],
                $meta['constraints']
            );
        }
    }

    /**
     * Get a entity relation wrapper linked to the entity
     *
     * @param string   $relationName
     * @param object   $entity
     *
     * @return EntityRelation
     */
    public function onRelation($relationName, $entity)
    {
        return new EntityRelation($entity, $this->relation($relationName));
    }

    /**

Parameter $relationName should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function relation($relationName)
    {
        if (!isset($this->relations[$relationName])) {
            $this->relations[$relationName] = Relation::make($this, $relationName, $this->mapper->relation($relationName));
        }
        
        return $this->relations[$relationName];
    }

    /**
     * Save entity and its relations
     *
     * @param object         $entity
     * @param string|array   $relations
     *
     * @return int

Expected "integer" but found "int" for function return type

     */
    public function saveAll($entity, $relations)
    {
        $relations = Relation::sanitizeRelations((array)$relations);

Expected 1 space(s) after cast statement; 0 found

        return $this->transaction(function() use($entity, $relations) {

Expected 1 space after FUNCTION keyword; 0 found

Expected 1 space after USE keyword; found 0

            $nb = $this->save($entity);

            foreach ((array)$relations as $relationName => $info) {

Expected 1 space(s) after cast statement; 0 found

                $nb += $this->relation($relationName)->saveAll($entity, $info['relations']);
            }

            return $nb;
        });
    }

    /**
     * Delete entity and its relations
     *
     * @param object         $entity
     * @param string|array   $relations
     *
     * @return int

Expected "integer" but found "int" for function return type

     */
    public function deleteAll($entity, $relations)
    {
        $relations = Relation::sanitizeRelations((array)$relations);

Expected 1 space(s) after cast statement; 0 found

        return $this->transaction(function() use($entity, $relations) {

Expected 1 space after FUNCTION keyword; 0 found

Expected 1 space after USE keyword; found 0

            $nb = $this->delete($entity);

            foreach ((array)$relations as $relationName => $info) {

Expected 1 space(s) after cast statement; 0 found

                $nb += $this->relation($relationName)->deleteAll($entity, $info['relations']);
            }

            return $nb;
        });
    }

    /**

Parameter $context should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function constraints($context = null)
    {
        if ($this->withoutConstraints === true) {
            $this->withoutConstraints = false;
            return [];
        }

        $constraints = $this->metadata()->constraints;

        if ($context && is_array($constraints)) {
            $context .= '.';
            foreach ($constraints as $key => $value) {
                $constraints[$context.$key] = $value;
                unset($constraints[$key]);
            }
        }

        return $constraints;
    }
    
    /**
     * Disable global constraints on this repository.
     * Only for the current query

Doc comment short description must be on a single line, further text should be a separate paragraph

     * 
     * @return $this
     */
    public function withoutConstraints()
    {
        $this->withoutConstraints = true;

        return $this;
    }

    /**
     * Check whether the current query has global constraints
     *
     * @return bool

Expected "boolean" but found "bool" for function return type

     */
    public function isWithoutConstraints()
    {
        return $this->withoutConstraints;
    }

    /**
     * Get query builder
     * 
     * @return QueryInterface
     */
    public function builder()
    {
        return $this->queries->builder();
    }

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

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

    /**
     * Count entity
     * 
     * @param array $criteria
     * @param string|array $attributes
     * 
     * @return int

Expected "integer" but found "int" for function return type

     */
    public function count(array $criteria = [], $attributes = null)
    {
        return $this->builder()->where($criteria)->count($attributes);

The method count() does not exist on Bdf\Prime\Query\QueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Bdf\Prime\Query\QueryInterface.

    }

    /**
     * Assert that entity exists in repository
     *
     * @param object $entity
     *
     * @return boolean

Expected "bool" but found "boolean" for function return type

     */
    public function exists($entity)
    {
        return $this->queries->countKeyValue($this->mapper()->primaryCriteria($entity)) > 0;
    }

    /**
     * Refresh the entity form the repository
     *
     * @param object $entity
     * @param array  $criteria
     *
     * @return object           The refreshed object
     */
    public function refresh($entity, array $criteria = [])
    {
        if (empty($criteria)) {
            return $this->queries->findById($this->mapper()->primaryCriteria($entity));

The expression return $this->queries->findById($this->mapper()->primaryCriteria($entity)) also could return the type array which is incompatible with the documented return type object.

        }

        $criteria += $this->mapper()->primaryCriteria($entity);

        return $this->builder()->where($criteria)->first();

The expression return $this->builder()->where($criteria)->first() also could return the type array which is incompatible with the documented return type object.

    }

    /**
     * Check if the entity is new
     *
     * @param object $entity
     *
     * @return bool|null     Retuns null if entity is composite primary

Expected "boolean|null" but found "bool|null" for function return type

     */
    public function isNew($entity)
    {
        $metadata = $this->mapper->metadata();

        if ($metadata->isCompositePrimaryKey()) {
            return null;
        }

        $primaryValue = $this->mapper->getId($entity);

        if (empty($primaryValue)) {
            return true;
        }

        return $metadata->isForeignPrimaryKey() ? null : false;

Inline IF statements are not allowed

    }

    /**
     * Insert or update an entity
     * 
     * @param object $entity
     * 
     * @return int

Expected "integer" but found "int" for function return type

     */
    public function save($entity)
    {
        $isNew = $this->isNew($entity);

        if ($this->notify(Events::PRE_SAVE, [$entity, $this, $isNew]) === false) {
            return 0;
        }

        // composite primary

Inline comments must start with a capital letter

        if ($isNew === null) {
            $count = $this->replace($entity);
        } elseif ($isNew) {

Usage of ELSEIF not allowed; use ELSE IF instead

            $count = $this->insert($entity);
        } else {
            $count = $this->update($entity);
        }

        $this->notify(Events::POST_SAVE, [$entity, $this, $count, $isNew]);
        
        return $count;
    }

    /**
     * Replace an entity
     *
     * @param object $entity
     *
     * @return int  Returns 2 if updated and 1 if inserting

Expected "integer" but found "int" for function return type

     */
    public function replace($entity)
    {
        $isNew = $this->isNew($entity);

        if ($isNew !== true && $this->exists($entity)) {
            return $this->update($entity) + 1;

Operation must be bracketed

        }

        return $this->insert($entity);
    }

    /**
     * Duplicate an entity
     * remove primary key and launch insertion

Doc comment short description must be on a single line, further text should be a separate paragraph

     * 
     * @param object $entity
     * 
     * @return int

Expected "integer" but found "int" for function return type

     */
    public function duplicate($entity)
    {
        $this->mapper()->setId($entity, null);
        
        return $this->insert($entity);
    }
    
    /**
     * Insert an entity
     * 
     * @param object $entity
     * @param bool   $ignore

Expected "boolean" but found "bool" for parameter type

     * 
     * @return int

Expected "integer" but found "int" for function return type

     */
    public function insert($entity, $ignore = false)
    {
        return $this->writer->insert($entity, ['ignore' => $ignore]);
    }

    /**
     * Insert ignore
     * 
     * @param object $entity
     * 
     * @return int

Expected "integer" but found "int" for function return type

     */
    public function insertIgnore($entity)
    {
        return $this->insert($entity, true);
    }
    
    /**
     * Update an entity
     *
     * @param object $entity
     * @param array  $attributes
     *
     * @return int

Expected "integer" but found "int" for function return type

     */
    public function update($entity, array $attributes = null)
    {
        return $this->writer->update($entity, ['attributes' => $attributes]);
    }

    /**
     * Update collection of entities
     * 
     * @param array $attributes
     * @param array $criteria
     * 
     * @return int

Expected "integer" but found "int" for function return type

     */
    public function updateBy(array $attributes, array $criteria = [])
    {
        return $this->builder()->where($criteria)->update($attributes);
    }
    
    /**
     * Remove a entity
     * 
     * @param object $entity
     * 
     * @return int

Expected "integer" but found "int" for function return type

     */
    public function delete($entity)
    {
        return $this->writer->delete($entity);
    }
    
    /**
     * Remove a collection of entities
     * 
     * @param array $criteria
     * 
     * @return int

Expected "integer" but found "int" for function return type

     */
    public function deleteBy(array $criteria)
    {
        return $this->builder()->where($criteria)->delete();
    }

    /**

Parameter $force should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function schema($force = false)
    {
        if (!$this->mapper->hasSchemaManager() && !$force) {
            return new NullResolver();
        }
        
        return new Resolver($this->serviceLocator, $this->mapper->metadata());
    }
    
    /**
     * Gets custom filters
     *
     * @return array
     */
    public function filters()
    {
        return $this->mapper->filters();
    }
    
    /**
     * Repository extensions
     *
     * @return array
     */
    public function scopes()
    {
        return $this->mapper->scopes();
    }
    
    //----- events

No space found before comment text; expected "// ----- events" but found "//----- events"

    /**
     * Register post load event
     *
     * @param callable $listener
     * @param bool     $once    Register on event once

Expected "boolean" but found "bool" for parameter type

     *
     * @return $this
     */
    public function loaded(callable $listener, $once = false)
    {
        if ($once) {
            $this->once(Events::POST_LOAD, $listener);
        } else {
            $this->listen(Events::POST_LOAD, $listener);
        }

        return $this;
    }

    /**
     * Register pre save event
     *
     * @param callable $listener
     * @param bool     $once    Register on event once

Expected "boolean" but found "bool" for parameter type

     *
     * @return $this
     */
    public function saving(callable $listener, $once = false)
    {
        if ($once) {
            $this->once(Events::PRE_SAVE, $listener);
        } else {
            $this->listen(Events::PRE_SAVE, $listener);
        }

        return $this;
    }

    /**
     * Register post save event
     *
     * @param callable $listener
     * @param bool     $once    Register on event once

Expected "boolean" but found "bool" for parameter type

     *
     * @return $this
     */
    public function saved(callable $listener, $once = false)
    {
        if ($once) {
            $this->once(Events::POST_SAVE, $listener);
        } else {
            $this->listen(Events::POST_SAVE, $listener);
        }

        return $this;
    }

    /**
     * Register post insert event
     *
     * @param callable $listener
     * @param bool     $once    Register on event once

Expected "boolean" but found "bool" for parameter type

     *
     * @return $this
     */
    public function inserting(callable $listener, $once = false)
    {
        if ($once) {
            $this->once(Events::PRE_INSERT, $listener);
        } else {
            $this->listen(Events::PRE_INSERT, $listener);
        }

        return $this;
    }

    /**
     * Register post insert event
     *
     * @param callable $listener
     * @param bool     $once    Register on event once

Expected "boolean" but found "bool" for parameter type

     *
     * @return $this
     */
    public function inserted(callable $listener, $once = false)
    {
        if ($once) {
            $this->once(Events::POST_INSERT, $listener);
        } else {
            $this->listen(Events::POST_INSERT, $listener);
        }

        return $this;
    }

    /**
     * Register post update event
     *
     * @param callable $listener
     * @param bool     $once    Register on event once

Expected "boolean" but found "bool" for parameter type

     *
     * @return $this
     */
    public function updating(callable $listener, $once = false)
    {
        if ($once) {
            $this->once(Events::PRE_UPDATE, $listener);
        } else {
            $this->listen(Events::PRE_UPDATE, $listener);
        }

        return $this;
    }

    /**
     * Register post update event
     *
     * @param callable $listener
     * @param bool     $once    Register on event once

Expected "boolean" but found "bool" for parameter type

     *
     * @return $this
     */
    public function updated(callable $listener, $once = false)
    {
        if ($once) {
            $this->once(Events::POST_UPDATE, $listener);
        } else {
            $this->listen(Events::POST_UPDATE, $listener);
        }

        return $this;
    }

    /**
     * Register post delete event
     *
     * @param callable $listener
     * @param bool     $once    Register on event once

Expected "boolean" but found "bool" for parameter type

     *
     * @return $this
     */
    public function deleting(callable $listener, $once = false)
    {
        if ($once) {
            $this->once(Events::PRE_DELETE, $listener);
        } else {
            $this->listen(Events::PRE_DELETE, $listener);
        }

        return $this;
    }

    /**
     * Register post delete event
     *
     * @param callable $listener
     * @param bool     $once    Register on event once

Expected "boolean" but found "bool" for parameter type

     *
     * @return $this
     */
    public function deleted(callable $listener, $once = false)
    {
        if ($once) {
            $this->once(Events::POST_DELETE, $listener);
        } else {
            $this->listen(Events::POST_DELETE, $listener);
        }

        return $this;
    }

    /**
     * Query method
     * redirect method to the query builder

Doc comment short description must be on a single line, further text should be a separate paragraph

     * 
     * @param string $name         Query builder method
     * @param array  $arguments
     * 
     * @return int|QueryInterface

Expected "integer|QueryInterface" but found "int|QueryInterface" for function return type

     */
    public function __call($name, $arguments)

Type hint "array" missing for $arguments

    {
        return $this->queries->$name(...$arguments);
    }
    
    //--- Methodes for optimisation: alias of query methods

No space found before comment text; expected "// --- Methodes for optimisation: alias of query methods" but found "//--- Methodes for optimisation: alias of query methods"

    
    /**
     * @see QueryRepositoryExtension::with
     * 
     * @param string|array $relations

Parameter tags must be defined first in a doc comment

     * 
     * @return QueryInterface
     */
    public function with($relations)
    {
        return $this->builder()->with($relations);

The method with() does not exist on Bdf\Prime\Query\QueryInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Bdf\Prime\Query\SqlQueryInterface. Are you sure you never get one of those?

    }

    /**
     * @see QueryRepositoryExtension::without
     *
     * @param string|array $relations

Parameter tags must be defined first in a doc comment

     *
     * @return QueryInterface
     */
    public function without($relations)
    {
        return $this->builder()->without($relations);

The method without() does not exist on Bdf\Prime\Query\QueryInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Bdf\Prime\Query\SqlQueryInterface. Are you sure you never get one of those?

    }
    
    /**
     * @see QueryRepositoryExtension::by
     * 
     * @param string|array $attribute

Parameter tags must be defined first in a doc comment

     * @param boolean      $combine

Expected "bool" but found "boolean" for parameter type

     * 
     * @return QueryInterface
     */
    public function by($attribute, $combine = false)
    {
        return $this->builder()->by($attribute, $combine);

The method by() does not exist on Bdf\Prime\Query\QueryInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Bdf\Prime\Query\SqlQueryInterface. Are you sure you never get one of those?

    }
    
    /**
     * @see QueryInterface::wrapAs
     * 
     * @param string $wrapperClass

Parameter tags must be defined first in a doc comment

     * 
     * @return QueryInterface
     */
    public function wrapAs($wrapperClass)
    {
        return $this->builder()->wrapAs($wrapperClass);
    }
    
    /**
     * @param array $criteria
     * @param array $attributes
     * 
     * @return array
     */
    public function find(array $criteria, $attributes = null)

Type hint "array" missing for $attributes

    {
        return $this->builder()->find($criteria, $attributes);

The expression return $this->builder()->find($criteria, $attributes) also could return the type Bdf\Prime\Collection\CollectionInterface|Bdf\Prime\Query\Pagination\PaginatorInterface which is incompatible with the documented return type array.

    }
    
    /**
     * @param array $criteria
     * @param array $attributes
     * 
     * @return object
     */
    public function findOne(array $criteria, $attributes = null)

Type hint "array" missing for $attributes

    {
        return $this->builder()->findOne($criteria, $attributes);
    }
    
    /**

Parameter $column should have a doc-comment as per coding-style.

Parameter $operator should have a doc-comment as per coding-style.

Parameter $value should have a doc-comment as per coding-style.

Parameter $column is not described in comment

Parameter $operator is not described in comment

Parameter $value is not described in comment

     * @see QueryInterface::where
     * 
     * @param string|array $relations

Parameter tags must be defined first in a doc comment

Doc comment for parameter $relations does not match actual variable name $column

Doc comment for parameter $relations does not match actual variable name $value

     * 
     * @return QueryInterface
     */
    public function where($column, $operator = null, $value = null)
    {
        return $this->builder()->where($column, $operator, $value);
    }

    /**
     * {@inheritdoc}
     */
    public function onConnectionClosed()
    {
        $this->reset();
    }

    /**
     * {@inheritdoc}
     */
    public function getSubscribedEvents()
    {
        return [ConnectionClosedListenerInterface::EVENT_NAME];
    }

    /**
     * Free metadata information on the given entity
     * Note: This method is called by the model destructor

Doc comment short description must be on a single line, further text should be a separate paragraph

     *
     * @param object $entity
     *
     * @return void

If there is no return value for a function, there must not be a @return tag.

     */
    public function free($entity)
    {
        foreach ($this->relations as $relation) {
            $relation->clearInfo($entity);
        }
    }

    /**
     * Clear dependencies for break cyclic references
     * After this call, the repository will be unusable

Doc comment short description must be on a single line, further text should be a separate paragraph

     *
     * @internal
     */
    public function destroy()
    {
        $this->connection()->getEventManager()->removeEventSubscriber($this);

        $this->serviceLocator = null;
        $this->queries = null;
        $this->writer = null;
        $this->relations = [];
        $this->collectionFactory = null;

        $this->mapper->destroy();
        $this->mapper = null;

        if ($this->resultCache) {
            $this->resultCache->clear();
            $this->resultCache = null;
        }
    }

    /**
     * Change the active connection on the repository
     * All queries will be reseted

Doc comment short description must be on a single line, further text should be a separate paragraph

     *
     * /!\ The method will not check if the connection exists nor the new connection is same as the active

Doc comment long description must end with a full stop

     *
     * @param string $connectionName The new connection name
     *
     * @return string The last active connection name
     */
    private function changeActiveConnection($connectionName)

Private method name "EntityRepository::changeActiveConnection" must be prefixed with an underscore

    {
        $this->connection()->getEventManager()->removeEventSubscriber($this);

        $original = $this->mapper->metadata()->connection;
        $this->mapper->metadata()->connection = $connectionName;

        $this->connection()->getEventManager()->addEventSubscriber($this);
        $this->reset();

        return $original;
    }

    /**
     * Reset the inner queries
     * Use for invalidate prepared queries, or when connection changed

Doc comment short description must be on a single line, further text should be a separate paragraph

     */
    private function reset()

Private method name "EntityRepository::reset" must be prefixed with an underscore

    {
        // Reset queries
        $this->queries = new RepositoryQueryFactory($this, $this->resultCache);
        $this->writer = new Writer($this, $this->serviceLocator);
        $this->relations = []; // Relation may contains inner query : it must be reseted

Comments may not appear after statements

        if ($this->resultCache) {
            $this->resultCache->clear();
        }
    }
}