SnapshotRepository::merge() - Code Metrics - Inspection of "[Jobs,Core] Fix: Changes are not applied when job..." - cross-solution/YAWIK - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( e95d13...02ce7e )

unknown

created 2017-02-22 10:31 UTC

SnapshotRepository::merge() A

↳ Parent: SnapshotRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	10
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	5
nc	1
nop	1

<?php
/**
 * YAWIK
 *
 * @filesource
 * @license MIT
 * @copyright  2013 - 2017 Cross Solution <http://cross-solution.de>
 */
  
/** */
namespace Core\Repository;

use Core\Entity\Collection\ArrayCollection;
use Core\Entity\EntityInterface;
use Core\Entity\Hydrator\EntityHydrator;
use Core\Entity\SnapshotAttributesProviderInterface;
use Core\Entity\SnapshotInterface;
use Doctrine\Common\Collections\Collection;
use Doctrine\ODM\MongoDB\DocumentRepository;
use Zend\Hydrator\HydratorInterface;

/**
 * ${CARET}
 * 
 * @author Mathias Gelhausen <[email protected]>
 * @todo write test 
 */
class SnapshotRepository extends DocumentRepository
{
    /**
     *
     *
     * @var HydratorInterface
     */
    protected $hydrator;

    /**
     *
     *
     * @var HydratorInterface
     */
    protected $sourceHydrator;

    /**
     *
     *
     * @var array
     */
    protected $snapshotAttributes = [];

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

        return $this;
    }

    /**
     * @return \Zend\Hydrator\HydratorInterface
     */
    public function getHydrator()
    {
        if (!$this->hydrator) {
            $this->setHydrator(new EntityHydrator());
        }
        return $this->hydrator;
    }

    /**
     * @param \Zend\Hydrator\HydratorInterface $sourceHydrator
     *
     * @return self
     */
    public function setSourceHydrator($sourceHydrator)
    {
        $this->sourceHydrator = $sourceHydrator;

        return $this;
    }

    /**
     * @return \Zend\Hydrator\HydratorInterface
     */
    public function getSourceHydrator()
    {
        if (!$this->sourceHydrator) {
            return $this->getHydrator();
        }

        return $this->sourceHydrator;
    }

    /**
     * @param array $snapshotAttributes
     *
     * @return self
     */
    public function setSnapshotAttributes($snapshotAttributes)
    {
        $this->snapshotAttributes = $snapshotAttributes;

        return $this;
    }

    /**
     * @return array
     */
    public function getSnapshotAttributes()
    {
        return $this->snapshotAttributes;
    }



    public function create(EntityInterface $source, $persist = true)
    {

        $snapshot = $this->getDocumentName();
        $snapshot = new $snapshot($source);

        $this->copy($source, $snapshot);

        if ($persist) {
            $this->store($snapshot);
        }

        return $snapshot;
    }

    protected function copy($source, $target, $attributes = null)
    {
        if (!$attributes) {
            if ($source instanceOf SnapshotAttributesProviderInterface) {
                $attributes = $source->getSnapshotAttributes();
            } else if ($target instanceOf SnapshotAttributesProviderInterface) {
                $attributes = $target->getSnapshotAttributes();
            } else {
                $attributes = $this->getSnapshotAttributes();
            }
        }

        $data = $this->getSourceHydrator()->extract(clone $source);
        $data = array_intersect_key($data, array_flip($attributes));
        $this->getHydrator()->hydrate($data, $target);
    }

    public function merge(SnapshotInterface $snapshot)
    {
        $this->checkEntityType($snapshot);

        $entity = $snapshot->getSnapshotMeta()->getEntity();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->copy($snapshot, $entity);

        return $entity;
    }

    public function findLatest($sourceId, $isDraft = false)
    {
        return $this->createQueryBuilder()
          ->field('snapshotMeta.entity.$id')->equals(new \MongoId($sourceId))
          ->field('snapshotMeta.isDraft')->equals($isDraft)
          ->sort('snapshotMeta.dateCreated.date', 'desc')
          ->limit(1)
          ->getQuery()
          ->getSingleResult();

    }

    public function findBySourceId($sourceId, $includeDrafts = false)
    {
        $criteria = ['snapshotMeta.entity.$id' => $sourceId];

        if (!$includeDrafts) {
            $criteria['snapshotMeta.isDraft'] = false;
        }

        return $this->findBy($criteria);
    }

    /**
     * @param $entity
     * @throws \InvalidArgumentException
     * @return self
     */
    public function store($entity)
    {
        $this->checkEntityType($entity);
        $this->dm->persist($entity);
        $this->dm->flush($entity);

        return $this;
    }

    public function remove($entity)
    {
        $this->checkEntityType($entity);
        $this->dm->remove($entity);

        return $this;
    }

    public function removeAll($sourceId)

    {

    }

    protected function checkEntityType($entity)
    {
        if ( !is_a($entity,  $this->getDocumentName()) ) {
            throw new \InvalidArgumentException(sprintf(
                'Entity must be of type %s but recieved %s instead',
                $this->getDocumentName(),
                get_class($entity)
            ));
        }

    }

    protected function extract($source, array $attributes = [])
    {
        $hydrator = $this->getSourceHydrator();
        $data     = $hydrator->extract($source);
        $hydrate  = [];

        if (empty($attributes)) {
            $attributes = array_keys($data);
        }

        foreach ($attributes as $key => $spec) {
            if (is_numeric($key)) {
                $key = $spec;
                $spec = null;
            }

            if ($data[$key] instanceOf EntityInterface) {
                $hydrate[$key] = clone $data[$key];

            } else if ($data[$key] instanceOf Collection) {
                $collection = new ArrayCollection();
                foreach ($data[$key] as $item) {
                    $collection->add(clone $item);
                }
                $hydrate[$key] = $collection;

            } else {
                $hydrate[$key] = $data[$key];
            }
        }

        return $hydrate;
    }
}

1			<?php
2			/**
3			* YAWIK
4			*
5			* @filesource
6			* @license MIT
7			* @copyright 2013 - 2017 Cross Solution <http://cross-solution.de>
8			*/
9
10			/** */
11			namespace Core\Repository;
12
13			use Core\Entity\Collection\ArrayCollection;
14			use Core\Entity\EntityInterface;
15			use Core\Entity\Hydrator\EntityHydrator;
16			use Core\Entity\SnapshotAttributesProviderInterface;
17			use Core\Entity\SnapshotInterface;
18			use Doctrine\Common\Collections\Collection;
19			use Doctrine\ODM\MongoDB\DocumentRepository;
20			use Zend\Hydrator\HydratorInterface;
21
22			/**
23			* ${CARET}
24			*
25			* @author Mathias Gelhausen <[email protected]>
26			* @todo write test
27			*/
28			class SnapshotRepository extends DocumentRepository
29			{
30			/**
31			*
32			*
33			* @var HydratorInterface
34			*/
35			protected $hydrator;
36
37			/**
38			*
39			*
40			* @var HydratorInterface
41			*/
42			protected $sourceHydrator;
43
44			/**
45			*
46			*
47			* @var array
48			*/
49			protected $snapshotAttributes = [];
50
51			/**
52			* @param \Zend\Hydrator\HydratorInterface $hydrator
53			*
54			* @return self
55			*/
56			public function setHydrator($hydrator)
57			{
58			$this->hydrator = $hydrator;
59
60			return $this;
61			}
62
63			/**
64			* @return \Zend\Hydrator\HydratorInterface
65			*/
66			public function getHydrator()
67			{
68			if (!$this->hydrator) {
69			$this->setHydrator(new EntityHydrator());
70			}
71			return $this->hydrator;
72			}
73
74			/**
75			* @param \Zend\Hydrator\HydratorInterface $sourceHydrator
76			*
77			* @return self
78			*/
79			public function setSourceHydrator($sourceHydrator)
80			{
81			$this->sourceHydrator = $sourceHydrator;
82
83			return $this;
84			}
85
86			/**
87			* @return \Zend\Hydrator\HydratorInterface
88			*/
89			public function getSourceHydrator()
90			{
91			if (!$this->sourceHydrator) {
92			return $this->getHydrator();
93			}
94
95			return $this->sourceHydrator;
96			}
97
98			/**
99			* @param array $snapshotAttributes
100			*
101			* @return self
102			*/
103			public function setSnapshotAttributes($snapshotAttributes)
104			{
105			$this->snapshotAttributes = $snapshotAttributes;
106
107			return $this;
108			}
109
110			/**
111			* @return array
112			*/
113			public function getSnapshotAttributes()
114			{
115			return $this->snapshotAttributes;
116			}
117
118
119
120			public function create(EntityInterface $source, $persist = true)
121			{
122
123			$snapshot = $this->getDocumentName();
124			$snapshot = new $snapshot($source);
125
126			$this->copy($source, $snapshot);
127
128			if ($persist) {
129			$this->store($snapshot);
130			}
131
132			return $snapshot;
133			}
134
135			protected function copy($source, $target, $attributes = null)
136			{
137			if (!$attributes) {
138			if ($source instanceOf SnapshotAttributesProviderInterface) {
139			$attributes = $source->getSnapshotAttributes();
140			} else if ($target instanceOf SnapshotAttributesProviderInterface) {
141			$attributes = $target->getSnapshotAttributes();
142			} else {
143			$attributes = $this->getSnapshotAttributes();
144			}
145			}
146
147			$data = $this->getSourceHydrator()->extract(clone $source);
148			$data = array_intersect_key($data, array_flip($attributes));
149			$this->getHydrator()->hydrate($data, $target);
150			}
151
152			public function merge(SnapshotInterface $snapshot)
153			{
154			$this->checkEntityType($snapshot);
155
156			$entity = $snapshot->getSnapshotMeta()->getEntity();
			0 ignored issues – show Bug introduced 2017-02-22 10:41 UTC by Report Bug Copy Issue Report The method `getEntity` does only exist in `Core\Entity\SnapshotMeta`, but not in `Core\Entity\SnapshotInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
157
158			$this->copy($snapshot, $entity);
159
160			return $entity;
161			}
162
163			public function findLatest($sourceId, $isDraft = false)
164			{
165			return $this->createQueryBuilder()
166			->field('snapshotMeta.entity.$id')->equals(new \MongoId($sourceId))
167			->field('snapshotMeta.isDraft')->equals($isDraft)
168			->sort('snapshotMeta.dateCreated.date', 'desc')
169			->limit(1)
170			->getQuery()
171			->getSingleResult();
172
173			}
174
175			public function findBySourceId($sourceId, $includeDrafts = false)
176			{
177			$criteria = ['snapshotMeta.entity.$id' => $sourceId];
178
179			if (!$includeDrafts) {
180			$criteria['snapshotMeta.isDraft'] = false;
181			}
182
183			return $this->findBy($criteria);
184			}
185
186			/**
187			* @param $entity
188			* @throws \InvalidArgumentException
189			* @return self
190			*/
191			public function store($entity)
192			{
193			$this->checkEntityType($entity);
194			$this->dm->persist($entity);
195			$this->dm->flush($entity);
196
197			return $this;
198			}
199
200			public function remove($entity)
201			{
202			$this->checkEntityType($entity);
203			$this->dm->remove($entity);
204
205			return $this;
206			}
207
208			public function removeAll($sourceId)
			0 ignored issues – show Unused Code introduced 2017-02-16 16:50 UTC by Report Bug Copy Issue Report The parameter `$sourceId` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
209			{
210
211			}
212
213			protected function checkEntityType($entity)
214			{
215			if ( !is_a($entity, $this->getDocumentName()) ) {
216			throw new \InvalidArgumentException(sprintf(
217			'Entity must be of type %s but recieved %s instead',
218			$this->getDocumentName(),
219			get_class($entity)
220			));
221			}
222
223			}
224
225			protected function extract($source, array $attributes = [])
226			{
227			$hydrator = $this->getSourceHydrator();
228			$data = $hydrator->extract($source);
229			$hydrate = [];
230
231			if (empty($attributes)) {
232			$attributes = array_keys($data);
233			}
234
235			foreach ($attributes as $key => $spec) {
236			if (is_numeric($key)) {
237			$key = $spec;
238			$spec = null;
239			}
240
241			if ($data[$key] instanceOf EntityInterface) {
242			$hydrate[$key] = clone $data[$key];
243
244			} else if ($data[$key] instanceOf Collection) {
245			$collection = new ArrayCollection();
246			foreach ($data[$key] as $item) {
247			$collection->add(clone $item);
248			}
249			$hydrate[$key] = $collection;
250
251			} else {
252			$hydrate[$key] = $data[$key];
253			}
254			}
255
256			return $hydrate;
257			}
258			}

cross-solution / YAWIK

Push — develop ( e95d13...02ce7e )

SnapshotRepository::merge() A

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like