IQParts / content

src/Object/File.php

<?php
declare(strict_types=1);

namespace IQParts\Content\Object;

use IQParts\Content\MimeDetector;
use League\Flysystem\File as FlyFile;

/**
 * Class File
 * @package IQParts\Content\Object
 */
final class File extends Item
{
    /**
     * @var FlyFile
     */
    private $file;
    /**
     * @var string
     */
    private $path;
    /**
     * @var string
     */
    private $basename;
    /**
     * @var int
     */
    private $size;
    /**
     * @var string
     */
    private $extension;
    /**
     * @var string
     */
    private $parent;
    /**
     * @var \DateTime
     */
    private $date;
    /**
     * @var false|int
     */
    private $timestamp;
    /**
     * @var bool
     */
    private $isEditable;
    /**
     * @var string
     */
    private $content = null;

    /**
     * PublicFile constructor.
     * @param FlyFile $file
     */
    public function __construct(FlyFile $file = null)
    {
        if ($file !== null) {
            $editable = [
                "js" => true,
                "css" => true,
                "html" => true,
                "svg" => true
            ];

            $this->file = $file;
            $this->path = $file->getPath();
            $this->size = $file->getSize();

It seems like $file->getSize() can also be of type false. However, the property $size is declared as type integer. Maybe add an additional type check?

            $this->basename = basename($file->getPath());
            $this->date = new \DateTime();
            $timestamp = $file->getTimestamp();
            $this->date->setTimestamp($timestamp);
            $this->timestamp = $timestamp;

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

            $dotPlace = strrpos($this->basename, '.');
            if ($dotPlace !== false) $extension = substr($this->basename, $dotPlace + 1);
            else $extension = '';
            $this->extension = $extension;

            $parentSep = strrpos($this->path, '/');
            if ($parentSep !== false) {
                $parent = substr($this->path, 0, $parentSep);
            } else $parent = '/';
            $this->parent = base64_encode($parent);

            $isEditable = $editable[$extension] ?? false;
            $content = false;
            if ($isEditable) {
                $content = $file->read();
            }

            if ($isEditable && $content !== false) {
                $this->content = $content;
                $this->isEditable = true;
            } else {
                $this->isEditable = false;
            }
        }
    }

    /**
     * @return string
     */
    public function getId(): string
    {
        return base64_encode($this->path);
    }

    /**
     * @return FlyFile
     */
    public function getFile(): FlyFile
    {
        return $this->file;
    }

    /**
     * @return string
     */
    public function getPath(): string
    {
        return $this->path;
    }

    /**
     * @return int
     */
    public function getSize(): int
    {
        return $this->size;
    }

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

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

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

    /**
     * @return \DateTime
     */
    public function getDate(): \DateTime
    {
        return $this->date;
    }

    /**
     * @return int
     */
    public function getTimestamp()
    {
        return $this->timestamp;
    }

    /**
     * @return string
     */
    public function getMD5(): string
    {
        return md5($this->file->read());
    }

    /**
     * @return false|string
     */
    public function getContents()
    {
        if ($this->content !== null) return $this->content;
        return $this->file->read();
    }

    /**
     * @return false|resource
     */
    public function getStream()
    {
        return $this->file->readStream();
    }

    /**
     * @return false|string
     */
    public function getMimetype()
    {
        return $this->file->getMimetype();
    }

    /**
     * @return bool
     */
    public function isEditable(): bool
    {
        return (new MimeDetector())->isText($this->basename);
    }

    /**
     * @return array
     */
    public function toArray(): array
    {
        return [
            'basename' => $this->getBasename(),
            'contents' => $this->isEditable() ? $this->getContents() : null,
            'date' => $this->getDate()->format(DATE_ISO8601),
            'extension' => $this->getExtension(),
            'id' => $this->getId(),
            'isEditable' => $this->isEditable(),
            'mimetype' => $this->getMimetype(),
            'md5' => $this->getMD5(),
            'parent' => $this->getParent(),
            'path' => $this->getPath(),
            'size' => $this->getSize(),
            'timestamp' => $this->getTimestamp()
        ];
    }

    /**
     * @return bool
     */
    function isDir(): bool

It is generally recommended to explicitly declare the visibility for methods.

    {
        return false;
    }

    /**
     * @return bool
     */
    function isFile(): bool

It is generally recommended to explicitly declare the visibility for methods.

    {
        return true;
    }

    /**
     * @param string $path
     * @param string $parent
     * @param int $timestamp
     * @return File
     */
    public static function fromVariables(string $path, string $parent, int $timestamp): self
    {
        $file = new self;
        $file->path = $path;
        $file->parent = $parent;
        $file->timestamp = $timestamp;
        return $file;
    }
}