Laposte\DatanovaBundle\Service\Finder

Complexity

Total Complexity

16

Size/Duplication

Total Lines	171
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes	4
Bugs	1	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	setLogger()	0	4	1
A	setWorkingDirectory()	0	21	4
A	exists()	0	6	1
A	getFilePath()	0	17	1
B	save()	0	22	4
A	findDataset()	0	10	2
A	getContent()	0	9	2

<?php

namespace Laposte\DatanovaBundle\Service;

use Psr\Log\LoggerInterface;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\Filesystem\Exception\IOExceptionInterface;
use Symfony\Component\Filesystem\Filesystem;

class Finder
{
    const DEFAULT_FORMAT = 'JSON';
    const RESSOURCES_FOLDER = '@LaposteDatanovaBundle/Resources/dataset';

    /** @var Filesystem $filesystem */
    private $filesystem;

    /** @var FileLocator $locator */
    private $locator;

    /** @var string $directory */
    private $directory;

    /** @var LoggerInterface $logger */
    private $logger;

    /**
     * @param Filesystem $filesystem
     * @param FileLocator $locator
     * @param string $rootDir
     */
    public function __construct(Filesystem $filesystem, FileLocator $locator, $rootDir = self::RESSOURCES_FOLDER)
    {
        $this->filesystem = $filesystem;
        $this->locator = $locator;
        $rootDir = $this->locator->locate($rootDir);
        $this->setWorkingDirectory($rootDir);

It seems like $rootDir defined by $this->locator->locate($rootDir) on line 36 can also be of type array; however, Laposte\DatanovaBundle\Service\Finder::setWorkingDirectory() does only seem to accept string, maybe add an additional type check?

    }

    /**
     * @param LoggerInterface $logger
     */
    public function setLogger(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

    /**
     * @param string $directory the working directory for filesystem operations
     */
    public function setWorkingDirectory($directory)
    {
        $directory = preg_replace('#/+#', '/', $directory); // remove multiple slashes
        try {
            $directory = $this->locator->locate($directory);
        } catch (\Exception $exception) {

Consider adding a comment why this CATCH block is empty.

        }
        $exists = $this->filesystem->exists($directory);
        if (!$exists) {
            try {
                $this->filesystem->mkdir($directory);
                $this->logger->notice("Working directory created at " . $directory);
            } catch (IOExceptionInterface $exception) {
                $this->logger->error(
                    "An error occurred while creating your directory at " . $exception->getPath(),
                    $exception->getTrace()
                );
            }
        }
        $this->directory = $directory;

It seems like $directory can also be of type array. However, the property $directory is declared as type string. Maybe add an additional type check?

    }

    /**
     * Check if a dataset local file exists
     *
     * @param string $dataset
     * @param string $format
     * @param string $filter
     *
     * @return bool
     */
    public function exists($dataset, $format, $filter = null)
    {
        $uri = $this->getFilePath($dataset, $format, $filter);

        return $this->filesystem->exists($uri);
    }

    /**
     * @param string $dataset
     * @param string $format
     * @param string $filter
     *
     * @return string
     */
    private function getFilePath($dataset, $format, $filter = null)
    {
        $filter = preg_replace('#:|=#', '_', $filter);
        $filepath = sprintf(
            '%s%s%s%s%s_%s.%s',
            $this->directory,
            DIRECTORY_SEPARATOR,
            $dataset,
            DIRECTORY_SEPARATOR,
            $dataset,
            $filter,
            $format
        );
        $filepath = preg_replace('#/+#', '/', $filepath); // remove multiple slashes

        return $filepath;
    }

    /**
     * Save a records to dataset file
     *
     * @param string $dataset
     * @param string $content
     * @param string $format
     * @param string $filter
     * @param bool $force
     *
     * @return false|string saved file path
     */
    public function save($dataset, $content, $format = self::DEFAULT_FORMAT, $filter = null, $force = false)
    {
        $saved = false;
        $filename = $dataset;
        $path = $this->getFilePath($filename, $format, $filter);
        if ($this->filesystem->exists($path) && !$force) {
            $this->logger->error("An error occurred while saving existing dataset at " . $path);
        } else {
            try {
                $this->filesystem->dumpFile($path, $content);
                $this->logger->notice(sprintf('Saving %s dataset at %s', $dataset, $path));
                $saved = realpath($path);
            } catch (IOExceptionInterface $exception) {
                $this->logger->error(
                    "An error occurred while saving the dataset at " . $exception->getPath(),
                    $exception->getTrace()
                );
            }
        }

        return $saved;
    }

    /**
     * @param string $dataset
     * @param string $format
     * @param string $filter
     *
     * @return false|string dataset file path
     */
    public function findDataset($dataset, $format = self::DEFAULT_FORMAT, $filter = null)
    {
        $datasetPath = false;
        $path = $this->getFilePath($dataset, $format, $filter);
        if ($this->filesystem->exists($path)) {
            $datasetPath = realpath($path);
        }

        return $datasetPath;
    }

    /**
     * @param string $filepath
     *
     * @return null|string
     */
    public function getContent($filepath)
    {
        $content = null;
        if (file_exists($filepath)) {
            $content = file_get_contents($filepath);
        }

        return $content;
    }
}