ZikulaKernel::isClassInBundle() - Code Metrics - Inspection of "update vendors" - zikula/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 8a455a...42a228 )

by Craig

created 2019-12-14 23:31 UTC

ZikulaKernel::isClassInBundle() A

↳ Parent: ZikulaKernel

Complexity

Conditions	3
Paths	3

Size

Total Lines	10
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

declare(strict_types=1);

/*
 * This file is part of the Zikula package.
 *
 * Copyright Zikula Foundation - https://ziku.la/
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Zikula\Bundle\CoreBundle\HttpKernel;

use Composer\Autoload\ClassLoader;
use Exception;
use InvalidArgumentException;
use Symfony\Component\Debug\DebugClassLoader;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\HttpKernel\Bundle\BundleInterface;
use Symfony\Component\HttpKernel\DependencyInjection\MergeExtensionConfigurationPass;
use Symfony\Component\HttpKernel\Kernel;
use Symfony\Component\Yaml\Yaml;
use Zikula\AdminModule\ZikulaAdminModule;
use Zikula\BlocksModule\ZikulaBlocksModule;
use Zikula\CategoriesModule\ZikulaCategoriesModule;
use Zikula\Core\AbstractBundle;
use Zikula\Core\AbstractModule;
use Zikula\ExtensionsModule\ZikulaExtensionsModule;
use Zikula\GroupsModule\ZikulaGroupsModule;
use Zikula\MailerModule\ZikulaMailerModule;
use Zikula\MenuModule\ZikulaMenuModule;
use Zikula\PermissionsModule\ZikulaPermissionsModule;
use Zikula\RoutesModule\ZikulaRoutesModule;
use Zikula\SearchModule\ZikulaSearchModule;
use Zikula\SecurityCenterModule\ZikulaSecurityCenterModule;
use Zikula\SettingsModule\ZikulaSettingsModule;
use Zikula\ThemeModule\AbstractTheme;
use Zikula\ThemeModule\Engine\Engine as ThemeEngine;
use Zikula\ThemeModule\EventListener\AddJSConfigListener;
use Zikula\ThemeModule\ZikulaThemeModule;
use Zikula\UsersModule\ZikulaUsersModule;
use Zikula\ZAuthModule\ZikulaZAuthModule;

// Defines for access levels
define('ACCESS_INVALID', -1);
define('ACCESS_NONE', 0);
define('ACCESS_OVERVIEW', 100);
define('ACCESS_READ', 200);
define('ACCESS_COMMENT', 300);
define('ACCESS_MODERATE', 400);
define('ACCESS_EDIT', 500);
define('ACCESS_ADD', 600);
define('ACCESS_DELETE', 700);
define('ACCESS_ADMIN', 800);

abstract class ZikulaKernel extends Kernel implements ZikulaHttpKernelInterface
{
    public const VERSION = '3.0.0';

    public const PHP_MINIMUM_VERSION = '7.2.0';

    /**
     * The parameter name identifying the currently installed version of the core.
     */
    public const CORE_INSTALLED_VERSION_PARAM = 'core_installed_version';

    /**
     * The controller at the front of the application (the first file loaded as controlled by the server & .htaccess)
     * @see src/.htaccess
     * @see AddJSConfigListener::addJSConfig
     */
    public const FRONT_CONTROLLER = 'index.php';

    /**
     * Public list of core modules and their bundle class.
     * @var array
     */
    public static $coreModules = [
        'ZikulaAdminModule' => ZikulaAdminModule::class,
        'ZikulaBlocksModule' => ZikulaBlocksModule::class,
        'ZikulaCategoriesModule' => ZikulaCategoriesModule::class,
        'ZikulaExtensionsModule' => ZikulaExtensionsModule::class,
        'ZikulaGroupsModule' => ZikulaGroupsModule::class,
        'ZikulaMailerModule' => ZikulaMailerModule::class,
        'ZikulaMenuModule' => ZikulaMenuModule::class,
        'ZikulaPermissionsModule' => ZikulaPermissionsModule::class,
        'ZikulaRoutesModule' => ZikulaRoutesModule::class,
        'ZikulaSearchModule' => ZikulaSearchModule::class,
        'ZikulaSecurityCenterModule' => ZikulaSecurityCenterModule::class,
        'ZikulaSettingsModule' => ZikulaSettingsModule::class,
        'ZikulaThemeModule' => ZikulaThemeModule::class,
        'ZikulaUsersModule' => ZikulaUsersModule::class,
        'ZikulaZAuthModule' => ZikulaZAuthModule::class
    ];

    /**
     * @var boolean
     */
//    private $dump = true;

    /**
     * @var array
     */
    private $modules = [];

    /**
     * @var array
     */
    private $themes = [];

    /**
     * @var ClassLoader
     */
    private $autoloader;

//    public function setDump(bool $flag): void
//    {
//        $this->dump = $flag;
//    }

    public function boot()
    {
        if (null === $this->autoloader) {
            $this->getAutoloader();
        }

        parent::boot();

        foreach ($this->bundles as $name => $bundle) {
            if ($bundle instanceof AbstractModule && !isset($this->modules[$name])) {
                $this->modules[$name] = $bundle;
            } elseif ($bundle instanceof AbstractTheme && !isset($this->themes[$name])) {
                $this->themes[$name] = $bundle;
            }
        }
    }

    public function getModule(string $moduleName): AbstractModule
    {
        if (!isset($this->modules[$moduleName])) {
            throw new InvalidArgumentException(sprintf('Module "%s" does not exist or it is not enabled.', $moduleName));
        }

        return $this->modules[$moduleName];
    }

    public function getModules(): array
    {
        return $this->modules;
    }

    public static function isCoreModule(string $moduleName): bool
    {
        return array_key_exists($moduleName, self::$coreModules);
    }

    public function getTheme(string $themeName): AbstractTheme
    {
        if (!isset($this->themes[$themeName])) {
            throw new InvalidArgumentException(sprintf('Theme "%s" does not exist or it is not enabled.', $themeName));
        }

        return $this->themes[$themeName];
    }

    public function getThemes(): array
    {
        return $this->themes;
    }

    public function getJustBundles(): array
    {
        $bundles = [];
        foreach ($this->bundles as $bundle) {
            if (!$bundle instanceof AbstractBundle) {
                $bundles[] = $bundle;
            }
        }

        return $bundles;
    }

    public function isBundle(string $name): bool
    {
        try {
            $this->getBundle($name);

            return true;
        } catch (Exception $exception) {
            return false;
        }
    }

    public function setAutoloader(ClassLoader $autoloader): void
    {
        $this->autoloader = $autoloader;
    }

    public function getAutoloader(): ClassLoader
    {
        if (null === $this->autoloader) {
            $loaders = spl_autoload_functions();
            if ($loaders[0][0] instanceof DebugClassLoader) {
                $classLoader = $loaders[0][0]->getClassLoader();
                if (is_callable($classLoader) && is_object($classLoader[0])) {
                    $this->autoloader = $classLoader[0];
                } elseif (is_object($classLoader)) {
                    $this->autoloader = $classLoader;
                }
            } else {
                $this->autoloader = $loaders[0][0];
            }
        }

        return $this->autoloader;
    }

    public function getConnectionConfig(): array
    {
        $config = Yaml::parse(file_get_contents($this->getProjectDir() . '/app/config/parameters.yml'));
        if (is_readable($file = $this->getProjectDir() . '/app/config/custom_parameters.yml')) {
            $config = array_merge($config, Yaml::parse(file_get_contents($file)));
        }

        return $config;
    }

    public function isClassInBundle(string $class): bool
    {
        /* @var BundleInterface $bundle */
        foreach ($this->getBundles() as $bundle) {
            if (0 === mb_strpos($class, $bundle->getNamespace())) {
                return $bundle instanceof AbstractBundle;
            }
        }

        return false;
    }

    /**
     * Initializes the service container.
     *
     * The cached version of the service container is used when fresh, otherwise the
     * container is built.
     *
     * Overridden not to dump the container.
     */
//    protected function initializeContainer()
//    {
//        if (true === $this->dump) {
//            return parent::initializeContainer();
//        }
//
//        $this->container = $this->buildContainer();
//        $this->container->set('kernel', $this);
//    }

    /**
     * Prepares the ContainerBuilder before it is compiled.
     */
//    protected function prepareContainer(ContainerBuilder $container)
//    {
//        $extensions = [];
//        foreach ($this->bundles as $bundle) {
//            if ($bundle instanceof AbstractBundle && AbstractBundle::STATE_ACTIVE !== $bundle->getState()) {
//                continue;
//            }
//            if ($extension = $bundle->getContainerExtension()) {
//                $container->registerExtension($extension);
//                $extensions[] = $extension->getAlias();
//            }
//
//            if ($this->debug) {
//                $container->addObjectResource($bundle);
//            }
//        }
//
//        foreach ($this->bundles as $bundle) {
//            if ($bundle instanceof AbstractBundle && AbstractBundle::STATE_ACTIVE !== $bundle->getState()) {
//                continue;
//            }
//            $bundle->build($container);
//        }
//
//        $this->build($container);
//
//        foreach ($container->getExtensions() as $extension) {
//            $extensions[] = $extension->getAlias();
//        }
//
//        // ensure these extensions are implicitly loaded
//        $container->getCompilerPassConfig()->setMergePass(new MergeExtensionConfigurationPass($extensions));
//    }

    /**
     * REMOVE THIS I THINK
     */
//    public function locateResource($name, $dir = null, $first = true)
//    {
//        $locations = parent::locateResource($name, $dir, false);
//        if ($locations && null !== $dir && false !== mb_strpos($locations[0], $dir)) {
//            // if found in $dir (typically app/Resources) return it immediately.
//            return $locations[0];
//        }
//
//        $themeBundle = $this->container->get(ThemeEngine::class)->getTheme();
//        // add theme path to template locator
//        // this method functions if the controller uses `@Template` or `ZikulaSpecModule:Foo:index.html.twig` naming scheme
//        // if `@ZikulaSpecModule/Foo/index.html.twig` (name-spaced) naming scheme is used
//        // the \Zikula\ThemeModule\EventListener\TemplatePathOverrideListener::setUpThemePathOverrides method is used instead
//        if ($themeBundle && false === mb_strpos($name, $themeBundle->getName())) {
//            // do not add theme override path to theme files
//            $customThemePath = $themeBundle->getPath() . '/Resources';
//
//            return parent::locateResource($name, $customThemePath);
//        }
//
//        return $locations[0];
//    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Zikula package.
7			*
8			* Copyright Zikula Foundation - https://ziku.la/
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Zikula\Bundle\CoreBundle\HttpKernel;
15
16			use Composer\Autoload\ClassLoader;
17			use Exception;
18			use InvalidArgumentException;
19			use Symfony\Component\Debug\DebugClassLoader;
20			use Symfony\Component\DependencyInjection\ContainerBuilder;
21			use Symfony\Component\HttpKernel\Bundle\BundleInterface;
22			use Symfony\Component\HttpKernel\DependencyInjection\MergeExtensionConfigurationPass;
23			use Symfony\Component\HttpKernel\Kernel;
24			use Symfony\Component\Yaml\Yaml;
25			use Zikula\AdminModule\ZikulaAdminModule;
26			use Zikula\BlocksModule\ZikulaBlocksModule;
27			use Zikula\CategoriesModule\ZikulaCategoriesModule;
28			use Zikula\Core\AbstractBundle;
29			use Zikula\Core\AbstractModule;
30			use Zikula\ExtensionsModule\ZikulaExtensionsModule;
31			use Zikula\GroupsModule\ZikulaGroupsModule;
32			use Zikula\MailerModule\ZikulaMailerModule;
33			use Zikula\MenuModule\ZikulaMenuModule;
34			use Zikula\PermissionsModule\ZikulaPermissionsModule;
35			use Zikula\RoutesModule\ZikulaRoutesModule;
36			use Zikula\SearchModule\ZikulaSearchModule;
37			use Zikula\SecurityCenterModule\ZikulaSecurityCenterModule;
38			use Zikula\SettingsModule\ZikulaSettingsModule;
39			use Zikula\ThemeModule\AbstractTheme;
40			use Zikula\ThemeModule\Engine\Engine as ThemeEngine;
41			use Zikula\ThemeModule\EventListener\AddJSConfigListener;
42			use Zikula\ThemeModule\ZikulaThemeModule;
43			use Zikula\UsersModule\ZikulaUsersModule;
44			use Zikula\ZAuthModule\ZikulaZAuthModule;
45
46			// Defines for access levels
47			define('ACCESS_INVALID', -1);
48			define('ACCESS_NONE', 0);
49			define('ACCESS_OVERVIEW', 100);
50			define('ACCESS_READ', 200);
51			define('ACCESS_COMMENT', 300);
52			define('ACCESS_MODERATE', 400);
53			define('ACCESS_EDIT', 500);
54			define('ACCESS_ADD', 600);
55			define('ACCESS_DELETE', 700);
56			define('ACCESS_ADMIN', 800);
57
58			abstract class ZikulaKernel extends Kernel implements ZikulaHttpKernelInterface
59			{
60			public const VERSION = '3.0.0';
61
62			public const PHP_MINIMUM_VERSION = '7.2.0';
63
64			/**
65			* The parameter name identifying the currently installed version of the core.
66			*/
67			public const CORE_INSTALLED_VERSION_PARAM = 'core_installed_version';
68
69			/**
70			* The controller at the front of the application (the first file loaded as controlled by the server & .htaccess)
71			* @see src/.htaccess
72			* @see AddJSConfigListener::addJSConfig
73			*/
74			public const FRONT_CONTROLLER = 'index.php';
75
76			/**
77			* Public list of core modules and their bundle class.
78			* @var array
79			*/
80			public static $coreModules = [
81			'ZikulaAdminModule' => ZikulaAdminModule::class,
82			'ZikulaBlocksModule' => ZikulaBlocksModule::class,
83			'ZikulaCategoriesModule' => ZikulaCategoriesModule::class,
84			'ZikulaExtensionsModule' => ZikulaExtensionsModule::class,
85			'ZikulaGroupsModule' => ZikulaGroupsModule::class,
86			'ZikulaMailerModule' => ZikulaMailerModule::class,
87			'ZikulaMenuModule' => ZikulaMenuModule::class,
88			'ZikulaPermissionsModule' => ZikulaPermissionsModule::class,
89			'ZikulaRoutesModule' => ZikulaRoutesModule::class,
90			'ZikulaSearchModule' => ZikulaSearchModule::class,
91			'ZikulaSecurityCenterModule' => ZikulaSecurityCenterModule::class,
92			'ZikulaSettingsModule' => ZikulaSettingsModule::class,
93			'ZikulaThemeModule' => ZikulaThemeModule::class,
94			'ZikulaUsersModule' => ZikulaUsersModule::class,
95			'ZikulaZAuthModule' => ZikulaZAuthModule::class
96			];
97
98			/**
99			* @var boolean
100			*/
101			// private $dump = true;
102
103			/**
104			* @var array
105			*/
106			private $modules = [];
107
108			/**
109			* @var array
110			*/
111			private $themes = [];
112
113			/**
114			* @var ClassLoader
115			*/
116			private $autoloader;
117
118			// public function setDump(bool $flag): void
119			// {
120			// $this->dump = $flag;
121			// }
122
123			public function boot()
124			{
125			if (null === $this->autoloader) {
126			$this->getAutoloader();
127			}
128
129			parent::boot();
130
131			foreach ($this->bundles as $name => $bundle) {
132			if ($bundle instanceof AbstractModule && !isset($this->modules[$name])) {
133			$this->modules[$name] = $bundle;
134			} elseif ($bundle instanceof AbstractTheme && !isset($this->themes[$name])) {
135			$this->themes[$name] = $bundle;
136			}
137			}
138			}
139
140			public function getModule(string $moduleName): AbstractModule
141			{
142			if (!isset($this->modules[$moduleName])) {
143			throw new InvalidArgumentException(sprintf('Module "%s" does not exist or it is not enabled.', $moduleName));
144			}
145
146			return $this->modules[$moduleName];
147			}
148
149			public function getModules(): array
150			{
151			return $this->modules;
152			}
153
154			public static function isCoreModule(string $moduleName): bool
155			{
156			return array_key_exists($moduleName, self::$coreModules);
157			}
158
159			public function getTheme(string $themeName): AbstractTheme
160			{
161			if (!isset($this->themes[$themeName])) {
162			throw new InvalidArgumentException(sprintf('Theme "%s" does not exist or it is not enabled.', $themeName));
163			}
164
165			return $this->themes[$themeName];
166			}
167
168			public function getThemes(): array
169			{
170			return $this->themes;
171			}
172
173			public function getJustBundles(): array
174			{
175			$bundles = [];
176			foreach ($this->bundles as $bundle) {
177			if (!$bundle instanceof AbstractBundle) {
178			$bundles[] = $bundle;
179			}
180			}
181
182			return $bundles;
183			}
184
185			public function isBundle(string $name): bool
186			{
187			try {
188			$this->getBundle($name);
189
190			return true;
191			} catch (Exception $exception) {
192			return false;
193			}
194			}
195
196			public function setAutoloader(ClassLoader $autoloader): void
197			{
198			$this->autoloader = $autoloader;
199			}
200
201			public function getAutoloader(): ClassLoader
202			{
203			if (null === $this->autoloader) {
204			$loaders = spl_autoload_functions();
205			if ($loaders[0][0] instanceof DebugClassLoader) {
206			$classLoader = $loaders[0][0]->getClassLoader();
207			if (is_callable($classLoader) && is_object($classLoader[0])) {
208			$this->autoloader = $classLoader[0];
209			} elseif (is_object($classLoader)) {
210			$this->autoloader = $classLoader;
211			}
212			} else {
213			$this->autoloader = $loaders[0][0];
214			}
215			}
216
217			return $this->autoloader;
218			}
219
220			public function getConnectionConfig(): array
221			{
222			$config = Yaml::parse(file_get_contents($this->getProjectDir() . '/app/config/parameters.yml'));
223			if (is_readable($file = $this->getProjectDir() . '/app/config/custom_parameters.yml')) {
224			$config = array_merge($config, Yaml::parse(file_get_contents($file)));
225			}
226
227			return $config;
228			}
229
230			public function isClassInBundle(string $class): bool
231			{
232			/* @var BundleInterface $bundle */
233			foreach ($this->getBundles() as $bundle) {
234			if (0 === mb_strpos($class, $bundle->getNamespace())) {
235			return $bundle instanceof AbstractBundle;
236			}
237			}
238
239			return false;
240			}
241
242			/**
243			* Initializes the service container.
244			*
245			* The cached version of the service container is used when fresh, otherwise the
246			* container is built.
247			*
248			* Overridden not to dump the container.
249			*/
250			// protected function initializeContainer()
251			// {
252			// if (true === $this->dump) {
253			// return parent::initializeContainer();
254			// }
255			//
256			// $this->container = $this->buildContainer();
257			// $this->container->set('kernel', $this);
258			// }
259
260			/**
261			* Prepares the ContainerBuilder before it is compiled.
262			*/
263			// protected function prepareContainer(ContainerBuilder $container)
264			// {
265			// $extensions = [];
266			// foreach ($this->bundles as $bundle) {
267			// if ($bundle instanceof AbstractBundle && AbstractBundle::STATE_ACTIVE !== $bundle->getState()) {
268			// continue;
269			// }
270			// if ($extension = $bundle->getContainerExtension()) {
271			// $container->registerExtension($extension);
272			// $extensions[] = $extension->getAlias();
273			// }
274			//
275			// if ($this->debug) {
276			// $container->addObjectResource($bundle);
277			// }
278			// }
279			//
280			// foreach ($this->bundles as $bundle) {
281			// if ($bundle instanceof AbstractBundle && AbstractBundle::STATE_ACTIVE !== $bundle->getState()) {
282			// continue;
283			// }
284			// $bundle->build($container);
285			// }
286			//
287			// $this->build($container);
288			//
289			// foreach ($container->getExtensions() as $extension) {
290			// $extensions[] = $extension->getAlias();
291			// }
292			//
293			// // ensure these extensions are implicitly loaded
294			// $container->getCompilerPassConfig()->setMergePass(new MergeExtensionConfigurationPass($extensions));
295			// }
296
297			/**
298			* REMOVE THIS I THINK
299			*/
300			// public function locateResource($name, $dir = null, $first = true)
301			// {
302			// $locations = parent::locateResource($name, $dir, false);
303			// if ($locations && null !== $dir && false !== mb_strpos($locations[0], $dir)) {
304			// // if found in $dir (typically app/Resources) return it immediately.
305			// return $locations[0];
306			// }
307			//
308			// $themeBundle = $this->container->get(ThemeEngine::class)->getTheme();
309			// // add theme path to template locator
310			// // this method functions if the controller uses `@Template` or `ZikulaSpecModule:Foo:index.html.twig` naming scheme
311			// // if `@ZikulaSpecModule/Foo/index.html.twig` (name-spaced) naming scheme is used
312			// // the \Zikula\ThemeModule\EventListener\TemplatePathOverrideListener::setUpThemePathOverrides method is used instead
313			// if ($themeBundle && false === mb_strpos($name, $themeBundle->getName())) {
314			// // do not add theme override path to theme files
315			// $customThemePath = $themeBundle->getPath() . '/Resources';
316			//
317			// return parent::locateResource($name, $customThemePath);
318			// }
319			//
320			// return $locations[0];
321			// }
322			}
323

zikula / core

Push — master ( 8a455a...42a228 )

ZikulaKernel::isClassInBundle() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like