roxblnfk\SmartStream\Data\FileBucket

Complexity

Total Complexity

30

Size/Duplication

Total Lines	136
Duplicated Lines	0 %

Test Coverage

Coverage

94.81%

Importance

Changes	2
Bugs	2	Features	1

15 Methods

Rating	Name	Duplication	Size	Complexity
A	isInline()	0	3	1
A	hasDisposition()	0	3	1
B	fileContentType()	0	18	9
A	withInline()	0	5	1
A	setDispositionHeader()	0	11	3
A	getContentType()	0	3	1
A	isAttachment()	0	3	1
A	withContentType()	0	5	1
A	getFileName()	0	3	1
A	createFromPath()	0	3	1
A	setAttachment()	0	5	1
A	setContentType()	0	4	1
A	withAttachment()	0	5	1
A	setInline()	0	4	1
A	__construct()	0	23	6

<?php

namespace roxblnfk\SmartStream\Data;

use InvalidArgumentException;
use SplFileInfo;
use Yiisoft\Http\Header;

class FileBucket extends DataBucket
{
    public const TYPE_OCTET_STREAM = 'application/octet-stream';

    protected const DISPOSITION_INLINE = 'inline';
    protected const DISPOSITION_ATTACHMENT = 'attachment';

    protected const IS_CONVERTABLE = false;
    protected ?string $contentType = null;
    protected ?string $contentDisposition = null;
    protected ?string $fileName = null;

    /**
     * FileBucket constructor.
     * @param string|resource|SplFileInfo $data
     * @param null|string $contentType
     * @param null|string $fileName
     * @throws \Exception
     */
    public function __construct($data, string $contentType = null, string $fileName = null)
    {
        switch (true) {
            case $data instanceof SplFileInfo:
                $fileName = $fileName ?? $data->getFilename();
                $contentType = $contentType ?? $this->fileContentType($data->getPathname());
                parent::__construct($data);
                break;
            case is_string($data):
            case is_resource($data):
                parent::__construct($data);
                break;
            default:
                throw new InvalidArgumentException(
                    'The $data parameter must be a resource, a string or an instance of SplFileInfo.'
                );
        }

        if ($contentType !== null) {
            $this->setContentType($contentType);
        }
        if ($fileName !== null) {
            $this->setAttachment($fileName);
        }
    }

    public static function createFromPath(string $filePath, string $contentType = null, string $fileName = null): self
    {
        return new static(new SplFileInfo($filePath), $contentType, $fileName);
    }

    public function getContentType(): ?string
    {
        return $this->contentType;
    }
    public function getFileName(): ?string
    {
        return $this->fileName;
    }
    public function hasDisposition(): bool
    {
        return $this->contentDisposition !== null;
    }
    public function isAttachment(): bool
    {
        return $this->contentDisposition === self::DISPOSITION_ATTACHMENT;
    }
    public function isInline(): bool
    {
        return $this->contentDisposition === self::DISPOSITION_INLINE;
    }

    public function withAttachment(string $filename = null): self
    {
        $clone = clone $this;
        $clone->setAttachment($filename);
        return $clone;
    }
    public function withContentType(?string $contentType): self
    {
        $clone = clone $this;
        $clone->setContentType($contentType);
        return $clone;
    }
    public function withInline(): self
    {
        $clone = clone $this;
        $clone->setInline();
        return $clone;
    }

    protected function setContentType(?string $contentType): void
    {
        $this->contentType = $contentType;
        $this->setHeader(Header::CONTENT_TYPE, $contentType);
    }
    protected function setInline(): void
    {
        $this->contentDisposition = self::DISPOSITION_INLINE;
        $this->setDispositionHeader();
    }
    final protected function setAttachment(?string $fileName): void
    {
        $this->contentDisposition = self::DISPOSITION_ATTACHMENT;
        $this->fileName = $fileName;
        $this->setDispositionHeader();
    }
    final protected function setDispositionHeader(): void
    {
        $headerBody = ($this->contentDisposition === self::DISPOSITION_ATTACHMENT && $this->fileName !== null)
            ? sprintf(
                '%s; filename="%s"; filename*=UTF-8\'\'%s',
                $this->contentDisposition,
                preg_replace('/[\x00-\x1F\x7F\"]/', ' ', $this->fileName),
                rawurlencode($this->fileName)
            )
            : $this->contentDisposition;
        $this->setHeader(Header::CONTENT_DISPOSITION, $headerBody);
    }
    private function fileContentType(?string $filePath): ?string
    {
        if ($filePath === null || !is_file($filePath) || !is_readable($filePath)) {
            return null;
        }
        $result = null;
        try {
            if (function_exists('finfo_open')) {
                $finfo = finfo_open(FILEINFO_MIME_TYPE);
                $result = finfo_file($finfo, $filePath);
                if (is_string($result)) {
                    return $result;
                }
            }
            $result = $result ?? (function_exists('mime_content_type') ? mime_content_type($filePath) : null);
            return is_string($result) ? $result : null;
        } catch (\Throwable $e) {
            return null;
        }
    }
}