Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilder

Complexity

Total Complexity

18

Size/Duplication

Total Lines	216
Duplicated Lines	0 %

Test Coverage

Coverage

91.55%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getDateObject()	0	3	1
A	randomPath()	0	13	3
A	pathForVariant()	0	3	1
A	path()	0	3	1
A	__construct()	0	6	2
A	filename()	0	16	3
A	buildPath()	0	39	4
A	parseTemplate()	0	13	1
A	randomPathSha1()	0	11	2

<?php

/**
 * Copyright (c) Florian Krämer (https://florian-kraemer.net)
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright Copyright (c) Florian Krämer (https://florian-kraemer.net)
 * @author    Florian Krämer
 * @link      https://github.com/Phauthentic
 * @license   https://opensource.org/licenses/MIT MIT License
 */

declare(strict_types=1);

namespace Phauthentic\Infrastructure\Storage\PathBuilder;

use DateTime;
use DateTimeInterface;
use InvalidArgumentException;
use Phauthentic\Infrastructure\Storage\FileInterface;
use Phauthentic\Infrastructure\Storage\Utility\FilenameSanitizer;
use Phauthentic\Infrastructure\Storage\Utility\FilenameSanitizerInterface;
use Phauthentic\Infrastructure\Storage\Utility\PathInfo;

/**
 * A path builder is an utility class that generates a path and filename for a
 * file storage entity. All the fields from the entity can bed used to create
 * a path and file name.
 */
class PathBuilder implements PathBuilderInterface
{
    /**
     * Default settings.
     *
     * @var array
     */
    protected array $defaultConfig = [
        'directorySeparator' => DIRECTORY_SEPARATOR,
        'randomPath' => 'sha1',
        'sanitizeFilename' => true,
        'beautifyFilename' => false,
        'sanitizer' => null,
        'pathTemplate' => '{model}{ds}{randomPath}{ds}{strippedId}{ds}{filename}.{extension}',
        'variantPathTemplate' => '{model}{ds}{randomPath}{ds}{strippedId}{ds}{filename}.{hashedVariant}.{extension}',
        'dateFormat' => [
            'year' => 'Y',
            'month' => 'm',
            'day' => 'd',
            'hour' => 'H',
            'minute' => 'i',
            'custom' => 'Y-m-d'
        ]
    ];

    /**
     * @var array
     */
    protected array $config = [];

    /**
     * @var \Phauthentic\Infrastructure\Storage\Utility\FilenameSanitizerInterface
     */
    protected FilenameSanitizerInterface $filenameSanitizer;

    /**
     * Constructor
     *
     * @param array $config Configuration options.
     */
    public function __construct(array $config = [])
    {
        $this->config = array_merge($this->defaultConfig, $config);

        if (!$this->config['sanitizer'] instanceof FilenameSanitizerInterface) {
            $this->filenameSanitizer = new FilenameSanitizer();
        }
    }

    /**
     * Builds the path under which the data gets stored in the storage adapter.
     *
     * @param \Phauthentic\Infrastructure\Storage\FileInterface $file
     * @param array $options Options
     * @return string
     */
    public function path(FileInterface $file, array $options = []): string
    {
        return $this->buildPath($file, null, $options);
    }

    /**
     * @inheritDoc
     */
    public function pathForVariant(FileInterface $file, string $variant, array $options = []): string
    {
        return $this->buildPath($file, $variant, $options);
    }

    /**
     * @param \Phauthentic\Infrastructure\Storage\FileInterface $file
     * @param array $options Options
     * @return string
     */
    protected function filename(FileInterface $file, array $options = []): string
    {
        $config = array_merge($this->config, $options);

        $pathInfo = PathInfo::for($file->filename());
        $filename = $pathInfo->filename();

        if ($config['sanitizeFilename'] === true) {
            $filename = $this->filenameSanitizer->sanitize($pathInfo->filename());
        }

        if ($config['beautifyFilename'] === true) {
            $filename = $this->filenameSanitizer->beautify($pathInfo->filename());
        }

        return $filename;
    }

    /**
     * Creates a semi-random path based on a string.
     *
     * Makes it possible to overload this functionality.
     *
     * @param string $string Input string
     * @param int $level Depth of the path to generate.
     * @param string $method Hash method, crc32 or sha1.
     * @throws \InvalidArgumentException
     * @return string
     */
    protected function randomPath($string, $level = 3, $method = 'sha1'): string
    {
        if ($method === 'sha1') {
            return $this->randomPathSha1($string, $level);
        }

        if (is_callable($method)) {
            return $method($string, $level);
        }

        throw new InvalidArgumentException(sprintf(
            'BasepathBuilder::randomPath() invalid hash `%s` method provided!',
            $method
        ));
    }

    /**
     * Creates a semi-random path based on a string.
     *
     * Makes it possible to overload this functionality.
     *
     * @param string $string Input string
     * @param int $level Depth of the path to generate.
     * @return string
     */
    protected function randomPathSha1(string $string, int $level): string
    {
        $result = sha1($string);
        $randomString = '';
        $counter = 0;
        for ($i = 1; $i <= $level; $i++) {
            $counter += 2;
            $randomString .= substr($result, $counter, 2) . DIRECTORY_SEPARATOR;
        }

        return substr($randomString, 0, -1);
    }

    /**
     * Override this methods if you want or need another object
     *
     * @return \DateTimeInterface
     */
    protected function getDateObject(): DateTimeInterface
    {
        return new DateTime();
    }

    /**
     * @inheritDoc
     */
    protected function buildPath(FileInterface $file, ?string $variant, array $options = []): string
    {
        $config = array_merge($this->config, $options);
        $ds = $this->config['directorySeparator'];
        $filename = $this->filename($file, $options);
        $hashedVariant = substr(hash('sha1', (string)$variant), 0, 6);
        $template = $variant ? $config['variantPathTemplate'] : $config['pathTemplate'];
        $dateTime = $this->getDateObject();

        $placeholders = [
            '{ds}' => $ds,
            '{model}' => $file->model(),
            '{collection}' => $file->collection(),
            '{id}' => $file->uuid(),
            '{randomPath}' => $this->randomPath($file->uuid()),
            '{modelId}' => $file->modelId(),
            '{strippedId}' => str_replace('-', '', $file->uuid()),
            '{extension}' => $file->extension(),
            '{mimeType}' => $file->mimeType(),
            '{filename}' => $filename,
            '{hashedFilename}' => sha1($filename),
            '{variant}' => $variant,
            '{hashedVariant}' => $hashedVariant,
            '{year}' => $dateTime->format($config['dateFormat']['year']),
            '{month}' => $dateTime->format($config['dateFormat']['month']),
            '{day}' => $dateTime->format($config['dateFormat']['day']),
            '{hour}' => $dateTime->format($config['dateFormat']['hour']),
            '{minute}' => $dateTime->format($config['dateFormat']['minute']),
            '{date}' => $dateTime->format($config['dateFormat']['custom']),
        ];

        $result = $this->parseTemplate($placeholders, $template, $ds);

        $pathInfo = PathInfo::for($result);
        if (!$pathInfo->hasExtension() && substr($result, -1) === '.') {
            return substr($result, 0, -1);
        }

        return $result;
    }

    /**
     * Parses the path string template
     *
     * @param array $placeholders Assoc array of placeholder to value
     * @param string $template Template string
     * @param string $separator Directory Separator
     * @return string
     */
    protected function parseTemplate(
        array $placeholders,
        string $template,
        string $separator
    ): string {
        $result = str_replace(
            array_keys($placeholders),
            array_values($placeholders),
            $template
        );

        // Remove double or more separators caused by empty template vars
        return  preg_replace('/(\\\{2,})|(\/{2,})/', $separator, $result);
    }
}