frictionlessdata\datapackage\Resources\BaseResource

Complexity

Total Complexity

53

Size/Duplication

Total Lines	270
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	3
A	handlesDescriptor()	0	4	1
C	read()	0	34	13
A	dataStreams()	0	15	4
A	descriptor()	0	4	1
A	name()	0	4	1
A	path()	0	13	3
A	isLocal()	0	4	1
A	isRemote()	0	5	3
A	data()	0	4	2
A	rewind()	0	8	2
A	current()	0	4	1
A	key()	0	4	1
A	next()	0	4	1
A	valid()	0	17	3
A	getFileExtension()	0	4	1
A	save()	0	19	3
A	validateDataSource()	0	13	3
A	normalizeDataSource()	0	12	4
A	validateResource()	0	4	1
	getDataStream()	0	1	?
	getInlineDataStream()	0	1	?
A	handlesProfile()	0	4	1

<?php

namespace frictionlessdata\datapackage\Resources;

use frictionlessdata\datapackage\DataStreams\BaseDataStream;
use frictionlessdata\datapackage\Registry;
use frictionlessdata\datapackage\Validators\ResourceValidationError;
use frictionlessdata\datapackage\Validators\ResourceValidator;
use frictionlessdata\datapackage\Exceptions\ResourceValidationFailedException;
use frictionlessdata\datapackage\Utils;

abstract class BaseResource implements \Iterator
{

    /**
     * BaseResource constructor.
     *
     * @param object $descriptor
     * @param null|string $basePath
     *
     * @param bool $skipValidations
     *
     * @throws \frictionlessdata\datapackage\Exceptions\ResourceValidationFailedException
     */
    public function __construct($descriptor, $basePath, $skipValidations = false)
    {
        $this->basePath = $basePath;
        $this->descriptor = Utils::objectify($descriptor);
        $this->skipValidations = $skipValidations;
        if (!$this->skipValidations) {
            $validationErrors = $this->validateResource();
            if (count($validationErrors) > 0) {
                throw new ResourceValidationFailedException($validationErrors);
            }
        }
    }

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

    public function read($readOptions = null)
    {
        $limit = ($readOptions && isset($readOptions['limit'])) ? $readOptions['limit'] : null;
        $rows = [];
        foreach ($this->dataStreams() as $dataStream) {

The expression $this->dataStreams() of type array<integer,object<frictionlessdata\datapackage\DataStreams\BaseDataStream>>|null is not guaranteed to be traversable. How about adding an additional type check?

            if (isset($dataStream->table)) {
                $readOptions['limit'] = $limit;
                foreach ($dataStream->table->read($readOptions) as $row) {
                    $rows[] = $row;
                    if ($limit !== null) {
                        --$limit;
                        if ($limit < 0) {
                            break;
                        }
                    }
                }
            } else {
                foreach ($dataStream as $row) {
                    $rows[] = $row;
                    if ($limit !== null) {
                        --$limit;
                        if ($limit < 0) {
                            break;
                        }
                    }
                }
            }
            if ($limit !== null && $limit < 0) {
                break;
            }
        }

        return $rows;
    }

    /**
     * Loads $this->dataStreams based on $this->path() and $this->data
     * @return BaseDataStream[]|null
     */
    public function dataStreams()
    {
        if (is_null($this->dataStreams)) {
            $this->dataStreams = [];
            foreach ($this->path() as $path) {
                $this->dataStreams[] = $this->getDataStream($path);
            }
            $data = $this->data();
            if ($data) {
                $this->dataStreams[] = $this->getInlineDataStream($data);
            }
        }

        return $this->dataStreams;
    }

    /**
     * @return object
     */
    public function descriptor()
    {
        return $this->descriptor;
    }

    /**
     * @return string
     */
    public function name()
    {
        return $this->descriptor()->name;
    }

    public function path()
    {
        if (isset($this->descriptor()->path)) {
            $path = $this->descriptor()->path;
            if (!is_array($path)) {
                $path = [$path];
            }

            return $path;
        } else {
            return [];
        }
    }

    /**
     * If the resource's $path is local (non-http)
     * @return bool
     */
    public function isLocal()
    {
        return !$this->isRemote();
    }

    /**
     * If the resource's $path is remote (http)
     * @return bool
     */
    public function isRemote()
    {
        $path = $this->path();
        return Utils::isHttpSource(is_array($path) && count($path) > 0 ? $path[0] : $path);
    }

    public function data()
    {
        return isset($this->descriptor()->data) ? $this->descriptor()->data : null;
    }

    // standard iterator functions - to iterate over the data sources
    public function rewind()
    {
        $this->dataStreams = null;
        $this->currentDataStream = 0;
        foreach ($this->dataStreams() as $dataStream) {

The expression $this->dataStreams() of type array<integer,object<frictionlessdata\datapackage\DataStreams\BaseDataStream>>|null is not guaranteed to be traversable. How about adding an additional type check?

            $dataStream->rewind();
        }
    }

    public function current()
    {
        return $this->dataStreams()[$this->currentDataStream]->current();
    }

    public function key()
    {
        return $this->dataStreams()[$this->currentDataStream]->key();
    }

    public function next()
    {
        return $this->dataStreams()[$this->currentDataStream]->next();
    }

    public function valid()
    {
        $dataStreams = $this->dataStreams();
        if ($dataStreams[$this->currentDataStream]->valid()) {
            // current data stream is still valid
            return true;
        } else {
            ++$this->currentDataStream;
            if (isset($dataStreams[$this->currentDataStream])) {
                // current data stream is done, but we have another data stream
                return true;
            } else {
                // no more data and no more data streams
                return false;
            }
        }
    }

    public function getFileExtension()
    {
        return '';
    }

    public function save($baseFilename)
    {
        $dataStreams = $this->dataStreams();
        $numDataStreams = count($dataStreams);
        $fileNames = [];
        $i = 0;
        foreach ($dataStreams as $dataStream) {

The expression $dataStreams of type array<integer,object<frictionlessdata\datapackage\DataStreams\BaseDataStream>>|null is not guaranteed to be traversable. How about adding an additional type check?

            if ($numDataStreams == 1) {
                $filename = $baseFilename.$this->getFileExtension();
            } else {
                $filename = $baseFilename.'-data-'.$i.$this->getFileExtension();
            }
            $fileNames[] = $filename;
            $dataStream->save($filename);
            ++$i;
        }

        return $fileNames;
    }

    public static function validateDataSource($dataSource, $basePath = null)
    {
        $errors = [];
        $dataSource = static::normalizeDataSource($dataSource, $basePath);
        if (!Utils::isHttpSource($dataSource) && !file_exists($dataSource)) {
            $errors[] = new ResourceValidationError(
                ResourceValidationError::SCHEMA_VIOLATION,
                "data source file does not exist or is not readable: {$dataSource}"
            );
        }

        return $errors;
    }

    /**
     * allows extending classes to add custom sources
     * used by unit tests to add a mock http source.
     *
     * @param string $dataSource
     * @param string|null $basePath
     *
     * @return string
     */
    public static function normalizeDataSource($dataSource, string $basePath = null)
    {
        if (!empty($basePath) && !Utils::isHttpSource($dataSource)) {
            // TODO: support JSON pointers
            $absPath = $basePath.DIRECTORY_SEPARATOR.$dataSource;
            if (file_exists($absPath)) {
                $dataSource = $absPath;
            }
        }

        return $dataSource;
    }

    protected $descriptor;
    protected $basePath;
    protected $skipValidations = false;
    protected $currentDataPosition = 0;
    protected $currentDataStream = 0;
    protected $dataStreams = null;

    protected function validateResource()
    {
        return ResourceValidator::validate($this->descriptor(), $this->basePath);

It seems like $this->basePath can also be of type string; however, frictionlessdata\datapackage\Validators\BaseValidator::validate() does only seem to accept null, maybe add an additional type check?

    }

    /**
     * @param string $dataSource
     *
     * @return BaseDataStream
     */
    abstract protected function getDataStream($dataSource);

    abstract protected function getInlineDataStream($data);

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