HTMLPurifierBundle/src/DependencyInjection/ExerciseHTMLPurifierExtension.php at 5aa8abe863458e128948336353e8e9b1c5149680 · dmaicher/HTMLPurifierBundle · 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
<?php

namespace Exercise\HTMLPurifierBundle\DependencyInjection;

use Exercise\HTMLPurifierBundle\DependencyInjection\Compiler\HTMLPurifierPass;
use Exercise\HTMLPurifierBundle\HTMLPurifierConfigFactory;
use Exercise\HTMLPurifierBundle\HTMLPurifiersRegistry;
use Exercise\HTMLPurifierBundle\HTMLPurifiersRegistryInterface;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Extension\Extension;
use Symfony\Component\DependencyInjection\Loader\PhpFileLoader;
use Symfony\Component\DependencyInjection\Reference;

class ExerciseHTMLPurifierExtension extends Extension
{
    public function load(array $configs, ContainerBuilder $container): void
    {
        $loader = new PhpFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));

        $loader->load('services.php');

        $configs = $this->processConfiguration(new Configuration(), $configs);

        // Set default serializer cache path, while ensuring a default profile is defined
        $configs['html_profiles']['default']['config']['Cache.SerializerPath'] = $configs['default_cache_serializer_path'];

        if (!isset($configs['html_profiles']['default']['config']['Cache.SerializerPermissions'])) {
            $configs['html_profiles']['default']['config']['Cache.SerializerPermissions'] = $configs['default_cache_serializer_permissions'];
        }

        $serializerPaths = [];

        foreach ($configs['html_profiles'] as $name => $definition) {
            $configId = "exercise_html_purifier.config.$name";
            $default = null;
            $parents = []; // stores inherited configs

            if ('default' !== $name) {
                $default = new Reference('exercise_html_purifier.config.default');
                $parentNames = $definition['parents'];

                unset($parentNames['default']); // default is always inherited
                foreach ($parentNames as $parentName) {
                    self::resolveProfileInheritance($parentName, $configs['html_profiles'], $parents);
                }
            }

            $container->register($configId, \HTMLPurifier_Config::class)
                ->setFactory([HTMLPurifierConfigFactory::class, 'create'])
                ->setArguments([
                    $name,
                    $definition['config'],
                    $default,
                    self::getResolvedConfig('config', $parents),
                    self::getResolvedConfig('attributes', $parents, $definition),
                    self::getResolvedConfig('elements', $parents, $definition),
                    self::getResolvedConfig('blank_elements', $parents, $definition),
                ])
            ;

            $id = "exercise_html_purifier.$name";
            $container->register($id, \HTMLPurifier::class)
                ->setArguments([new Reference($configId)])
                ->addTag(HTMLPurifierPass::PURIFIER_TAG, ['profile' => $name])
            ;

            if (isset($definition['config']['Cache.SerializerPath'])) {
                $serializerPaths[] = $definition['config']['Cache.SerializerPath'];
            }

            if ($default) {
                $container->registerAliasForArgument($id, \HTMLPurifier::class, "$name.purifier");
            }
        }

        $container->register('exercise_html_purifier.purifiers_registry', HTMLPurifiersRegistry::class)
            ->setPublic(false)
        ;
        $container->setAlias(HTMLPurifiersRegistryInterface::class, 'exercise_html_purifier.purifiers_registry')
            ->setPublic(false)
        ;
        $container->setAlias(\HTMLPurifier::class, 'exercise_html_purifier.default')
            ->setPublic(false)
        ;
        $container->getDefinition('exercise_html_purifier.cache_warmer.serializer')
            ->setArgument(0, array_unique($serializerPaths))
            ->setArgument(1, array_keys($configs['html_profiles']))
        ;
    }

    public function getAlias(): string
    {
        return 'exercise_html_purifier';
    }

    private static function resolveProfileInheritance(string $parent, array $configs, array &$resolved): void
    {
        if (isset($resolved[$parent])) {
            // Another profile already inherited this config, skip
            return;
        }

        foreach ($configs[$parent]['parents'] as $grandParent) {
            self::resolveProfileInheritance($grandParent, $configs, $resolved);
        }

        $resolved[$parent]['config'] = $configs[$parent]['config'];
        $resolved[$parent]['attributes'] = $configs[$parent]['attributes'];
        $resolved[$parent]['elements'] = $configs[$parent]['elements'];
        $resolved[$parent]['blank_elements'] = $configs[$parent]['blank_elements'];
    }

    private static function getResolvedConfig(string $parameter, array $parents, ?array $definition = null): array
    {
        if (null !== $definition) {
            return array_filter(array_merge(
                array_column($parents, $parameter),
                isset($definition[$parameter]) ? $definition[$parameter] : []
            ));
        }

        return array_filter(array_column($parents, $parameter));
    }
}