Spatie\BladeX\Compiler

Complexity

Total Complexity

26

Size/Duplication

Total Lines	211
Duplicated Lines	9.48 %

Coupling/Cohesion

Components	2
Dependencies	4

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	parseSlots()	0	14	1
A	__construct()	0	4	1
A	compile()	0	8	1
A	parseComponentHtml()	0	12	1
A	parseSelfClosingTags()	10	10	1
A	parseOpeningTags()	10	10	1
A	parseClosingTags()	0	6	1
A	componentString()	0	4	1
A	componentStartString()	0	31	3
A	componentEndString()	0	8	2
A	getAttributesFromAttributeString()	0	36	5
A	parseBindAttributes()	0	4	1
A	attributesToString()	0	8	1
A	stripQuotes()	0	8	2
A	containsEchoes()	0	4	1
A	compileEchoes()	0	23	3

<?php

namespace Spatie\BladeX;

use Illuminate\Support\Str;
use Illuminate\Support\Collection;

class Compiler
{
    /** @var \Spatie\BladeX\BladeX */
    protected $bladeX;

    public function __construct(BladeX $bladeX)
    {
        return $this->bladeX = $bladeX;

Constructors do not have meaningful return values, anything that is returned from here is discarded. Are you sure this is correct?

    }

    public function compile(string $viewContents): string
    {
        return array_reduce(
            $this->bladeX->registeredComponents(),
            [$this, 'parseComponentHtml'],
            $viewContents
        );
    }

    protected function parseComponentHtml(string $viewContents, Component $component)
    {
        $viewContents = $this->parseSlots($viewContents);

        $viewContents = $this->parseSelfClosingTags($viewContents, $component);

        $viewContents = $this->parseOpeningTags($viewContents, $component);

        $viewContents = $this->parseClosingTags($viewContents, $component);

        return $viewContents;
    }

    protected function parseSelfClosingTags(string $viewContents, Component $component): string

This method seems to be duplicated in your project.

    {
        $pattern = "/<\s*{$component->getTag()}\s*(?<attributes>(?:\s+[\w\-:]+(=(?:\\\"[^\\\"]+\\\"|\'[^\']+\'|[^\'\\\"=<>]+))?)*\s*)\/>/";

        return preg_replace_callback($pattern, function (array $matches) use ($component) {
            $attributes = $this->getAttributesFromAttributeString($matches['attributes']);

            return $this->componentString($component, $attributes);
        }, $viewContents);
    }

    protected function parseOpeningTags(string $viewContents, Component $component): string

This method seems to be duplicated in your project.

    {
        $pattern = "/<\s*{$component->getTag()}(?<attributes>(?:\s+[\w\-:]+(=(?:\\\"[^\\\"]*\\\"|\'[^\']*\'|[^\'\\\"=<>]+))?)*\s*)(?<![\/=\-])>/";

        return preg_replace_callback($pattern, function (array $matches) use ($component) {
            $attributes = $this->getAttributesFromAttributeString($matches['attributes']);

            return $this->componentStartString($component, $attributes);
        }, $viewContents);
    }

    protected function parseClosingTags(string $viewContents, Component $component): string
    {
        $pattern = "/<\/\s*{$component->getTag()}\s*>/";

        return preg_replace($pattern, $this->componentEndString($component), $viewContents);
    }

    protected function componentString(Component $component, array $attributes = []): string
    {
        return $this->componentStartString($component, $attributes).$this->componentEndString($component);
    }

    protected function componentStartString(Component $component, array $attributes = []): string
    {
        $attributesString = $this->attributesToString($attributes);

        $componentAttributeString = "[{$attributesString}]";

        if ($component->view === 'bladex::context') {
            return " @php(app(Spatie\BladeX\ContextStack::class)->push({$componentAttributeString})) ";
        }

        if ($component->viewModel) {
            $componentAttributeString = "
                array_merge(
                    app(Spatie\BladeX\ContextStack::class)->read(),
                    {$componentAttributeString},
                    app(
                        '{$component->viewModel}',
                        array_merge(
                            app(Spatie\BladeX\ContextStack::class)->read(),
                            {$componentAttributeString}
                        )
                    )->toArray()
                )";
        }

        return " @component(
           '{$component->view}',
           array_merge(app(Spatie\BladeX\ContextStack::class)->read(),
           {$componentAttributeString})
        ) ";
    }

    protected function componentEndString(Component $component): string
    {
        if ($component->view === 'bladex::context') {
            return "@php(app(Spatie\BladeX\ContextStack::class)->pop())";
        }

        return ' @endcomponent ';
    }

    protected function getAttributesFromAttributeString(string $attributeString): array
    {
        $attributeString = $this->parseBindAttributes($attributeString);

        $pattern = '/(?<attribute>[\w:-]+)(=(?<value>(\"[^\"]+\"|\\\'[^\\\']+\\\'|[^\s>]+)))?/';

        if (! preg_match_all($pattern, $attributeString, $matches, PREG_SET_ORDER)) {
            return [];
        }

        return collect($matches)->mapWithKeys(function ($match) {
            $attribute = Str::camel($match['attribute']);
            $value = $match['value'] ?? null;

            if (is_null($value)) {
                $value = 'true';
                $attribute = Str::start($attribute, 'bind:');
            }

            $value = $this->stripQuotes($value);

            if ($this->containsEchoes($value)) {
                $attribute = Str::start($attribute, 'bind:');
                $value = $this->compileEchoes($value);
            }

            if (Str::startsWith($attribute, 'bind:')) {
                $attribute = Str::after($attribute, 'bind:');
            } else {
                $value = str_replace("'", "\\'", $value);
                $value = "'{$value}'";
            }

            return [$attribute => $value];
        })->toArray();
    }

    protected function parseSlots(string $viewContents): string
    {
        $openingPattern = '/<\s*slot\s+name=(?<name>(\"[^\"]+\"|\\\'[^\\\']+\\\'|[^\s>]+))\s*>/';
        $viewContents = preg_replace_callback($openingPattern, function ($matches) {
            $name = $this->stripQuotes($matches['name']);

            return " @slot('{$name}') ";
        }, $viewContents);

        $closingPattern = '/<\/\s*slot[^>]*>/';
        $viewContents = preg_replace($closingPattern, ' @endslot', $viewContents);

        return $viewContents;
    }

    protected function parseBindAttributes(string $attributeString): string
    {
        return preg_replace("/\s*:([\w-]+)=/m", ' bind:$1=', $attributeString);
    }

    protected function attributesToString(array $attributes): string
    {
        return collect($attributes)
            ->map(function (string $value, string $attribute) {
                return "'{$attribute}' => {$value}";
            })
            ->implode(',');
    }

    protected function stripQuotes(string $string): string
    {
        if (Str::startsWith($string, ['"', '\''])) {
            return substr($string, 1, -1);
        }

        return $string;
    }

    protected function containsEchoes(string $value): bool
    {
        return preg_match('/{{\s*(.+?)\s*}}|{!!\s*(.+?)\s*!!}/s', $value);
    }

    protected function compileEchoes(string $value): string
    {
        $segments = preg_split('/({{\s*.+?\s*}}|{!!\s*.+?\s*!!})/s', $value, -1, PREG_SPLIT_DELIM_CAPTURE);

        $string = Collection::make($segments)
            ->reject(function ($segment) {
                return '' === $segment;
            })
            ->map(function ($segment) {
                if (preg_match('/{{\s*(.+?)\s*}}/s', $segment, $matches)) {
                    return 'e('.$matches[1].')';
                }

                if (preg_match('/{!!\s*(.+?)\s*!!}/s', $segment, $matches)) {
                    return $matches[1];
                }

                return "'".str_replace("'", "\\'", $segment)."'";
            })
            ->implode('.');
        
        return "new \\Illuminate\\Support\\HtmlString({$string})";
    }
}