Hyde\Framework\Actions\CreatesNewPageSourceFile

Complexity

Total Complexity

19

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	makeOutputPath()	0	3	1
A	normalizeSubdirectory()	0	3	1
A	createBladeFile()	0	11	1
A	getMarkdownPageContent()	0	3	1
A	formatIdentifier()	0	3	1
A	fileName()	0	10	2
A	failIfFileCannotBeSaved()	0	4	3
A	parseTitle()	0	3	1
A	createDocumentationFile()	0	3	1
A	save()	0	11	1
A	createMarkdownFile()	0	3	1
A	validateType()	0	4	2
A	getBladePageContent()	0	7	2

<?php

declare(strict_types=1);

namespace Hyde\Framework\Actions;

use Hyde\Hyde;
use Hyde\Pages\BladePage;
use Illuminate\Support\Str;
use Hyde\Pages\MarkdownPage;
use Hyde\Pages\DocumentationPage;
use Hyde\Framework\Exceptions\FileConflictException;
use Hyde\Framework\Concerns\InteractsWithDirectories;
use Hyde\Framework\Exceptions\UnsupportedPageTypeException;

use function trim;
use function sprintf;
use function file_put_contents;
use function file_exists;
use function basename;
use function in_array;
use function str_contains;
use function Hyde\unslash;
use function rtrim;

/**
 * Scaffold a new Markdown, Blade, or documentation page.
 */
class CreatesNewPageSourceFile
{
    use InteractsWithDirectories;

    /** @var class-string<\Hyde\Pages\Concerns\HydePage> */

The doc comment class-string<\Hyde\Pages\Concerns\HydePage> at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<\Hyde\Pages\Concerns\HydePage>.

    protected string $pageClass;

    protected string $title;
    protected string $filename;
    protected string $outputPath;
    protected string $subDir = '';
    protected bool $force;

    protected ?string $customContent;

    public function __construct(string $title, string $pageClass = MarkdownPage::class, bool $force = false, ?string $customContent = null)
    {
        $this->validateType($pageClass);
        $this->pageClass = $pageClass;

        $this->title = $this->parseTitle($title);
        $this->filename = $this->fileName($title);
        $this->force = $force;
        $this->customContent = $customContent;

        $this->outputPath = $this->makeOutputPath($pageClass);
    }

    public function save(): string
    {
        $this->failIfFileCannotBeSaved($this->outputPath);

        match ($this->pageClass) {
            BladePage::class => $this->createBladeFile(),

Are you sure the usage of $this->createBladeFile() targeting Hyde\Framework\Actions\CreatesNewPageSourceFile::createBladeFile() seems to always return null.

            MarkdownPage::class => $this->createMarkdownFile(),

Are you sure the usage of $this->createMarkdownFile() targeting Hyde\Framework\Actions\CreatesNewPageSourceFile::createMarkdownFile() seems to always return null.

            DocumentationPage::class => $this->createDocumentationFile(),

Are you sure the usage of $this->createDocumentationFile() targeting Hyde\Framework\Actions\CreatesNewPageSourceFile::createDocumentationFile() seems to always return null.

        };

        return $this->outputPath;
    }

    protected function parseTitle(string $title): string
    {
        return Str::afterLast($title, '/');
    }

    protected function fileName(string $title): string
    {
        // If title contains a slash, it's a subdirectory
        if (str_contains($title, '/')) {
            // So we normalize the subdirectory name
            $this->subDir = $this->normalizeSubdirectory($title);
        }

        // And return a slug made from just the title without the subdirectory
        return Hyde::makeSlug(basename($title));

The method makeSlug() does not exist on Hyde\Hyde. Since you implemented __callStatic, consider adding a @method annotation.

    }

    protected function normalizeSubdirectory(string $title): string
    {
        return unslash('/'.rtrim(Str::beforeLast($title, '/').'/', '/\\'));
    }

    /** @param class-string<\Hyde\Pages\Concerns\HydePage> $pageClass */

The doc comment class-string<\Hyde\Pages\Concerns\HydePage> at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<\Hyde\Pages\Concerns\HydePage>.

    protected function makeOutputPath(string $pageClass): string
    {
        return Hyde::path($pageClass::sourcePath($this->formatIdentifier()));

The method path() does not exist on Hyde\Hyde. Since you implemented __callStatic, consider adding a @method annotation.

    }

    protected function createBladeFile(): void
    {
        $this->needsParentDirectory($this->outputPath);

        file_put_contents($this->outputPath, Hyde::normalizeNewlines(<<<BLADE

The method normalizeNewlines() does not exist on Hyde\Hyde. Since you implemented __callStatic, consider adding a @method annotation.

            @extends('hyde::layouts.app')
            @section('content')
            @php(\$title = "$this->title")

            <main class="mx-auto max-w-7xl py-16 px-8">
                {$this->getBladePageContent()}
            </main>

            @endsection

            BLADE
        ));
    }

    protected function createMarkdownFile(): void
    {
        (new MarkdownPage($this->formatIdentifier(), ['title' => $this->title], $this->getMarkdownPageContent()))->save();
    }

    protected function createDocumentationFile(): void
    {
        (new DocumentationPage($this->formatIdentifier(), [], "# $this->title"))->save();
    }

    protected function formatIdentifier(): string
    {
        return "$this->subDir/$this->filename";
    }

    protected function validateType(string $pageClass): void
    {
        if (! in_array($pageClass, [MarkdownPage::class, BladePage::class, DocumentationPage::class])) {
            throw new UnsupportedPageTypeException('The page type must be either "markdown", "blade", or "documentation"');
        }
    }

    protected function failIfFileCannotBeSaved(string $path): void
    {
        if ($this->force !== true && file_exists($path)) {
            throw new FileConflictException($path);
        }
    }

    protected function getBladePageContent(): string
    {
        $baseContent = "<h1 class=\"text-center text-3xl font-bold\">$this->title</h1>";

        return $this->customContent
            ? trim(sprintf("%s\n\n    <div>\n        %s\n    </div>", $baseContent, $this->customContent))
            : $baseContent;
    }

    protected function getMarkdownPageContent(): string
    {
        return trim(sprintf("# $this->title\n\n%s", $this->customContent ?? ''));
    }
}