Bdf\Prime\Prime

Complexity

Total Complexity

44

Size/Duplication

Total Lines	411
Duplicated Lines	0 %

Test Coverage

Coverage

92.38%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	3	1
A	one()	0	10	3
A	find()	0	10	3
A	exists()	0	17	4
A	repository()	0	7	2
A	push()	0	3	1
A	truncate()	0	3	1
A	callSchemaResolverMethod()	0	8	3
B	initialize()	0	46	8
B	callRepositoryMethod()	0	19	8
A	drop()	0	3	1
A	save()	0	3	1
A	remove()	0	3	1
A	isConfigured()	0	3	1
A	refresh()	0	5	1
A	connection()	0	3	1
A	configure()	0	8	2
A	service()	0	7	2

<?php

namespace Bdf\Prime;

use Bdf\Prime\Connection\Configuration\ConfigurationResolver;
use Bdf\Prime\Connection\ConnectionInterface;
use Bdf\Prime\Connection\ConnectionRegistry;
use Bdf\Prime\Connection\Factory\ChainFactory;
use Bdf\Prime\Connection\Factory\ConnectionFactory;
use Bdf\Prime\Connection\Factory\MasterSlaveConnectionFactory;
use Bdf\Prime\Connection\Factory\ShardingConnectionFactory;
use Bdf\Prime\Exception\PrimeException;
use Bdf\Prime\Mapper\MapperFactory;
use Bdf\Prime\Repository\RepositoryInterface;
use Psr\Container\ContainerInterface;
use RuntimeException;

/**
 * Prime
 * 
 * Usefull facade to manipulate repositories
 * Allow user to create, drop, truncate repositories
 * Allow user to find, insert entities

Doc comment long description must end with a full stop

 */
class Prime
{
    /**
     * @var mixed
     */
    protected static $config;

    /**
     * @var ServiceLocator
     */
    protected static $serviceLocator;


    /**
     * Configure the locator
     * 
     * @param array|ContainerInterface|ServiceLocator $config
     */
    public static function configure($config)

Expected 1 blank line before function; 2 found

    {
        if ($config instanceof ServiceLocator) {
            static::$config = null;
            static::$serviceLocator = $config;
        } else {
            static::$config = $config;
            static::$serviceLocator = null;
        }
    }

    /**
     * Check whether prime is configured
     *
     * @return bool

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

     */
    public static function isConfigured()
    {
        return static::$config !== null;
    }

    //
    //--------- repository

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

    //
    
    /**
     * Get a repository
     * 
     * @param string|object|RepositoryInterface $repository
     *
     * @return RepositoryInterface
     */
    public static function repository($repository)
    {
        if ($repository instanceof RepositoryInterface) {
            return $repository;
        }

        return static::service()->repository($repository);
    }
    
    /**
     * Create repositories
     * 
     * @param string|array|RepositoryInterface $repositories
     * @param boolean                          $force @see EntityRepository::schema

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

Parameter comment must start with a capital letter

     * @throws PrimeException

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

     */
    public static function create($repositories, $force = false)
    {
        static::callSchemaResolverMethod('migrate', $repositories, $force);
    }

    /**
     * Drop repositories
     * 
     * @param string|array|RepositoryInterface $repositories
     * @param boolean                          $force @see EntityRepository::schema

Parameter comment must start with a capital letter

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

     * @throws PrimeException

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

     */
    public static function drop($repositories, $force = false)
    {
        static::callSchemaResolverMethod('drop', $repositories, $force);
    }

    /**
     * Truncate repositories
     * 
     * @param string|array|RepositoryInterface $repositories
     * @param boolean                          $force @see EntityRepository::schema

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

Parameter comment must start with a capital letter

     * @throws PrimeException

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

     */
    public static function truncate($repositories, $force = false)
    {
        static::callSchemaResolverMethod('truncate', $repositories, $force);
    }

    /**
     * Call schema resolver method
     * 
     * @param string  $method
     * @param mixed   $repositories
     * @param boolean $force

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

     *
     * @throws PrimeException
     */
    protected static function callSchemaResolverMethod($method, $repositories, $force)
    {
        if (!is_array($repositories)) {
            $repositories = [$repositories];
        }
        
        foreach ($repositories as $repository) {
            static::repository($repository)->schema($force)->$method();
        }
    }
    
    //
    //--------- entities

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

    //

    /**
     * Push multiple entities in repository
     * launch replace method from repository
     * 
     * User can add
     *  * entity object
     *  * collection of entity object
     *  * an array of entity attributes

Doc comment long description must end with a full stop

     * 
     * <code>
     *  Prime::push(new EntityClass());
     *  Prime::push([new EntityClass()]);
     *  Prime::push($repository, ['id' => '...']);
     *  Prime::push('EntityClass', ['id' => '...']);
     *  Prime::push('EntityClass', [['id' => '...']]);
     * </code>
     * 
     * @param mixed $repositoryName
     * @param mixed $entities
     *
     * @throws PrimeException
     */
    public static function push($repositoryName, $entities = null)
    {
        static::callRepositoryMethod('replace', $repositoryName, $entities);
    }

    /**
     * Save multiple entities in repository
     * launch save method from repository
     * 
     * User can add
     *  * entity object
     *  * collection of entity object
     *  * an array of entity attributes

Doc comment long description must end with a full stop

     * 
     * <code>
     *  Prime::save(new EntityClass());
     *  Prime::save([new EntityClass()]);
     *  Prime::save($repository, ['id' => '...']);
     *  Prime::save('EntityClass', ['id' => '...']);
     *  Prime::save('EntityClass', [['id' => '...']]);
     * </code>
     * 
     * @param mixed $repositoryName
     * @param mixed $entities
     *
     * @throws PrimeException
     */
    public static function save($repositoryName, $entities = null)
    {
        static::callRepositoryMethod('save', $repositoryName, $entities);
    }

    /**
     * Remove multiple entities in repository
     * 
     * User can add
     *  * entity object
     *  * collection of entity object
     *  * an array of entity attributes

Doc comment long description must end with a full stop

     * 
     * <code>
     *  Prime::remove(new EntityClass());
     *  Prime::remove([new EntityClass()]);
     *  Prime::remove($repository, ['id' => '...']);
     *  Prime::remove('EntityClass', ['id' => '...']);
     *  Prime::remove('EntityClass', [['id' => '...']]);
     * </code>
     * 
     * @param mixed $repositoryName
     * @param mixed $entities
     *
     * @throws PrimeException
     */
    public static function remove($repositoryName, $entities = null)
    {
        static::callRepositoryMethod('delete', $repositoryName, $entities);
    }
    
    /**
     * Call repository method for entities
     *  
     * @param string $method
     * @param mixed $repositoryName
     * @param mixed $entities
     *
     * @throws PrimeException
     */
    protected static function callRepositoryMethod($method, $repositoryName, $entities)
    {
        if (!is_string($repositoryName) && !$repositoryName instanceof RepositoryInterface) {
            $entities = $repositoryName;
            $repositoryName = null;
        }
        
        if (!is_array($entities) || !isset($entities[0])) {
            $entities = [$entities];
        }
        
        foreach ($entities as $entity) {
            $repository = static::repository($repositoryName ?: $entity);

Inline shorthand IF statement requires brackets around comparison

The value of a comparison must not be assigned to a variable

            
            if (is_array($entity)) {
                $entity = $repository->entity($entity);
            }
            
            $repository->$method($entity);
        }
    }

    /**
     * Assert that entity exists
     * 
     * @param object $entity
     * @param bool   $compare  Will compare entity with the expected one

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

     * 
     * @return bool

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

     *
     * @throws PrimeException
     */
    public static function exists($entity, $compare = true)
    {
        $repository = static::repository($entity);
        
        $expected = $repository->findOne($repository->mapper()->primaryCriteria($entity));

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

        
        if ($expected === null) {
            return false;
        }
        
        if (!$compare) {
            return true;
        }
        
        return $entity == $expected 
                ? true

Inline shorthand IF statement must be declared on a single line

                : serialize($entity) === serialize($expected);
    }

    /**
     * Find entity
     * 
     * <code>
     *  Prime::find(new EntityClass());
     *  Prime::find('EntityClass', ['id' => '...']);
     *  Prime::find($repository, ['id' => '...']);
     * </code>
     * 
     * @param string|RepositoryInterface  $repositoryName     Repo name or Entity instance
     * @param array|object                $criteria           Array of criteria. Optionnal if repository name is an object
     * 
     * @return object|array
     *
     * @throws PrimeException
     */
    public static function find($repositoryName, $criteria = null)
    {
        $repository = static::repository($repositoryName);
        
        // if $repositoryName is an entity

Inline comments must start with a capital letter

        if (is_object($repositoryName) && !$repositoryName instanceof RepositoryInterface) {

$repositoryName is always a sub-type of Bdf\Prime\Repository\RepositoryInterface.

            $criteria = $repository->mapper()->prepareToRepository($repositoryName);
        }
        
        return $repository->find($criteria);

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

    }

    /**
     * Find one entity
     * 
     * <code>
     *  Prime::one(new EntityClass());
     *  Prime::one('EntityClass', ['id' => '...']);
     *  Prime::one($repository, ['id' => '...']);
     * </code>
     * 
     * @param string|RepositoryInterface  $repositoryName     Repo name or Entity instance
     * @param array|object                $criteria           Array of criteria. Optionnal if repository name is an object
     * 
     * @return object|array
     *
     * @throws PrimeException
     */
    public static function one($repositoryName, $criteria = null)
    {
        $repository = static::repository($repositoryName);
        
        // if $repositoryName is an entity

Inline comments must start with a capital letter

        if (is_object($repositoryName) && !$repositoryName instanceof RepositoryInterface) {

$repositoryName is always a sub-type of Bdf\Prime\Repository\RepositoryInterface.

            $criteria = $repository->mapper()->prepareToRepository($repositoryName);
        }
        
        return $repository->findOne($criteria);
    }

    /**
     * Refresh entity from repository
     * 
     * @param object $entity
     * @param array  $additionnalCriteria  Criteria to add to primary key
     * 
     * @return object New refresh entity
     *
     * @throws PrimeException
     */
    public static function refresh($entity, $additionnalCriteria = [])

Type hint "array" missing for $additionnalCriteria

    {
        $repository = static::repository($entity);
        
        return $repository->findOne($repository->mapper()->primaryCriteria($entity) + $additionnalCriteria);
    }
    
    //
    //--------- service

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

    //
    
    /**
     * Get active connection from profile name
     * 
     * @param string $name
     * 
     * @return ConnectionInterface
     */
    public static function connection($name = null)
    {
        return static::service()->connection($name);
    }

    /**
     * Get service locator
     * 
     * @return ServiceLocator
     */
    public static function service()
    {
        if (static::$serviceLocator === null) {
            static::initialize();
        }

        return static::$serviceLocator;
    }

    /**
     * Initializes the service locator
     */

Missing @throws tag in function comment

    protected static function initialize()
    {
        if (static::$config instanceof ContainerInterface) {
            static::$serviceLocator = static::$config->get('prime');
            
            return;
        }
        
        if (!is_array(static::$config)) {
            throw new RuntimeException('Prime is not configured');
        }

        $factory = new ConnectionFactory();
        $registry = new ConnectionRegistry(
            static::$config['connection']['config'] ?? [],

Operation must be bracketed

            new ChainFactory([
                new MasterSlaveConnectionFactory($factory),
                new ShardingConnectionFactory($factory),
                $factory,
            ]),
            new ConfigurationResolver([], $configuration = new Configuration())
        );

        $mapperFactory = new MapperFactory(
            null,
            static::$config['metadataCache'] ?? null,

Operation must be bracketed

            static::$config['resultCache'] ?? null

Operation must be bracketed

        );

        static::$serviceLocator = new ServiceLocator(
            new ConnectionManager($registry),
            $mapperFactory
        );

        if ($logger = static::$config['logger'] ?? null) {

Operation must be bracketed

Assignments must be the first block of code on a line

Variable assignment found within a condition. Did you mean to do a comparison ?

            $configuration->setSQLLogger($logger);
        }

        if ($types = static::$config['types'] ?? null) {

Variable assignment found within a condition. Did you mean to do a comparison ?

Operation must be bracketed

Assignments must be the first block of code on a line

            foreach ($types as $alias => $type) {
                $configuration->getTypes()->register($type, is_string($alias) ? $alias : null);
            }
        }

        if ($serializer = static::$config['serializer'] ?? null) {

Operation must be bracketed

Assignments must be the first block of code on a line

Variable assignment found within a condition. Did you mean to do a comparison ?

            static::$serviceLocator->setSerializer($serializer);
        }
    }
}