Hyde\Framework\Services\MarkdownService

Complexity

Total Complexity

41

Size/Duplication

Total Lines	226
Duplicated Lines	0 %

Importance

Changes	18
Bugs	0	Features	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	parse()	0	11	1
A	setupConverter()	0	16	2
A	__construct()	0	4	1
A	addExtension()	0	4	2
A	runPreProcessing()	0	5	2
A	withPermalinks()	0	5	1
A	canEnableTorchlight()	0	4	2
A	configurePermalinksExtension()	0	13	1
A	runPostProcessing()	0	9	3
A	determineIfTorchlightAttributionShouldBeInjected()	0	5	3
A	hasFeature()	0	3	1
A	addFeature()	0	7	2
A	getExtensions()	0	3	1
A	injectTorchlightAttribution()	0	5	1
A	enableAllHtmlElements()	0	9	1
A	removeFeature()	0	7	2
A	isDocumentationPage()	0	3	2
A	withTableOfContents()	0	5	1
A	canEnablePermalinks()	0	11	4
A	findLineContentPositions()	0	14	4
A	normalizeIndentationLevel()	0	13	3
A	getNormalizedLines()	0	3	1

<?php

declare(strict_types=1);

namespace Hyde\Framework\Services;

use Hyde\Facades\Features;
use Hyde\Framework\Concerns\Internal\SetsUpMarkdownConverter;
use Hyde\Markdown\Contracts\MarkdownPostProcessorContract as PostProcessor;
use Hyde\Markdown\Contracts\MarkdownPreProcessorContract as PreProcessor;
use Hyde\Markdown\MarkdownConverter;
use Hyde\Pages\DocumentationPage;
use League\CommonMark\Extension\DisallowedRawHtml\DisallowedRawHtmlExtension;
use League\CommonMark\Extension\HeadingPermalink\HeadingPermalinkExtension;

/**
 * Dynamically creates a Markdown converter tailored for the target model and setup,
 * then converts the Markdown to HTML using both pre- and post-processors.
 *
 * @see \Hyde\Framework\Testing\Feature\MarkdownServiceTest
 */
class MarkdownService
{
    use SetsUpMarkdownConverter;

    public string $markdown;
    public ?string $sourceModel = null;

    protected array $config = [];
    protected array $extensions = [];
    protected MarkdownConverter $converter;

    protected string $html;
    protected array $features = [];

    protected array $preprocessors = [];
    protected array $postprocessors = [];

    public function __construct(string $markdown, ?string $sourceModel = null)
    {
        $this->sourceModel = $sourceModel;
        $this->markdown = $markdown;
    }

    public function parse(): string
    {
        $this->setupConverter();

        $this->runPreProcessing();

        $this->html = (string) $this->converter->convert($this->markdown);

        $this->runPostProcessing();

        return $this->html;
    }

    protected function setupConverter(): void
    {
        $this->enableDynamicExtensions();

        $this->enableConfigDefinedExtensions();

        $this->mergeMarkdownConfiguration();

        $this->converter = new MarkdownConverter($this->config);

        foreach ($this->extensions as $extension) {
            $this->initializeExtension($extension);
        }

        $this->registerPreProcessors();
        $this->registerPostProcessors();
    }

    public function addExtension(string $extensionClassName): void
    {
        if (! in_array($extensionClassName, $this->extensions)) {
            $this->extensions[] = $extensionClassName;
        }
    }

    protected function runPreProcessing(): void
    {
        /** @var PreProcessor $processor */
        foreach ($this->preprocessors as $preprocessor) {
            $this->markdown = $preprocessor::preprocess($this->markdown);
        }
    }

    protected function runPostProcessing(): void
    {
        if ($this->determineIfTorchlightAttributionShouldBeInjected()) {
            $this->html .= $this->injectTorchlightAttribution();
        }

        /** @var PostProcessor $processor */
        foreach ($this->postprocessors as $postprocessor) {
            $this->html = $postprocessor::postprocess($this->html);
        }
    }

    public function getExtensions(): array
    {
        return $this->extensions;
    }

    public function removeFeature(string $feature): static
    {
        if (in_array($feature, $this->features)) {
            $this->features = array_diff($this->features, [$feature]);
        }

        return $this;
    }

    public function addFeature(string $feature): static
    {
        if (! in_array($feature, $this->features)) {
            $this->features[] = $feature;
        }

        return $this;
    }

    public function withPermalinks(): static
    {
        $this->addFeature('permalinks');

        return $this;
    }

    public function isDocumentationPage(): bool
    {
        return isset($this->sourceModel) && $this->sourceModel === DocumentationPage::class;
    }

    public function withTableOfContents(): static
    {
        $this->addFeature('table-of-contents');

        return $this;
    }

    public function canEnableTorchlight(): bool
    {
        return $this->hasFeature('torchlight') ||
            Features::hasTorchlight();
    }

    public function canEnablePermalinks(): bool
    {
        if ($this->hasFeature('permalinks')) {
            return true;
        }

        if ($this->isDocumentationPage() && DocumentationPage::hasTableOfContents()) {
            return true;
        }

        return false;
    }

    public function hasFeature(string $feature): bool
    {
        return in_array($feature, $this->features);
    }

    protected function determineIfTorchlightAttributionShouldBeInjected(): bool
    {
        return ! $this->isDocumentationPage()
            && config('torchlight.attribution.enabled', true)
            && str_contains($this->html, 'Syntax highlighted by torchlight.dev');
    }

    protected function injectTorchlightAttribution(): string
    {
        return '<br>'.$this->converter->convert(config(
            'torchlight.attribution.markdown',
            'Syntax highlighted by torchlight.dev'
        ));
    }

    protected function configurePermalinksExtension(): void
    {
        $this->addExtension(HeadingPermalinkExtension::class);

        $this->config = array_merge([
            'heading_permalink' => [
                'id_prefix' => '',
                'fragment_prefix' => '',
                'symbol' => '#',
                'insert' => 'after',
                'min_heading_level' => 2,
            ],
        ], $this->config);
    }

    protected function enableAllHtmlElements(): void
    {
        $this->addExtension(DisallowedRawHtmlExtension::class);

        $this->config = array_merge([
            'disallowed_raw_html' => [
                'disallowed_tags' => [],
            ],
        ], $this->config);
    }

    /**
     * Normalize indentation for an un-compiled Markdown string.
     */
    public static function normalizeIndentationLevel(string $string): string
    {
        $lines = self::getNormalizedLines($string);

        [$startNumber, $indentationLevel] = self::findLineContentPositions($lines);

        foreach ($lines as $lineNumber => $line) {
            if ($lineNumber >= $startNumber) {
                $lines[$lineNumber] = substr($line, $indentationLevel);
            }
        }

        return implode("\n", $lines);
    }

    protected static function getNormalizedLines(string $string): array
    {
        return explode("\n", str_replace(["\t", "\r\n"], ['    ', "\n"], $string));
    }

    /** @return int[]  Find the indentation level and position of the first line that has content */
    protected static function findLineContentPositions(array $lines): array
    {
        foreach ($lines as $lineNumber => $line) {
            if (filled(trim($line))) {
                $lineLen = strlen($line);
                $stripLen = strlen(ltrim($line)); // Length of the line without indentation lets us know its indentation level, and thus how much to strip from each line

                if ($lineLen !== $stripLen) {
                    return [$lineNumber, $lineLen - $stripLen];
                }
            }
        }

        return [0, 0];
    }
}