BaseDatapackage::save() - Code Metrics - Inspection of "Update the save() method to set relative paths for..." - frictionlessdata/datapackage-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#51)

unknown

created 2021-04-25 07:10 UTC

BaseDatapackage::save() B

↳ Parent: BaseDatapackage

Complexity

Conditions	7
Paths	18

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	7
nc	18
nop	1
dl	0
loc	39
rs	8.3626
c	0
b	0
f	0

<?php

namespace frictionlessdata\datapackage\Datapackages;

use frictionlessdata\datapackage\Factory;
use frictionlessdata\datapackage\Package;
use frictionlessdata\datapackage\Registry;
use frictionlessdata\datapackage\Utils;
use frictionlessdata\datapackage\Validators\DatapackageValidator;
use frictionlessdata\datapackage\Exceptions\DatapackageValidationFailedException;
use frictionlessdata\datapackage\Exceptions\DatapackageInvalidSourceException;
use ZipArchive;

abstract class BaseDatapackage implements \Iterator
{

    /**
     * BaseDatapackage constructor.
     *
     * @param object $descriptor
     * @param null|string $basePath
     *
     * @param bool $skipValidations
     *
     * @throws \frictionlessdata\datapackage\Exceptions\DatapackageValidationFailedException
     */
    public function __construct($descriptor, $basePath = null, $skipValidations = false)
    {
        $this->descriptor = $descriptor;
        $this->basePath = $basePath;
        $this->skipValidations = $skipValidations;
        if (!$this->skipValidations) {
            $this->revalidate();
        }
    }

    public static function create($name, $resources, $basePath = null)
    {
        $datapackage = new static((object) [
            'name' => $name,
            'resources' => [],
        ], $basePath, true);
        foreach ($resources as $resource) {
            $datapackage->addResource($resource);

        }

        return $datapackage;
    }

    public function revalidate()
    {
        $this->rewind();
        $validationErrors = $this->datapackageValidate();
        if (count($validationErrors) > 0) {
            throw new DatapackageValidationFailedException($validationErrors);
        }
    }

    public static function handlesDescriptor($descriptor)
    {
        return static::handlesProfile(Registry::getDatapackageValidationProfile($descriptor));
    }

    /**
     * returns the descriptor as-is, without adding default values or normalizing.
     *
     * @return object
     */
    public function descriptor()
    {
        return $this->descriptor;
    }

    public function resources()
    {
        $resources = [];
        foreach ($this->descriptor->resources as $resourceDescriptor) {
            $resources[$resourceDescriptor->name] = $this->initResource($resourceDescriptor);
        }

        return $resources;
    }

    public function getResource($name)
    {
        foreach ($this->descriptor->resources as $resourceDescriptor) {
            if ($resourceDescriptor->name == $name) {
                return $this->initResource($resourceDescriptor);
            }
        }
        throw new \Exception("couldn't find matching resource with name =  '{$name}'");
    }

    public function addResource($name, $resource)
    {
        if (is_a($resource, 'frictionlessdata\\datapackage\\Resources\\BaseResource')) {
            $resource = $resource->descriptor();
        } else {
            $resource = Utils::objectify($resource);
        }
        $resource->name = $name;
        $resourceDescriptors = [];
        $gotMatch = false;
        foreach ($this->descriptor->resources as $resourceDescriptor) {
            if ($resourceDescriptor->name == $resource->name) {
                $resourceDescriptors[] = $resource;
                $gotMatch = true;
            } else {
                $resourceDescriptors[] = $resourceDescriptor;
            }
        }
        if (!$gotMatch) {
            $resourceDescriptors[] = $resource;
        }
        $this->descriptor->resources = $resourceDescriptors;
        if (!$this->skipValidations) {
            $this->revalidate();
        }
    }

    // TODO: remove this function and use the getResource / addResource directly (will need to modify a lot of tests code)
    public function resource($name, $resource = null)
    {
        if ($resource) {
            $this->addResource($name, $resource);
        } else {
            return $this->getResource($name);
        }
    }

    public function removeResource($name)
    {
        $resourceDescriptors = [];
        foreach ($this->descriptor->resources as $resourceDescriptor) {
            if ($resourceDescriptor->name != $name) {
                $resourceDescriptors[] = $resourceDescriptor;
            }
        }
        $this->descriptor->resources = $resourceDescriptors;
        if (!$this->skipValidations) {
            $this->revalidate();
        }
    }

    public function saveDescriptor($filename)
    {
        return file_put_contents($filename, json_encode($this->descriptor()));
    }

    // standard iterator functions - to iterate over the resources
    public function rewind()
    {
        $this->currentResourcePosition = 0;
    }

    public function current()
    {
        return $this->initResource($this->descriptor()->resources[$this->currentResourcePosition]);
    }

    public function key()
    {
        return $this->currentResourcePosition;
    }

    public function next()
    {
        ++$this->currentResourcePosition;
    }

    public function valid()
    {
        return isset($this->descriptor()->resources[$this->currentResourcePosition]);
    }

    /**
     * @param $zip_filename
     *
     * @throws \frictionlessdata\datapackage\Exceptions\DatapackageInvalidSourceException
     * @throws \Exception
     */
    public function save($zip_filename)
    {
        Package::isZipPresent();
        $zip = new ZipArchive();

        $packageCopy = $this->copy();

        $base = tempnam(sys_get_temp_dir(), 'datapackage-zip-');
        $files = [
            'datapackage.json' => $base.'datapackage.json',
        ];
        $ri = 0;
        foreach ($packageCopy as $resource) {
            if ($resource->isRemote()) continue;

            $resourceFiles = [];
            $fileNames = $resource->save($base.'resource-'.$ri);
            foreach ($fileNames as $fileName) {
                $relname = str_replace($base.'resource-'.$ri, '', $fileName);
                $files['resource-'.$ri.$relname] = $fileName;
                $resourceFiles[] = 'resource-'.$ri.$relname;
            }
            $resource->descriptor()->path = count($resourceFiles) == 1 ? $resourceFiles[0] : $resourceFiles;
            ++$ri;
        }
        $packageCopy->saveDescriptor($files['datapackage.json']);

        register_shutdown_function(function () use ($base) {
            Utils::removeDir($base);
        });
        if ($zip->open($zip_filename, ZipArchive::CREATE | ZipArchive::OVERWRITE) === true) {
            foreach ($files as $filename => $resource) {
                $zip->addFile($resource, $filename);
            }
            $zip->close();
        } else {
            throw new DatapackageInvalidSourceException('zip file could not be saved.');
        }
    }

    /**
     * Make a new Datapackage object that is a copy of the current Datapackage. Bypasses validation.
     * @return $this
     * @throws DatapackageValidationFailedException
     */
    protected function copy()
    {
        return new static($this->descriptor, $this->basePath, true);
    }

    protected $descriptor;
    protected $currentResourcePosition = 0;
    protected $basePath;
    protected $skipValidations = false;

    /**
     * called by the resources iterator for each iteration.
     *
     * @param object $descriptor
     *
     * @return \frictionlessdata\datapackage\Resources\BaseResource
     * @throws \frictionlessdata\datapackage\Exceptions\ResourceValidationFailedException
     */
    protected function initResource($descriptor)
    {
        return Factory::resource($descriptor, $this->basePath, $this->skipValidations);
    }

    protected function datapackageValidate()
    {
        return DatapackageValidator::validate($this->descriptor(), $this->basePath);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    protected static function handlesProfile($profile)
    {
        return false;
    }
}


1			<?php
2
3			namespace frictionlessdata\datapackage\Datapackages;
4
5			use frictionlessdata\datapackage\Factory;
6			use frictionlessdata\datapackage\Package;
7			use frictionlessdata\datapackage\Registry;
8			use frictionlessdata\datapackage\Utils;
9			use frictionlessdata\datapackage\Validators\DatapackageValidator;
10			use frictionlessdata\datapackage\Exceptions\DatapackageValidationFailedException;
11			use frictionlessdata\datapackage\Exceptions\DatapackageInvalidSourceException;
12			use ZipArchive;
13
14			abstract class BaseDatapackage implements \Iterator
15			{
16
17			/**
18			* BaseDatapackage constructor.
19			*
20			* @param object $descriptor
21			* @param null\|string $basePath
22			*
23			* @param bool $skipValidations
24			*
25			* @throws \frictionlessdata\datapackage\Exceptions\DatapackageValidationFailedException
26			*/
27			public function __construct($descriptor, $basePath = null, $skipValidations = false)
28			{
29			$this->descriptor = $descriptor;
30			$this->basePath = $basePath;
31			$this->skipValidations = $skipValidations;
32			if (!$this->skipValidations) {
33			$this->revalidate();
34			}
35			}
36
37			public static function create($name, $resources, $basePath = null)
38			{
39			$datapackage = new static((object) [
40			'name' => $name,
41			'resources' => [],
42			], $basePath, true);
43			foreach ($resources as $resource) {
44			$datapackage->addResource($resource);
			0 ignored issues – show Bug introduced 2017-11-30 14:10 UTC by Report Bug Copy Issue Report The call to `addResource()` misses a required argument `$resource`. This check looks for function calls that miss required arguments. Loading history...
45			}
46
47			return $datapackage;
48			}
49
50			public function revalidate()
51			{
52			$this->rewind();
53			$validationErrors = $this->datapackageValidate();
54			if (count($validationErrors) > 0) {
55			throw new DatapackageValidationFailedException($validationErrors);
56			}
57			}
58
59			public static function handlesDescriptor($descriptor)
60			{
61			return static::handlesProfile(Registry::getDatapackageValidationProfile($descriptor));
62			}
63
64			/**
65			* returns the descriptor as-is, without adding default values or normalizing.
66			*
67			* @return object
68			*/
69			public function descriptor()
70			{
71			return $this->descriptor;
72			}
73
74			public function resources()
75			{
76			$resources = [];
77			foreach ($this->descriptor->resources as $resourceDescriptor) {
78			$resources[$resourceDescriptor->name] = $this->initResource($resourceDescriptor);
79			}
80
81			return $resources;
82			}
83
84			public function getResource($name)
85			{
86			foreach ($this->descriptor->resources as $resourceDescriptor) {
87			if ($resourceDescriptor->name == $name) {
88			return $this->initResource($resourceDescriptor);
89			}
90			}
91			throw new \Exception("couldn't find matching resource with name = '{$name}'");
92			}
93
94			public function addResource($name, $resource)
95			{
96			if (is_a($resource, 'frictionlessdata\\datapackage\\Resources\\BaseResource')) {
97			$resource = $resource->descriptor();
98			} else {
99			$resource = Utils::objectify($resource);
100			}
101			$resource->name = $name;
102			$resourceDescriptors = [];
103			$gotMatch = false;
104			foreach ($this->descriptor->resources as $resourceDescriptor) {
105			if ($resourceDescriptor->name == $resource->name) {
106			$resourceDescriptors[] = $resource;
107			$gotMatch = true;
108			} else {
109			$resourceDescriptors[] = $resourceDescriptor;
110			}
111			}
112			if (!$gotMatch) {
113			$resourceDescriptors[] = $resource;
114			}
115			$this->descriptor->resources = $resourceDescriptors;
116			if (!$this->skipValidations) {
117			$this->revalidate();
118			}
119			}
120
121			// TODO: remove this function and use the getResource / addResource directly (will need to modify a lot of tests code)
122			public function resource($name, $resource = null)
123			{
124			if ($resource) {
125			$this->addResource($name, $resource);
126			} else {
127			return $this->getResource($name);
128			}
129			}
130
131			public function removeResource($name)
132			{
133			$resourceDescriptors = [];
134			foreach ($this->descriptor->resources as $resourceDescriptor) {
135			if ($resourceDescriptor->name != $name) {
136			$resourceDescriptors[] = $resourceDescriptor;
137			}
138			}
139			$this->descriptor->resources = $resourceDescriptors;
140			if (!$this->skipValidations) {
141			$this->revalidate();
142			}
143			}
144
145			public function saveDescriptor($filename)
146			{
147			return file_put_contents($filename, json_encode($this->descriptor()));
148			}
149
150			// standard iterator functions - to iterate over the resources
151			public function rewind()
152			{
153			$this->currentResourcePosition = 0;
154			}
155
156			public function current()
157			{
158			return $this->initResource($this->descriptor()->resources[$this->currentResourcePosition]);
159			}
160
161			public function key()
162			{
163			return $this->currentResourcePosition;
164			}
165
166			public function next()
167			{
168			++$this->currentResourcePosition;
169			}
170
171			public function valid()
172			{
173			return isset($this->descriptor()->resources[$this->currentResourcePosition]);
174			}
175
176			/**
177			* @param $zip_filename
178			*
179			* @throws \frictionlessdata\datapackage\Exceptions\DatapackageInvalidSourceException
180			* @throws \Exception
181			*/
182			public function save($zip_filename)
183			{
184			Package::isZipPresent();
185			$zip = new ZipArchive();
186
187			$packageCopy = $this->copy();
188
189			$base = tempnam(sys_get_temp_dir(), 'datapackage-zip-');
190			$files = [
191			'datapackage.json' => $base.'datapackage.json',
192			];
193			$ri = 0;
194			foreach ($packageCopy as $resource) {
195			if ($resource->isRemote()) continue;
196
197			$resourceFiles = [];
198			$fileNames = $resource->save($base.'resource-'.$ri);
199			foreach ($fileNames as $fileName) {
200			$relname = str_replace($base.'resource-'.$ri, '', $fileName);
201			$files['resource-'.$ri.$relname] = $fileName;
202			$resourceFiles[] = 'resource-'.$ri.$relname;
203			}
204			$resource->descriptor()->path = count($resourceFiles) == 1 ? $resourceFiles[0] : $resourceFiles;
205			++$ri;
206			}
207			$packageCopy->saveDescriptor($files['datapackage.json']);
208
209			register_shutdown_function(function () use ($base) {
210			Utils::removeDir($base);
211			});
212			if ($zip->open($zip_filename, ZipArchive::CREATE \| ZipArchive::OVERWRITE) === true) {
213			foreach ($files as $filename => $resource) {
214			$zip->addFile($resource, $filename);
215			}
216			$zip->close();
217			} else {
218			throw new DatapackageInvalidSourceException('zip file could not be saved.');
219			}
220			}
221
222			/**
223			* Make a new Datapackage object that is a copy of the current Datapackage. Bypasses validation.
224			* @return $this
225			* @throws DatapackageValidationFailedException
226			*/
227			protected function copy()
228			{
229			return new static($this->descriptor, $this->basePath, true);
230			}
231
232			protected $descriptor;
233			protected $currentResourcePosition = 0;
234			protected $basePath;
235			protected $skipValidations = false;
236
237			/**
238			* called by the resources iterator for each iteration.
239			*
240			* @param object $descriptor
241			*
242			* @return \frictionlessdata\datapackage\Resources\BaseResource
243			* @throws \frictionlessdata\datapackage\Exceptions\ResourceValidationFailedException
244			*/
245			protected function initResource($descriptor)
246			{
247			return Factory::resource($descriptor, $this->basePath, $this->skipValidations);
248			}
249
250			protected function datapackageValidate()
251			{
252			return DatapackageValidator::validate($this->descriptor(), $this->basePath);
			0 ignored issues – show Bug introduced 2021-02-24 01:30 UTC by Report Bug Copy Issue Report It seems like `$this->basePath` can also be of type `string`; however, `frictionlessdata\datapac...seValidator::validate()` does only seem to accept `null`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
253			}
254
255			protected static function handlesProfile($profile)
256			{
257			return false;
258			}
259			}
260

frictionlessdata / datapackage-php

Pull Request — master (#51)

BaseDatapackage::save() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like