allejo\stakx\Document\ReadableDocument

Complexity

Total Complexity

10

Size/Duplication

Total Lines	119
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

92.31%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	17	3
A	getContent()	0	4	1
A	getIndexName()	0	4	1
A	getRelativeFilePath()	0	4	1
A	getExtension()	0	4	1
A	getBasename()	0	4	1
A	getAbsoluteFilePath()	0	4	1
A	getFilename()	0	4	1
	readContent()	0	1	?

<?php

/**
 * @copyright 2017 Vladimir Jimenez
 * @license   https://github.com/allejo/stakx/blob/master/LICENSE.md MIT
 */

namespace allejo\stakx\Document;

use allejo\stakx\Filesystem\File;
use allejo\stakx\Filesystem\FilesystemLoader as fs;
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;

    /**
     * ReadableDocument Constructor.
     *
     * @throws FileNotFoundException When the file given in the constructor does not exist or may not be accessible.
     */
    public function __construct(File $file)
    {
        $filePath = (string)$file;

        if (!fs::exists($filePath))
        {
            throw new FileNotFoundException(null, 0, null, $filePath);
        }

        $this->metadata = [];
        $this->file = $file;

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

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

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

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

    /**
     * Read the contents of the file and handle any parsing that needs to be done.
     *
     * For example, if a file needs to parse and evaluate FrontMatter, that will need to be in this function call after
     * reading the file contents.
     *
     * @throws \RuntimeException When the file cannot be read.
     *
     * @return void
     */
    abstract public function readContent();
}