Context::offsetSet() - Code Metrics - Inspection of "Implement and expose article keywords (#213)" - ahilles107/web-publisher - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8d3dbf...7592af )

by Paweł

created 2017-01-12 19:27 UTC

Context::offsetSet() A

↳ Parent: Context

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes

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

<?php

/*
 * This file is part of the Superdesk Web Publisher Templates System.
 *
 * Copyright 2015 Sourcefabric z.ú. and contributors.
 *
 * For the full copyright and license information, please see the
 * AUTHORS and LICENSE files distributed with this source code.
 *
 * @copyright 2015 Sourcefabric z.ú
 * @license http://www.superdesk.org/license
 */

namespace SWP\Component\TemplatesSystem\Gimme\Context;

use Doctrine\Common\Cache\Cache;
use SWP\Component\TemplatesSystem\Gimme\Meta\Meta;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Yaml\Parser;

class Context implements \ArrayAccess
{
    /**
     * Array with current page information's.
     *
     * @var Meta
     */
    protected $currentPage;

    /**
     * Array will all registered meta types.
     *
     * @var Meta[]
     */
    protected $registeredMeta = [];

    /**
     * Array with available meta configs.
     *
     * @var array
     */
    protected $availableConfigs = [];

    /**
     * @var Cache
     */
    protected $metadataCache;

    /**
     * @var string
     */
    protected $configsPath;

    /**
     * @var array
     */
    private $temporaryMeta = [];

    /**
     * Context constructor.
     *
     * @param Cache  $metadataCache
     * @param string $configsPath
     */
    public function __construct(Cache $metadataCache, $configsPath = null)
    {
        $this->metadataCache = $metadataCache;
        $this->configsPath = $configsPath;
    }

    /**
     * @return array
     */
    public function getAvailableConfigs()
    {
        if (0 === count($this->availableConfigs)) {
            $this->loadConfigsFromPath($this->configsPath);
        }

        return $this->availableConfigs;
    }

    /**
     * @param array $configuration
     *
     * @return bool
     */
    public function addAvailableConfig(array $configuration)
    {
        if (isset($configuration['class']) && !isset($this->availableConfigs[$configuration['class']])) {
            $this->availableConfigs[$configuration['class']] = $configuration;

            return true;
        }

        return false;
    }

    /**
     * @param array $availableConfigs
     *
     * @return Context
     */
    public function setAvailableConfigs(array $availableConfigs)
    {
        $this->availableConfigs = $availableConfigs;

        return $this;
    }

    /**
     * @param string $configsPath
     */
    public function loadConfigsFromPath($configsPath)
    {
        if (file_exists($configsPath)) {
            $finder = new Finder();
            $finder->in($configsPath)->files()->name('*.yml');

            foreach ($finder as $file) {
                $this->addNewConfig($file->getRealPath());
            }
        }
    }

    /**
     * @param mixed $value
     *
     * @return array
     *
     * @throws \Exception
     */
    public function getConfigurationForValue($value)
    {
        if (false === is_object($value)) {
            throw new \Exception('Context supports configuration loading only for objects');
        }

        foreach ($this->getAvailableConfigs() as $class => $configuration) {
            if ($value instanceof $class) {
                return $configuration;
            }
        }

        return [];
    }

    /**
     * @param mixed $value
     *
     * @return Meta
     */
    public function getMetaForValue($value)
    {
        return new Meta($this, $value, $this->getConfigurationForValue($value));
    }

    /**
     * @param mixed $value
     *
     * @return bool
     */
    public function isSupported($value)
    {
        if (!is_object($value)) {
            return false;
        }

        return count($this->getConfigurationForValue($value)) > 0 ? true : false;
    }

    /**
     * @param string $filePath
     *
     * @return $this
     */
    public function addNewConfig($filePath)
    {
        $cacheKey = md5($filePath);
        if (!$this->metadataCache->contains($cacheKey)) {
            if (!is_readable($filePath)) {
                throw new \InvalidArgumentException('Configuration file is not readable for parser');
            }
            $parser = new Parser();
            $configuration = $parser->parse(file_get_contents($filePath));
            $this->metadataCache->save($cacheKey, $configuration);
        } else {
            $configuration = $this->metadataCache->fetch($cacheKey);
        }

        $this->addAvailableConfig($configuration);

        return $configuration;
    }

    /**
     * Set current context page information's.
     *
     * @param Meta $currentPage
     *
     * @return self
     */
    public function setCurrentPage(Meta $currentPage)
    {
        $this->currentPage = $currentPage;

        return $this;
    }

    /**
     * Get current context page information's.
     *
     * @return Meta
     */
    public function getCurrentPage()
    {
        return $this->currentPage;
    }

    /**
     * Register new meta type, registration is required before setting new value for meta.
     *
     * @param Meta|null $meta Meta object
     *
     * @throws \Exception if already registered
     *
     * @return bool if registered successfully
     */
    public function registerMeta(Meta $meta = null)
    {
        $configuration = $meta->getConfiguration();
function someFunction(A $objectMaybe = null)
{
    if ($objectMaybe instanceof A) {
        $objectMaybe->doSomething();
    }
}
        $name = $configuration['name'];
        if (!array_key_exists($name, $this->registeredMeta)) {
            $this->registeredMeta[$name] = $configuration;
        }

        if (array_key_exists($name, $this->registeredMeta) && !is_null($meta)) {
            $this[$name] = $meta;

            return true;
        }

        return false;
    }

    /**
     * @return Meta[]
     */
    public function getRegisteredMeta()
    {
        return $this->registeredMeta;
    }

    /**
     * {@inheritdoc}
     */
    public function offsetSet($name, $meta)
    {
        if (array_key_exists($name, $this->registeredMeta)) {
            $this->$name = $meta;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function offsetExists($name)
    {
        return isset($this->$name);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetUnset($name)
    {
        unset($this->$name);

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function offsetGet($name)
    {
        if (array_key_exists($name, $this->registeredMeta) && isset($this->$name)) {
            return $this->$name;
        }

        return false;
    }

    /**
     * @param array $keys
     *
     * @return string
     */
    public function temporaryUnset(array $keys)
    {
        $metas = [];
        $keysId = md5(serialize($keys));

        if (count($keys) === 0) {
            foreach ($this->registeredMeta as $key => $configuration) {
                if (isset($this[$key])) {
                    $metas[$key] = $this[$key];
                    unset($this[$key]);
                }
            }
        }

        foreach ($keys as $key) {
            if (array_key_exists($key, $this->registeredMeta)) {
                $metas[$key] = $this[$key];
                unset($this[$key]);
            }
        }
        $this->temporaryMeta[$keysId] = $metas;

        return $keysId;
    }

    /**
     * @param $id
     *
     * @return null|true
     */
    public function restoreTemporaryUnset($id)
    {
        $metas = $this->temporaryMeta[$id];
        if (!is_array($metas)) {
            return;
        }

        foreach ($metas as $key => $value) {
            $this[$key] = $value;
        }

        return true;
    }
}


1		<?php
2
3		/*
4		* This file is part of the Superdesk Web Publisher Templates System.
5		*
6		* Copyright 2015 Sourcefabric z.ú. and contributors.
7		*
8		* For the full copyright and license information, please see the
9		* AUTHORS and LICENSE files distributed with this source code.
10		*
11		* @copyright 2015 Sourcefabric z.ú
12		* @license http://www.superdesk.org/license
13		*/
14
15		namespace SWP\Component\TemplatesSystem\Gimme\Context;
16
17		use Doctrine\Common\Cache\Cache;
18		use SWP\Component\TemplatesSystem\Gimme\Meta\Meta;
19		use Symfony\Component\Finder\Finder;
20		use Symfony\Component\Yaml\Parser;
21
22		class Context implements \ArrayAccess
23		{
24		/**
25		* Array with current page information's.
26		*
27		* @var Meta
28		*/
29		protected $currentPage;
30
31		/**
32		* Array will all registered meta types.
33		*
34		* @var Meta[]
35		*/
36		protected $registeredMeta = [];
37
38		/**
39		* Array with available meta configs.
40		*
41		* @var array
42		*/
43		protected $availableConfigs = [];
44
45		/**
46		* @var Cache
47		*/
48		protected $metadataCache;
49
50		/**
51		* @var string
52		*/
53		protected $configsPath;
54
55		/**
56		* @var array
57		*/
58		private $temporaryMeta = [];
59
60		/**
61		* Context constructor.
62		*
63		* @param Cache $metadataCache
64		* @param string $configsPath
65		*/
66	126	public function __construct(Cache $metadataCache, $configsPath = null)
67		{
68	126	$this->metadataCache = $metadataCache;
69	126	$this->configsPath = $configsPath;
70	126	}
71
72		/**
73		* @return array
74		*/
75	20	public function getAvailableConfigs()
76		{
77	20	if (0 === count($this->availableConfigs)) {
78	19	$this->loadConfigsFromPath($this->configsPath);
79		}
80
81	20	return $this->availableConfigs;
82		}
83
84		/**
85		* @param array $configuration
86		*
87		* @return bool
88		*/
89	20	public function addAvailableConfig(array $configuration)
90		{
91	20	if (isset($configuration['class']) && !isset($this->availableConfigs[$configuration['class']])) {
92	20	$this->availableConfigs[$configuration['class']] = $configuration;
93
94	20	return true;
95		}
96
97		return false;
98		}
99
100		/**
101		* @param array $availableConfigs
102		*
103		* @return Context
104		*/
105		public function setAvailableConfigs(array $availableConfigs)
106		{
107		$this->availableConfigs = $availableConfigs;
108
109		return $this;
110		}
111
112		/**
113		* @param string $configsPath
114		*/
115	19	public function loadConfigsFromPath($configsPath)
116		{
117	19	if (file_exists($configsPath)) {
118	18	$finder = new Finder();
119	18	$finder->in($configsPath)->files()->name('*.yml');
120
121	18	foreach ($finder as $file) {
122	18	$this->addNewConfig($file->getRealPath());
123		}
124		}
125	19	}
126
127		/**
128		* @param mixed $value
129		*
130		* @return array
131		*
132		* @throws \Exception
133		*/
134	18	public function getConfigurationForValue($value)
135		{
136	18	if (false === is_object($value)) {
137		throw new \Exception('Context supports configuration loading only for objects');
138		}
139
140	18	foreach ($this->getAvailableConfigs() as $class => $configuration) {
141	18	if ($value instanceof $class) {
142	18	return $configuration;
143		}
144		}
145
146	10	return [];
147		}
148
149		/**
150		* @param mixed $value
151		*
152		* @return Meta
153		*/
154	10	public function getMetaForValue($value)
155		{
156	10	return new Meta($this, $value, $this->getConfigurationForValue($value));
157		}
158
159		/**
160		* @param mixed $value
161		*
162		* @return bool
163		*/
164	20	public function isSupported($value)
165		{
166	20	if (!is_object($value)) {
167	19	return false;
168		}
169
170	10	return count($this->getConfigurationForValue($value)) > 0 ? true : false;
171		}
172
173		/**
174		* @param string $filePath
175		*
176		* @return $this
177		*/
178	20	public function addNewConfig($filePath)
179		{
180	20	$cacheKey = md5($filePath);
181	20	if (!$this->metadataCache->contains($cacheKey)) {
182	20	if (!is_readable($filePath)) {
183		throw new \InvalidArgumentException('Configuration file is not readable for parser');
184		}
185	20	$parser = new Parser();
186	20	$configuration = $parser->parse(file_get_contents($filePath));
187	20	$this->metadataCache->save($cacheKey, $configuration);
188		} else {
189		$configuration = $this->metadataCache->fetch($cacheKey);
190		}
191
192	20	$this->addAvailableConfig($configuration);
193
194	20	return $configuration;
195		}
196
197		/**
198		* Set current context page information's.
199		*
200		* @param Meta $currentPage
201		*
202		* @return self
203		*/
204	13	public function setCurrentPage(Meta $currentPage)
205		{
206	13	$this->currentPage = $currentPage;
207
208	13	return $this;
209		}
210
211		/**
212		* Get current context page information's.
213		*
214		* @return Meta
215		*/
216	2	public function getCurrentPage()
217		{
218	2	return $this->currentPage;
219		}
220
221		/**
222		* Register new meta type, registration is required before setting new value for meta.
223		*
224		* @param Meta\|null $meta Meta object
225		*
226		* @throws \Exception if already registered
227		*
228		* @return bool if registered successfully
229		*/
230	20	public function registerMeta(Meta $meta = null)
231		{
232	20	$configuration = $meta->getConfiguration();
		0 ignored issues – show Bug introduced 2016-09-05 17:16 UTC by Report Bug Copy Issue Report It seems like `$meta` is not always an object, but can also be of type `null`. Maybe add an additional type check? If a variable is not always an object, we recommend to add an additional type check to ensure your method call is safe: function someFunction(A $objectMaybe = null) { if ($objectMaybe instanceof A) { $objectMaybe->doSomething(); } } Loading history...
233	20	$name = $configuration['name'];
234	20	if (!array_key_exists($name, $this->registeredMeta)) {
235	20	$this->registeredMeta[$name] = $configuration;
236		}
237
238	20	if (array_key_exists($name, $this->registeredMeta) && !is_null($meta)) {
239	20	$this[$name] = $meta;
240
241	20	return true;
242		}
243
244		return false;
245		}
246
247		/**
248		* @return Meta[]
249		*/
250	3	public function getRegisteredMeta()
251		{
252	3	return $this->registeredMeta;
253		}
254
255		/**
256		* {@inheritdoc}
257		*/
258	20	public function offsetSet($name, $meta)
259		{
260	20	if (array_key_exists($name, $this->registeredMeta)) {
261	20	$this->$name = $meta;
262		}
263
264	20	return true;
265		}
266
267		/**
268		* {@inheritdoc}
269		*/
270	11	public function offsetExists($name)
271		{
272	11	return isset($this->$name);
273		}
274
275		/**
276		* {@inheritdoc}
277		*/
278	1	public function offsetUnset($name)
279		{
280	1	unset($this->$name);
281
282	1	return true;
283		}
284
285		/**
286		* {@inheritdoc}
287		*/
288	10	public function offsetGet($name)
289		{
290	10	if (array_key_exists($name, $this->registeredMeta) && isset($this->$name)) {
291	10	return $this->$name;
292		}
293
294		return false;
295		}
296
297		/**
298		* @param array $keys
299		*
300		* @return string
301		*/
302	1	public function temporaryUnset(array $keys)
303		{
304	1	$metas = [];
305	1	$keysId = md5(serialize($keys));
306
307	1	if (count($keys) === 0) {
308		foreach ($this->registeredMeta as $key => $configuration) {
309		if (isset($this[$key])) {
310		$metas[$key] = $this[$key];
311		unset($this[$key]);
312		}
313		}
314		}
315
316	1	foreach ($keys as $key) {
317	1	if (array_key_exists($key, $this->registeredMeta)) {
318	1	$metas[$key] = $this[$key];
319	1	unset($this[$key]);
320		}
321		}
322	1	$this->temporaryMeta[$keysId] = $metas;
323
324	1	return $keysId;
325		}
326
327		/**
328		* @param $id
329		*
330		* @return null\|true
331		*/
332	1	public function restoreTemporaryUnset($id)
333		{
334	1	$metas = $this->temporaryMeta[$id];
335	1	if (!is_array($metas)) {
336		return;
337		}
338
339	1	foreach ($metas as $key => $value) {
340	1	$this[$key] = $value;
341		}
342
343	1	return true;
344		}
345		}
346

ahilles107 / web-publisher

Push — master ( 8d3dbf...7592af )

Context::offsetSet() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like