vendor/elao/enum/src/Bridge/Symfony/Bundle/DependencyInjection/Configuration.php line 23

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /*
  6.  * This file is part of the "elao/enum" package.
  7.  *
  8.  * Copyright (C) Elao
  9.  *
  10.  * @author Elao <contact@elao.com>
  11.  */
  13. namespace Elao\Enum\Bridge\Symfony\Bundle\DependencyInjection;
  15. use Elao\Enum\Bridge\Doctrine\DBAL\Types\TypesDumper as DBALTypesDumper;
  16. use Elao\Enum\Bridge\Doctrine\ODM\Types\TypesDumper as ODMTypesDumper;
  17. use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
  18. use Symfony\Component\Config\Definition\Builder\TreeBuilder;
  19. use Symfony\Component\Config\Definition\ConfigurationInterface;
  21. class Configuration implements ConfigurationInterface
  22. {
  23.     public function getConfigTreeBuilder(): TreeBuilder
  24.     {
  25.         $treeBuilder = new TreeBuilder('elao_enum');
  27.         $this->addDoctrineDbalSection($treeBuilder->getRootNode());
  28.         $this->addDoctrineOdmSection($treeBuilder->getRootNode());
  30.         return $treeBuilder;
  31.     }
  33.     private function addDoctrineDbalSection(ArrayNodeDefinition $rootNode)
  34.     {
  35.         $rootNode->children()
  36.             ->arrayNode('doctrine')
  37.             ->addDefaultsIfNotSet()
  38.             ->fixXmlConfig('type')
  39.             ->children()
  40.                 ->booleanNode('enum_sql_declaration')
  41.                     ->defaultValue(false)
  42.                     ->info('If true, generate DBAL types with an ENUM SQL declaration with enum values instead of a VARCHAR/INT (Your platform must support it)')
  43.                 ->end()
  44.                 ->arrayNode('types')
  45.                     ->beforeNormalization()
  46.                         ->always(static function (array $values): array {
  47.                             // Allows reusing type name as the enum class implicitly
  48.                             foreach ($values as $name => &$config) {
  49.                                 if (null === $config) {
  50.                                     $config['class'] = $name;
  51.                                     continue;
  52.                                 }
  54.                                 if (\is_array($config) && !isset($config['class'])) {
  55.                                     $config['class'] = $name;
  56.                                 }
  57.                             }
  59.                             return $values;
  60.                         })
  61.                     ->end()
  62.                     ->useAttributeAsKey('name')
  63.                     ->arrayPrototype()
  64.                     ->beforeNormalization()
  65.                         // Allows passing the class as string directly instead of the whole config array
  66.                         ->ifString()->then(static function (string $v): array { return ['class' => $v]; })
  67.                     ->end()
  68.                     ->children()
  69.                         ->scalarNode('class')
  70.                             ->cannotBeEmpty()
  71.                             ->validate()
  72.                                 ->ifTrue(static function (string $class): bool { return !is_a($class, \BackedEnum::class, true); })
  73.                                 ->thenInvalid(sprintf('Invalid class. Expected instance of "%s"', \BackedEnum::class) . '. Got %s.')
  74.                             ->end()
  75.                         ->end()
  76.                         ->enumNode('type')
  77.                             ->values(DBALTypesDumper::TYPES)
  78.                             ->info(<<<TXT
  79. Which column definition to use and the way the enumeration values are stored in the database:
  80. - scalar: VARCHAR/INT based on BackedEnum type
  81. - enum: ENUM(...values) as strings based on BackedEnum type (Your platform must support it)
  82. Default is either "scalar" or "enum", controlled by the `elao_enum.doctrine.enum_sql_declaration` option.
  83. Default for flagged enums is "int".
  84. TXT
  85.                             )
  86.                             ->cannotBeEmpty()
  87.                             ->defaultValue(null)
  88.                         ->end()
  89.                         ->variableNode('default')
  90.                             ->info('Default enumeration case on NULL')
  91.                             ->cannotBeEmpty()
  92.                             ->defaultValue(null)
  93.                         ->end()
  94.                     ->end()
  95.                 ->end()
  96.             ->end()
  97.         ->end();
  98.     }
  100.     private function addDoctrineOdmSection(ArrayNodeDefinition $rootNode)
  101.     {
  102.         $rootNode->children()
  103.             ->arrayNode('doctrine_mongodb')
  104.             ->addDefaultsIfNotSet()
  105.             ->fixXmlConfig('type')
  106.             ->children()
  107.                 ->arrayNode('types')
  108.                     ->beforeNormalization()
  109.                         ->always(static function (array $values): array {
  110.                             // Allows reusing type name as the enum class implicitly
  111.                             foreach ($values as $name => &$config) {
  112.                                 if (null === $config) {
  113.                                     $config['class'] = $name;
  114.                                     continue;
  115.                                 }
  117.                                 if (\is_array($config) && !isset($config['class'])) {
  118.                                     $config['class'] = $name;
  119.                                 }
  120.                             }
  122.                             return $values;
  123.                         })
  124.                     ->end()
  125.                     ->useAttributeAsKey('name')
  126.                     ->arrayPrototype()
  127.                     ->beforeNormalization()
  128.                         // Allows passing the class as string directly instead of the whole config array
  129.                         ->ifString()->then(static function (string $v): array { return ['class' => $v]; })
  130.                     ->end()
  131.                     ->children()
  132.                         ->scalarNode('class')
  133.                             ->cannotBeEmpty()
  134.                             ->validate()
  135.                                 ->ifTrue(static function (string $class): bool { return !is_a($class, \BackedEnum::class, true); })
  136.                                 ->thenInvalid(sprintf('Invalid class. Expected instance of "%s"', \BackedEnum::class) . '. Got %s.')
  137.                             ->end()
  138.                         ->end()
  139.                         ->enumNode('type')
  140.                             ->values(ODMTypesDumper::TYPES)
  141.                             ->cannotBeEmpty()
  142.                             ->defaultValue(ODMTypesDumper::TYPE_SINGLE)
  143.                         ->end()
  144.                     ->end()
  145.                 ->end()
  146.             ->end()
  147.         ->end();
  148.     }
  149. }