Product::loadMeta() - Code Metrics - Inspection of "Merge branch 'release/2.0.0'" - reliqarts/laravel-docweaver - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3fdc21...2574b5 )

by ReliQ

created 2019-03-23 20:58 UTC

Product::loadMeta() B

↳ Parent: Product

Complexity

Conditions	6
Paths	32

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	31
rs	8.8017
c	0
b	0
f	0
cc	6
nc	32
nop	1

<?php

declare(strict_types=1);

namespace ReliqArts\Docweaver\Models;

use Carbon\Carbon;
use Illuminate\Contracts\Support\Arrayable;
use Illuminate\Contracts\Support\Jsonable;
use Illuminate\Support\Str;
use ReliqArts\Docweaver\Contracts\ConfigProvider;
use ReliqArts\Docweaver\Contracts\Exception;
use ReliqArts\Docweaver\Contracts\Filesystem;
use ReliqArts\Docweaver\Exceptions\ParsingFailed;
use ReliqArts\Docweaver\Exceptions\Product\AssetPublicationFailed;
use ReliqArts\Docweaver\Exceptions\Product\InvalidAssetDirectory;
use Symfony\Component\Yaml\Exception\ParseException;
use Symfony\Component\Yaml\Yaml;

/**
 * A documented product.
 */
class Product implements Arrayable, Jsonable
{
    public const VERSION_MASTER = 'master';
    public const VERSION_UNKNOWN = 'unknown';

    private const ASSET_URL_PLACEHOLDER_1 = '{{docs}}';
    private const ASSET_URL_PLACEHOLDER_2 = '{{doc}}';
    private const ASSET_URL_PLACEHOLDERS = [
        self::ASSET_URL_PLACEHOLDER_1,
        self::ASSET_URL_PLACEHOLDER_2,
    ];
    private const META_FILE = '.docweaver.yml';

    /**
     * Product key.
     *
     * @var string
     */
    private $key;

    /**
     * Filesystem.
     *
     * @var Filesystem
     */
    private $filesystem;

    /**
     * @var ConfigProvider
     */
    private $configProvider;

    /**
     * Last time product was modified (timestamp).
     *
     * @var int
     */
    private $lastModified;

    /**
     * Product name.
     *
     * @var string
     */
    private $name;

    /**
     * Product description.
     *
     * @var null|string
     */
    private $description;

    /**
     * Product image url.
     *
     * @var null|string
     */
    private $imageUrl;

    /**
     * Product resource directory.
     *
     * @var string
     */
    private $directory;

    /**
     * Product meta (from file).
     *
     * @var array
     */
    private $meta;

    /**
     * List of available product versions.
     *
     * @var array
     */
    private $versions;

    /**
     * Create product instance.
     *
     * @param Filesystem     $filesystem
     * @param ConfigProvider $configProvider
     * @param string         $directory
     */
    public function __construct(Filesystem $filesystem, ConfigProvider $configProvider, string $directory)
    {
        $this->filesystem = $filesystem;
        $this->configProvider = $configProvider;
        $this->name = Str::title(basename($directory));
        $this->key = strtolower($this->name);
        $this->directory = $directory;
        $this->meta = [];
        $this->versions = [];
    }

    /**
     * Populate product.
     *
     * @throws Exception if meta file could not be parsed
     */
    public function populate(): void
    {
        $this->loadVersions();
        $this->loadMeta();
    }

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

    /**
     * Get default version for product.
     *
     * @param bool $allowWordedDefault whether a worded version should be accepted as default
     *
     * @return string
     */
    public function getDefaultVersion(bool $allowWordedDefault = false): string
    {
        $versions = empty($this->versions) ? $this->getVersions() : $this->versions;
        $allowWordedDefault = $allowWordedDefault || $this->configProvider->isWordedDefaultVersionAllowed();
        $defaultVersion = self::VERSION_UNKNOWN;

        foreach ($versions as $tag => $ver) {
            if (!$allowWordedDefault) {
                if (is_numeric($tag)) {
                    $defaultVersion = $tag;

                    break;
                }
            } else {
                $defaultVersion = $tag;

                break;
            }
        }

        return $defaultVersion;
    }

    /**
     * Get product directory.
     *
     * @return string
     */
    public function getDirectory(): string
    {
        return $this->directory;
    }

    /**
     * Get product name.
     *
     * @return string
     */
    public function getName(): string
    {
        return $this->name;
    }

    /**
     * Get product description.
     *
     * @return null|string
     */
    public function getDescription(): ?string
    {
        return $this->description;
    }

    /**
     * Get product image url.
     *
     * @return null|string
     */
    public function getImageUrl(): ?string
    {
        return $this->imageUrl;
    }

    /**
     * Get the publicly available versions of the product.
     *
     * @return array
     */
    public function getVersions(): array
    {
        return $this->versions;
    }

    /**
     * Get last modified time.
     *
     * @return Carbon
     */
    public function getLastModified(): Carbon
    {
        return Carbon::createFromTimestamp($this->lastModified);
    }

    /**
     * Determine if the given string is a valid version.
     *
     * @param string $version
     *
     * @return bool
     */
    public function hasVersion(string $version): bool
    {
        return in_array($version, array_keys($this->getVersions()), true);
    }

    /**
     * Publish product public assets.
     *
     * @param string $version
     *
     * @throws Exception if products asset directory is invalid or assets could not be published
     */
    public function publishAssets(string $version): void
    {
        $version = empty($version) ? $this->getDefaultVersion() : $version;
        $storagePath = storage_path(
            sprintf('app/public/%s/%s/%s', $this->configProvider->getRoutePrefix(), $this->key, $version)
        );
        $imageDirectory = sprintf('%s/%s/images', $this->directory, $version);

        if (!$this->filesystem->isDirectory($imageDirectory)) {
            throw InvalidAssetDirectory::forDirectory($imageDirectory);
        }

        if (!$this->filesystem->copyDirectory($imageDirectory, sprintf('%s/images', $storagePath))) {
            throw AssetPublicationFailed::forProductAssetsOfType($this, 'image');
        }
    }

    /**
     * Get the instance as an array.
     *
     * @return array
     */
    public function toArray(): array
    {
        return [
            'key' => $this->key,
            'name' => $this->name,
            'description' => $this->description,
            'imageUrl' => $this->imageUrl,
            'directory' => $this->directory,
            'versions' => $this->versions,
            'defaultVersion' => $this->getDefaultVersion(),
            'lastModified' => $this->getLastModified(),
        ];
    }

    /**
     * Convert the object to its JSON representation.
     *
     * @param int $options
     *
     * @return string
     */
    public function toJson($options = 0): string
    {
        return json_encode($this->toArray());
    }

    /**
     * @return string
     */
    public function getMasterDirectory(): string
    {
        return sprintf('%s/%s', $this->getDirectory(), Product::VERSION_MASTER);
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
    }

    /**
     * Convert url string to asset url relative to current product.
     *
     * @param string $url
     * @param string $version
     *
     * @return string
     */
    private function getAssetUrl(string $url, string $version): string
    {
        $url = empty($url) ? self::ASSET_URL_PLACEHOLDER_1 : $url;

        if (stripos($url, 'http') === 0) {
            return $url;
        }

        return asset(
            str_replace(
                self::ASSET_URL_PLACEHOLDERS,
                sprintf('storage/%s/%s/%s', $this->configProvider->getRoutePrefix(), $this->key, $version),
                $url
            )
        );
    }

    /**
     * Load meta onto product.
     *
     * @param string $version Version to load configuration from. (optional)

     *
     * @throws Exception if meta file could not be parsed
     */
    private function loadMeta(string $version = null): void
    {
        $version = empty($version) ? $this->getDefaultVersion() : $version;
        $metaFile = realpath(sprintf('%s/%s/%s', $this->directory, $version, self::META_FILE));

        if (empty($metaFile)) {
            return;
        }

        try {
            $meta = Yaml::parse(file_get_contents($metaFile));

            if (!empty($meta['name'])) {
                $this->name = $meta['name'];
            }
            if (!empty($meta['description'])) {
                $this->description = $meta['description'];
            }

            $this->imageUrl = $this->getAssetUrl($meta['image_url'] ?? '', $version);
            $this->meta = $meta;
        } catch (ParseException $exception) {
            $message = sprintf(
                'Failed to parse meta file `%s`. %s',
                $metaFile,
                $exception->getMessage()
            );

            throw ParsingFailed::forFile($metaFile)->withMessage($message);
        }
    }

    /**
     * Load product versions.
     */
    private function loadVersions(): void
    {
        $versions = [];

        if ($this->key) {
            $versionDirs = $this->filesystem->directories($this->directory);

            // add versions to version array
            foreach ($versionDirs as $ver) {
                $versionTag = basename($ver);
                $versionName = Str::title($versionTag);
                $versions[$versionTag] = $versionName;
            }

            // update last modified
            $this->lastModified = $this->filesystem->lastModified($this->directory);

            // sort versions
            krsort($versions);
        }

        $this->versions = $versions;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace ReliqArts\Docweaver\Models;
6
7			use Carbon\Carbon;
8			use Illuminate\Contracts\Support\Arrayable;
9			use Illuminate\Contracts\Support\Jsonable;
10			use Illuminate\Support\Str;
11			use ReliqArts\Docweaver\Contracts\ConfigProvider;
12			use ReliqArts\Docweaver\Contracts\Exception;
13			use ReliqArts\Docweaver\Contracts\Filesystem;
14			use ReliqArts\Docweaver\Exceptions\ParsingFailed;
15			use ReliqArts\Docweaver\Exceptions\Product\AssetPublicationFailed;
16			use ReliqArts\Docweaver\Exceptions\Product\InvalidAssetDirectory;
17			use Symfony\Component\Yaml\Exception\ParseException;
18			use Symfony\Component\Yaml\Yaml;
19
20			/**
21			* A documented product.
22			*/
23			class Product implements Arrayable, Jsonable
24			{
25			public const VERSION_MASTER = 'master';
26			public const VERSION_UNKNOWN = 'unknown';
27
28			private const ASSET_URL_PLACEHOLDER_1 = '{{docs}}';
29			private const ASSET_URL_PLACEHOLDER_2 = '{{doc}}';
30			private const ASSET_URL_PLACEHOLDERS = [
31			self::ASSET_URL_PLACEHOLDER_1,
32			self::ASSET_URL_PLACEHOLDER_2,
33			];
34			private const META_FILE = '.docweaver.yml';
35
36			/**
37			* Product key.
38			*
39			* @var string
40			*/
41			private $key;
42
43			/**
44			* Filesystem.
45			*
46			* @var Filesystem
47			*/
48			private $filesystem;
49
50			/**
51			* @var ConfigProvider
52			*/
53			private $configProvider;
54
55			/**
56			* Last time product was modified (timestamp).
57			*
58			* @var int
59			*/
60			private $lastModified;
61
62			/**
63			* Product name.
64			*
65			* @var string
66			*/
67			private $name;
68
69			/**
70			* Product description.
71			*
72			* @var null\|string
73			*/
74			private $description;
75
76			/**
77			* Product image url.
78			*
79			* @var null\|string
80			*/
81			private $imageUrl;
82
83			/**
84			* Product resource directory.
85			*
86			* @var string
87			*/
88			private $directory;
89
90			/**
91			* Product meta (from file).
92			*
93			* @var array
94			*/
95			private $meta;
96
97			/**
98			* List of available product versions.
99			*
100			* @var array
101			*/
102			private $versions;
103
104			/**
105			* Create product instance.
106			*
107			* @param Filesystem $filesystem
108			* @param ConfigProvider $configProvider
109			* @param string $directory
110			*/
111			public function __construct(Filesystem $filesystem, ConfigProvider $configProvider, string $directory)
112			{
113			$this->filesystem = $filesystem;
114			$this->configProvider = $configProvider;
115			$this->name = Str::title(basename($directory));
116			$this->key = strtolower($this->name);
117			$this->directory = $directory;
118			$this->meta = [];
119			$this->versions = [];
120			}
121
122			/**
123			* Populate product.
124			*
125			* @throws Exception if meta file could not be parsed
126			*/
127			public function populate(): void
128			{
129			$this->loadVersions();
130			$this->loadMeta();
131			}
132
133			/**
134			* @return string
135			*/
136			public function getKey(): string
137			{
138			return $this->key;
139			}
140
141			/**
142			* Get default version for product.
143			*
144			* @param bool $allowWordedDefault whether a worded version should be accepted as default
145			*
146			* @return string
147			*/
148			public function getDefaultVersion(bool $allowWordedDefault = false): string
149			{
150			$versions = empty($this->versions) ? $this->getVersions() : $this->versions;
151			$allowWordedDefault = $allowWordedDefault \|\| $this->configProvider->isWordedDefaultVersionAllowed();
152			$defaultVersion = self::VERSION_UNKNOWN;
153
154			foreach ($versions as $tag => $ver) {
155			if (!$allowWordedDefault) {
156			if (is_numeric($tag)) {
157			$defaultVersion = $tag;
158
159			break;
160			}
161			} else {
162			$defaultVersion = $tag;
163
164			break;
165			}
166			}
167
168			return $defaultVersion;
169			}
170
171			/**
172			* Get product directory.
173			*
174			* @return string
175			*/
176			public function getDirectory(): string
177			{
178			return $this->directory;
179			}
180
181			/**
182			* Get product name.
183			*
184			* @return string
185			*/
186			public function getName(): string
187			{
188			return $this->name;
189			}
190
191			/**
192			* Get product description.
193			*
194			* @return null\|string
195			*/
196			public function getDescription(): ?string
197			{
198			return $this->description;
199			}
200
201			/**
202			* Get product image url.
203			*
204			* @return null\|string
205			*/
206			public function getImageUrl(): ?string
207			{
208			return $this->imageUrl;
209			}
210
211			/**
212			* Get the publicly available versions of the product.
213			*
214			* @return array
215			*/
216			public function getVersions(): array
217			{
218			return $this->versions;
219			}
220
221			/**
222			* Get last modified time.
223			*
224			* @return Carbon
225			*/
226			public function getLastModified(): Carbon
227			{
228			return Carbon::createFromTimestamp($this->lastModified);
229			}
230
231			/**
232			* Determine if the given string is a valid version.
233			*
234			* @param string $version
235			*
236			* @return bool
237			*/
238			public function hasVersion(string $version): bool
239			{
240			return in_array($version, array_keys($this->getVersions()), true);
241			}
242
243			/**
244			* Publish product public assets.
245			*
246			* @param string $version
247			*
248			* @throws Exception if products asset directory is invalid or assets could not be published
249			*/
250			public function publishAssets(string $version): void
251			{
252			$version = empty($version) ? $this->getDefaultVersion() : $version;
253			$storagePath = storage_path(
254			sprintf('app/public/%s/%s/%s', $this->configProvider->getRoutePrefix(), $this->key, $version)
255			);
256			$imageDirectory = sprintf('%s/%s/images', $this->directory, $version);
257
258			if (!$this->filesystem->isDirectory($imageDirectory)) {
259			throw InvalidAssetDirectory::forDirectory($imageDirectory);
260			}
261
262			if (!$this->filesystem->copyDirectory($imageDirectory, sprintf('%s/images', $storagePath))) {
263			throw AssetPublicationFailed::forProductAssetsOfType($this, 'image');
264			}
265			}
266
267			/**
268			* Get the instance as an array.
269			*
270			* @return array
271			*/
272			public function toArray(): array
273			{
274			return [
275			'key' => $this->key,
276			'name' => $this->name,
277			'description' => $this->description,
278			'imageUrl' => $this->imageUrl,
279			'directory' => $this->directory,
280			'versions' => $this->versions,
281			'defaultVersion' => $this->getDefaultVersion(),
282			'lastModified' => $this->getLastModified(),
283			];
284			}
285
286			/**
287			* Convert the object to its JSON representation.
288			*
289			* @param int $options
290			*
291			* @return string
292			*/
293			public function toJson($options = 0): string
294			{
295			return json_encode($this->toArray());
296			}
297
298			/**
299			* @return string
300			*/
301			public function getMasterDirectory(): string
302			{
303			return sprintf('%s/%s', $this->getDirectory(), Product::VERSION_MASTER);
			0 ignored issues – show Coding Style introduced 2019-03-20 21:50 UTC by Report Bug Copy Issue Report As per coding style, `self` should be used for accessing local static members. This check looks for accesses to local static members using the fully qualified name instead of `self::`. <?php class Certificate { const TRIPLEDES_CBC = 'ASDFGHJKL'; private $key; public function __construct() { $this->key = Certificate::TRIPLEDES_CBC; } } While this is perfectly valid, the fully qualified name of `Certificate::TRIPLEDES_CBC` could just as well be replaced by `self::TRIPLEDES_CBC`. Referencing local members with `self::` assured the access will still work when the class is renamed, makes it perfectly clear that the member is in fact local and will usually be shorter. Loading history...
304			}
305
306			/**
307			* Convert url string to asset url relative to current product.
308			*
309			* @param string $url
310			* @param string $version
311			*
312			* @return string
313			*/
314			private function getAssetUrl(string $url, string $version): string
315			{
316			$url = empty($url) ? self::ASSET_URL_PLACEHOLDER_1 : $url;
317
318			if (stripos($url, 'http') === 0) {
319			return $url;
320			}
321
322			return asset(
323			str_replace(
324			self::ASSET_URL_PLACEHOLDERS,
325			sprintf('storage/%s/%s/%s', $this->configProvider->getRoutePrefix(), $this->key, $version),
326			$url
327			)
328			);
329			}
330
331			/**
332			* Load meta onto product.
333			*
334			* @param string $version Version to load configuration from. (optional)
			0 ignored issues – show Documentation introduced 2019-03-03 01:41 UTC by Report Bug Copy Issue Report Should the type for parameter `$version` not be `null\|string`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
335			*
336			* @throws Exception if meta file could not be parsed
337			*/
338			private function loadMeta(string $version = null): void
339			{
340			$version = empty($version) ? $this->getDefaultVersion() : $version;
341			$metaFile = realpath(sprintf('%s/%s/%s', $this->directory, $version, self::META_FILE));
342
343			if (empty($metaFile)) {
344			return;
345			}
346
347			try {
348			$meta = Yaml::parse(file_get_contents($metaFile));
349
350			if (!empty($meta['name'])) {
351			$this->name = $meta['name'];
352			}
353			if (!empty($meta['description'])) {
354			$this->description = $meta['description'];
355			}
356
357			$this->imageUrl = $this->getAssetUrl($meta['image_url'] ?? '', $version);
358			$this->meta = $meta;
359			} catch (ParseException $exception) {
360			$message = sprintf(
361			'Failed to parse meta file `%s`. %s',
362			$metaFile,
363			$exception->getMessage()
364			);
365
366			throw ParsingFailed::forFile($metaFile)->withMessage($message);
367			}
368			}
369
370			/**
371			* Load product versions.
372			*/
373			private function loadVersions(): void
374			{
375			$versions = [];
376
377			if ($this->key) {
378			$versionDirs = $this->filesystem->directories($this->directory);
379
380			// add versions to version array
381			foreach ($versionDirs as $ver) {
382			$versionTag = basename($ver);
383			$versionName = Str::title($versionTag);
384			$versions[$versionTag] = $versionName;
385			}
386
387			// update last modified
388			$this->lastModified = $this->filesystem->lastModified($this->directory);
389
390			// sort versions
391			krsort($versions);
392			}
393
394			$this->versions = $versions;
395			}
396			}
397

reliqarts / laravel-docweaver

Push — master ( 3fdc21...2574b5 )

Product::loadMeta() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like