Issues in PackageFileConverter.php - Failed Issues - Inspection of "Decouple JSON conversion from encoding" - puli/manager - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#49)

by Bernhard

created 2016-01-28 10:25 UTC

src/Package/PackageFileConverter.php (1 issue)

Labels

Unused Code 1

Severity

Major 1

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?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\Package;

use Puli\Discovery\Api\Type\BindingParameter;
use Puli\Discovery\Api\Type\BindingType;
use Puli\Discovery\Binding\ClassBinding;
use Puli\Discovery\Binding\ResourceBinding;
use Puli\Manager\Api\Discovery\BindingDescriptor;
use Puli\Manager\Api\Discovery\BindingTypeDescriptor;
use Puli\Manager\Api\Package\PackageFile;
use Puli\Manager\Api\Repository\PathMapping;
use Puli\Manager\Assert\Assert;
use Rhumsaa\Uuid\Uuid;
use stdClass;
use Webmozart\Json\Conversion\JsonConverter;

/**
 * Converts package files to JSON and back.
 *
 * @since  1.0
 *
 * @author Bernhard Schussek <[email protected]>
 */
class PackageFileConverter implements JsonConverter
{
    /**
     * The JSON version this converter supports.
     */
    const VERSION = '1.0';

    /**
     * The default order of the keys in the written package file.
     *
     * @var string[]
     */
    private static $keyOrder = array(
        'version',
        'name',
        'path-mappings',
        'bindings',
        'binding-types',
        'override',
        'extra',
    );

    public static function compareBindingDescriptors(BindingDescriptor $a, BindingDescriptor $b)
    {
        // Make sure that bindings are always printed in the same order
        return strcmp($a->getUuid()->toString(), $b->getUuid()->toString());
    }

    /**
     * {@inheritdoc}
     */
    public function toJson($packageFile, array $options = array())
    {
        Assert::isInstanceOf($packageFile, 'Puli\Manager\Api\Package\PackageFile');

        $jsonData = new stdClass();

        $this->addPackageFileToJson($packageFile, $jsonData);

        // Sort according to key order
        $jsonArray = (array) $jsonData;
        $orderedKeys = array_intersect_key(array_flip(self::$keyOrder), $jsonArray);
        $jsonData = (object) array_replace($orderedKeys, $jsonArray);

        return $jsonData;
    }

    /**
     * {@inheritdoc}
     */
    public function fromJson($jsonData, array $options = array())
    {
        Assert::isInstanceOf($jsonData, 'stdClass');

        $packageFile = new PackageFile(null, isset($options['path']) ? $options['path'] : null);

        $this->addJsonToPackageFile($jsonData, $packageFile);

        return $packageFile;
    }

    protected function addPackageFileToJson(PackageFile $packageFile, stdClass $jsonData)
    {
        $mappings = $packageFile->getPathMappings();
        $bindingDescriptors = $packageFile->getBindingDescriptors();
        $typeDescriptors = $packageFile->getTypeDescriptors();
        $overrides = $packageFile->getOverriddenPackages();
        $extra = $packageFile->getExtraKeys();

        if (null !== $packageFile->getPackageName()) {
            $jsonData->name = $packageFile->getPackageName();
        }

        if (count($mappings) > 0) {
            $jsonData->{'path-mappings'} = new stdClass();

            foreach ($mappings as $mapping) {
                $puliPath = $mapping->getRepositoryPath();
                $localPaths = $mapping->getPathReferences();

                $jsonData->{'path-mappings'}->$puliPath = count($localPaths) > 1 ? $localPaths : reset($localPaths);
            }
        }

        if (count($bindingDescriptors) > 0) {
            uasort($bindingDescriptors, array(__CLASS__, 'compareBindingDescriptors'));

            $jsonData->bindings = new stdClass();

            foreach ($bindingDescriptors as $bindingDescriptor) {
                $binding = $bindingDescriptor->getBinding();
                $bindingData = new stdClass();
                $bindingData->_class = get_class($binding);

                // This needs to be moved to external classes to allow adding
                // custom binding classes at some point
                if ($binding instanceof ResourceBinding) {
                    $bindingData->query = $binding->getQuery();

                    if ('glob' !== $binding->getLanguage()) {
                        $bindingData->language = $binding->getLanguage();
                    }
                } elseif ($binding instanceof ClassBinding) {
                    $bindingData->class = $binding->getClassName();
                }

                $bindingData->type = $bindingDescriptor->getTypeName();

                // Don't include the default values of the binding type
                if ($binding->hasParameterValues(false)) {
                    $parameterData = $binding->getParameterValues(false);
                    ksort($parameterData);
                    $bindingData->parameters = (object) $parameterData;
                }

                $jsonData->bindings->{$bindingDescriptor->getUuid()->toString()} = $bindingData;
            }
        }

        if (count($typeDescriptors) > 0) {
            $bindingTypesData = array();

            foreach ($typeDescriptors as $typeDescriptor) {
                $type = $typeDescriptor->getType();
                $typeData = new stdClass();

                if ($typeDescriptor->getDescription()) {
                    $typeData->description = $typeDescriptor->getDescription();
                }

                if ($type->hasParameters()) {
                    $parametersData = array();

                    foreach ($type->getParameters() as $parameter) {
                        $parameterData = new stdClass();

                        if ($typeDescriptor->hasParameterDescription($parameter->getName())) {
                            $parameterData->description = $typeDescriptor->getParameterDescription($parameter->getName());
                        }

                        if ($parameter->isRequired()) {
                            $parameterData->required = true;
                        }

                        if (null !== $parameter->getDefaultValue()) {
                            $parameterData->default = $parameter->getDefaultValue();
                        }

                        $parametersData[$parameter->getName()] = $parameterData;
                    }

                    ksort($parametersData);

                    $typeData->parameters = (object) $parametersData;
                }

                $bindingTypesData[$type->getName()] = $typeData;
            }

            ksort($bindingTypesData);

            $jsonData->{'binding-types'} = (object) $bindingTypesData;
        }

        if (count($overrides) > 0) {
            $jsonData->override = count($overrides) > 1 ? $overrides : reset($overrides);
        }

        if (count($extra) > 0) {
            $jsonData->extra = (object) $extra;
        }
    }

    protected function addJsonToPackageFile(stdClass $jsonData, PackageFile $packageFile)
    {
        if (isset($jsonData->name)) {
            $packageFile->setPackageName($jsonData->name);
        }

        if (isset($jsonData->{'path-mappings'})) {
            foreach ($jsonData->{'path-mappings'} as $path => $relativePaths) {
                $packageFile->addPathMapping(new PathMapping($path, (array) $relativePaths));
            }
        }

        if (isset($jsonData->bindings)) {
            foreach ($jsonData->bindings as $uuid => $bindingData) {
                $binding = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                $class = isset($bindingData->_class)
                    ? $bindingData->_class
                    : 'Puli\Discovery\Binding\ResourceBinding';

                // Move this code to external classes to allow use of custom
                // bindings
                switch ($class) {
                    case 'Puli\Discovery\Binding\ClassBinding':
                        $binding = new ClassBinding(
                            $bindingData->class,
                            $bindingData->type,
                            isset($bindingData->parameters) ? (array) $bindingData->parameters : array(),
                            Uuid::fromString($uuid)
                        );
                        break;
                    case 'Puli\Discovery\Binding\ResourceBinding':
                        $binding = new ResourceBinding(
                            $bindingData->query,
                            $bindingData->type,
                            isset($bindingData->parameters) ? (array) $bindingData->parameters : array(),
                            isset($bindingData->language) ? $bindingData->language : 'glob',
                            Uuid::fromString($uuid)
                        );
                        break;
                    default:
                        continue 2;
                }

                $packageFile->addBindingDescriptor(new BindingDescriptor($binding));
            }
        }

        if (isset($jsonData->{'binding-types'})) {
            foreach ((array) $jsonData->{'binding-types'} as $typeName => $data) {
                $parameters = array();
                $parameterDescriptions = array();

                if (isset($data->parameters)) {
                    foreach ((array) $data->parameters as $parameterName => $parameterData) {
                        $required = isset($parameterData->required) ? $parameterData->required : false;

                        $parameters[] = new BindingParameter(
                            $parameterName,
                            $required ? BindingParameter::REQUIRED : BindingParameter::OPTIONAL,
                            isset($parameterData->default) ? $parameterData->default : null
                        );

                        if (isset($parameterData->description)) {
                            $parameterDescriptions[$parameterName] = $parameterData->description;
                        };
                    }
                }

                $packageFile->addTypeDescriptor(new BindingTypeDescriptor(
                    new BindingType($typeName, $parameters),
                    isset($data->description) ? $data->description : null,
                    $parameterDescriptions
                ));
            }
        }

        if (isset($jsonData->override)) {
            $packageFile->setOverriddenPackages((array) $jsonData->override);
        }

        if (isset($jsonData->extra)) {
            $packageFile->setExtraKeys((array) $jsonData->extra);
        }
    }
}


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\Package;
13
14			use Puli\Discovery\Api\Type\BindingParameter;
15			use Puli\Discovery\Api\Type\BindingType;
16			use Puli\Discovery\Binding\ClassBinding;
17			use Puli\Discovery\Binding\ResourceBinding;
18			use Puli\Manager\Api\Discovery\BindingDescriptor;
19			use Puli\Manager\Api\Discovery\BindingTypeDescriptor;
20			use Puli\Manager\Api\Package\PackageFile;
21			use Puli\Manager\Api\Repository\PathMapping;
22			use Puli\Manager\Assert\Assert;
23			use Rhumsaa\Uuid\Uuid;
24			use stdClass;
25			use Webmozart\Json\Conversion\JsonConverter;
26
27			/**
28			* Converts package files to JSON and back.
29			*
30			* @since 1.0
31			*
32			* @author Bernhard Schussek <[email protected]>
33			*/
34			class PackageFileConverter implements JsonConverter
35			{
36			/**
37			* The JSON version this converter supports.
38			*/
39			const VERSION = '1.0';
40
41			/**
42			* The default order of the keys in the written package file.
43			*
44			* @var string[]
45			*/
46			private static $keyOrder = array(
47			'version',
48			'name',
49			'path-mappings',
50			'bindings',
51			'binding-types',
52			'override',
53			'extra',
54			);
55
56	3		public static function compareBindingDescriptors(BindingDescriptor $a, BindingDescriptor $b)
57			{
58			// Make sure that bindings are always printed in the same order
59	3		return strcmp($a->getUuid()->toString(), $b->getUuid()->toString());
60			}
61
62			/**
63			* {@inheritdoc}
64			*/
65	14	View Code Duplication	public function toJson($packageFile, array $options = array())
66			{
67	14		Assert::isInstanceOf($packageFile, 'Puli\Manager\Api\Package\PackageFile');
68
69	14		$jsonData = new stdClass();
70
71	14		$this->addPackageFileToJson($packageFile, $jsonData);
72
73			// Sort according to key order
74	14		$jsonArray = (array) $jsonData;
75	14		$orderedKeys = array_intersect_key(array_flip(self::$keyOrder), $jsonArray);
76	14		$jsonData = (object) array_replace($orderedKeys, $jsonArray);
77
78	14		return $jsonData;
79			}
80
81			/**
82			* {@inheritdoc}
83			*/
84	22		public function fromJson($jsonData, array $options = array())
85			{
86	22		Assert::isInstanceOf($jsonData, 'stdClass');
87
88	22		$packageFile = new PackageFile(null, isset($options['path']) ? $options['path'] : null);
89
90	22		$this->addJsonToPackageFile($jsonData, $packageFile);
91
92	22		return $packageFile;
93			}
94
95	20		protected function addPackageFileToJson(PackageFile $packageFile, stdClass $jsonData)
96			{
97	20		$mappings = $packageFile->getPathMappings();
98	20		$bindingDescriptors = $packageFile->getBindingDescriptors();
99	20		$typeDescriptors = $packageFile->getTypeDescriptors();
100	20		$overrides = $packageFile->getOverriddenPackages();
101	20		$extra = $packageFile->getExtraKeys();
102
103	20		if (null !== $packageFile->getPackageName()) {
104	2		$jsonData->name = $packageFile->getPackageName();
105			}
106
107	20		if (count($mappings) > 0) {
108	4		$jsonData->{'path-mappings'} = new stdClass();
109
110	4		foreach ($mappings as $mapping) {
111	4		$puliPath = $mapping->getRepositoryPath();
112	4		$localPaths = $mapping->getPathReferences();
113
114	4		$jsonData->{'path-mappings'}->$puliPath = count($localPaths) > 1 ? $localPaths : reset($localPaths);
115			}
116			}
117
118	20		if (count($bindingDescriptors) > 0) {
119	6		uasort($bindingDescriptors, array(__CLASS__, 'compareBindingDescriptors'));
120
121	6		$jsonData->bindings = new stdClass();
122
123	6		foreach ($bindingDescriptors as $bindingDescriptor) {
124	6		$binding = $bindingDescriptor->getBinding();
125	6		$bindingData = new stdClass();
126	6		$bindingData->_class = get_class($binding);
127
128			// This needs to be moved to external classes to allow adding
129			// custom binding classes at some point
130	6		if ($binding instanceof ResourceBinding) {
131	6		$bindingData->query = $binding->getQuery();
132
133	6		if ('glob' !== $binding->getLanguage()) {
134	6		$bindingData->language = $binding->getLanguage();
135			}
136			} elseif ($binding instanceof ClassBinding) {
137	3		$bindingData->class = $binding->getClassName();
138			}
139
140	6		$bindingData->type = $bindingDescriptor->getTypeName();
141
142			// Don't include the default values of the binding type
143	6		if ($binding->hasParameterValues(false)) {
144	1		$parameterData = $binding->getParameterValues(false);
145	1		ksort($parameterData);
146	1		$bindingData->parameters = (object) $parameterData;
147			}
148
149	6		$jsonData->bindings->{$bindingDescriptor->getUuid()->toString()} = $bindingData;
150			}
151			}
152
153	20		if (count($typeDescriptors) > 0) {
154	8		$bindingTypesData = array();
155
156	8		foreach ($typeDescriptors as $typeDescriptor) {
157	8		$type = $typeDescriptor->getType();
158	8		$typeData = new stdClass();
159
160	8		if ($typeDescriptor->getDescription()) {
161	2		$typeData->description = $typeDescriptor->getDescription();
162			}
163
164	8		if ($type->hasParameters()) {
165	6		$parametersData = array();
166
167	6		foreach ($type->getParameters() as $parameter) {
168	6		$parameterData = new stdClass();
169
170	6		if ($typeDescriptor->hasParameterDescription($parameter->getName())) {
171	3		$parameterData->description = $typeDescriptor->getParameterDescription($parameter->getName());
172			}
173
174	6		if ($parameter->isRequired()) {
175	1		$parameterData->required = true;
176			}
177
178	6		if (null !== $parameter->getDefaultValue()) {
179	3		$parameterData->default = $parameter->getDefaultValue();
180			}
181
182	6		$parametersData[$parameter->getName()] = $parameterData;
183			}
184
185	6		ksort($parametersData);
186
187	6		$typeData->parameters = (object) $parametersData;
188			}
189
190	8		$bindingTypesData[$type->getName()] = $typeData;
191			}
192
193	8		ksort($bindingTypesData);
194
195	8		$jsonData->{'binding-types'} = (object) $bindingTypesData;
196			}
197
198	20		if (count($overrides) > 0) {
199	3		$jsonData->override = count($overrides) > 1 ? $overrides : reset($overrides);
200			}
201
202	20		if (count($extra) > 0) {
203	2		$jsonData->extra = (object) $extra;
204			}
205	20		}
206
207	38		protected function addJsonToPackageFile(stdClass $jsonData, PackageFile $packageFile)
208			{
209	38		if (isset($jsonData->name)) {
210	28		$packageFile->setPackageName($jsonData->name);
211			}
212
213	38		if (isset($jsonData->{'path-mappings'})) {
214	2		foreach ($jsonData->{'path-mappings'} as $path => $relativePaths) {
215	2		$packageFile->addPathMapping(new PathMapping($path, (array) $relativePaths));
216			}
217			}
218
219	38		if (isset($jsonData->bindings)) {
220	6		foreach ($jsonData->bindings as $uuid => $bindingData) {
221	6		$binding = null;
			0 ignored issues – show Unused Code introduced 2016-01-28 10:48 UTC by Report Bug Copy Issue Report Show Similar Issues like this `$binding` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
222	6		$class = isset($bindingData->_class)
223	4		? $bindingData->_class
224	6		: 'Puli\Discovery\Binding\ResourceBinding';
225
226			// Move this code to external classes to allow use of custom
227			// bindings
228			switch ($class) {
229	6		case 'Puli\Discovery\Binding\ClassBinding':
230	3		$binding = new ClassBinding(
231	3		$bindingData->class,
232	3		$bindingData->type,
233	3		isset($bindingData->parameters) ? (array) $bindingData->parameters : array(),
234	3		Uuid::fromString($uuid)
235			);
236	3		break;
237			case 'Puli\Discovery\Binding\ResourceBinding':
238	5		$binding = new ResourceBinding(
239	5		$bindingData->query,
240	5		$bindingData->type,
241	5		isset($bindingData->parameters) ? (array) $bindingData->parameters : array(),
242	5		isset($bindingData->language) ? $bindingData->language : 'glob',
243	5		Uuid::fromString($uuid)
244			);
245	5		break;
246			default:
247			continue 2;
248			}
249
250	6		$packageFile->addBindingDescriptor(new BindingDescriptor($binding));
251			}
252			}
253
254	38		if (isset($jsonData->{'binding-types'})) {
255	3		foreach ((array) $jsonData->{'binding-types'} as $typeName => $data) {
256	3		$parameters = array();
257	3		$parameterDescriptions = array();
258
259	3		if (isset($data->parameters)) {
260	3		foreach ((array) $data->parameters as $parameterName => $parameterData) {
261	3		$required = isset($parameterData->required) ? $parameterData->required : false;
262
263	3		$parameters[] = new BindingParameter(
264			$parameterName,
265	3		$required ? BindingParameter::REQUIRED : BindingParameter::OPTIONAL,
266	3		isset($parameterData->default) ? $parameterData->default : null
267			);
268
269	3		if (isset($parameterData->description)) {
270	3		$parameterDescriptions[$parameterName] = $parameterData->description;
271			};
272			}
273			}
274
275	3		$packageFile->addTypeDescriptor(new BindingTypeDescriptor(
276	3		new BindingType($typeName, $parameters),
277	3		isset($data->description) ? $data->description : null,
278			$parameterDescriptions
279			));
280			}
281			}
282
283	38		if (isset($jsonData->override)) {
284	2		$packageFile->setOverriddenPackages((array) $jsonData->override);
285			}
286
287	38		if (isset($jsonData->extra)) {
288	2		$packageFile->setExtraKeys((array) $jsonData->extra);
289			}
290	38		}
291			}
292

puli / manager

Pull Request — master (#49)

src/Package/PackageFileConverter.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like