TransferManager::__construct() - Code Metrics - jhonatanTeixeira/restfull-client-orm - Measure and Improve Code Quality continuously with Scrutinizer

TransferManager::__construct() A
last analyzed 2018-06-13 22:43 UTC

↳ Parent: TransferManager

Complexity

Conditions	1
Paths	1

Size

Total Lines	12
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	12
c	0
b	0
f	0
ccs	6
cts	6
cp	1
rs	9.4285
cc	1
eloc	5
nc	1
nop	4
crap	1

<?php

namespace Vox\Webservice;

use Metadata\MetadataFactoryInterface;
use Vox\Webservice\Event\DispatchEventTrait;
use Vox\Webservice\Event\LifecycleEvent;
use Vox\Webservice\Event\ManagerEvent;
use Vox\Webservice\Event\PersistenceEvents;
use Vox\Webservice\Metadata\TransferMetadata;
use Vox\Webservice\Proxy\ProxyFactory;
use Vox\Webservice\Proxy\ProxyFactoryInterface;

/**
 * This is the transfer manager, it is the best way for you to control the state of your transfers.
 * this class is a facade to simplify the use of the unity of work and the repository pattern contained
 * on this project
 * 
 * @author Jhonatan Teixeira <[email protected]>
 */
class TransferManager implements TransferManagerInterface
{
    use DispatchEventTrait;
    
    /**
     * @var UnityOfWorkInterface
filter:
    dependency_paths: ["lib/*"]
     */
    private $unitOfWork;
    
    /**
     * @var MetadataFactoryInterface
     */
    private $metadataFactory;
    
    /**
     * @var WebserviceClientInterface
     */
    private $webserviceClient;
    
    /**
     * @var TransferPersisterInterface
     */
    private $transferPersister;
    
    /**
     * @var ProxyFactoryInterface
     */
    private $proxyFactory;
    
    /**
     * @var EventDispatcherInterface
     */
    private $eventDispatcher;
    
    public function __construct(
        MetadataFactoryInterface $metadataFactory,
        WebserviceClientInterface $webserviceClient,
        ProxyFactoryInterface $proxyFactory = null,
        EventDispatcherInterface $eventDispatcher = null
    ) {
        $this->metadataFactory  = $metadataFactory;
        $this->webserviceClient = $webserviceClient;
        $this->proxyFactory     = $proxyFactory ?? new ProxyFactory();
        $this->eventDispatcher  = $eventDispatcher;
        
        $this->clear();
    }
    
    /**
     * @todo injection of these objects
     * 
     * @param type $objectName
filter:
    dependency_paths: ["lib/*"]
     */
    public function clear($objectName = null)
    {
        $this->unitOfWork       = new UnitOfWork($this->metadataFactory);

        $this->transferPersister = new TransferPersister(
            $this->metadataFactory,
            $this->unitOfWork,
            $this->webserviceClient,
            $this,
            $this->eventDispatcher
        );
    }

    public function contains($object): bool
    {
        return $this->unitOfWork->contains($object);
    }

    public function detach($object)
    {
        $this->unitOfWork->detach($object);
    }

    public function find($className, $id)
    {
        return $this->getRepository($className)->find($id);
    }

    public function flush()
    {
        $event = new ManagerEvent($this);
        
        $this->dispatchEvent(PersistenceEvents::PRE_FLUSH, $event);
        
        foreach ($this->unitOfWork as $transfer) {
            $this->transferPersister->save($transfer);
        }
        
        $this->dispatchEvent(PersistenceEvents::POST_FLUSH, $event);
    }

    public function getClassMetadata($className): TransferMetadata
    {
        if(is_object($className)) {
            $className = get_class($className);
        }
        
        return $this->metadataFactory->getMetadataForClass($className);

    }

    public function getMetadataFactory(): MetadataFactoryInterface
    {
        return $this->metadataFactory;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    public function getRepository($className): TransferRepositoryInterface
    {
        return new TransferRepository(
            $className,
            $this->webserviceClient,
            $this->unitOfWork,
            $this,
            $this->proxyFactory
        );
    }

    public function initializeObject($obj)
    {
        
    }

    public function merge($object)
    {
        
    }

    public function persist($object)
    {
        $this->dispatchEvent(PersistenceEvents::PRE_PERSIST, new LifecycleEvent($object, $this));
        $this->unitOfWork->attach($object);
    }

    public function refresh($object)
    {
        
    }

    public function remove($object)
    {
        $this->unitOfWork->remove($object);
    }
    
    public function getUnitOfWork(): UnitOfWorkInterface
    {
        return $this->unitOfWork;
    }
}


1		<?php
2
3		namespace Vox\Webservice;
4
5		use Metadata\MetadataFactoryInterface;
6		use Vox\Webservice\Event\DispatchEventTrait;
7		use Vox\Webservice\Event\LifecycleEvent;
8		use Vox\Webservice\Event\ManagerEvent;
9		use Vox\Webservice\Event\PersistenceEvents;
10		use Vox\Webservice\Metadata\TransferMetadata;
11		use Vox\Webservice\Proxy\ProxyFactory;
12		use Vox\Webservice\Proxy\ProxyFactoryInterface;
13
14		/**
15		* This is the transfer manager, it is the best way for you to control the state of your transfers.
16		* this class is a facade to simplify the use of the unity of work and the repository pattern contained
17		* on this project
18		*
19		* @author Jhonatan Teixeira <[email protected]>
20		*/
21		class TransferManager implements TransferManagerInterface
22		{
23		use DispatchEventTrait;
24
25		/**
26		* @var UnityOfWorkInterface
		0 ignored issues – show Bug introduced 2018-04-19 14:46 UTC by Report Bug Copy Issue Report The type `Vox\Webservice\UnityOfWorkInterface` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
27		*/
28		private $unitOfWork;
29
30		/**
31		* @var MetadataFactoryInterface
32		*/
33		private $metadataFactory;
34
35		/**
36		* @var WebserviceClientInterface
37		*/
38		private $webserviceClient;
39
40		/**
41		* @var TransferPersisterInterface
42		*/
43		private $transferPersister;
44
45		/**
46		* @var ProxyFactoryInterface
47		*/
48		private $proxyFactory;
49
50		/**
51		* @var EventDispatcherInterface
52		*/
53		private $eventDispatcher;
54
55	40	public function __construct(
56		MetadataFactoryInterface $metadataFactory,
57		WebserviceClientInterface $webserviceClient,
58		ProxyFactoryInterface $proxyFactory = null,
59		EventDispatcherInterface $eventDispatcher = null
60		) {
61	40	$this->metadataFactory = $metadataFactory;
62	40	$this->webserviceClient = $webserviceClient;
63	40	$this->proxyFactory = $proxyFactory ?? new ProxyFactory();
64	40	$this->eventDispatcher = $eventDispatcher;
65
66	40	$this->clear();
67	40	}
68
69		/**
70		* @todo injection of these objects
71		*
72		* @param type $objectName
		0 ignored issues – show Bug introduced 2017-12-14 01:20 UTC by Report Bug Copy Issue Report The type `Vox\Webservice\type` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
73		*/
74	40	public function clear($objectName = null)
75		{
76	40	$this->unitOfWork = new UnitOfWork($this->metadataFactory);
		0 ignored issues – show Documentation Bug introduced 2018-05-18 20:36 UTC by Report Bug Copy Issue Report It seems like `new Vox\Webservice\UnitO...$this->metadataFactory)` of type `Vox\Webservice\UnitOfWork` is incompatible with the declared type `Vox\Webservice\UnityOfWorkInterface` of property `$unitOfWork`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
77	40	$this->transferPersister = new TransferPersister(
78	40	$this->metadataFactory,
79	40	$this->unitOfWork,
80	40	$this->webserviceClient,
81	40	$this,
82	40	$this->eventDispatcher
83		);
84	40	}
85
86		public function contains($object): bool
87		{
88		return $this->unitOfWork->contains($object);
89		}
90
91		public function detach($object)
92		{
93		$this->unitOfWork->detach($object);
94		}
95
96	14	public function find($className, $id)
97		{
98	14	return $this->getRepository($className)->find($id);
99		}
100
101	17	public function flush()
102		{
103	17	$event = new ManagerEvent($this);
104
105	17	$this->dispatchEvent(PersistenceEvents::PRE_FLUSH, $event);
106
107	17	foreach ($this->unitOfWork as $transfer) {
108	17	$this->transferPersister->save($transfer);
109		}
110
111	16	$this->dispatchEvent(PersistenceEvents::POST_FLUSH, $event);
112	16	}
113
114	32	public function getClassMetadata($className): TransferMetadata
115		{
116	32	if(is_object($className)) {
117		$className = get_class($className);
118		}
119
120	32	return $this->metadataFactory->getMetadataForClass($className);
		0 ignored issues – show Bug Best Practice introduced 2017-12-09 01:30 UTC by Report Bug Copy Issue Report The expression `return $this->metadataFa...ataForClass($className)` returns the type `null\|Metadata\ClassHierarchyMetadata` which is incompatible with the type-hinted return `Vox\Webservice\Metadata\TransferMetadata`. Loading history...
121		}
122
123		public function getMetadataFactory(): MetadataFactoryInterface
124		{
125		return $this->metadataFactory;
		0 ignored issues – show Bug Best Practice introduced 2017-12-09 01:30 UTC by Report Bug Copy Issue Report The expression `return $this->metadataFactory` returns the type `Metadata\MetadataFactoryInterface` which is incompatible with the return type mandated by `Doctrine\Common\Persiste...r::getMetadataFactory()` of `Doctrine\Common\Persiste...ng\ClassMetadataFactory`. In the issue above, the returned value is violating the contract defined by the mentioned interface. Let's take a look at an example: interface HasName { /** @return string / public function getName(); } class Name { public $name; } class User implements HasName { /* @return string\|Name */ public function getName() { return new Name('foo'); // This is a violation of the ``HasName`` interface // which only allows a string value to be returned. } } Loading history...
126		}
127
128	25	public function getRepository($className): TransferRepositoryInterface
129		{
130	25	return new TransferRepository(
131	25	$className,
132	25	$this->webserviceClient,
133	25	$this->unitOfWork,
134	25	$this,
135	25	$this->proxyFactory
136		);
137		}
138
139		public function initializeObject($obj)
140		{
141
142		}
143
144		public function merge($object)
145		{
146
147		}
148
149	8	public function persist($object)
150		{
151	8	$this->dispatchEvent(PersistenceEvents::PRE_PERSIST, new LifecycleEvent($object, $this));
152	8	$this->unitOfWork->attach($object);
153	8	}
154
155		public function refresh($object)
156		{
157
158		}
159
160	5	public function remove($object)
161		{
162	5	$this->unitOfWork->remove($object);
163	5	}
164
165	1	public function getUnitOfWork(): UnitOfWorkInterface
166		{
167	1	return $this->unitOfWork;
168		}
169		}
170

jhonatanTeixeira / restfull-client-orm

TransferManager::__construct() A last analyzed 2018-06-13 22:43 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

TransferManager::__construct() A
last analyzed 2018-06-13 22:43 UTC