MetaData::__construct() - Code Metrics - Inspection of "update composer.lock" - zikula/core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( cd21c6...a50cd0 )

by Craig

created 2020-01-10 00:01 UTC

MetaData::__construct() A

↳ Parent: MetaData

Complexity

Conditions	1
Paths	1

Size

Total Lines	20
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	18
nc	1
nop	1
dl	0
loc	20
rs	9.6666
c	0
b	0
f	0

<?php

declare(strict_types=1);

/*
 * This file is part of the Zikula package.
 *
 * Copyright Zikula Foundation - https://ziku.la/
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Zikula\Bundle\CoreBundle\Bundle;

use ArrayAccess;
use Exception;
use Symfony\Component\HttpKernel\Exception\PreconditionRequiredHttpException;
use Zikula\Common\Translator\TranslatorTrait;

class MetaData implements ArrayAccess
{
    use TranslatorTrait;

    public const TYPE_MODULE = 2;

    public const TYPE_SYSTEM = 3;

    public const TYPE_CORE = 4;

    public const DEPENDENCY_REQUIRED = 1;

    public const DEPENDENCY_RECOMMENDED = 2;

    public const DEPENDENCY_CONFLICTS = 3;

    private $name;

    private $version;

    private $description;

    private $type;

    private $dependencies;

    private $shortName;

    private $class;

    private $namespace;

    private $basePath;

    private $rootPath;

    private $autoload;

    private $displayName;

    private $url;

    private $oldNames;

    private $capabilities;

    private $securitySchema;

    private $extensionType;

    private $coreCompatibility;

    public function __construct(array $json = [])
    {
        $this->name = $json['name'];
        $this->version = $json['version'] ?? '';
        $this->description = $json['description'] ?? '';
        $this->type = $json['type'];
        $this->dependencies = $this->formatDependencies($json);
        $this->shortName = $json['extra']['zikula']['short-name'];
        $this->class = $json['extra']['zikula']['class'];
        $this->namespace = mb_substr($this->class, 0, mb_strrpos($this->class, '\\') + 1);
        $this->basePath = $json['extra']['zikula']['base-path'];
        $this->rootPath = $json['extra']['zikula']['root-path'];
        $this->autoload = $json['autoload'];
        $this->displayName = $json['extra']['zikula']['displayname'] ?? '';
        $this->url = $json['extra']['zikula']['url'] ?? '';
        $this->oldNames = $json['extra']['zikula']['oldnames'] ?? [];
        $this->capabilities = $json['extra']['zikula']['capabilities'] ?? [];
        $this->securitySchema = $json['extra']['zikula']['securityschema'] ?? [];
        $this->extensionType = $json['extensionType'] ?? self::TYPE_MODULE;
        $this->coreCompatibility = $json['extra']['zikula']['core-compatibility'] ?? null;
    }

    public function getName(): string
    {
        return $this->name;
    }

    public function getVersion(): string
    {
        return $this->version;
    }

    public function getShortName(): string
    {
        return $this->shortName;
    }

    public function getPsr0(): array
    {
        return $this->autoload['psr-0'] ?? [];
    }

    public function getPsr4(): array
    {
        return $this->autoload['psr-4'] ?? [];
    }

    public function getAutoload(): array
    {
        return $this->autoload;
    }

    public function getBasePath(): string
    {
        return $this->basePath;
    }

    public function getRootPath(): string
    {
        return $this->rootPath;
    }

    public function getClass(): string
    {
        return $this->class;
    }

    public function getNamespace(): string
    {
        return $this->namespace;
    }

    public function getType(): string
    {
        return $this->type;
    }

    public function getDescription(): string
    {
        $this->confirmTranslator();

        $description = $this->trans(/** @Ignore */$this->description);

        return empty($description) ? $this->description : $description;
    }

    public function setDescription(string $description): void
    {
        $this->description = $description;
    }

    public function getDependencies(): array
    {
        return $this->dependencies;
    }

    public function getDisplayName(): string
    {
        $this->confirmTranslator();

        $display_name = $this->trans(/** @Ignore */$this->displayName);

        return empty($display_name) ? $this->displayName : $display_name;
    }

    public function setDisplayName(string $name): void
    {
        $this->displayName = $name;
    }

    public function getUrl(bool $translated = true): string
    {
        if ($translated) {
            $this->confirmTranslator();
            $url = $this->trans(/** @Ignore */$this->url);

            return empty($url) ? $this->url : $url;
        }

        return $this->url;
    }

    public function setUrl(string $url): void
    {
        $this->url = $url;
    }

    public function getOldNames(): array
    {
        return $this->oldNames;
    }

    public function getCapabilities(): array
    {
        return $this->capabilities;
    }

    public function getSecuritySchema(): array
    {
        return $this->securitySchema;
    }

    public function getExtensionType(): int
    {
        return $this->extensionType;
    }

    public function getCoreCompatibility(): ?string
    {
        return $this->coreCompatibility;
    }

    private function formatDependencies(array $json = []): array
    {
        $dependencies = [];
        if (!empty($json['require'])) {
            foreach ($json['require'] as $package => $version) {
                $dependencies[] = [
                    'modname' => $package,
                    'minversion' => $version,
                    'maxversion' => $version,
                    'status' => self::DEPENDENCY_REQUIRED
                ];
            }
        } else {
            $dependencies[] = [
                'modname' => 'zikula/core',
                'minversion' => '>=1.4.1 <3.0.0',
                'maxversion' => '>=1.4.1 <3.0.0',
                'status' => self::DEPENDENCY_REQUIRED
            ];
        }
        if (!empty($json['suggest'])) {
            foreach ($json['suggest'] as $package => $reason) {
                if (mb_strpos($package, ':')) {
                    list($name, $version) = explode(':', $package, 2);
                } else {
                    $name = $package;
                    $version = '-1';
                }
                $dependencies[] = [
                    'modname' => $name,
                    'minversion' => $version,
                    'maxversion' => $version,
                    'reason' => $reason,
                    'status' => self::DEPENDENCY_RECOMMENDED
                ];
            }
        }

        return $dependencies;
    }

    private function confirmTranslator(): void
    {
        if (!isset($this->translator)) {
            throw new PreconditionRequiredHttpException(sprintf('The translator property is not set correctly in %s', __CLASS__));
        }
    }

    /**
     * Theme MetaData as array
     */
    public function getThemeFilteredVersionInfoArray(): array
    {
        $capabilities = $this->getCapabilities();

        return [
            'name' => $this->getShortName(),
            'type' => $this->getExtensionType(),
            'displayname' => $this->getDisplayName(),
            'description' => $this->getDescription(),
            'version' => $this->getVersion(),
//            'capabilities' => $this->getCapabilities(),
            // It would be better to add capabilities to DB and move to inverse in legacy code and refactor later checks. refs #3644
            'user' => $capabilities['user'] ?? true,
            'admin' => $capabilities['admin'] ?? true,
            'system' => $capabilities['system'] ?? false,
            'xhtml' => $capabilities['xhtml'] ?? true, // this is not truly valid in 2.0
        ];
    }

    /**
     * Module MetaData as array
     */
    public function getFilteredVersionInfoArray(): array
    {
        return [
            'name' => $this->getShortName(),
            'type' => $this->getExtensionType(),
            'displayname' => $this->getDisplayName(),
            'oldnames' => $this->getOldNames(),
            'description' => $this->getDescription(),
            'version' => $this->getVersion(),
            'url' => $this->getUrl(),
            'capabilities' => $this->getCapabilities(),
            'securityschema' => $this->getSecuritySchema(),
            'dependencies' => $this->getDependencies(),
            'coreCompatibility' => $this->getCoreCompatibility()
        ];
    }

    public function offsetExists($offset)
    {
        return isset($this->{$offset});
    }

    public function offsetGet($offset)
    {
        $method = 'get' . ucwords($offset);

        return $this->{$method}();
    }

    public function offsetSet($offset, $value): void
    {
        throw new Exception('Setting values by array access is not allowed.');
    }

    public function offsetUnset($offset): void
    {
        throw new Exception('Unsetting values by array access is not allowed.');
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Zikula package.
7			*
8			* Copyright Zikula Foundation - https://ziku.la/
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Zikula\Bundle\CoreBundle\Bundle;
15
16			use ArrayAccess;
17			use Exception;
18			use Symfony\Component\HttpKernel\Exception\PreconditionRequiredHttpException;
19			use Zikula\Common\Translator\TranslatorTrait;
20
21			class MetaData implements ArrayAccess
22			{
23			use TranslatorTrait;
24
25			public const TYPE_MODULE = 2;
26
27			public const TYPE_SYSTEM = 3;
28
29			public const TYPE_CORE = 4;
30
31			public const DEPENDENCY_REQUIRED = 1;
32
33			public const DEPENDENCY_RECOMMENDED = 2;
34
35			public const DEPENDENCY_CONFLICTS = 3;
36
37			private $name;
38
39			private $version;
40
41			private $description;
42
43			private $type;
44
45			private $dependencies;
46
47			private $shortName;
48
49			private $class;
50
51			private $namespace;
52
53			private $basePath;
54
55			private $rootPath;
56
57			private $autoload;
58
59			private $displayName;
60
61			private $url;
62
63			private $oldNames;
64
65			private $capabilities;
66
67			private $securitySchema;
68
69			private $extensionType;
70
71			private $coreCompatibility;
72
73			public function __construct(array $json = [])
74			{
75			$this->name = $json['name'];
76			$this->version = $json['version'] ?? '';
77			$this->description = $json['description'] ?? '';
78			$this->type = $json['type'];
79			$this->dependencies = $this->formatDependencies($json);
80			$this->shortName = $json['extra']['zikula']['short-name'];
81			$this->class = $json['extra']['zikula']['class'];
82			$this->namespace = mb_substr($this->class, 0, mb_strrpos($this->class, '\\') + 1);
83			$this->basePath = $json['extra']['zikula']['base-path'];
84			$this->rootPath = $json['extra']['zikula']['root-path'];
85			$this->autoload = $json['autoload'];
86			$this->displayName = $json['extra']['zikula']['displayname'] ?? '';
87			$this->url = $json['extra']['zikula']['url'] ?? '';
88			$this->oldNames = $json['extra']['zikula']['oldnames'] ?? [];
89			$this->capabilities = $json['extra']['zikula']['capabilities'] ?? [];
90			$this->securitySchema = $json['extra']['zikula']['securityschema'] ?? [];
91			$this->extensionType = $json['extensionType'] ?? self::TYPE_MODULE;
92			$this->coreCompatibility = $json['extra']['zikula']['core-compatibility'] ?? null;
93			}
94
95			public function getName(): string
96			{
97			return $this->name;
98			}
99
100			public function getVersion(): string
101			{
102			return $this->version;
103			}
104
105			public function getShortName(): string
106			{
107			return $this->shortName;
108			}
109
110			public function getPsr0(): array
111			{
112			return $this->autoload['psr-0'] ?? [];
113			}
114
115			public function getPsr4(): array
116			{
117			return $this->autoload['psr-4'] ?? [];
118			}
119
120			public function getAutoload(): array
121			{
122			return $this->autoload;
123			}
124
125			public function getBasePath(): string
126			{
127			return $this->basePath;
128			}
129
130			public function getRootPath(): string
131			{
132			return $this->rootPath;
133			}
134
135			public function getClass(): string
136			{
137			return $this->class;
138			}
139
140			public function getNamespace(): string
141			{
142			return $this->namespace;
143			}
144
145			public function getType(): string
146			{
147			return $this->type;
148			}
149
150			public function getDescription(): string
151			{
152			$this->confirmTranslator();
153
154			$description = $this->trans(/** @Ignore */$this->description);
155
156			return empty($description) ? $this->description : $description;
157			}
158
159			public function setDescription(string $description): void
160			{
161			$this->description = $description;
162			}
163
164			public function getDependencies(): array
165			{
166			return $this->dependencies;
167			}
168
169			public function getDisplayName(): string
170			{
171			$this->confirmTranslator();
172
173			$display_name = $this->trans(/** @Ignore */$this->displayName);
174
175			return empty($display_name) ? $this->displayName : $display_name;
176			}
177
178			public function setDisplayName(string $name): void
179			{
180			$this->displayName = $name;
181			}
182
183			public function getUrl(bool $translated = true): string
184			{
185			if ($translated) {
186			$this->confirmTranslator();
187			$url = $this->trans(/** @Ignore */$this->url);
188
189			return empty($url) ? $this->url : $url;
190			}
191
192			return $this->url;
193			}
194
195			public function setUrl(string $url): void
196			{
197			$this->url = $url;
198			}
199
200			public function getOldNames(): array
201			{
202			return $this->oldNames;
203			}
204
205			public function getCapabilities(): array
206			{
207			return $this->capabilities;
208			}
209
210			public function getSecuritySchema(): array
211			{
212			return $this->securitySchema;
213			}
214
215			public function getExtensionType(): int
216			{
217			return $this->extensionType;
218			}
219
220			public function getCoreCompatibility(): ?string
221			{
222			return $this->coreCompatibility;
223			}
224
225			private function formatDependencies(array $json = []): array
226			{
227			$dependencies = [];
228			if (!empty($json['require'])) {
229			foreach ($json['require'] as $package => $version) {
230			$dependencies[] = [
231			'modname' => $package,
232			'minversion' => $version,
233			'maxversion' => $version,
234			'status' => self::DEPENDENCY_REQUIRED
235			];
236			}
237			} else {
238			$dependencies[] = [
239			'modname' => 'zikula/core',
240			'minversion' => '>=1.4.1 <3.0.0',
241			'maxversion' => '>=1.4.1 <3.0.0',
242			'status' => self::DEPENDENCY_REQUIRED
243			];
244			}
245			if (!empty($json['suggest'])) {
246			foreach ($json['suggest'] as $package => $reason) {
247			if (mb_strpos($package, ':')) {
248			list($name, $version) = explode(':', $package, 2);
249			} else {
250			$name = $package;
251			$version = '-1';
252			}
253			$dependencies[] = [
254			'modname' => $name,
255			'minversion' => $version,
256			'maxversion' => $version,
257			'reason' => $reason,
258			'status' => self::DEPENDENCY_RECOMMENDED
259			];
260			}
261			}
262
263			return $dependencies;
264			}
265
266			private function confirmTranslator(): void
267			{
268			if (!isset($this->translator)) {
269			throw new PreconditionRequiredHttpException(sprintf('The translator property is not set correctly in %s', __CLASS__));
270			}
271			}
272
273			/**
274			* Theme MetaData as array
275			*/
276			public function getThemeFilteredVersionInfoArray(): array
277			{
278			$capabilities = $this->getCapabilities();
279
280			return [
281			'name' => $this->getShortName(),
282			'type' => $this->getExtensionType(),
283			'displayname' => $this->getDisplayName(),
284			'description' => $this->getDescription(),
285			'version' => $this->getVersion(),
286			// 'capabilities' => $this->getCapabilities(),
287			// It would be better to add capabilities to DB and move to inverse in legacy code and refactor later checks. refs #3644
288			'user' => $capabilities['user'] ?? true,
289			'admin' => $capabilities['admin'] ?? true,
290			'system' => $capabilities['system'] ?? false,
291			'xhtml' => $capabilities['xhtml'] ?? true, // this is not truly valid in 2.0
292			];
293			}
294
295			/**
296			* Module MetaData as array
297			*/
298			public function getFilteredVersionInfoArray(): array
299			{
300			return [
301			'name' => $this->getShortName(),
302			'type' => $this->getExtensionType(),
303			'displayname' => $this->getDisplayName(),
304			'oldnames' => $this->getOldNames(),
305			'description' => $this->getDescription(),
306			'version' => $this->getVersion(),
307			'url' => $this->getUrl(),
308			'capabilities' => $this->getCapabilities(),
309			'securityschema' => $this->getSecuritySchema(),
310			'dependencies' => $this->getDependencies(),
311			'coreCompatibility' => $this->getCoreCompatibility()
312			];
313			}
314
315			public function offsetExists($offset)
316			{
317			return isset($this->{$offset});
318			}
319
320			public function offsetGet($offset)
321			{
322			$method = 'get' . ucwords($offset);
323
324			return $this->{$method}();
325			}
326
327			public function offsetSet($offset, $value): void
328			{
329			throw new Exception('Setting values by array access is not allowed.');
330			}
331
332			public function offsetUnset($offset): void
333			{
334			throw new Exception('Unsetting values by array access is not allowed.');
335			}
336			}
337

zikula / core

Push — master ( cd21c6...a50cd0 )

MetaData::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like