BindingDescriptor::getState() - Code Metrics - puli/manager - Measure and Improve Code Quality continuously with Scrutinizer

BindingDescriptor::getState() A
last analyzed 2016-08-15 16:04 UTC

↳ Parent: BindingDescriptor

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	2.0625

Importance

Changes

Metric	Value
dl	0
loc	8
c	0
b	0
f	0
ccs	3
cts	4
cp	0.75
rs	9.4285
cc	2
eloc	4
nc	2
nop	0
crap	2.0625

<?php

/*
 * This file is part of the puli/manager 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\Manager\Api\Discovery;

use Exception;
use Puli\Discovery\Api\Binding\Binding;
use Puli\Discovery\Binding\ResourceBinding;
use Puli\Manager\Api\AlreadyLoadedException;
use Puli\Manager\Api\Module\Module;
use Puli\Manager\Api\Module\RootModule;
use Puli\Manager\Api\NotLoadedException;
use Rhumsaa\Uuid\Uuid;

/**
 * Describes a resource binding.
 *
 * This class contains a high-level model of {@link ResourceBinding} as it is
 * used in this module.
 *
 * @since  1.0
 *
 * @author Bernhard Schussek <[email protected]>
 *
 * @see    ResourceBinding
 */
class BindingDescriptor
{
    /**
     * @var Binding
     */
    private $binding;

    /**
     * @var int
     */
    private $state;

    /**
     * @var Module
     */
    private $containingModule;

    /**
     * @var BindingTypeDescriptor
     */
    private $typeDescriptor;

    /**
     * @var Exception[]
     */
    private $loadErrors;

    /**
     * Creates a new binding descriptor.
     *
     * @param Binding $binding The described binding.
     */
    public function __construct(Binding $binding)
    {
        $this->binding = $binding;
    }

    /**
     * Loads the binding descriptor.
     *
     * @param Module                     $containingModule The module that
     *                                                     contains the
     *                                                     descriptor.
     * @param BindingTypeDescriptor|null $typeDescriptor   The type descriptor.
     *
     * @throws AlreadyLoadedException If the descriptor is already loaded.
     */
    public function load(Module $containingModule, BindingTypeDescriptor $typeDescriptor = null)
    {
        if (null !== $this->state) {
            throw new AlreadyLoadedException('The binding descriptor is already loaded.');
        }

        $this->loadErrors = array();

        if ($typeDescriptor && $typeDescriptor->isLoaded() && $typeDescriptor->isEnabled()) {
            try {
                $this->binding->initialize($typeDescriptor->getType());
            } catch (Exception $e) {
                $this->loadErrors[] = $e;
            }
        }

        $this->containingModule = $containingModule;
        $this->typeDescriptor = $typeDescriptor;

        $this->refreshState();
    }

    /**
     * Unloads the binding descriptor.
     *
     * All memory allocated during {@link load()} is freed.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     */
    public function unload()
    {
        if (null === $this->state) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        $this->containingModule = null;
        $this->typeDescriptor = null;
        $this->loadErrors = array();
        $this->state = null;
    }

    /**
     * Returns whether the descriptor is loaded.
     *
     * @return bool Returns `true` if the descriptor is loaded.
     */
    public function isLoaded()
    {
        return null !== $this->state;
    }

    /**
     * Returns the UUID of the described binding.
     *
     * @return Uuid The UUID.
     */
    public function getUuid()
    {
        return $this->binding->getUuid();
    }

    /**
     * Returns the name of the bound type.
     *
     * @return string The type name.
     */
    public function getTypeName()
    {
        return $this->binding->getTypeName();
    }

    /**
     * Returns the described binding.
     *
     * @return Binding The binding.
     */
    public function getBinding()
    {
        return $this->binding;
    }

    /**
     * Returns the errors that happened during loading.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return Exception[] The load errors.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     */
    public function getLoadErrors()
    {
        if (null === $this->loadErrors) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return $this->loadErrors;
    }

    /**
     * Returns the module that contains the descriptor.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return Module The containing module.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     */
    public function getContainingModule()
    {
        if (null === $this->containingModule) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return $this->containingModule;
    }

    /**
     * Returns the type descriptor.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return BindingTypeDescriptor|null The type descriptor or null, if no
     *                                    type descriptor exists for the
     *                                    binding's type name.
     *
     * @throws NotLoadedException If the binding descriptor is not loaded.
     */
    public function getTypeDescriptor()
    {
        // Check containing module, as the type descriptor may be null
        if (null === $this->containingModule) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return $this->typeDescriptor;
    }

    /**
     * Returns the state of the binding.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return int One of the {@link BindingState} constants.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     */
    public function getState()
    {
        if (null === $this->state) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return $this->state;
    }

    /**
     * Returns whether the binding is enabled.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return bool Returns `true` if the state is {@link BindingState::ENABLED}.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     *
     * @see BindingState::ENABLED
     */
    public function isEnabled()

    {
        if (null === $this->state) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return BindingState::ENABLED === $this->state;
    }

    /**
     * Returns whether the binding is disabled.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return bool Returns `true` if the state is {@link BindingState::DISABLED}.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     *
     * @see BindingState::DISABLED
     */
    public function isDisabled()

    {
        if (null === $this->state) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return BindingState::DISABLED === $this->state;
    }

    /**
     * Returns whether the type of the binding does not exist.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return bool Returns `true` if the state is {@link BindingState::TYPE_NOT_FOUND}.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     *
     * @see BindingState::TYPE_NOT_FOUND
     */
    public function isTypeNotFound()

    {
        if (null === $this->state) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return BindingState::TYPE_NOT_FOUND === $this->state;
    }

    /**
     * Returns whether the type of the binding is not enabled.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return bool Returns `true` if the state is {@link BindingState::TYPE_NOT_ENABLED}.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     *
     * @see BindingState::TYPE_NOT_ENABLED
     */
    public function isTypeNotEnabled()

    {
        if (null === $this->state) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return BindingState::TYPE_NOT_ENABLED === $this->state;
    }

    /**
     * Returns whether the binding is invalid.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return bool Returns `true` if the state is {@link BindingState::INVALID}.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     *
     * @see BindingState::INVALID
     */
    public function isInvalid()

    {
        if (null === $this->state) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return BindingState::INVALID === $this->state;
    }

    private function refreshState()
    {
        if (null === $this->typeDescriptor || !$this->typeDescriptor->isLoaded()) {
            $this->state = BindingState::TYPE_NOT_FOUND;
        } elseif (!$this->typeDescriptor->isEnabled()) {
            $this->state = BindingState::TYPE_NOT_ENABLED;
        } elseif (count($this->loadErrors) > 0) {
            $this->state = BindingState::INVALID;
        } elseif ($this->containingModule instanceof RootModule) {
            $this->state = BindingState::ENABLED;
        } elseif ($this->containingModule->getInstallInfo()->hasDisabledBindingUuid($this->binding->getUuid())) {
            $this->state = BindingState::DISABLED;
        } else {
            $this->state = BindingState::ENABLED;
        }
    }
}


1			<?php
2
3			/*
4			* This file is part of the puli/manager 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\Manager\Api\Discovery;
13
14			use Exception;
15			use Puli\Discovery\Api\Binding\Binding;
16			use Puli\Discovery\Binding\ResourceBinding;
17			use Puli\Manager\Api\AlreadyLoadedException;
18			use Puli\Manager\Api\Module\Module;
19			use Puli\Manager\Api\Module\RootModule;
20			use Puli\Manager\Api\NotLoadedException;
21			use Rhumsaa\Uuid\Uuid;
22
23			/**
24			* Describes a resource binding.
25			*
26			* This class contains a high-level model of {@link ResourceBinding} as it is
27			* used in this module.
28			*
29			* @since 1.0
30			*
31			* @author Bernhard Schussek <[email protected]>
32			*
33			* @see ResourceBinding
34			*/
35			class BindingDescriptor
36			{
37			/**
38			* @var Binding
39			*/
40			private $binding;
41
42			/**
43			* @var int
44			*/
45			private $state;
46
47			/**
48			* @var Module
49			*/
50			private $containingModule;
51
52			/**
53			* @var BindingTypeDescriptor
54			*/
55			private $typeDescriptor;
56
57			/**
58			* @var Exception[]
59			*/
60			private $loadErrors;
61
62			/**
63			* Creates a new binding descriptor.
64			*
65			* @param Binding $binding The described binding.
66			*/
67	116		public function __construct(Binding $binding)
68			{
69	116		$this->binding = $binding;
70	116		}
71
72			/**
73			* Loads the binding descriptor.
74			*
75			* @param Module $containingModule The module that
76			* contains the
77			* descriptor.
78			* @param BindingTypeDescriptor\|null $typeDescriptor The type descriptor.
79			*
80			* @throws AlreadyLoadedException If the descriptor is already loaded.
81			*/
82	64		public function load(Module $containingModule, BindingTypeDescriptor $typeDescriptor = null)
83			{
84	64		if (null !== $this->state) {
85			throw new AlreadyLoadedException('The binding descriptor is already loaded.');
86			}
87
88	64		$this->loadErrors = array();
89
90	64		if ($typeDescriptor && $typeDescriptor->isLoaded() && $typeDescriptor->isEnabled()) {
91			try {
92	49		$this->binding->initialize($typeDescriptor->getType());
93	6		} catch (Exception $e) {
94	6		$this->loadErrors[] = $e;
95			}
96			}
97
98	64		$this->containingModule = $containingModule;
99	64		$this->typeDescriptor = $typeDescriptor;
100
101	64		$this->refreshState();
102	64		}
103
104			/**
105			* Unloads the binding descriptor.
106			*
107			* All memory allocated during {@link load()} is freed.
108			*
109			* @throws NotLoadedException If the descriptor is not loaded.
110			*/
111	20		public function unload()
112			{
113	20		if (null === $this->state) {
114			throw new NotLoadedException('The binding descriptor is not loaded.');
115			}
116
117	20		$this->containingModule = null;
118	20		$this->typeDescriptor = null;
119	20		$this->loadErrors = array();
120	20		$this->state = null;
121	20		}
122
123			/**
124			* Returns whether the descriptor is loaded.
125			*
126			* @return bool Returns `true` if the descriptor is loaded.
127			*/
128	52		public function isLoaded()
129			{
130	52		return null !== $this->state;
131			}
132
133			/**
134			* Returns the UUID of the described binding.
135			*
136			* @return Uuid The UUID.
137			*/
138	67		public function getUuid()
139			{
140	67		return $this->binding->getUuid();
141			}
142
143			/**
144			* Returns the name of the bound type.
145			*
146			* @return string The type name.
147			*/
148	62		public function getTypeName()
149			{
150	62		return $this->binding->getTypeName();
151			}
152
153			/**
154			* Returns the described binding.
155			*
156			* @return Binding The binding.
157			*/
158	31		public function getBinding()
159			{
160	31		return $this->binding;
161			}
162
163			/**
164			* Returns the errors that happened during loading.
165			*
166			* The method {@link load()} needs to be called before calling this method,
167			* otherwise an exception is thrown.
168			*
169			* @return Exception[] The load errors.
170			*
171			* @throws NotLoadedException If the descriptor is not loaded.
172			*/
173	11		public function getLoadErrors()
174			{
175	11		if (null === $this->loadErrors) {
176			throw new NotLoadedException('The binding descriptor is not loaded.');
177			}
178
179	11		return $this->loadErrors;
180			}
181
182			/**
183			* Returns the module that contains the descriptor.
184			*
185			* The method {@link load()} needs to be called before calling this method,
186			* otherwise an exception is thrown.
187			*
188			* @return Module The containing module.
189			*
190			* @throws NotLoadedException If the descriptor is not loaded.
191			*/
192	38		public function getContainingModule()
193			{
194	38		if (null === $this->containingModule) {
195			throw new NotLoadedException('The binding descriptor is not loaded.');
196			}
197
198	38		return $this->containingModule;
199			}
200
201			/**
202			* Returns the type descriptor.
203			*
204			* The method {@link load()} needs to be called before calling this method,
205			* otherwise an exception is thrown.
206			*
207			* @return BindingTypeDescriptor\|null The type descriptor or null, if no
208			* type descriptor exists for the
209			* binding's type name.
210			*
211			* @throws NotLoadedException If the binding descriptor is not loaded.
212			*/
213	7		public function getTypeDescriptor()
214			{
215			// Check containing module, as the type descriptor may be null
216	7		if (null === $this->containingModule) {
217			throw new NotLoadedException('The binding descriptor is not loaded.');
218			}
219
220	7		return $this->typeDescriptor;
221			}
222
223			/**
224			* Returns the state of the binding.
225			*
226			* The method {@link load()} needs to be called before calling this method,
227			* otherwise an exception is thrown.
228			*
229			* @return int One of the {@link BindingState} constants.
230			*
231			* @throws NotLoadedException If the descriptor is not loaded.
232			*/
233	8		public function getState()
234			{
235	8		if (null === $this->state) {
236			throw new NotLoadedException('The binding descriptor is not loaded.');
237			}
238
239	8		return $this->state;
240			}
241
242			/**
243			* Returns whether the binding is enabled.
244			*
245			* The method {@link load()} needs to be called before calling this method,
246			* otherwise an exception is thrown.
247			*
248			* @return bool Returns `true` if the state is {@link BindingState::ENABLED}.
249			*
250			* @throws NotLoadedException If the descriptor is not loaded.
251			*
252			* @see BindingState::ENABLED
253			*/
254	32	View Code Duplication	public function isEnabled()
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 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...
255			{
256	32		if (null === $this->state) {
257			throw new NotLoadedException('The binding descriptor is not loaded.');
258			}
259
260	32		return BindingState::ENABLED === $this->state;
261			}
262
263			/**
264			* Returns whether the binding is disabled.
265			*
266			* The method {@link load()} needs to be called before calling this method,
267			* otherwise an exception is thrown.
268			*
269			* @return bool Returns `true` if the state is {@link BindingState::DISABLED}.
270			*
271			* @throws NotLoadedException If the descriptor is not loaded.
272			*
273			* @see BindingState::DISABLED
274			*/
275	4	View Code Duplication	public function isDisabled()
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 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...
276			{
277	4		if (null === $this->state) {
278			throw new NotLoadedException('The binding descriptor is not loaded.');
279			}
280
281	4		return BindingState::DISABLED === $this->state;
282			}
283
284			/**
285			* Returns whether the type of the binding does not exist.
286			*
287			* The method {@link load()} needs to be called before calling this method,
288			* otherwise an exception is thrown.
289			*
290			* @return bool Returns `true` if the state is {@link BindingState::TYPE_NOT_FOUND}.
291			*
292			* @throws NotLoadedException If the descriptor is not loaded.
293			*
294			* @see BindingState::TYPE_NOT_FOUND
295			*/
296	19	View Code Duplication	public function isTypeNotFound()
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 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...
297			{
298	19		if (null === $this->state) {
299			throw new NotLoadedException('The binding descriptor is not loaded.');
300			}
301
302	19		return BindingState::TYPE_NOT_FOUND === $this->state;
303			}
304
305			/**
306			* Returns whether the type of the binding is not enabled.
307			*
308			* The method {@link load()} needs to be called before calling this method,
309			* otherwise an exception is thrown.
310			*
311			* @return bool Returns `true` if the state is {@link BindingState::TYPE_NOT_ENABLED}.
312			*
313			* @throws NotLoadedException If the descriptor is not loaded.
314			*
315			* @see BindingState::TYPE_NOT_ENABLED
316			*/
317	15	View Code Duplication	public function isTypeNotEnabled()
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 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...
318			{
319	15		if (null === $this->state) {
320			throw new NotLoadedException('The binding descriptor is not loaded.');
321			}
322
323	15		return BindingState::TYPE_NOT_ENABLED === $this->state;
324			}
325
326			/**
327			* Returns whether the binding is invalid.
328			*
329			* The method {@link load()} needs to be called before calling this method,
330			* otherwise an exception is thrown.
331			*
332			* @return bool Returns `true` if the state is {@link BindingState::INVALID}.
333			*
334			* @throws NotLoadedException If the descriptor is not loaded.
335			*
336			* @see BindingState::INVALID
337			*/
338		View Code Duplication	public function isInvalid()
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 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...
339			{
340			if (null === $this->state) {
341			throw new NotLoadedException('The binding descriptor is not loaded.');
342			}
343
344			return BindingState::INVALID === $this->state;
345			}
346
347	64		private function refreshState()
348			{
349	64		if (null === $this->typeDescriptor \|\| !$this->typeDescriptor->isLoaded()) {
350	13		$this->state = BindingState::TYPE_NOT_FOUND;
351	56		} elseif (!$this->typeDescriptor->isEnabled()) {
352	8		$this->state = BindingState::TYPE_NOT_ENABLED;
353	49		} elseif (count($this->loadErrors) > 0) {
354	6		$this->state = BindingState::INVALID;
355	43		} elseif ($this->containingModule instanceof RootModule) {
356	25		$this->state = BindingState::ENABLED;
357	24		} elseif ($this->containingModule->getInstallInfo()->hasDisabledBindingUuid($this->binding->getUuid())) {
358	12		$this->state = BindingState::DISABLED;
359			} else {
360	20		$this->state = BindingState::ENABLED;
361			}
362	64		}
363			}
364

puli / manager

BindingDescriptor::getState() A last analyzed 2016-08-15 16:04 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

BindingDescriptor::getState() A
last analyzed 2016-08-15 16:04 UTC