JsonDiscovery - Code Metrics - Inspection of "Merge pull request #31 from webmozart/update-compo..." - puli/discovery - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3ac92f...176d93 )

by Bernhard

created 2016-01-14 08:58 UTC

JsonDiscovery D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	616
Duplicated Lines	12.82 %

Coupling/Cohesion

Components	1
Dependencies	11

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
wmc	96
c	2
b	0
f	1
lcom	1
cbo	11
dl	79
loc	616
ccs	249
cts	249
cp	1
rs	4.438

27 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	reindexBindingsForKey()	0	6	1
A	flush()	0	4	1
A	addBindingType()	0	22	3
B	removeBindingType()	0	33	5
A	removeBindingTypes()	0	17	2
A	hasBindingType()	0	10	2
A	getBindingType()	3	20	4
A	hasBindingTypes()	0	8	2
A	getBindingTypes()	3	16	4
B	addBinding()	0	32	5
B	removeBinding()	32	32	6
A	hasBinding()	0	8	2
B	getBinding()	0	26	6
B	findBindings()	0	26	5
A	getBindings()	0	16	3
A	removeAllBindings()	0	13	2
B	removeBindingsThatMatch()	12	23	5
B	removeBindingsWithTypeName()	0	26	5
B	removeBindingsWithTypeNameThatMatch()	29	29	6
A	hasAnyBinding()	0	8	2
B	hasBindingsThatMatch()	0	18	5
A	hasBindingsWithTypeName()	0	14	3
B	hasBindingsWithTypeNameThatMatch()	0	24	6
A	loadAllBindings()	0	11	4
A	loadBindingsForKey()	0	10	3
A	load()	0	17	3

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like JsonDiscovery often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use JsonDiscovery, and based on these observations, apply Extract Interface, too.

<?php

/*
 * This file is part of the puli/discovery package.
 *
 * (c) Bernhard Schussek <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Puli\Discovery;

use Puli\Discovery\Api\Binding\Binding;
use Puli\Discovery\Api\Binding\Initializer\BindingInitializer;
use Puli\Discovery\Api\Binding\NoSuchBindingException;
use Puli\Discovery\Api\Type\BindingType;
use Puli\Discovery\Api\Type\DuplicateTypeException;
use Puli\Discovery\Api\Type\NoSuchTypeException;
use Rhumsaa\Uuid\Uuid;
use RuntimeException;
use Webmozart\Assert\Assert;
use Webmozart\Expression\Expression;
use Webmozart\Json\JsonDecoder;
use Webmozart\Json\JsonEncoder;

/**
 * A resource discovery backed by a JSON file.
 *
 * @since  1.0
 *
 * @author Bernhard Schussek <[email protected]>
 */
class JsonDiscovery extends AbstractEditableDiscovery
{
    /**
     * @var string
     */
    private $path;

    /**
     * @var array
     */
    private $json;

    /**
     * @var JsonEncoder
     */
    private $encoder;

    /**
     * Stores the binding type for each key.
     *
     * Synchronized with the entries "t:<key>" in the store.
     *
     * @var BindingType[]
     */
    private $typesByKey = array();

    /**
     * Stores the bindings for each key.
     *
     * Synchronized with the entries "b:<key>" in the store.
     *
     * @var Binding[][]
     */
    private $bindingsByKey = array();

    /**
     * Creates a new resource discovery.
     *
     * @param string               $path         The path to the JSON file.
     * @param BindingInitializer[] $initializers The binding initializers to
     *                                           apply to newly created or
     *                                           unserialized bindings.
     */
    public function __construct($path, array $initializers = array())
    {
        Assert::stringNotEmpty($path, 'The path to the JSON file must be a non-empty string. Got: %s');

        parent::__construct($initializers);

        $this->path = $path;
        $this->encoder = new JsonEncoder();
        $this->encoder->setPrettyPrinting(true);
        $this->encoder->setEscapeSlash(false);
    }

    /**
     * {@inheritdoc}
     */
    public function addBindingType(BindingType $type)
    {
        if (null === $this->json) {
            $this->load();
        }

        if (isset($this->json['keysByTypeName'][$type->getName()])) {
            throw DuplicateTypeException::forTypeName($type->getName());
        }

        $key = $this->json['nextKey']++;

        $this->json['keysByTypeName'][$type->getName()] = $key;

        $this->typesByKey[$key] = $type;

        // Use integer keys to reduce storage space
        // (compared to fully-qualified class names)
        $this->json['typesByKey'][$key] = serialize($type);

        $this->flush();
    }

    /**
     * {@inheritdoc}
     */
    public function removeBindingType($typeName)
    {
        Assert::stringNotEmpty($typeName, 'The type class must be a non-empty string. Got: %s');

        if (null === $this->json) {
            $this->load();
        }

        if (!isset($this->json['keysByTypeName'][$typeName])) {
            return;
        }

        $key = $this->json['keysByTypeName'][$typeName];

        if (!isset($this->bindingsByKey[$key])) {
            // no initialize, since we're removing this anyway
            $this->loadBindingsForKey($key, false);
        }

        // Remove all binding UUIDs for this binding type
        foreach ($this->bindingsByKey[$key] as $binding) {
            unset($this->json['keysByUuid'][$binding->getUuid()->toString()]);
        }

        unset($this->typesByKey[$key]);
        unset($this->bindingsByKey[$key]);

        unset($this->json['keysByTypeName'][$typeName]);
        unset($this->json['typesByKey'][$key]);
        unset($this->json['bindingsByKey'][$key]);

        $this->flush();
    }

    /**
     * {@inheritdoc}
     */
    public function removeBindingTypes()
    {
        if (null === $this->json) {
            $this->load();
        }

        $this->typesByKey = array();
        $this->bindingsByKey = array();

        $this->json['keysByTypeName'] = array();
        $this->json['keysByUuid'] = array();
        $this->json['typesByKey'] = array();
        $this->json['bindingsByKey'] = array();
        $this->json['nextKey'] = 0;

        $this->flush();
    }

    /**
     * {@inheritdoc}
     */
    public function hasBindingType($typeName)
    {
        Assert::stringNotEmpty($typeName, 'The type class must be a non-empty string. Got: %s');

        if (null === $this->json) {
            $this->load();
        }

        return isset($this->json['keysByTypeName'][$typeName]);
    }

    /**
     * {@inheritdoc}
     */
    public function getBindingType($typeName)
    {
        Assert::stringNotEmpty($typeName, 'The type class must be a non-empty string. Got: %s');

        if (null === $this->json) {
            $this->load();
        }

        if (!isset($this->json['keysByTypeName'][$typeName])) {
            throw NoSuchTypeException::forTypeName($typeName);
        }

        $key = $this->json['keysByTypeName'][$typeName];

        if (!isset($this->typesByKey[$key])) {

            $this->typesByKey[$key] = unserialize($this->json['typesByKey'][$key]);
        }

        return $this->typesByKey[$key];
    }

    /**
     * {@inheritdoc}
     */
    public function hasBindingTypes()
    {
        if (null === $this->json) {
            $this->load();
        }

        return count($this->json['keysByTypeName']) > 0;
    }

    /**
     * {@inheritdoc}
     */
    public function getBindingTypes()
    {
        if (null === $this->json) {
            $this->load();
        }

        foreach ($this->json['keysByTypeName'] as $key) {
            if (!isset($this->typesByKey[$key])) {

                $this->typesByKey[$key] = unserialize($this->json['typesByKey'][$key]);
            }
        }

        ksort($this->typesByKey);

        return $this->typesByKey;
    }

    /**
     * {@inheritdoc}
     */
    public function addBinding(Binding $binding)
    {
        if (null === $this->json) {
            $this->load();
        }

        $typeName = $binding->getTypeName();

        if (!isset($this->json['keysByTypeName'][$typeName])) {
            throw NoSuchTypeException::forTypeName($typeName);
        }

        if (isset($this->json['keysByUuid'][$binding->getUuid()->toString()])) {
            // Ignore duplicates
            return;
        }

        $key = $this->json['keysByTypeName'][$typeName];

        if (!isset($this->bindingsByKey[$key])) {
            $this->loadBindingsForKey($key);
        }

        $this->initializeBinding($binding);

        $this->bindingsByKey[$key][] = $binding;

        $this->json['keysByUuid'][$binding->getUuid()->toString()] = $key;
        $this->json['bindingsByKey'][$key] = serialize($this->bindingsByKey[$key]);

        $this->flush();
    }

    /**
     * {@inheritdoc}
     */
    public function removeBinding(Uuid $uuid)

    {
        if (null === $this->json) {
            $this->load();
        }

        $uuidString = $uuid->toString();

        if (!isset($this->json['keysByUuid'][$uuidString])) {
            return;
        }

        $key = $this->json['keysByUuid'][$uuidString];

        if (!isset($this->bindingsByKey[$key])) {
            $this->loadBindingsForKey($key);
        }

        foreach ($this->bindingsByKey[$key] as $i => $binding) {
            if ($binding->getUuid()->equals($uuid)) {
                unset($this->bindingsByKey[$key][$i]);
            }
        }

        $this->reindexBindingsForKey($key);

        unset($this->json['keysByUuid'][$uuidString]);

        $this->json['bindingsByKey'][$key] = serialize($this->bindingsByKey[$key]);

        $this->flush();
    }

    /**
     * {@inheritdoc}
     */
    public function hasBinding(Uuid $uuid)
    {
        if (null === $this->json) {
            $this->load();
        }

        return isset($this->json['keysByUuid'][$uuid->toString()]);
    }

    /**
     * {@inheritdoc}
     */
    public function getBinding(Uuid $uuid)
    {
        if (null === $this->json) {
            $this->load();
        }

        if (!isset($this->json['keysByUuid'][$uuid->toString()])) {
            throw NoSuchBindingException::forUuid($uuid);
        }

        $key = $this->json['keysByUuid'][$uuid->toString()];

        if (!isset($this->bindingsByKey[$key])) {
            $this->loadBindingsForKey($key);
        }

        foreach ($this->bindingsByKey[$key] as $binding) {
            if ($binding->getUuid()->equals($uuid)) {
                return $binding;
            }
        }

        // This does not happen except if someone plays with the JSON file
        // contents (or there's a bug here..)
        throw new RuntimeException('The discovery is corrupt. Please rebuild it.');
    }

    /**
     * {@inheritdoc}
     */
    public function findBindings($typeName, Expression $expr = null)
    {
        Assert::stringNotEmpty($typeName, 'The type class must be a non-empty string. Got: %s');

        if (null === $this->json) {
            $this->load();
        }

        if (!isset($this->json['keysByTypeName'][$typeName])) {
            return array();
        }

        $key = $this->json['keysByTypeName'][$typeName];

        if (!isset($this->bindingsByKey[$key])) {
            $this->loadBindingsForKey($key);
        }

        $bindings = $this->bindingsByKey[$key];

        if (null !== $expr) {
            $bindings = $this->filterBindings($bindings, $expr);
        }

        return $bindings;
    }

    /**
     * {@inheritdoc}
     */
    public function getBindings()
    {
        if (null === $this->json) {
            $this->load();
        }

        $this->loadAllBindings();

        $bindings = array();

        foreach ($this->bindingsByKey as $bindingsForKey) {
            $bindings = array_merge($bindings, $bindingsForKey);
        }

        return $bindings;
    }

    /**
     * {@inheritdoc}
     */
    protected function removeAllBindings()
    {
        if (null === $this->json) {
            $this->load();
        }

        $this->bindingsByKey = array();

        $this->json['bindingsByKey'] = array();
        $this->json['keysByUuid'] = array();

        $this->flush();
    }

    /**
     * {@inheritdoc}
     */
    protected function removeBindingsThatMatch(Expression $expr)
    {
        if (null === $this->json) {
            $this->load();
        }

        $this->loadAllBindings();

        foreach ($this->bindingsByKey as $key => $bindingsForKey) {

            foreach ($bindingsForKey as $i => $binding) {
                if ($expr->evaluate($binding)) {
                    unset($this->bindingsByKey[$key][$i]);
                    unset($this->json['keysByUuid'][$binding->getUuid()->toString()]);
                }
            }

            $this->reindexBindingsForKey($key);

            $this->json['bindingsByKey'][$key] = serialize($this->bindingsByKey[$key]);
        }

        $this->flush();
    }

    /**
     * {@inheritdoc}
     */
    protected function removeBindingsWithTypeName($typeName)
    {
        if (null === $this->json) {
            $this->load();
        }

        if (!isset($this->json['keysByTypeName'][$typeName])) {
            return;
        }

        $key = $this->json['keysByTypeName'][$typeName];

        if (!isset($this->bindingsByKey[$key])) {
            // no initialize, since we're removing this anyway
            $this->loadBindingsForKey($key, false);
        }

        foreach ($this->bindingsByKey[$key] as $binding) {
            unset($this->json['keysByUuid'][$binding->getUuid()->toString()]);
        }

        unset($this->bindingsByKey[$key]);
        unset($this->json['bindingsByKey'][$key]);

        $this->flush();
    }

    /**
     * {@inheritdoc}
     */
    protected function removeBindingsWithTypeNameThatMatch($typeName, Expression $expr)

    {
        if (null === $this->json) {
            $this->load();
        }

        if (!isset($this->json['keysByTypeName'][$typeName])) {
            return;
        }

        $key = $this->json['keysByTypeName'][$typeName];

        if (!isset($this->bindingsByKey[$key])) {
            $this->loadBindingsForKey($key);
        }

        foreach ($this->bindingsByKey[$key] as $i => $binding) {
            if ($expr->evaluate($binding)) {
                unset($this->bindingsByKey[$key][$i]);
                unset($this->json['keysByUuid'][$binding->getUuid()->toString()]);
            }
        }

        $this->reindexBindingsForKey($key);

        $this->json['bindingsByKey'][$key] = serialize($this->bindingsByKey[$key]);

        $this->flush();
    }

    /**
     * {@inheritdoc}
     */
    protected function hasAnyBinding()
    {
        if (null === $this->json) {
            $this->load();
        }

        return count($this->json['keysByUuid']) > 0;
    }

    /**
     * {@inheritdoc}
     */
    protected function hasBindingsThatMatch(Expression $expr)
    {
        if (null === $this->json) {
            $this->load();
        }

        $this->loadAllBindings();

        foreach ($this->bindingsByKey as $bindingsForKey) {
            foreach ($bindingsForKey as $binding) {
                if ($expr->evaluate($binding)) {
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    protected function hasBindingsWithTypeName($typeName)
    {
        if (null === $this->json) {
            $this->load();
        }

        if (!isset($this->json['keysByTypeName'][$typeName])) {
            return false;
        }

        $key = $this->json['keysByTypeName'][$typeName];

        return false !== array_search($key, $this->json['keysByUuid'], true);
    }

    protected function hasBindingsWithTypeNameThatMatch($typeName, Expression $expr)
    {
        if (null === $this->json) {
            $this->load();
        }

        if (!$this->hasBindingsWithTypeName($typeName)) {
            return false;
        }

        $key = $this->json['keysByTypeName'][$typeName];

        if (!isset($this->bindingsByKey[$key])) {
            $this->loadBindingsForKey($key);
        }

        foreach ($this->bindingsByKey[$key] as $binding) {
            if ($expr->evaluate($binding)) {
                return true;
            }
        }

        return false;
    }

    private function loadAllBindings()
    {
        foreach ($this->json['keysByTypeName'] as $key) {
            if (!isset($this->bindingsByKey[$key])) {
                $this->bindingsByKey[$key] = isset($this->json['bindingsByKey'][$key])
                    ? unserialize($this->json['bindingsByKey'][$key])
                    : array();
                $this->initializeBindings($this->bindingsByKey[$key]);
            }
        }
    }

    private function loadBindingsForKey($key, $initialize = true)
    {
        $this->bindingsByKey[$key] = isset($this->json['bindingsByKey'][$key])
            ? unserialize($this->json['bindingsByKey'][$key])
            : array();

        if ($initialize) {
            $this->initializeBindings($this->bindingsByKey[$key]);
        }
    }

    private function reindexBindingsForKey($key)
    {
        $this->bindingsByKey[$key] = array_values($this->bindingsByKey[$key]);

        $this->json['bindingsByKey'][$key] = serialize($this->bindingsByKey[$key]);
    }

    /**
     * Loads the JSON file.
     */
    private function load()
    {
        $decoder = new JsonDecoder();
        $decoder->setObjectDecoding(JsonDecoder::ASSOC_ARRAY);

        $this->json = file_exists($this->path)

            ? $decoder->decodeFile($this->path)
            : array();

        if (!isset($this->json['keysByTypeName'])) {
            $this->json['keysByTypeName'] = array();
            $this->json['keysByUuid'] = array();
            $this->json['typesByKey'] = array();
            $this->json['bindingsByKey'] = array();
            $this->json['nextKey'] = 0;
        }
    }

    /**
     * Writes the JSON file.
     */
    private function flush()
    {
        $this->encoder->encodeFile($this->json, $this->path);
    }
}


1			<?php
2
3			/*
4			* This file is part of the puli/discovery package.
5			*
6			* (c) Bernhard Schussek <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Puli\Discovery;
13
14			use Puli\Discovery\Api\Binding\Binding;
15			use Puli\Discovery\Api\Binding\Initializer\BindingInitializer;
16			use Puli\Discovery\Api\Binding\NoSuchBindingException;
17			use Puli\Discovery\Api\Type\BindingType;
18			use Puli\Discovery\Api\Type\DuplicateTypeException;
19			use Puli\Discovery\Api\Type\NoSuchTypeException;
20			use Rhumsaa\Uuid\Uuid;
21			use RuntimeException;
22			use Webmozart\Assert\Assert;
23			use Webmozart\Expression\Expression;
24			use Webmozart\Json\JsonDecoder;
25			use Webmozart\Json\JsonEncoder;
26
27			/**
28			* A resource discovery backed by a JSON file.
29			*
30			* @since 1.0
31			*
32			* @author Bernhard Schussek <[email protected]>
33			*/
34			class JsonDiscovery extends AbstractEditableDiscovery
35			{
36			/**
37			* @var string
38			*/
39			private $path;
40
41			/**
42			* @var array
43			*/
44			private $json;
45
46			/**
47			* @var JsonEncoder
48			*/
49			private $encoder;
50
51			/**
52			* Stores the binding type for each key.
53			*
54			* Synchronized with the entries "t:<key>" in the store.
55			*
56			* @var BindingType[]
57			*/
58			private $typesByKey = array();
59
60			/**
61			* Stores the bindings for each key.
62			*
63			* Synchronized with the entries "b:<key>" in the store.
64			*
65			* @var Binding[][]
66			*/
67			private $bindingsByKey = array();
68
69			/**
70			* Creates a new resource discovery.
71			*
72			* @param string $path The path to the JSON file.
73			* @param BindingInitializer[] $initializers The binding initializers to
74			* apply to newly created or
75			* unserialized bindings.
76			*/
77	113		public function __construct($path, array $initializers = array())
78			{
79	113		Assert::stringNotEmpty($path, 'The path to the JSON file must be a non-empty string. Got: %s');
80
81	113		parent::__construct($initializers);
82
83	113		$this->path = $path;
84	113		$this->encoder = new JsonEncoder();
85	113		$this->encoder->setPrettyPrinting(true);
86	113		$this->encoder->setEscapeSlash(false);
87	113		}
88
89			/**
90			* {@inheritdoc}
91			*/
92	79		public function addBindingType(BindingType $type)
93			{
94	79		if (null === $this->json) {
95	79		$this->load();
96			}
97
98	79		if (isset($this->json['keysByTypeName'][$type->getName()])) {
99	2		throw DuplicateTypeException::forTypeName($type->getName());
100			}
101
102	79		$key = $this->json['nextKey']++;
103
104	79		$this->json['keysByTypeName'][$type->getName()] = $key;
105
106	79		$this->typesByKey[$key] = $type;
107
108			// Use integer keys to reduce storage space
109			// (compared to fully-qualified class names)
110	79		$this->json['typesByKey'][$key] = serialize($type);
111
112	79		$this->flush();
113	79		}
114
115			/**
116			* {@inheritdoc}
117			*/
118	10		public function removeBindingType($typeName)
119			{
120	10		Assert::stringNotEmpty($typeName, 'The type class must be a non-empty string. Got: %s');
121
122	8		if (null === $this->json) {
123	1		$this->load();
124			}
125
126	8		if (!isset($this->json['keysByTypeName'][$typeName])) {
127	2		return;
128			}
129
130	6		$key = $this->json['keysByTypeName'][$typeName];
131
132	6		if (!isset($this->bindingsByKey[$key])) {
133			// no initialize, since we're removing this anyway
134	3		$this->loadBindingsForKey($key, false);
135			}
136
137			// Remove all binding UUIDs for this binding type
138	6		foreach ($this->bindingsByKey[$key] as $binding) {
139	4		unset($this->json['keysByUuid'][$binding->getUuid()->toString()]);
140			}
141
142	6		unset($this->typesByKey[$key]);
143	6		unset($this->bindingsByKey[$key]);
144
145	6		unset($this->json['keysByTypeName'][$typeName]);
146	6		unset($this->json['typesByKey'][$key]);
147	6		unset($this->json['bindingsByKey'][$key]);
148
149	6		$this->flush();
150	6		}
151
152			/**
153			* {@inheritdoc}
154			*/
155	4		public function removeBindingTypes()
156			{
157	4		if (null === $this->json) {
158			$this->load();
159			}
160
161	4		$this->typesByKey = array();
162	4		$this->bindingsByKey = array();
163
164	4		$this->json['keysByTypeName'] = array();
165	4		$this->json['keysByUuid'] = array();
166	4		$this->json['typesByKey'] = array();
167	4		$this->json['bindingsByKey'] = array();
168	4		$this->json['nextKey'] = 0;
169
170	4		$this->flush();
171	4		}
172
173			/**
174			* {@inheritdoc}
175			*/
176	10		public function hasBindingType($typeName)
177			{
178	10		Assert::stringNotEmpty($typeName, 'The type class must be a non-empty string. Got: %s');
179
180	8		if (null === $this->json) {
181	2		$this->load();
182			}
183
184	8		return isset($this->json['keysByTypeName'][$typeName]);
185			}
186
187			/**
188			* {@inheritdoc}
189			*/
190	65		public function getBindingType($typeName)
191			{
192	65		Assert::stringNotEmpty($typeName, 'The type class must be a non-empty string. Got: %s');
193
194	63		if (null === $this->json) {
195	4		$this->load();
196			}
197
198	63		if (!isset($this->json['keysByTypeName'][$typeName])) {
199	2		throw NoSuchTypeException::forTypeName($typeName);
200			}
201
202	61		$key = $this->json['keysByTypeName'][$typeName];
203
204	61	View Code Duplication	if (!isset($this->typesByKey[$key])) {
			0 ignored issues – show Duplication introduced 2016-01-05 11:36 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
205	24		$this->typesByKey[$key] = unserialize($this->json['typesByKey'][$key]);
206			}
207
208	61		return $this->typesByKey[$key];
209			}
210
211			/**
212			* {@inheritdoc}
213			*/
214			public function hasBindingTypes()
215			{
216			if (null === $this->json) {
217			$this->load();
218			}
219
220			return count($this->json['keysByTypeName']) > 0;
221			}
222
223			/**
224			* {@inheritdoc}
225			*/
226	6		public function getBindingTypes()
227			{
228	6		if (null === $this->json) {
229	3		$this->load();
230			}
231
232	6		foreach ($this->json['keysByTypeName'] as $key) {
233	4	View Code Duplication	if (!isset($this->typesByKey[$key])) {
			0 ignored issues – show Duplication introduced 2016-01-05 11:36 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
234	4		$this->typesByKey[$key] = unserialize($this->json['typesByKey'][$key]);
235			}
236			}
237
238	6		ksort($this->typesByKey);
239
240	6		return $this->typesByKey;
241			}
242
243			/**
244			* {@inheritdoc}
245			*/
246	57		public function addBinding(Binding $binding)
247			{
248	57		if (null === $this->json) {
249	4		$this->load();
250			}
251
252	57		$typeName = $binding->getTypeName();
253
254	57		if (!isset($this->json['keysByTypeName'][$typeName])) {
255	2		throw NoSuchTypeException::forTypeName($typeName);
256			}
257
258	55		if (isset($this->json['keysByUuid'][$binding->getUuid()->toString()])) {
259			// Ignore duplicates
260	2		return;
261			}
262
263	55		$key = $this->json['keysByTypeName'][$typeName];
264
265	55		if (!isset($this->bindingsByKey[$key])) {
266	55		$this->loadBindingsForKey($key);
267			}
268
269	55		$this->initializeBinding($binding);
270
271	53		$this->bindingsByKey[$key][] = $binding;
272
273	53		$this->json['keysByUuid'][$binding->getUuid()->toString()] = $key;
274	53		$this->json['bindingsByKey'][$key] = serialize($this->bindingsByKey[$key]);
275
276	53		$this->flush();
277	53		}
278
279			/**
280			* {@inheritdoc}
281			*/
282	7	View Code Duplication	public function removeBinding(Uuid $uuid)
			0 ignored issues – show Duplication introduced 2016-01-05 08:16 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
283			{
284	7		if (null === $this->json) {
285	2		$this->load();
286			}
287
288	7		$uuidString = $uuid->toString();
289
290	7		if (!isset($this->json['keysByUuid'][$uuidString])) {
291	2		return;
292			}
293
294	5		$key = $this->json['keysByUuid'][$uuidString];
295
296	5		if (!isset($this->bindingsByKey[$key])) {
297	2		$this->loadBindingsForKey($key);
298			}
299
300	5		foreach ($this->bindingsByKey[$key] as $i => $binding) {
301	5		if ($binding->getUuid()->equals($uuid)) {
302	5		unset($this->bindingsByKey[$key][$i]);
303			}
304			}
305
306	5		$this->reindexBindingsForKey($key);
307
308	5		unset($this->json['keysByUuid'][$uuidString]);
309
310	5		$this->json['bindingsByKey'][$key] = serialize($this->bindingsByKey[$key]);
311
312	5		$this->flush();
313	5		}
314
315			/**
316			* {@inheritdoc}
317			*/
318	20		public function hasBinding(Uuid $uuid)
319			{
320	20		if (null === $this->json) {
321	1		$this->load();
322			}
323
324	20		return isset($this->json['keysByUuid'][$uuid->toString()]);
325			}
326
327			/**
328			* {@inheritdoc}
329			*/
330	5		public function getBinding(Uuid $uuid)
331			{
332	5		if (null === $this->json) {
333	4		$this->load();
334			}
335
336	5		if (!isset($this->json['keysByUuid'][$uuid->toString()])) {
337	2		throw NoSuchBindingException::forUuid($uuid);
338			}
339
340	3		$key = $this->json['keysByUuid'][$uuid->toString()];
341
342	3		if (!isset($this->bindingsByKey[$key])) {
343	2		$this->loadBindingsForKey($key);
344			}
345
346	3		foreach ($this->bindingsByKey[$key] as $binding) {
347	3		if ($binding->getUuid()->equals($uuid)) {
348	3		return $binding;
349			}
350			}
351
352			// This does not happen except if someone plays with the JSON file
353			// contents (or there's a bug here..)
354			throw new RuntimeException('The discovery is corrupt. Please rebuild it.');
355			}
356
357			/**
358			* {@inheritdoc}
359			*/
360	27		public function findBindings($typeName, Expression $expr = null)
361			{
362	27		Assert::stringNotEmpty($typeName, 'The type class must be a non-empty string. Got: %s');
363
364	25		if (null === $this->json) {
365	13		$this->load();
366			}
367
368	25		if (!isset($this->json['keysByTypeName'][$typeName])) {
369	2		return array();
370			}
371
372	23		$key = $this->json['keysByTypeName'][$typeName];
373
374	23		if (!isset($this->bindingsByKey[$key])) {
375	13		$this->loadBindingsForKey($key);
376			}
377
378	23		$bindings = $this->bindingsByKey[$key];
379
380	23		if (null !== $expr) {
381	2		$bindings = $this->filterBindings($bindings, $expr);
382			}
383
384	23		return $bindings;
385			}
386
387			/**
388			* {@inheritdoc}
389			*/
390	41		public function getBindings()
391			{
392	41		if (null === $this->json) {
393	11		$this->load();
394			}
395
396	41		$this->loadAllBindings();
397
398	41		$bindings = array();
399
400	41		foreach ($this->bindingsByKey as $bindingsForKey) {
401	31		$bindings = array_merge($bindings, $bindingsForKey);
402			}
403
404	41		return $bindings;
405			}
406
407			/**
408			* {@inheritdoc}
409			*/
410	6		protected function removeAllBindings()
411			{
412	6		if (null === $this->json) {
413	3		$this->load();
414			}
415
416	6		$this->bindingsByKey = array();
417
418	6		$this->json['bindingsByKey'] = array();
419	6		$this->json['keysByUuid'] = array();
420
421	6		$this->flush();
422	6		}
423
424			/**
425			* {@inheritdoc}
426			*/
427	2		protected function removeBindingsThatMatch(Expression $expr)
428			{
429	2		if (null === $this->json) {
430			$this->load();
431			}
432
433	2		$this->loadAllBindings();
434
435	2	View Code Duplication	foreach ($this->bindingsByKey as $key => $bindingsForKey) {
			0 ignored issues – show Duplication introduced 2016-01-05 08:16 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
436	2		foreach ($bindingsForKey as $i => $binding) {
437	2		if ($expr->evaluate($binding)) {
438	2		unset($this->bindingsByKey[$key][$i]);
439	2		unset($this->json['keysByUuid'][$binding->getUuid()->toString()]);
440			}
441			}
442
443	2		$this->reindexBindingsForKey($key);
444
445	2		$this->json['bindingsByKey'][$key] = serialize($this->bindingsByKey[$key]);
446			}
447
448	2		$this->flush();
449	2		}
450
451			/**
452			* {@inheritdoc}
453			*/
454	8		protected function removeBindingsWithTypeName($typeName)
455			{
456	8		if (null === $this->json) {
457	3		$this->load();
458			}
459
460	8		if (!isset($this->json['keysByTypeName'][$typeName])) {
461	2		return;
462			}
463
464	6		$key = $this->json['keysByTypeName'][$typeName];
465
466	6		if (!isset($this->bindingsByKey[$key])) {
467			// no initialize, since we're removing this anyway
468	3		$this->loadBindingsForKey($key, false);
469			}
470
471	6		foreach ($this->bindingsByKey[$key] as $binding) {
472	4		unset($this->json['keysByUuid'][$binding->getUuid()->toString()]);
473			}
474
475	6		unset($this->bindingsByKey[$key]);
476	6		unset($this->json['bindingsByKey'][$key]);
477
478	6		$this->flush();
479	6		}
480
481			/**
482			* {@inheritdoc}
483			*/
484	8	View Code Duplication	protected function removeBindingsWithTypeNameThatMatch($typeName, Expression $expr)
			0 ignored issues – show Duplication introduced 2016-01-05 08:16 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
485			{
486	8		if (null === $this->json) {
487	3		$this->load();
488			}
489
490	8		if (!isset($this->json['keysByTypeName'][$typeName])) {
491	2		return;
492			}
493
494	6		$key = $this->json['keysByTypeName'][$typeName];
495
496	6		if (!isset($this->bindingsByKey[$key])) {
497	3		$this->loadBindingsForKey($key);
498			}
499
500	6		foreach ($this->bindingsByKey[$key] as $i => $binding) {
501	4		if ($expr->evaluate($binding)) {
502	4		unset($this->bindingsByKey[$key][$i]);
503	4		unset($this->json['keysByUuid'][$binding->getUuid()->toString()]);
504			}
505			}
506
507	6		$this->reindexBindingsForKey($key);
508
509	6		$this->json['bindingsByKey'][$key] = serialize($this->bindingsByKey[$key]);
510
511	6		$this->flush();
512	6		}
513
514			/**
515			* {@inheritdoc}
516			*/
517	4		protected function hasAnyBinding()
518			{
519	4		if (null === $this->json) {
520	2		$this->load();
521			}
522
523	4		return count($this->json['keysByUuid']) > 0;
524			}
525
526			/**
527			* {@inheritdoc}
528			*/
529			protected function hasBindingsThatMatch(Expression $expr)
530			{
531			if (null === $this->json) {
532			$this->load();
533			}
534
535			$this->loadAllBindings();
536
537			foreach ($this->bindingsByKey as $bindingsForKey) {
538			foreach ($bindingsForKey as $binding) {
539			if ($expr->evaluate($binding)) {
540			return true;
541			}
542			}
543			}
544
545			return false;
546			}
547
548			/**
549			* {@inheritdoc}
550			*/
551	8		protected function hasBindingsWithTypeName($typeName)
552			{
553	8		if (null === $this->json) {
554	3		$this->load();
555			}
556
557	8		if (!isset($this->json['keysByTypeName'][$typeName])) {
558	4		return false;
559			}
560
561	4		$key = $this->json['keysByTypeName'][$typeName];
562
563	4		return false !== array_search($key, $this->json['keysByUuid'], true);
564			}
565
566	4		protected function hasBindingsWithTypeNameThatMatch($typeName, Expression $expr)
567			{
568	4		if (null === $this->json) {
569	3		$this->load();
570			}
571
572	4		if (!$this->hasBindingsWithTypeName($typeName)) {
573	2		return false;
574			}
575
576	2		$key = $this->json['keysByTypeName'][$typeName];
577
578	2		if (!isset($this->bindingsByKey[$key])) {
579	1		$this->loadBindingsForKey($key);
580			}
581
582	2		foreach ($this->bindingsByKey[$key] as $binding) {
583	2		if ($expr->evaluate($binding)) {
584	2		return true;
585			}
586			}
587
588	2		return false;
589			}
590
591	41		private function loadAllBindings()
592			{
593	41		foreach ($this->json['keysByTypeName'] as $key) {
594	31		if (!isset($this->bindingsByKey[$key])) {
595	6		$this->bindingsByKey[$key] = isset($this->json['bindingsByKey'][$key])
596	4		? unserialize($this->json['bindingsByKey'][$key])
597	2		: array();
598	31		$this->initializeBindings($this->bindingsByKey[$key]);
599			}
600			}
601	41		}
602
603	61		private function loadBindingsForKey($key, $initialize = true)
604			{
605	61		$this->bindingsByKey[$key] = isset($this->json['bindingsByKey'][$key])
606	20		? unserialize($this->json['bindingsByKey'][$key])
607	61		: array();
608
609	61		if ($initialize) {
610	57		$this->initializeBindings($this->bindingsByKey[$key]);
611			}
612	61		}
613
614	13		private function reindexBindingsForKey($key)
615			{
616	13		$this->bindingsByKey[$key] = array_values($this->bindingsByKey[$key]);
617
618	13		$this->json['bindingsByKey'][$key] = serialize($this->bindingsByKey[$key]);
619	13		}
620
621			/**
622			* Loads the JSON file.
623			*/
624	99		private function load()
625			{
626	99		$decoder = new JsonDecoder();
627	99		$decoder->setObjectDecoding(JsonDecoder::ASSOC_ARRAY);
628
629	99		$this->json = file_exists($this->path)
			0 ignored issues – show Documentation Bug introduced 2016-01-05 08:16 UTC by Report Bug Copy Issue Report It seems like `file_exists($this->path)...($this->path) : array()` of type `*` is incompatible with the declared type `array` of property `$json`. 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...
630	41		? $decoder->decodeFile($this->path)
631	99		: array();
632
633	99		if (!isset($this->json['keysByTypeName'])) {
634	99		$this->json['keysByTypeName'] = array();
635	99		$this->json['keysByUuid'] = array();
636	99		$this->json['typesByKey'] = array();
637	99		$this->json['bindingsByKey'] = array();
638	99		$this->json['nextKey'] = 0;
639			}
640	99		}
641
642			/**
643			* Writes the JSON file.
644			*/
645	81		private function flush()
646			{
647	81		$this->encoder->encodeFile($this->json, $this->path);
648	81		}
649			}
650

puli / discovery