Model::rawContent() - Code Metrics - Inspection of "Merge pull request #22 from roelofjan-elsinga/mode..." - roelofjan-elsinga/aloia-cms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( f717a4...f2d01f )

by Roelof Jan

created 2020-10-20 17:36 UTC

Model::rawContent() A

↳ Parent: Model

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
eloc	4
nc	2
nop	0
dl	0
loc	9
ccs	5
cts	5
cp	1
crap	2
rs	10
c	0
b	0
f	0

<?php


namespace AloiaCms\Models;

use ContentParser\ContentParser;
use AloiaCms\InlineBlockParser;
use AloiaCms\Models\Contracts\ModelInterface;
use AloiaCms\Models\Contracts\StorableInterface;
use AloiaCms\Writer\FolderCreator;
use AloiaCms\Writer\FrontMatterCreator;
use Illuminate\Support\Arr;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Config;
use Illuminate\Support\Facades\File;
use Spatie\YamlFrontMatter\YamlFrontMatter;

class Model implements ModelInterface, StorableInterface
{
    protected $folder = '';

    protected $file_name = null;

    protected $extension = 'md';

    protected $matter = [];

    protected $body = '';

    protected $required_fields = [];

    /**
     * Find a single model
     *
     * @param string $file_name
     * @return ModelInterface
     */
    public static function find(string $file_name): ModelInterface
    {
        $instance = new static();

        $instance->setFileName($file_name);

        return $instance;
    }

    /**
     * Return all instances of the model
     *
     * @return Collection|ModelInterface[]
     */
    public static function all(): Collection
    {
        $instance = new static();

        $files = File::allFiles($instance->getFolderPath());

        return Collection::make($files)
            ->map(function (\SplFileInfo $fileInfo): ModelInterface {
                return self::find(pathinfo($fileInfo->getFilename(), PATHINFO_FILENAME));
            });
    }

    /**
     * Rename this file to the given name
     *
     * @param string $new_name
     * @return Model
     */
    public function rename(string $new_name): ModelInterface
    {
        $old_file_path = $this->getFilePath();

        $this->file_name = $new_name;

        $new_file_path = $this->getFilePath();

        File::move($old_file_path, $new_file_path);

        return self::find($new_name);
    }

    /**
     * Get the raw content of the file + front matter
     *
     * @return string
     */
    public function rawContent(): string
    {
        $file_path = $this->getFilePath();

        if ($this->exists()) {
            return file_get_contents($file_path);
        }

        return "";
    }

    /**
     * Parse the file for this model into model variables
     */
    private function parseFile(): void
    {
        $parsed_file = YamlFrontMatter::parse($this->rawContent());

        $this->matter = $parsed_file->matter();
        $this->body = $parsed_file->body();
    }

    /**
     * Save this instance to file
     *
     * @return ModelInterface
     * @throws \Exception
     */
    public function save(): ModelInterface
    {
        $file_content = FrontMatterCreator::seed($this->matter, $this->body)->create();

        $this->assertFilenameExists();

        $this->assertRequiredMatterIsPresent();

        $file_path = $this->getFilePath();

        file_put_contents($file_path, $file_content);

        return $this;
    }

    /**
     * Get the file path for this instance
     *
     * @return string
     */
    private function getFilePath(): string
    {
        $folder_path = $this->getFolderPath();

        if (!is_null($matching_filepath = $this->getFileMatchFromDisk())) {
            $this->setExtension(pathinfo($matching_filepath, PATHINFO_EXTENSION));
        }

        return "{$folder_path}/{$this->file_name}.{$this->extension}";
    }

    /**
     * Get the folder path for this model
     *
     * @return string
     */
    public function getFolderPath(): string
    {
        $folder_path = Config::get('aloiacms.collections_path') . "/{$this->folder}";

        FolderCreator::forPath($folder_path);

        return $folder_path;
    }

    /**
     * Get the front matter
     *
     * @return array
     */
    public function matter(): array
    {
        return $this->matter;
    }

    /**
     * Set a value on the specified key in the configuration
     *
     * Kept around for backward compatibility
     *
     * @param string $key
     * @param $value
     * @return ModelInterface
     *
     * @deprecated since 3.2.0
     */
    public function addMatter(string $key, $value): ModelInterface
    {
        return $this->set($key, $value);
    }
    
    /**
     * Set data in the front matter, but only for the keys specified in the input array
     *
     * @param array $matter
     * @return ModelInterface
     */
    public function setMatter(array $matter): ModelInterface
    {
        foreach (array_keys($matter) as $key) {
            $this->matter[$key] = $matter[$key];
        }

        return $this;
    }

    /**
     * Determine whether a key is present in the configuration
     *
     * @param string $key
     * @return bool
     */
    public function has(string $key): bool
    {
        return isset($this->matter[$key]);
    }

    /**
     * Get the value of the specified key, return null if it doesn't exist
     *
     * @param string $key
     * @return mixed|null
     */
    public function get(string $key)
    {
        return $this->matter[$key] ?? null;
    }

    /**
     * Set a value on the specified key in the configuration
     *
     * @param string $key
     * @param $value
     * @return $this|ModelInterface
     */
    public function set(string $key, $value): ModelInterface
    {
        $this->matter[$key] = $value;

        return $this;
    }

    /**
     * Remove a key from the configuration
     *
     * @param string $key
     * @return $this|ModelInterface
     */
    public function remove(string $key): ModelInterface
    {
        if ($this->has($key)) {
            unset($this->matter[$key]);
        }

        return $this;
    }

    /**
     * Get the raw file body
     *
     * @return string
     */
    public function rawBody(): string
    {
        return $this->body;
    }

    /**
     * Get the parse file body
     *
     * @return string
     */
    public function body(): string
    {
        $content = new ContentParser($this->rawBody(), $this->extension());

        return (new InlineBlockParser)->parseHtmlString($content->parse());
    }

    /**
     * Set the file body
     *
     * @param string $body
     * @return ModelInterface
     */
    public function setBody(string $body): ModelInterface
    {
        $this->body = $body;

        return $this;
    }

    /**
     * Get the file extension
     *
     * @return string
     */
    public function extension(): string
    {
        return $this->extension;
    }

    /**
     * Set the file extension
     *
     * @param string $extension
     * @return ModelInterface
     */
    public function setExtension(string $extension): ModelInterface
    {
        $this->extension = $extension;

        return $this;
    }

    /**
     * Get the file name for this instance
     *
     * @return string
     */
    public function filename(): ?string
    {
        return $this->file_name;
    }

    /**
     * Set the file name for this instance
     *
     * @param string $file_name
     * @return ModelInterface
     */
    protected function setFileName(string $file_name): ModelInterface
    {
        $this->file_name = $file_name;

        $this->parseFile();

        return $this;
    }

    /**
     * Get all models for this type
     *
     * @return array
     */
    private function getModelFiles(): array
    {
        return File::allFiles($this->getFolderPath());
    }

    /**
     * Get the filename from disk
     *
     * @return string|null
     */
    private function getFileMatchFromDisk(): ?string
    {
        return Arr::first($this->getModelFiles(), function (string $file_name) {
            return strpos($file_name, "/{$this->file_name}.");
        });
    }

    /**
     * Determine whether the current model exists
     *
     * @return bool
     */
    public function exists(): bool
    {
        return !is_null($this->getFileMatchFromDisk());
    }

    /**
     * Delete the current model
     *
     * @return bool
     */
    public function delete(): bool
    {
        return File::delete($this->getFilePath());
    }

    /**
     * Get front matter information through an accessor
     *
     * @param $key
     * @return mixed|null
     */
    public function __get($key)
    {
        return $this->get($key);
    }

    /**
     * Throw exception when the file name is not set for this instance
     *
     * @throws \Exception
     */
    private function assertFilenameExists()
    {
        if (is_null($this->file_name)) {
            throw new \Exception("Filename is required");
        }
    }

    /**
     * Throw exception if at least one required matter attribute is not present
     *
     * @throws \Exception
     */
    private function assertRequiredMatterIsPresent()
    {
        foreach ($this->required_fields as $required_field) {
            if (!isset($this->matter[$required_field])) {
                throw new \Exception("Attribute {$required_field} is required");
            }
        }
    }
}


1		<?php
2
3
4		namespace AloiaCms\Models;
5
6		use ContentParser\ContentParser;
7		use AloiaCms\InlineBlockParser;
8		use AloiaCms\Models\Contracts\ModelInterface;
9		use AloiaCms\Models\Contracts\StorableInterface;
10		use AloiaCms\Writer\FolderCreator;
11		use AloiaCms\Writer\FrontMatterCreator;
12		use Illuminate\Support\Arr;
13		use Illuminate\Support\Collection;
14		use Illuminate\Support\Facades\Config;
15		use Illuminate\Support\Facades\File;
16		use Spatie\YamlFrontMatter\YamlFrontMatter;
17
18		class Model implements ModelInterface, StorableInterface
19		{
20		protected $folder = '';
21
22		protected $file_name = null;
23
24		protected $extension = 'md';
25
26		protected $matter = [];
27
28		protected $body = '';
29
30		protected $required_fields = [];
31
32		/**
33		* Find a single model
34		*
35		* @param string $file_name
36		* @return ModelInterface
37		*/
38	63	public static function find(string $file_name): ModelInterface
39		{
40	63	$instance = new static();
41
42	63	$instance->setFileName($file_name);
43
44	63	return $instance;
45		}
46
47		/**
48		* Return all instances of the model
49		*
50		* @return Collection\|ModelInterface[]
51		*/
52	7	public static function all(): Collection
53		{
54	7	$instance = new static();
55
56	7	$files = File::allFiles($instance->getFolderPath());
57
58	7	return Collection::make($files)
59	7	->map(function (\SplFileInfo $fileInfo): ModelInterface {
60	7	return self::find(pathinfo($fileInfo->getFilename(), PATHINFO_FILENAME));
61	7	});
62		}
63
64		/**
65		* Rename this file to the given name
66		*
67		* @param string $new_name
68		* @return Model
69		*/
70	1	public function rename(string $new_name): ModelInterface
71		{
72	1	$old_file_path = $this->getFilePath();
73
74	1	$this->file_name = $new_name;
75
76	1	$new_file_path = $this->getFilePath();
77
78	1	File::move($old_file_path, $new_file_path);
79
80	1	return self::find($new_name);
81		}
82
83		/**
84		* Get the raw content of the file + front matter
85		*
86		* @return string
87		*/
88	63	public function rawContent(): string
89		{
90	63	$file_path = $this->getFilePath();
91
92	63	if ($this->exists()) {
93	47	return file_get_contents($file_path);
94		}
95
96	62	return "";
97		}
98
99		/**
100		* Parse the file for this model into model variables
101		*/
102	63	private function parseFile(): void
103		{
104	63	$parsed_file = YamlFrontMatter::parse($this->rawContent());
105
106	63	$this->matter = $parsed_file->matter();
107	63	$this->body = $parsed_file->body();
108	63	}
109
110		/**
111		* Save this instance to file
112		*
113		* @return ModelInterface
114		* @throws \Exception
115		*/
116	52	public function save(): ModelInterface
117		{
118	52	$file_content = FrontMatterCreator::seed($this->matter, $this->body)->create();
119
120	52	$this->assertFilenameExists();
121
122	51	$this->assertRequiredMatterIsPresent();
123
124	49	$file_path = $this->getFilePath();
125
126	49	file_put_contents($file_path, $file_content);
127
128	49	return $this;
129		}
130
131		/**
132		* Get the file path for this instance
133		*
134		* @return string
135		*/
136	63	private function getFilePath(): string
137		{
138	63	$folder_path = $this->getFolderPath();
139
140	63	if (!is_null($matching_filepath = $this->getFileMatchFromDisk())) {
141	47	$this->setExtension(pathinfo($matching_filepath, PATHINFO_EXTENSION));
142		}
143
144	63	return "{$folder_path}/{$this->file_name}.{$this->extension}";
145		}
146
147		/**
148		* Get the folder path for this model
149		*
150		* @return string
151		*/
152	66	public function getFolderPath(): string
153		{
154	66	$folder_path = Config::get('aloiacms.collections_path') . "/{$this->folder}";
155
156	66	FolderCreator::forPath($folder_path);
157
158	66	return $folder_path;
159		}
160
161		/**
162		* Get the front matter
163		*
164		* @return array
165		*/
166	2	public function matter(): array
167		{
168	2	return $this->matter;
169		}
170
171		/**
172		* Set a value on the specified key in the configuration
173		*
174		* Kept around for backward compatibility
175		*
176		* @param string $key
177		* @param $value
178		* @return ModelInterface
179		*
180		* @deprecated since 3.2.0
181		*/
182	1	public function addMatter(string $key, $value): ModelInterface
183		{
184	1	return $this->set($key, $value);
185		}
186
187		/**
188		* Set data in the front matter, but only for the keys specified in the input array
189		*
190		* @param array $matter
191		* @return ModelInterface
192		*/
193	46	public function setMatter(array $matter): ModelInterface
194		{
195	46	foreach (array_keys($matter) as $key) {
196	46	$this->matter[$key] = $matter[$key];
197		}
198
199	46	return $this;
200		}
201
202		/**
203		* Determine whether a key is present in the configuration
204		*
205		* @param string $key
206		* @return bool
207		*/
208	2	public function has(string $key): bool
209		{
210	2	return isset($this->matter[$key]);
211		}
212
213		/**
214		* Get the value of the specified key, return null if it doesn't exist
215		*
216		* @param string $key
217		* @return mixed\|null
218		*/
219	15	public function get(string $key)
220		{
221	15	return $this->matter[$key] ?? null;
222		}
223
224		/**
225		* Set a value on the specified key in the configuration
226		*
227		* @param string $key
228		* @param $value
229		* @return $this\|ModelInterface
230		*/
231	3	public function set(string $key, $value): ModelInterface
232		{
233	3	$this->matter[$key] = $value;
234
235	3	return $this;
236		}
237
238		/**
239		* Remove a key from the configuration
240		*
241		* @param string $key
242		* @return $this\|ModelInterface
243		*/
244	2	public function remove(string $key): ModelInterface
245		{
246	2	if ($this->has($key)) {
247	2	unset($this->matter[$key]);
248		}
249
250	2	return $this;
251		}
252
253		/**
254		* Get the raw file body
255		*
256		* @return string
257		*/
258	21	public function rawBody(): string
259		{
260	21	return $this->body;
261		}
262
263		/**
264		* Get the parse file body
265		*
266		* @return string
267		*/
268	19	public function body(): string
269		{
270	19	$content = new ContentParser($this->rawBody(), $this->extension());
271
272	19	return (new InlineBlockParser)->parseHtmlString($content->parse());
273		}
274
275		/**
276		* Set the file body
277		*
278		* @param string $body
279		* @return ModelInterface
280		*/
281	38	public function setBody(string $body): ModelInterface
282		{
283	38	$this->body = $body;
284
285	38	return $this;
286		}
287
288		/**
289		* Get the file extension
290		*
291		* @return string
292		*/
293	20	public function extension(): string
294		{
295	20	return $this->extension;
296		}
297
298		/**
299		* Set the file extension
300		*
301		* @param string $extension
302		* @return ModelInterface
303		*/
304	47	public function setExtension(string $extension): ModelInterface
305		{
306	47	$this->extension = $extension;
307
308	47	return $this;
309		}
310
311		/**
312		* Get the file name for this instance
313		*
314		* @return string
315		*/
316	1	public function filename(): ?string
317		{
318	1	return $this->file_name;
319		}
320
321		/**
322		* Set the file name for this instance
323		*
324		* @param string $file_name
325		* @return ModelInterface
326		*/
327	63	protected function setFileName(string $file_name): ModelInterface
328		{
329	63	$this->file_name = $file_name;
330
331	63	$this->parseFile();
332
333	63	return $this;
334		}
335
336		/**
337		* Get all models for this type
338		*
339		* @return array
340		*/
341	63	private function getModelFiles(): array
342		{
343	63	return File::allFiles($this->getFolderPath());
344		}
345
346		/**
347		* Get the filename from disk
348		*
349		* @return string\|null
350		*/
351	63	private function getFileMatchFromDisk(): ?string
352		{
353	63	return Arr::first($this->getModelFiles(), function (string $file_name) {
354	47	return strpos($file_name, "/{$this->file_name}.");
355	63	});
356		}
357
358		/**
359		* Determine whether the current model exists
360		*
361		* @return bool
362		*/
363	63	public function exists(): bool
364		{
365	63	return !is_null($this->getFileMatchFromDisk());
366		}
367
368		/**
369		* Delete the current model
370		*
371		* @return bool
372		*/
373	2	public function delete(): bool
374		{
375	2	return File::delete($this->getFilePath());
376		}
377
378		/**
379		* Get front matter information through an accessor
380		*
381		* @param $key
382		* @return mixed\|null
383		*/
384	12	public function __get($key)
385		{
386	12	return $this->get($key);
387		}
388
389		/**
390		* Throw exception when the file name is not set for this instance
391		*
392		* @throws \Exception
393		*/
394	52	private function assertFilenameExists()
395		{
396	52	if (is_null($this->file_name)) {
397	1	throw new \Exception("Filename is required");
398		}
399	51	}
400
401		/**
402		* Throw exception if at least one required matter attribute is not present
403		*
404		* @throws \Exception
405		*/
406	51	private function assertRequiredMatterIsPresent()
407		{
408	51	foreach ($this->required_fields as $required_field) {
409	43	if (!isset($this->matter[$required_field])) {
410	43	throw new \Exception("Attribute {$required_field} is required");
411		}
412		}
413	49	}
414		}
415

roelofjan-elsinga / aloia-cms

GitHub Access Token became invalid

Push — master ( f717a4...f2d01f )

Model::rawContent() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like