Puli\Manager\Cache\CacheFileStorage

Complexity

Total Complexity

9

Size/Duplication

Total Lines	118
Duplicated Lines	20.34 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

16.22%

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	loadCacheFile()	0	17	2
A	saveCacheFile()	0	7	1
A	fileExists()	0	4	1
A	encode()	12	12	2
A	decode()	12	12	2

<?php

/*
 * This file is part of the puli/manager package.
 *
 * (c) Bernhard Schussek <bschussek@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Puli\Manager\Cache;

use Puli\Manager\Api\Cache\CacheFile;
use Puli\Manager\Api\FileNotFoundException;
use Puli\Manager\Api\InvalidConfigException;
use Puli\Manager\Api\Storage\ReadException;
use Puli\Manager\Api\Storage\Storage;
use Puli\Manager\Api\Storage\WriteException;
use stdClass;
use Webmozart\Json\Conversion\ConversionFailedException;
use Webmozart\Json\Conversion\JsonConverter;
use Webmozart\Json\DecodingFailedException;
use Webmozart\Json\EncodingFailedException;
use Webmozart\Json\JsonDecoder;
use Webmozart\Json\JsonEncoder;

/**
 * Loads and saves cache files.
 *
 * @since  1.0
 *
 * @author Mateusz Sojda <mateusz@sojda.pl>
 */
class CacheFileStorage
{
    /**
     * @var Storage
     */
    private $storage;

    /**
     * @var JsonConverter
     */
    private $converter;

    /**
     * Creates a new storage.
     *
     * @param Storage         $storage          The file storage.
     * @param JsonConverter   $converter        The cache file converter.
     * @param JsonEncoder     $jsonEncoder      The JSON encoder.
     * @param JsonDecoder     $jsonDecoder      The JSON decoder.
     */
    public function __construct(
        Storage $storage,
        JsonConverter $converter,
        JsonEncoder $jsonEncoder,
        JsonDecoder $jsonDecoder
    )
    {
        $this->storage = $storage;
        $this->converter = $converter;
        $this->jsonEncoder = $jsonEncoder;

The property jsonEncoder does not exist. Did you maybe forget to declare it?

        $this->jsonDecoder = $jsonDecoder;

The property jsonDecoder does not exist. Did you maybe forget to declare it?

    }

    /**
     * Loads a cache file from a file path.
     *
     * @param string $path The path to the cache file.
     *
     * @return CacheFile The loaded cache file.
     *
     * @throws FileNotFoundException       If the file does not exist.
     * @throws ReadException               If the file cannot be read.
     * @throws InvalidConfigException      If the file contains invalid
     *                                     configuration.
     */
    public function loadCacheFile($path)
    {
        $serialized = $this->storage->read($path);
        $jsonData = $this->decode($serialized, $path);

        try {
            return $this->converter->fromJson($jsonData, array(
                'path' => $path
            ));
        } catch (ConversionFailedException $e) {
            throw new InvalidConfigException(sprintf(
                'The JSON in %s could not be converted: %s',
                $path,
                $e->getMessage()
            ), 0, $e);
        }
    }

    /**
     * Saves a cache file.
     *
     * The cache file is saved to the same path that it was read from.
     *
     * @param CacheFile $cacheFile The cache file to save.
     *
     * @throws WriteException If the file cannot be written.
     */
    public function saveCacheFile(CacheFile $cacheFile)
    {
        $jsonData = $this->converter->toJson($cacheFile);
        $serialized = $this->encode($jsonData, $cacheFile->getPath());

        $this->storage->write($cacheFile->getPath(), $serialized);
    }

    /**
     * Returns whether a cache file exists.
     *
     * @param string $path The cache file path.
     *
     * @return bool Returns `true` if the cache file exists and `false` otherwise.
     */
    public function fileExists($path)
    {
        return $this->storage->exists($path);
    }

    private function encode(stdClass $jsonData, $path)

The return type could not be reliably inferred; please add a @return annotation.

This method seems to be duplicated in your project.

    {
        try {
            return $this->jsonEncoder->encode($jsonData);
        } catch (EncodingFailedException $e) {
            throw new InvalidConfigException(sprintf(
                'The configuration in %s could not be encoded: %s',
                $path,
                $e->getMessage()
            ), 0, $e);
        }
    }

    private function decode($json, $path)

The return type could not be reliably inferred; please add a @return annotation.

This method seems to be duplicated in your project.

    {
        try {
            return $this->jsonDecoder->decode($json);
        } catch (DecodingFailedException $e) {
            throw new InvalidConfigException(sprintf(
                'The configuration in %s could not be decoded: %s',
                $path,
                $e->getMessage()
            ), 0, $e);
        }
    }
}