Html/src/Visitor/Element.php at main · Innmind/Html · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
<?php
declare(strict_types = 1);

namespace Innmind\Html\Visitor;

use Innmind\Html\Document;
use Innmind\Xml\{
    Node,
    Element as Model,
    Element\Custom,
};
use Innmind\Immutable\{
    Maybe,
    Sequence,
    Predicate\Instance,
};

/**
 * @psalm-immutable
 */
final class Element
{
    /**
     * @param non-empty-string $name
     */
    private function __construct(private string $name)
    {
    }

    /**
     * @return Maybe<Model|Custom>
     */
    #[\NoDiscard]
    public function __invoke(Document|Node|Model|Custom $node): Maybe
    {
        return match (true) {
            $node instanceof Document => $this->visitDocument($node),
            $node instanceof Node => $this->visitNode($node),
            $node instanceof Model => $this->visitElement($node),
            $node instanceof Custom => $this->visitCustom($node),
        };
    }

    /**
     * @psalm-pure
     *
     * @param non-empty-string $name
     */
    #[\NoDiscard]
    public static function of(string $name): self
    {
        return new self($name);
    }

    /**
     * @psalm-pure
     */
    #[\NoDiscard]
    public static function head(): self
    {
        return new self('head');
    }

    /**
     * @psalm-pure
     */
    #[\NoDiscard]
    public static function body(): self
    {
        return new self('body');
    }

    /**
     * @return Maybe<Model|Custom>
     */
    private function visitDocument(Document $document): Maybe
    {
        return $this->visit($document->children());
    }

    /**
     * @return Maybe<Model|Custom>
     */
    private function visitNode(Node $node): Maybe
    {
        /** @var Maybe<Model|Custom> */
        return Maybe::nothing();
    }

    /**
     * @return Maybe<Model|Custom>
     */
    private function visitElement(Model $element): Maybe
    {
        if ($element->name()->toString() === $this->name) {
            return Maybe::just($element);
        }

        return $this->visit($element->children());
    }

    /**
     * @return Maybe<Model|Custom>
     */
    private function visitCustom(Custom $element): Maybe
    {
        $normalized = $element->normalize();

        if ($normalized->name()->toString() === $this->name) {
            return Maybe::just($element);
        }

        return $this->visit($normalized->children());
    }

    /**
     * @param Sequence<Model|Custom|Node> $children
     *
     * @return Maybe<Model|Custom>
     */
    private function visit(Sequence $children): Maybe
    {
        /** @var Model|Custom|null */
        $found = null;

        $found = $children
            ->sink($found)
            ->until(
                fn($found, $child, $continuation) => $this($child)->match(
                    static fn($found) => $continuation->stop($found),
                    static fn() => $continuation->continue($found),
                ),
            );

        return Maybe::of($found)->keep(
            Instance::of(Model::class)->or(
                Instance::of(Custom::class),
            ),
        );
    }
}