Kernel::getPublicDir() - Code Metrics - Inspection of "Moving things around to a more up-to-date Symfony..." - gnutix/swbooks - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 866487...6bcace )

by Dorian

created 2020-04-02 23:19 UTC

Kernel::getPublicDir() A

↳ Parent: Kernel

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace Gnutix\Kernel;

use Symfony\Bundle\TwigBundle\DependencyInjection\Compiler\TwigEnvironmentPass as SymfonyTwigEnvironmentPass;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\Config\Loader\LoaderInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;
use Symfony\Component\HttpKernel\HttpKernelInterface;

/**
 * Kernel
 */
abstract class Kernel implements HttpKernelInterface
{
    /** @var string */
    protected $projectDir;

    /** @var string */
    protected $environment;

    /** @var bool */
    protected $debug;

    /** @var \Symfony\Component\DependencyInjection\ContainerInterface */
    protected $container;

    /**
     * @param string $environment
     * @param bool   $debug
     */
    public function __construct($environment = 'prod', $debug = false)
    {
        $this->environment = $environment;
        $this->debug = $debug;

        $this->initializeContainer();
    }

    /**
     * @return \Symfony\Component\DependencyInjection\ContainerInterface
     */
    public function getContainer()
    {
        return $this->container;
    }

    /**
     * @return string
     */
    protected function getEnvironment()
    {
        return $this->environment;
    }

    /**
     * @return bool
     */
    protected function getDebug()
    {
        return $this->debug;
    }

    /**
     * @return string
     */
    protected function getApplicationRootDir()
    {
        if (null === $this->projectDir) {
            $r = new \ReflectionObject($this);

            if (!file_exists($dir = $r->getFileName())) {
                throw new \LogicException(sprintf(
                    'Cannot auto-detect project dir for kernel of class "%s".',
                    $r->name
                ));
            }

            $dir = $rootDir = \dirname($dir);
            while (!file_exists($dir.'/composer.json')) {
                if ($dir === \dirname($dir)) {
                    return $this->projectDir = $rootDir;
                }
                $dir = \dirname($dir);
            }
            $this->projectDir = $dir;
        }

        return $this->projectDir;
    }

    /**
     * @return string
     */
    protected function getConfigDir()
    {
        return $this->getApplicationRootDir().'/config';
    }

    /**
     * @return string
     */
    protected function getCacheDir()
    {
        return $this->getApplicationRootDir().'/var/cache/'.$this->getEnvironment();
    }

    /**
     * @return string
     */
    protected function getPublicDir()
    {
        return $this->getApplicationRootDir().'/public';
    }

    /**
     * @return string
     */
    protected function getCharset()
    {
        return 'utf-8';
    }

    /**
     * @return string
     */
    protected function getConfigFilesExtension()
    {
        return 'yml';
    }

    /**
     * @return \Symfony\Component\Config\Loader\LoaderInterface
     */
    protected function getConfigFilesLoader(ContainerBuilder $container)
    {
        return new YamlFileLoader($container, new FileLocator($this->getConfigDir()));
    }

    protected function addKernelParameters(ContainerBuilder $container): void
    {
        // Folder paths
        $container->setParameter('kernel.project_dir', $this->getApplicationRootDir());
        $container->setParameter('kernel.public_dir', $this->getPublicDir());
        $container->setParameter('kernel.cache_dir', $this->getCacheDir());

        // Configurations
        $container->setParameter('kernel.environment', $this->getEnvironment());
        $container->setParameter('kernel.debug', $this->getDebug());
        $container->setParameter('kernel.charset', $this->getCharset());
    }

    /**
     * Create the container
     */
    protected function initializeContainer(): void
    {
        // Create the container builder
        $container = new ContainerBuilder();
        $this->addKernelParameters($container);

        // Create a loader for the configuration files
        $configLoader = $this->getConfigFilesLoader($container);
        $configExtension = $this->getConfigFilesExtension();

        // Register the extensions before loading the configuration
        foreach ($this->getExtensions() as $extension) {
            $container->registerExtension($extension);
        }

        // Load the application's configuration files (so that it can configure the extensions)
        $this->loadConfigurationFile($configLoader, 'config', $configExtension);

        // Load the extensions configuration and services files
        foreach ($container->getExtensions() as $extension) {
            $extension->load($container->getExtensionConfig($extension->getAlias()), $container);
        }

        $container->addCompilerPass(new SymfonyTwigEnvironmentPass());

        // Load the application's services files (so that it can override the extensions ones)
        $this->loadConfigurationFile($configLoader, 'services', $configExtension, false);

        // Compile everything
        $container->compile();

        // Store the container
        $this->container = $container;
    }

    /**
     * @param string                                           $fileNamePrefix
     * @param string                                           $fileNameExtension
     * @param bool                                             $throwException
     *
     * @throws \InvalidArgumentException
     */
    protected function loadConfigurationFile(
        LoaderInterface $loader,
        $fileNamePrefix,
        $fileNameExtension,
        $throwException = true
    ): void {
        // Try to load the environment specific configuration files
        try {
            $loader->load($fileNamePrefix.'_'.$this->getEnvironment().'.'.$fileNameExtension);
        } catch (\InvalidArgumentException $e) {
            // Try to load the environment agnostic configuration file
            try {
                $loader->load($fileNamePrefix.'.'.$fileNameExtension);
            } catch (\InvalidArgumentException $e) {
                // If the application can't work without this file, we throw the exception
                if ($throwException) {
                    throw $e;
                }
            }
        }
    }

    /**
     * @return \Symfony\Component\DependencyInjection\Extension\ExtensionInterface[]
     */
    protected function getExtensions()
    {
        return [];
    }
}


1			<?php
2
3			namespace Gnutix\Kernel;
4
5			use Symfony\Bundle\TwigBundle\DependencyInjection\Compiler\TwigEnvironmentPass as SymfonyTwigEnvironmentPass;
6			use Symfony\Component\Config\FileLocator;
7			use Symfony\Component\Config\Loader\LoaderInterface;
8			use Symfony\Component\DependencyInjection\ContainerBuilder;
9			use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;
10			use Symfony\Component\HttpKernel\HttpKernelInterface;
11
12			/**
13			* Kernel
14			*/
15			abstract class Kernel implements HttpKernelInterface
16			{
17			/** @var string */
18			protected $projectDir;
19
20			/** @var string */
21			protected $environment;
22
23			/** @var bool */
24			protected $debug;
25
26			/** @var \Symfony\Component\DependencyInjection\ContainerInterface */
27			protected $container;
28
29			/**
30			* @param string $environment
31			* @param bool $debug
32			*/
33			public function __construct($environment = 'prod', $debug = false)
34			{
35			$this->environment = $environment;
36			$this->debug = $debug;
37
38			$this->initializeContainer();
39			}
40
41			/**
42			* @return \Symfony\Component\DependencyInjection\ContainerInterface
43			*/
44			public function getContainer()
45			{
46			return $this->container;
47			}
48
49			/**
50			* @return string
51			*/
52			protected function getEnvironment()
53			{
54			return $this->environment;
55			}
56
57			/**
58			* @return bool
59			*/
60			protected function getDebug()
61			{
62			return $this->debug;
63			}
64
65			/**
66			* @return string
67			*/
68			protected function getApplicationRootDir()
69			{
70			if (null === $this->projectDir) {
71			$r = new \ReflectionObject($this);
72
73			if (!file_exists($dir = $r->getFileName())) {
74			throw new \LogicException(sprintf(
75			'Cannot auto-detect project dir for kernel of class "%s".',
76			$r->name
77			));
78			}
79
80			$dir = $rootDir = \dirname($dir);
81			while (!file_exists($dir.'/composer.json')) {
82			if ($dir === \dirname($dir)) {
83			return $this->projectDir = $rootDir;
84			}
85			$dir = \dirname($dir);
86			}
87			$this->projectDir = $dir;
88			}
89
90			return $this->projectDir;
91			}
92
93			/**
94			* @return string
95			*/
96			protected function getConfigDir()
97			{
98			return $this->getApplicationRootDir().'/config';
99			}
100
101			/**
102			* @return string
103			*/
104			protected function getCacheDir()
105			{
106			return $this->getApplicationRootDir().'/var/cache/'.$this->getEnvironment();
107			}
108
109			/**
110			* @return string
111			*/
112			protected function getPublicDir()
113			{
114			return $this->getApplicationRootDir().'/public';
115			}
116
117			/**
118			* @return string
119			*/
120			protected function getCharset()
121			{
122			return 'utf-8';
123			}
124
125			/**
126			* @return string
127			*/
128			protected function getConfigFilesExtension()
129			{
130			return 'yml';
131			}
132
133			/**
134			* @return \Symfony\Component\Config\Loader\LoaderInterface
135			*/
136			protected function getConfigFilesLoader(ContainerBuilder $container)
137			{
138			return new YamlFileLoader($container, new FileLocator($this->getConfigDir()));
139			}
140
141			protected function addKernelParameters(ContainerBuilder $container): void
142			{
143			// Folder paths
144			$container->setParameter('kernel.project_dir', $this->getApplicationRootDir());
145			$container->setParameter('kernel.public_dir', $this->getPublicDir());
146			$container->setParameter('kernel.cache_dir', $this->getCacheDir());
147
148			// Configurations
149			$container->setParameter('kernel.environment', $this->getEnvironment());
150			$container->setParameter('kernel.debug', $this->getDebug());
151			$container->setParameter('kernel.charset', $this->getCharset());
152			}
153
154			/**
155			* Create the container
156			*/
157			protected function initializeContainer(): void
158			{
159			// Create the container builder
160			$container = new ContainerBuilder();
161			$this->addKernelParameters($container);
162
163			// Create a loader for the configuration files
164			$configLoader = $this->getConfigFilesLoader($container);
165			$configExtension = $this->getConfigFilesExtension();
166
167			// Register the extensions before loading the configuration
168			foreach ($this->getExtensions() as $extension) {
169			$container->registerExtension($extension);
170			}
171
172			// Load the application's configuration files (so that it can configure the extensions)
173			$this->loadConfigurationFile($configLoader, 'config', $configExtension);
174
175			// Load the extensions configuration and services files
176			foreach ($container->getExtensions() as $extension) {
177			$extension->load($container->getExtensionConfig($extension->getAlias()), $container);
178			}
179
180			$container->addCompilerPass(new SymfonyTwigEnvironmentPass());
181
182			// Load the application's services files (so that it can override the extensions ones)
183			$this->loadConfigurationFile($configLoader, 'services', $configExtension, false);
184
185			// Compile everything
186			$container->compile();
187
188			// Store the container
189			$this->container = $container;
190			}
191
192			/**
193			* @param string $fileNamePrefix
194			* @param string $fileNameExtension
195			* @param bool $throwException
196			*
197			* @throws \InvalidArgumentException
198			*/
199			protected function loadConfigurationFile(
200			LoaderInterface $loader,
201			$fileNamePrefix,
202			$fileNameExtension,
203			$throwException = true
204			): void {
205			// Try to load the environment specific configuration files
206			try {
207			$loader->load($fileNamePrefix.'_'.$this->getEnvironment().'.'.$fileNameExtension);
208			} catch (\InvalidArgumentException $e) {
209			// Try to load the environment agnostic configuration file
210			try {
211			$loader->load($fileNamePrefix.'.'.$fileNameExtension);
212			} catch (\InvalidArgumentException $e) {
213			// If the application can't work without this file, we throw the exception
214			if ($throwException) {
215			throw $e;
216			}
217			}
218			}
219			}
220
221			/**
222			* @return \Symfony\Component\DependencyInjection\Extension\ExtensionInterface[]
223			*/
224			protected function getExtensions()
225			{
226			return [];
227			}
228			}
229

gnutix / swbooks

Push — master ( 866487...6bcace )

Kernel::getPublicDir() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like