PathBuilder::randomPathSha1() - Code Metrics - Inspection of "Adding callbacks back, improved documentation" - Phauthentic/file-storage - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#7)

by Florian

created 2020-11-02 23:21 UTC

PathBuilder::randomPathSha1() A

↳ Parent: PathBuilder

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	7
c	1
b	0
f	0
nc	2
nop	2
dl	0
loc	11
ccs	8
cts	8
cp	1
crap	2
rs	10

<?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();
        }
    }

    /**
     * @param string $template Template string
     * @return self
     */
    public function setPathTemplate(string $template): self
    {
        $this->config['pathTemplate'] = $template;

        return $this;
    }

    /**
     * @param string $template Template string
     * @return self
     */
    public function setVariantPathTemplate(string $template): self
    {
        $this->config['variantPathTemplate'] = $template;

        return $this;
    }

    /**
     * @param string $format Date format
     * @return self
     */
    public function setCustomDateFormat(string $format): self
    {
        $this->config['dateFormat']['custom'] = $format;

        return $this;
    }

    /**
     * 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);
    }
}


1		<?php
2
3		/**
4		* Copyright (c) Florian Krämer (https://florian-kraemer.net)
5		* Licensed under The MIT License
6		* For full copyright and license information, please see the LICENSE.txt
7		* Redistributions of files must retain the above copyright notice.
8		*
9		* @copyright Copyright (c) Florian Krämer (https://florian-kraemer.net)
10		* @author Florian Krämer
11		* @link https://github.com/Phauthentic
12		* @license https://opensource.org/licenses/MIT MIT License
13		*/
14
15		declare(strict_types=1);
16
17		namespace Phauthentic\Infrastructure\Storage\PathBuilder;
18
19		use DateTime;
20		use DateTimeInterface;
21		use InvalidArgumentException;
22		use Phauthentic\Infrastructure\Storage\FileInterface;
23		use Phauthentic\Infrastructure\Storage\Utility\FilenameSanitizer;
24		use Phauthentic\Infrastructure\Storage\Utility\FilenameSanitizerInterface;
25		use Phauthentic\Infrastructure\Storage\Utility\PathInfo;
26
27		/**
28		* A path builder is an utility class that generates a path and filename for a
29		* file storage entity. All the fields from the entity can bed used to create
30		* a path and file name.
31		*/
32		class PathBuilder implements PathBuilderInterface
33		{
34		/**
35		* Default settings.
36		*
37		* @var array
38		*/
39		protected array $defaultConfig = [
40		'directorySeparator' => DIRECTORY_SEPARATOR,
41		'randomPath' => 'sha1',
42		'sanitizeFilename' => true,
43		'beautifyFilename' => false,
44		'sanitizer' => null,
45		'pathTemplate' => '{model}{ds}{randomPath}{ds}{strippedId}{ds}{filename}.{extension}',
46		'variantPathTemplate' => '{model}{ds}{randomPath}{ds}{strippedId}{ds}{filename}.{hashedVariant}.{extension}',
47		'dateFormat' => [
48		'year' => 'Y',
49		'month' => 'm',
50		'day' => 'd',
51		'hour' => 'H',
52		'minute' => 'i',
53		'custom' => 'Y-m-d'
54		]
55		];
56
57		/**
58		* @var array
59		*/
60		protected array $config = [];
61
62		/**
63		* @var \Phauthentic\Infrastructure\Storage\Utility\FilenameSanitizerInterface
64		*/
65		protected FilenameSanitizerInterface $filenameSanitizer;
66
67		/**
68		* Constructor
69		*
70		* @param array $config Configuration options.
71		*/
72	7	public function __construct(array $config = [])
73		{
74	7	$this->config = array_merge($this->defaultConfig, $config);
75
76	7	if (!$this->config['sanitizer'] instanceof FilenameSanitizerInterface) {
77	7	$this->filenameSanitizer = new FilenameSanitizer();
78		}
79	7	}
80
81		/**
82		* @param string $template Template string
83		* @return self
84		*/
85		public function setPathTemplate(string $template): self
86		{
87		$this->config['pathTemplate'] = $template;
88
89		return $this;
90		}
91
92		/**
93		* @param string $template Template string
94		* @return self
95		*/
96		public function setVariantPathTemplate(string $template): self
97		{
98		$this->config['variantPathTemplate'] = $template;
99
100		return $this;
101		}
102
103		/**
104		* @param string $format Date format
105		* @return self
106		*/
107		public function setCustomDateFormat(string $format): self
108		{
109		$this->config['dateFormat']['custom'] = $format;
110
111		return $this;
112		}
113
114		/**
115		* Builds the path under which the data gets stored in the storage adapter.
116		*
117		* @param \Phauthentic\Infrastructure\Storage\FileInterface $file
118		* @param array $options Options
119		* @return string
120		*/
121	6	public function path(FileInterface $file, array $options = []): string
122		{
123	6	return $this->buildPath($file, null, $options);
124		}
125
126		/**
127		* @inheritDoc
128		*/
129	2	public function pathForVariant(FileInterface $file, string $variant, array $options = []): string
130		{
131	2	return $this->buildPath($file, $variant, $options);
132		}
133
134		/**
135		* @param \Phauthentic\Infrastructure\Storage\FileInterface $file
136		* @param array $options Options
137		* @return string
138		*/
139	7	protected function filename(FileInterface $file, array $options = []): string
140		{
141	7	$config = array_merge($this->config, $options);
142
143	7	$pathInfo = PathInfo::for($file->filename());
144	7	$filename = $pathInfo->filename();
145
146	7	if ($config['sanitizeFilename'] === true) {
147	7	$filename = $this->filenameSanitizer->sanitize($pathInfo->filename());
148		}
149
150	7	if ($config['beautifyFilename'] === true) {
151		$filename = $this->filenameSanitizer->beautify($pathInfo->filename());
152		}
153
154	7	return $filename;
155		}
156
157		/**
158		* Creates a semi-random path based on a string.
159		*
160		* Makes it possible to overload this functionality.
161		*
162		* @param string $string Input string
163		* @param int $level Depth of the path to generate.
164		* @param string $method Hash method, crc32 or sha1.
165		* @throws \InvalidArgumentException
166		* @return string
167		*/
168	7	protected function randomPath($string, $level = 3, $method = 'sha1'): string
169		{
170	7	if ($method === 'sha1') {
171	7	return $this->randomPathSha1($string, $level);
172		}
173
174		if (is_callable($method)) {
175		return $method($string, $level);
176		}
177
178		throw new InvalidArgumentException(sprintf(
179		'BasepathBuilder::randomPath() invalid hash `%s` method provided!',
180		$method
181		));
182		}
183
184		/**
185		* Creates a semi-random path based on a string.
186		*
187		* Makes it possible to overload this functionality.
188		*
189		* @param string $string Input string
190		* @param int $level Depth of the path to generate.
191		* @return string
192		*/
193	7	protected function randomPathSha1(string $string, int $level): string
194		{
195	7	$result = sha1($string);
196	7	$randomString = '';
197	7	$counter = 0;
198	7	for ($i = 1; $i <= $level; $i++) {
199	7	$counter += 2;
200	7	$randomString .= substr($result, $counter, 2) . DIRECTORY_SEPARATOR;
201		}
202
203	7	return substr($randomString, 0, -1);
204		}
205
206		/**
207		* Override this methods if you want or need another object
208		*
209		* @return \DateTimeInterface
210		*/
211	6	protected function getDateObject(): DateTimeInterface
212		{
213	6	return new DateTime();
214		}
215
216		/**
217		* @inheritDoc
218		*/
219	7	protected function buildPath(FileInterface $file, ?string $variant, array $options = []): string
220		{
221	7	$config = array_merge($this->config, $options);
222	7	$ds = $this->config['directorySeparator'];
223	7	$filename = $this->filename($file, $options);
224	7	$hashedVariant = substr(hash('sha1', (string)$variant), 0, 6);
225	7	$template = $variant ? $config['variantPathTemplate'] : $config['pathTemplate'];
226	7	$dateTime = $this->getDateObject();
227
228		$placeholders = [
229	7	'{ds}' => $ds,
230	7	'{model}' => $file->model(),
231	7	'{collection}' => $file->collection(),
232	7	'{id}' => $file->uuid(),
233	7	'{randomPath}' => $this->randomPath($file->uuid()),
234	7	'{modelId}' => $file->modelId(),
235	7	'{strippedId}' => str_replace('-', '', $file->uuid()),
236	7	'{extension}' => $file->extension(),
237	7	'{mimeType}' => $file->mimeType(),
238	7	'{filename}' => $filename,
239	7	'{hashedFilename}' => sha1($filename),
240	7	'{variant}' => $variant,
241	7	'{hashedVariant}' => $hashedVariant,
242	7	'{year}' => $dateTime->format($config['dateFormat']['year']),
243	7	'{month}' => $dateTime->format($config['dateFormat']['month']),
244	7	'{day}' => $dateTime->format($config['dateFormat']['day']),
245	7	'{hour}' => $dateTime->format($config['dateFormat']['hour']),
246	7	'{minute}' => $dateTime->format($config['dateFormat']['minute']),
247	7	'{date}' => $dateTime->format($config['dateFormat']['custom']),
248		];
249
250	7	$result = $this->parseTemplate($placeholders, $template, $ds);
251
252	7	$pathInfo = PathInfo::for($result);
253	7	if (!$pathInfo->hasExtension() && substr($result, -1) === '.') {
254		return substr($result, 0, -1);
255		}
256
257	7	return $result;
258		}
259
260		/**
261		* Parses the path string template
262		*
263		* @param array $placeholders Assoc array of placeholder to value
264		* @param string $template Template string
265		* @param string $separator Directory Separator
266		* @return string
267		*/
268	7	protected function parseTemplate(
269		array $placeholders,
270		string $template,
271		string $separator
272		): string {
273	7	$result = str_replace(
274	7	array_keys($placeholders),
275	7	array_values($placeholders),
276		$template
277		);
278
279		// Remove double or more separators caused by empty template vars
280	7	return preg_replace('/(\\\{2,})\|(\/{2,})/', $separator, $result);
281		}
282		}
283

Phauthentic / file-storage

Pull Request — master (#7)

PathBuilder::randomPathSha1() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like