ReadableDocument::setContent() - Code Metrics - Inspection of "Allow Sass Static PageViews to recompile themselve..." - stakx-io/stakx - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#86)

by Vladimir

created 2018-11-07 07:01 UTC

ReadableDocument::setContent() A

↳ Parent: ReadableDocument

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

/**
 * @copyright 2018 Vladimir Jimenez
 * @license   https://github.com/stakx-io/stakx/blob/master/LICENSE.md MIT
 */

namespace allejo\stakx\Document;

use allejo\stakx\Filesystem\File;
use allejo\stakx\Utilities\NullableArray;
use Symfony\Component\Filesystem\Exception\FileNotFoundException;

abstract class ReadableDocument
{
    /**
     * Do not read the file immediately at construction. The object will need to execute the self::refreshFileContent()
     * manually at some point.
     *
     * @var bool
     */
    protected $noReadOnConstructor = false;

    /** @var string The content of the document's body. */
    protected $bodyContent = '';

    protected $metadata;
    protected $file;

    private $compiled = false;

    /**
     * ReadableDocument Constructor.
     *
     * @throws FileNotFoundException when the file given in the constructor does not exist or may not be accessible
     */
    public function __construct(File $file)
    {
        $this->metadata = new NullableArray();
        $this->file = $file;

        if (!$this->noReadOnConstructor)
        {
            $this->readContent();
        }
    }

    /**
     * Get the contents of this document.
     *
     * @return string
     */
    public function getContent()
    {
        return $this->bodyContent;
    }

    /**
     * Manually set the contents of this document.
     *
     * @param string $content
     */
    public function setContent($content)
    {
        $this->bodyContent = $content;
    }

    /**
     * @return string
     */
    public function getIndexName()
    {
        return $this->getRelativeFilePath();
    }

    /**
     * When a document is compiled, all of its internals are finished being configured.
     */
    final public function compile()
    {
        if ($this->compiled)
        {
            return;
        }

        $this->beforeCompile();

        $this->compiled = true;
    }

    /**
     * Determine whether or not this document has been compiled.
     *
     * @return bool
     */
    final protected function isCompiled()
    {
        return $this->compiled;
    }

    /**
     * Get the value stored under this key in the file's internal metadata only available to stakx.
     *
     * @param string $key
     *
     * @return mixed|null
     */
    final public function getMetadata($key)
    {
        return $this->metadata[$key];
    }

    /**
     * Set a value in the file's internal metadata only available to stakx.
     *
     * @param string $key
     * @param mixed  $value
     *
     * @return mixed
     */
    final public function setMetadata($key, $value)
    {
        return $this->metadata[$key] = $value;
    }

    /**
     * Get the original File object given to this document.
     *
     * @return File
     */
    final public function getFile()
    {
        return $this->file;
    }

    /**
     * Get the relative path to the file, with respect to the site root.
     *
     * @return string
     */
    final public function getRelativeFilePath()
    {
        return $this->file->getRelativeFilePath();
    }

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

    /**
     * Get the name of the file without the extension.
     *
     * @return string
     */
    final public function getBasename()
    {
        return $this->file->getBasename();
    }

    /**
     * Get the absolute path to the file.
     *
     * @return string
     */
    final public function getAbsoluteFilePath()
    {
        return $this->file->getAbsolutePath();
    }

    /**
     * Get the name of the file with its extension.
     *
     * @return string
     */
    final public function getFilename()
    {
        return $this->file->getFilename();
    }

    /**
     * Gets the last modified time.
     *
     * @return int The last modified time for the file, in a Unix timestamp
     */
    final public function getLastModified()
    {
        return $this->file->getLastModified();
    }

    /**
     * Read the contents of this file and handle all of the necessary processing/setup for this document.
     */
    final public function readContent()
    {
        $beforeEvent = $this->beforeReadContents();
        $actualEvent = $this->readContents($beforeEvent);
        $this->afterReadContents($actualEvent);
    }

    /**
     * Prepare the Document so it can handle the data that's about to be read in.
     *
     * @return mixed any information that will be passed to the readContents() method
     */
    protected function beforeReadContents()
    {
        return null;
    }

    /**
     * Read the contents of the file and store the information internally **only**.
     *
     * This method must **not** handle any parsing or processing of the file's content. That should be handled by the
     * `afterReadContents()` method.
     *
     * @param mixed $mixed any information returned from the beforeReadContents() method
     *
     * @throws \RuntimeException when the file cannot be read
     *
     * @return mixed
     */
    abstract protected function readContents($mixed);

    /**
     * After the Document's content has been read, process the it and handle any parsing that's needed.
     *
     * @param mixed $mixed any information returned from the readContents() method
     */
    protected function afterReadContents($mixed)
    {
    }

    /**
     * Functionality that needs to take place before this document is considered "compiled," meaning everything has been
     * processed, configured, and built.
     */
    protected function beforeCompile()
    {
    }
}


1		<?php
2
3		/**
4		* @copyright 2018 Vladimir Jimenez
5		* @license https://github.com/stakx-io/stakx/blob/master/LICENSE.md MIT
6		*/
7
8		namespace allejo\stakx\Document;
9
10		use allejo\stakx\Filesystem\File;
11		use allejo\stakx\Utilities\NullableArray;
12		use Symfony\Component\Filesystem\Exception\FileNotFoundException;
13
14		abstract class ReadableDocument
15		{
16		/**
17		* Do not read the file immediately at construction. The object will need to execute the self::refreshFileContent()
18		* manually at some point.
19		*
20		* @var bool
21		*/
22		protected $noReadOnConstructor = false;
23
24		/** @var string The content of the document's body. */
25		protected $bodyContent = '';
26
27		protected $metadata;
28		protected $file;
29
30		private $compiled = false;
31
32		/**
33		* ReadableDocument Constructor.
34		*
35		* @throws FileNotFoundException when the file given in the constructor does not exist or may not be accessible
36		*/
37	124	public function __construct(File $file)
38		{
39	124	$this->metadata = new NullableArray();
40	124	$this->file = $file;
41
42	124	if (!$this->noReadOnConstructor)
43		{
44	118	$this->readContent();
45		}
46	113	}
47
48		/**
49		* Get the contents of this document.
50		*
51		* @return string
52		*/
53	3	public function getContent()
54		{
55	3	return $this->bodyContent;
56		}
57
58		/**
59		* Manually set the contents of this document.
60		*
61		* @param string $content
62		*/
63		public function setContent($content)
64		{
65		$this->bodyContent = $content;
66		}
67
68		/**
69		* @return string
70		*/
71	53	public function getIndexName()
72		{
73	53	return $this->getRelativeFilePath();
74		}
75
76		/**
77		* When a document is compiled, all of its internals are finished being configured.
78		*/
79	10	final public function compile()
80		{
81	10	if ($this->compiled)
82		{
83		return;
84		}
85
86	10	$this->beforeCompile();
87
88	10	$this->compiled = true;
89	10	}
90
91		/**
92		* Determine whether or not this document has been compiled.
93		*
94		* @return bool
95		*/
96		final protected function isCompiled()
97		{
98		return $this->compiled;
99		}
100
101		/**
102		* Get the value stored under this key in the file's internal metadata only available to stakx.
103		*
104		* @param string $key
105		*
106		* @return mixed\|null
107		*/
108		final public function getMetadata($key)
109		{
110		return $this->metadata[$key];
111		}
112
113		/**
114		* Set a value in the file's internal metadata only available to stakx.
115		*
116		* @param string $key
117		* @param mixed $value
118		*
119		* @return mixed
120		*/
121		final public function setMetadata($key, $value)
122		{
123		return $this->metadata[$key] = $value;
124		}
125
126		/**
127		* Get the original File object given to this document.
128		*
129		* @return File
130		*/
131	2	final public function getFile()
132		{
133	2	return $this->file;
134		}
135
136		/**
137		* Get the relative path to the file, with respect to the site root.
138		*
139		* @return string
140		*/
141	104	final public function getRelativeFilePath()
142		{
143	104	return $this->file->getRelativeFilePath();
144		}
145
146		/**
147		* Get the extension of the file.
148		*
149		* @return string
150		*/
151	71	final public function getExtension()
152		{
153	71	return $this->file->getExtension();
154		}
155
156		/**
157		* Get the name of the file without the extension.
158		*
159		* @return string
160		*/
161	96	final public function getBasename()
162		{
163	96	return $this->file->getBasename();
164		}
165
166		/**
167		* Get the absolute path to the file.
168		*
169		* @return string
170		*/
171	14	final public function getAbsoluteFilePath()
172		{
173	14	return $this->file->getAbsolutePath();
174		}
175
176		/**
177		* Get the name of the file with its extension.
178		*
179		* @return string
180		*/
181	92	final public function getFilename()
182		{
183	92	return $this->file->getFilename();
184		}
185
186		/**
187		* Gets the last modified time.
188		*
189		* @return int The last modified time for the file, in a Unix timestamp
190		*/
191		final public function getLastModified()
192		{
193		return $this->file->getLastModified();
194		}
195
196		/**
197		* Read the contents of this file and handle all of the necessary processing/setup for this document.
198		*/
199	124	final public function readContent()
200		{
201	124	$beforeEvent = $this->beforeReadContents();
202	124	$actualEvent = $this->readContents($beforeEvent);
203	114	$this->afterReadContents($actualEvent);
204	113	}
205
206		/**
207		* Prepare the Document so it can handle the data that's about to be read in.
208		*
209		* @return mixed any information that will be passed to the readContents() method
210		*/
211	6	protected function beforeReadContents()
212		{
213	6	return null;
214		}
215
216		/**
217		* Read the contents of the file and store the information internally only.
218		*
219		* This method must not handle any parsing or processing of the file's content. That should be handled by the
220		* `afterReadContents()` method.
221		*
222		* @param mixed $mixed any information returned from the beforeReadContents() method
223		*
224		* @throws \RuntimeException when the file cannot be read
225		*
226		* @return mixed
227		*/
228		abstract protected function readContents($mixed);
229
230		/**
231		* After the Document's content has been read, process the it and handle any parsing that's needed.
232		*
233		* @param mixed $mixed any information returned from the readContents() method
234		*/
235	6	protected function afterReadContents($mixed)
236		{
237	6	}
238
239		/**
240		* Functionality that needs to take place before this document is considered "compiled," meaning everything has been
241		* processed, configured, and built.
242		*/
243		protected function beforeCompile()
244		{
245		}
246		}
247

stakx-io / stakx

Pull Request — master (#86)

ReadableDocument::setContent() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like