Orm::getMapper() - Code Metrics - Inspection of "Added mapper to create objects from DB data" - slickframework/orm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 814e9e...2525ff )

by Filipe

created 2016-02-29 21:01 UTC

Orm::getMapper() A

↳ Parent: Orm

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
cc	1
eloc	2
nc	1
nop	1
crap	1

<?php

/**
 * This file is part of slick/orm package
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Slick\Orm;

use Slick\Database\Adapter\AdapterInterface;
use Slick\Orm\Descriptor\EntityDescriptor;
use Slick\Orm\Descriptor\EntityDescriptorRegistry;
use Slick\Orm\Exception\InvalidArgumentException;
use Slick\Orm\Mapper\EntityMapper;
use Slick\Orm\Mapper\MappersMap;
use Slick\Orm\Repository\EntityRepository;

/**
 * Orm registry
 *
 * @package Slick\Orm
 * @author  Filipe Silva <[email protected]>
 */
final class Orm
{

    /**
     * @var MappersMap|EntityMapperInterface[]
     */
    private $mappers;

    /**
     * @var Orm
     */
    private static $instance;

    /**
     * @var AdaptersMap
     */
    private $adapters;

    /**
     * Initialize Orm registry with empty lists
     */
    private function __construct()
    {
        $this->mappers = new MappersMap();
        $this->adapters = new AdaptersMap();
    }

    /**
     * Avoid clone on a singleton
     * @codeCoverageIgnore
     */
    private function __clone()
    {

    }

    /**
     * Gets a ORM registry instance
     *
     * @return Orm
     */
    public static function getInstance()
    {
        if (null === self::$instance) {
            self::$instance = new static;
        }
        return self::$instance;
    }

    /**
     * Retrieves the mapper for provided entity
     *
     * If mapper does not exists it will be created and stored in the
     * mapper map.
     *
     * @param EntityInterface $entity
     * @return EntityMapper
     */
    public static function getMapper(EntityInterface $entity)
    {
        return self::getInstance()->getMapperFor($entity);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Gets repository for provided entity class name
     *
     * @param string $entityClass FQ entity class name
     *
     * @return EntityRepository
     *
     * @throws InvalidArgumentException If provide class name is not
     *   from a class that implements the EntityInterface interface.
     */
    public static function getRepository($entityClass)
    {
        return self::getInstance()->getRepositoryFor($entityClass);
    }

    /**
     * Gets repository for provided entity class name
     *
     * @param string $entityClass FQ entity class name
     *
     * @return EntityRepository
     *
     * @throws InvalidArgumentException If provide class name is not
     *   from a class that implements the EntityInterface interface.
     */
    public function getRepositoryFor($entityClass)
    {
        if (!is_subclass_of($entityClass, EntityInterface::class)) {
            throw new InvalidArgumentException(
                'Cannot create ORM repository for a class that does not '.
                'implement EntityInterface.'
            );
        }
        $repository = new EntityRepository();
        $repository->setAdapter(
            $this->adapters->get($this->getAdapterAlias($entityClass))
        )
            ->setEntityMapper($this->getMapperFor($entityClass))
            ->setEntityDescriptor(EntityDescriptorRegistry::getInstance()
            ->getDescriptorFor($entityClass));
        return $repository;
    }

    /**
     * Retrieves the mapper for provided entity
     *
     * If mapper does not exists it will be created and stored in the
     * mapper map.
     *
     * @param string $entity
     * @return EntityMapper
     */
    public function getMapperFor($entity)
    {
        return  $this->mappers->containsKey($entity)
            ? $this->mappers->get($entity)
            : $this->createMapper($entity);
    }

    /**
     * Sets default adapter
     *
     * @param AdapterInterface $adapter
     * @return $this|Orm|self
     */
    public function setDefaultAdapter(AdapterInterface $adapter)
    {
        return $this->setAdapter('default', $adapter);
    }

    /**
     * Sets an adapter mapped with alias name
     *
     * @param string $alias
     * @param AdapterInterface $adapter
     *
     * @return $this|Orm|self
     */
    public function setAdapter($alias, AdapterInterface $adapter)
    {
        $this->adapters->set($alias, $adapter);
        return $this;
    }

    /**
     * Creates entity map for provided entity
     *
     * @param string $entity
     * @return EntityMapper
     */
    private function createMapper($entity)
    {
        $mapper = new EntityMapper();
        $mapper->setAdapter(
            $this->adapters->get(
                $this->getAdapterAlias($entity)
            )
        );
        $this->mappers->set($entity, $mapper);
        return $mapper;
    }

    /**
     * Gets the adapter alias for current working entity
     *
     * @param string $entity
     *
     * @return EntityDescriptor|string
     */
    private function getAdapterAlias($entity)
    {
        $descriptor = EntityDescriptorRegistry::getInstance()
            ->getDescriptorFor($entity);
        return $descriptor->getAdapterAlias()
            ? $descriptor->getAdapterAlias()
            : 'default';
    }
}

1		<?php
2
3		/**
4		* This file is part of slick/orm package
5		*
6		* For the full copyright and license information, please view the LICENSE
7		* file that was distributed with this source code.
8		*/
9
10		namespace Slick\Orm;
11
12		use Slick\Database\Adapter\AdapterInterface;
13		use Slick\Orm\Descriptor\EntityDescriptor;
14		use Slick\Orm\Descriptor\EntityDescriptorRegistry;
15		use Slick\Orm\Exception\InvalidArgumentException;
16		use Slick\Orm\Mapper\EntityMapper;
17		use Slick\Orm\Mapper\MappersMap;
18		use Slick\Orm\Repository\EntityRepository;
19
20		/**
21		* Orm registry
22		*
23		* @package Slick\Orm
24		* @author Filipe Silva <[email protected]>
25		*/
26		final class Orm
27		{
28
29		/**
30		* @var MappersMap\|EntityMapperInterface[]
31		*/
32		private $mappers;
33
34		/**
35		* @var Orm
36		*/
37		private static $instance;
38
39		/**
40		* @var AdaptersMap
41		*/
42		private $adapters;
43
44		/**
45		* Initialize Orm registry with empty lists
46		*/
47	2	private function __construct()
48		{
49	2	$this->mappers = new MappersMap();
50	2	$this->adapters = new AdaptersMap();
51	2	}
52
53		/**
54		* Avoid clone on a singleton
55		* @codeCoverageIgnore
56		*/
57		private function __clone()
58		{
59
60		}
61
62		/**
63		* Gets a ORM registry instance
64		*
65		* @return Orm
66		*/
67	6	public static function getInstance()
68		{
69	6	if (null === self::$instance) {
70	2	self::$instance = new static;
71	1	}
72	6	return self::$instance;
73		}
74
75		/**
76		* Retrieves the mapper for provided entity
77		*
78		* If mapper does not exists it will be created and stored in the
79		* mapper map.
80		*
81		* @param EntityInterface $entity
82		* @return EntityMapper
83		*/
84	4	public static function getMapper(EntityInterface $entity)
85		{
86	4	return self::getInstance()->getMapperFor($entity);
		0 ignored issues – show Documentation introduced 2016-02-29 21:05 UTC by Report Bug Copy Issue Report `$entity` is of type `object<Slick\Orm\EntityInterface>`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
87		}
88
89		/**
90		* Gets repository for provided entity class name
91		*
92		* @param string $entityClass FQ entity class name
93		*
94		* @return EntityRepository
95		*
96		* @throws InvalidArgumentException If provide class name is not
97		* from a class that implements the EntityInterface interface.
98		*/
99		public static function getRepository($entityClass)
100		{
101		return self::getInstance()->getRepositoryFor($entityClass);
102		}
103
104		/**
105		* Gets repository for provided entity class name
106		*
107		* @param string $entityClass FQ entity class name
108		*
109		* @return EntityRepository
110		*
111		* @throws InvalidArgumentException If provide class name is not
112		* from a class that implements the EntityInterface interface.
113		*/
114		public function getRepositoryFor($entityClass)
115		{
116		if (!is_subclass_of($entityClass, EntityInterface::class)) {
117		throw new InvalidArgumentException(
118		'Cannot create ORM repository for a class that does not '.
119		'implement EntityInterface.'
120		);
121		}
122		$repository = new EntityRepository();
123		$repository->setAdapter(
124		$this->adapters->get($this->getAdapterAlias($entityClass))
125		)
126		->setEntityMapper($this->getMapperFor($entityClass))
127		->setEntityDescriptor(EntityDescriptorRegistry::getInstance()
128		->getDescriptorFor($entityClass));
129		return $repository;
130		}
131
132		/**
133		* Retrieves the mapper for provided entity
134		*
135		* If mapper does not exists it will be created and stored in the
136		* mapper map.
137		*
138		* @param string $entity
139		* @return EntityMapper
140		*/
141	4	public function getMapperFor($entity)
142		{
143	4	return $this->mappers->containsKey($entity)
144	2	? $this->mappers->get($entity)
145	4	: $this->createMapper($entity);
146		}
147
148		/**
149		* Sets default adapter
150		*
151		* @param AdapterInterface $adapter
152		* @return $this\|Orm\|self
153		*/
154	6	public function setDefaultAdapter(AdapterInterface $adapter)
155		{
156	6	return $this->setAdapter('default', $adapter);
157		}
158
159		/**
160		* Sets an adapter mapped with alias name
161		*
162		* @param string $alias
163		* @param AdapterInterface $adapter
164		*
165		* @return $this\|Orm\|self
166		*/
167	6	public function setAdapter($alias, AdapterInterface $adapter)
168		{
169	6	$this->adapters->set($alias, $adapter);
170	6	return $this;
171		}
172
173		/**
174		* Creates entity map for provided entity
175		*
176		* @param string $entity
177		* @return EntityMapper
178		*/
179	4	private function createMapper($entity)
180		{
181	4	$mapper = new EntityMapper();
182	4	$mapper->setAdapter(
183	4	$this->adapters->get(
184	4	$this->getAdapterAlias($entity)
185	2	)
186	2	);
187	4	$this->mappers->set($entity, $mapper);
188	4	return $mapper;
189		}
190
191		/**
192		* Gets the adapter alias for current working entity
193		*
194		* @param string $entity
195		*
196		* @return EntityDescriptor\|string
197		*/
198	4	private function getAdapterAlias($entity)
199		{
200	4	$descriptor = EntityDescriptorRegistry::getInstance()
201	4	->getDescriptorFor($entity);
202	4	return $descriptor->getAdapterAlias()
203	4	? $descriptor->getAdapterAlias()
204	4	: 'default';
205		}
206		}

slickframework / orm

Push — master ( 814e9e...2525ff )

Orm::getMapper() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like