carono / film-janitor

src/File.php

<?php

namespace carono\janitor;

use carono\janitor\engines\EngineAbstract;
use carono\janitor\engines\EngineInterface;
use carono\janitor\helpers\ArrayHelper;

/**
 * Class File
 *
 * @package carono\janitor
 */
class File
{
    /**
     * @var string
     */
    protected $filePath;
    /**
     * @var array
     */
    protected $movieNames = [];
    /**
     * @var EngineAbstract
     */
    protected $engine;
    /**
     * @var string
     */
    protected $lastRequest;

    /**
     * @return string
     */
    public function getParentFolder()
    {
        return basename($this->getFolder());
    }

    /**
     * @return string
     */
    public function getFolder()
    {
        return (string)pathinfo($this->filePath, PATHINFO_DIRNAME);
    }

    /**
     * @return string
     */
    public function getFileName()
    {
        return (string)pathinfo($this->filePath, PATHINFO_FILENAME);
    }

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

    /**
     * @return string
     */
    public function getFileExtension()
    {
        return (string)pathinfo($this->filePath, PATHINFO_EXTENSION);
    }

    /**
     * @return array
     */
    protected function getStoredSerials()
    {
        return $this->getCacheValue('serial-names') ?: [];
    }

    /**
     * @return mixed
     */
    public function getStoredSerialData()
    {
        if ($this->isFilm()) {
            return [];
        }
        return ArrayHelper::getValue($this->getStoredSerials(), $this->getParentFolder(), []);
    }

    /**
     *
     */
    public function restoreSerialData()
    {
        if ($data = $this->getStoredSerialData()) {
            $this->movieNames = $data['movieNames'];
        }
    }

    /**
     * @return bool
     */
    public function getStoredSerialName()
    {
        if ($data = $this->getStoredSerialData()) {
            return $data['newName'];
        }
        return false;
    }

    /**
     * @param $newName
     */
    public function storeSerialName($newName)
    {
        $title = $this->getReformFilmName($newName);
        if ($this->isSerial() && !$this->getStoredSerialData()) {
            $serials = $this->getStoredSerials();
            $data = [
                'title' => $title,
                'newName' => $newName,
                'movieNames' => $this->movieNames
            ];
            $serials[$this->getParentFolder()] = $data;
            $this->setCacheValue('serial-names', $serials);
        }
    }

    /**
     * @return bool
     */
    public function isFilm()
    {
        return !$this->getSeasonNumber() && !$this->getEpisodeNumber();

The expression $this->getSeasonNumber() of type integer|null is loosely compared to false; this is ambiguous if the integer can be zero. You might want to explicitly use === null instead.

The expression $this->getEpisodeNumber() of type integer|null is loosely compared to false; this is ambiguous if the integer can be zero. You might want to explicitly use === null instead.

    }

    /**
     * @return bool
     */
    public function isSerial()
    {
        return !$this->isFilm();
    }

    /**
     * @param null $request
     * @return string[]
     */
    public function searchFilmNames($request = null)
    {
        $search = $request ?: $this->filePath;
        if (!isset($this->movieNames[$search])) {
            $this->movieNames[$search] = $this->engine->getTitles($search, $this);
        }
        $this->lastRequest = $request;
        return $this->movieNames[$search];
    }

    /**
     * @param $newName
     * @return string
     */
    public function getReformFilePath($newName)
    {
        return $this->getFolder() . DIRECTORY_SEPARATOR . $this->getReformFileName($newName);
    }

    /**
     * @param $newName
     * @return string
     */
    public function getReformFileName($newName)
    {
        return $this->getReformFilmName($newName) . '.' . $this->getFileExtension();
    }

    /**
     * @param $newName
     * @return string
     */
    public function getReformFilmName($newName)
    {
        return $this->engine->reformFilmName($this, $newName, $this->lastRequest);
    }

    /**
     * @return string
     */
    public function getSuffix()
    {
        return Cli::getEpisodeName($this->getSeasonNumber(), $this->getEpisodeNumber());

It seems like $this->getSeasonNumber() targeting carono\janitor\File::getSeasonNumber() can also be of type integer; however, carono\janitor\Cli::getEpisodeName() does only seem to accept null, maybe add an additional type check?

It seems like $this->getEpisodeNumber() targeting carono\janitor\File::getEpisodeNumber() can also be of type integer; however, carono\janitor\Cli::getEpisodeName() does only seem to accept null, maybe add an additional type check?

    }

    /**
     * @return int|null
     */
    public function getEpisodeNumber()
    {
        if (!$episode = $this->engine->parseSerialEpisodeNumber($this->filePath)) {
            return $this->getSeasonNumber() ? 1 : null;
        }
        return $episode;
    }

    /**
     * @return int|null
     */
    public function getSeasonNumber()
    {
        return $this->engine->parseSerialSeason($this->filePath) ?: $this->engine->parseSerialSeason($this->getFolder());
    }

    protected function setCacheValue($key, $data)
    {
        $class = $this->engine;
        $class::setCacheValue($key, $data);
    }

    protected function getCacheValue($key)
    {
        $class = $this->engine;
        return $class::getCacheValue($key);
    }

    /**
     * @return bool
     */
    public function wasRenamed()
    {
        $key = 'store-file:' . md5($this->filePath);
        return (bool)$this->getCacheValue($key);
    }

    public function storeRename()
    {
        $key = 'store-file:' . md5($this->filePath);
        $this->setCacheValue($key, 1);
    }

    /**
     * @param $newName
     */
    public function renameFile($newName)
    {
        if (!rename($this->filePath, $newPath = $this->getReformFilePath($newName))) {
            dir("Fail rename $this->filePath, to $newPath");
        }
        $this->filePath = $newPath;
        $this->storeRename();
        $this->storeSerialName($newName);
    }

    /**
     * File constructor.
     *
     * @param $filePath
     * @throws \Exception
     */
    public function __construct(EngineInterface $engine, $filePath)
    {
        $this->engine = $engine;

$engine is of type object<carono\janitor\engines\EngineInterface>, but the property $engine was declared to be of type object<carono\janitor\engines\EngineAbstract>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        $this->filePath = $filePath;
        if (!file_exists($filePath)) {
            throw new \Exception("File $filePath not found");
        }
    }
}