vendor/symfony/config/Builder/ClassBuilder.php line 125

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Config\Builder;
  14. /**
  15.  * Build PHP classes to generate config.
  16.  *
  17.  * @internal
  18.  *
  19.  * @author Tobias Nyholm <tobias.nyholm@gmail.com>
  20.  */
  21. class ClassBuilder
  22. {
  23.     /** @var string */
  24.     private $namespace;
  26.     /** @var string */
  27.     private $name;
  29.     /** @var Property[] */
  30.     private $properties = [];
  32.     /** @var Method[] */
  33.     private $methods = [];
  34.     private $require = [];
  35.     private $use = [];
  36.     private $implements = [];
  37.     private $allowExtraKeys = false;
  39.     public function __construct(string $namespace, string $name)
  40.     {
  41.         $this->namespace = $namespace;
  42.         $this->name = ucfirst($this->camelCase($name)).'Config';
  43.     }
  45.     public function getDirectory(): string
  46.     {
  47.         return str_replace('\\', \DIRECTORY_SEPARATOR, $this->namespace);
  48.     }
  50.     public function getFilename(): string
  51.     {
  52.         return $this->name.'.php';
  53.     }
  55.     public function build(): string
  56.     {
  57.         $rootPath = explode(\DIRECTORY_SEPARATOR, $this->getDirectory());
  58.         $require = '';
  59.         foreach ($this->require as $class) {
  60.             // figure out relative path.
  61.             $path = explode(\DIRECTORY_SEPARATOR, $class->getDirectory());
  62.             $path[] = $class->getFilename();
  63.             foreach ($rootPath as $key => $value) {
  64.                 if ($path[$key] !== $value) {
  65.                     break;
  66.                 }
  67.                 unset($path[$key]);
  68.             }
  69.             $require .= sprintf('require_once __DIR__.\DIRECTORY_SEPARATOR.\'%s\';', implode('\'.\DIRECTORY_SEPARATOR.\'', $path))."\n";
  70.         }
  71.         $use = $require ? "\n" : '';
  72.         foreach (array_keys($this->use) as $statement) {
  73.             $use .= sprintf('use %s;', $statement)."\n";
  74.         }
  76.         $implements = [] === $this->implements ? '' : 'implements '.implode(', ', $this->implements);
  77.         $body = '';
  78.         foreach ($this->properties as $property) {
  79.             $body .= '    '.$property->getContent()."\n";
  80.         }
  81.         foreach ($this->methods as $method) {
  82.             $lines = explode("\n", $method->getContent());
  83.             foreach ($lines as $line) {
  84.                 $body .= ($line ? '    '.$line : '')."\n";
  85.             }
  86.         }
  88.         $content = strtr('<?php
  90. namespace NAMESPACE;
  92. REQUIREUSE
  93. /**
  94.  * This class is automatically generated to help in creating a config.
  95.  */
  96. class CLASS IMPLEMENTS
  97. {
  98. BODY
  99. }
  100. ', ['NAMESPACE' => $this->namespace, 'REQUIRE' => $require, 'USE' => $use, 'CLASS' => $this->getName(), 'IMPLEMENTS' => $implements, 'BODY' => $body]);
  102.         return $content;
  103.     }
  105.     public function addRequire(self $class): void
  106.     {
  107.         $this->require[] = $class;
  108.     }
  110.     public function addUse(string $class): void
  111.     {
  112.         $this->use[$class] = true;
  113.     }
  115.     public function addImplements(string $interface): void
  116.     {
  117.         $this->implements[] = '\\'.ltrim($interface, '\\');
  118.     }
  120.     public function addMethod(string $name, string $body, array $params = []): void
  121.     {
  122.         $this->methods[] = new Method(strtr($body, ['NAME' => $this->camelCase($name)] + $params));
  123.     }
  125.     public function addProperty(string $name, string $classType = null, string $defaultValue = null): Property
  126.     {
  127.         $property = new Property($name, '_' !== $name[0] ? $this->camelCase($name) : $name);
  128.         if (null !== $classType) {
  129.             $property->setType($classType);
  130.         }
  131.         $this->properties[] = $property;
  132.         $defaultValue = null !== $defaultValue ? sprintf(' = %s', $defaultValue) : '';
  133.         $property->setContent(sprintf('private $%s%s;', $property->getName(), $defaultValue));
  135.         return $property;
  136.     }
  138.     public function getProperties(): array
  139.     {
  140.         return $this->properties;
  141.     }
  143.     private function camelCase(string $input): string
  144.     {
  145.         $output = lcfirst(str_replace(' ', '', ucwords(str_replace('_', ' ', $input))));
  147.         return preg_replace('#\W#', '', $output);
  148.     }
  150.     public function getName(): string
  151.     {
  152.         return $this->name;
  153.     }
  155.     public function getNamespace(): string
  156.     {
  157.         return $this->namespace;
  158.     }
  160.     public function getFqcn(): string
  161.     {
  162.         return '\\'.$this->namespace.'\\'.$this->name;
  163.     }
  165.     public function setAllowExtraKeys(bool $allowExtraKeys): void
  166.     {
  167.         $this->allowExtraKeys = $allowExtraKeys;
  168.     }
  170.     public function shouldAllowExtraKeys(): bool
  171.     {
  172.         return $this->allowExtraKeys;
  173.     }
  174. }