AssetExtensionLoader::createVersionStrategy() - Code Metrics - Inspection of "Increase minimum Symfony version to 2.7" - regularjack/frontend-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#29)

by Paulo Rodrigues

created 2017-06-15 18:47 UTC

AssetExtensionLoader::createVersionStrategy() A

↳ Parent: AssetExtensionLoader

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	10
ccs	5
cts	5
cp	1
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	5
nc	2
nop	2
crap	2

<?php

namespace Rj\FrontendBundle\DependencyInjection;

use Rj\FrontendBundle\Util\Util;
use Symfony\Component\Config\Loader\LoaderInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\DefinitionDecorator;
use Symfony\Component\DependencyInjection\Reference;

class AssetExtensionLoader
{
    /**
     * @var string
     */
    private $alias;

    /**
     * @var ContainerBuilder
     */
    private $container;

    /**
     * @param string $alias
     * @param ContainerBuilder $container
     */
    public function __construct($alias, ContainerBuilder $container)
    {
        $this->alias = $alias;
        $this->container = $container;
    }

    /**
     * @param array $config
     * @param LoaderInterface $loader
     */
    public function load(array $config, LoaderInterface $loader)
    {
        $loader->load('asset.yml');

        if ($config['override_default_package']) {
            $loader->load('fallback.yml');

            $defaultPackage = $this->createPackage('default', array(
                'prefix'   => $config['prefix'],
                'manifest' => $config['manifest'],
            ));

            $defaultPackageId = $this->getPackageId('default');
            $this->container->setDefinition($defaultPackageId, $defaultPackage);

            $fallbackPackage = $this->createFallbackPackage(
                $config['fallback_patterns'],
                new Reference($defaultPackageId)
            );

            $this->container->setDefinition($this->namespaceService('package.fallback'), $fallbackPackage);
        }

        foreach ($config['packages'] as $name => $packageConfig) {
            $packageTag = $this->namespaceService('package.asset');
            $package = $this->createPackage($name, $packageConfig)
                ->addTag($packageTag, array('alias' => $name));

            $this->container->setDefinition($this->getPackageId($name), $package);
        }
    }

    /**
     * @param string $name
     * @param array $config
     * @return Definition
     */
    private function createPackage($name, array $config)
    {
        $prefixes = $config['prefix'];
        $isUrl = Util::containsUrl($prefixes);

        $packageDefinition = $isUrl
            ? new DefinitionDecorator($this->namespaceService('asset.package.url'))
            : new DefinitionDecorator($this->namespaceService('asset.package.path'))
        ;

        return $packageDefinition
            ->addArgument($isUrl ? $prefixes : $prefixes[0])
            ->addArgument($this->createVersionStrategy($name, $config['manifest']))
            ->setPublic(false);
    }

    /**
     * @param array $patterns
     * @param Reference $customDefaultPackage
     * @return Definition
     */
    private function createFallbackPackage(array $patterns, Reference $customDefaultPackage)
    {
        $packageDefinition = new DefinitionDecorator($this->namespaceService('asset.package.fallback'));

        return $packageDefinition
            ->setPublic(false)
            ->addArgument($patterns)
            ->addArgument($customDefaultPackage);
    }

    /**
     * @param string $name
     * @return string
     */
    private function getPackageId($name)
    {
        return $this->namespaceService("_package.$name");
    }

    /**
     * @param string $packageName
     * @param array $manifest
     * @return Reference
     */
    private function createVersionStrategy($packageName, array $manifest)
    {
        if ($manifest['enabled']) {
            return $this->createManifestVersionStrategy($packageName, $manifest);
        }

        $versionStrategy = new Reference($this->namespaceService('version_strategy.empty'));;
// Bad
$a = 5; $b = 6; $c = 7;

// Good
$a = 5;
$b = 6;
$c = 7;

        return $this->createAssetVersionStrategy($packageName, $versionStrategy);
    }

    /**
     * @param string $packageName
     * @param array $config
     * @return Reference
     */
    private function createManifestVersionStrategy($packageName, $config)
    {
        $loader = new DefinitionDecorator($this->namespaceService('manifest.loader.'.$config['format']));
        $loader
            ->addArgument($config['path'])
            ->addArgument($config['root_key'])
        ;

        $loaderId = $this->namespaceService("_package.$packageName.manifest_loader");
        $this->container->setDefinition($loaderId, $loader);

        $cachedLoader = new DefinitionDecorator($this->namespaceService('manifest.loader.cached'));
        $cachedLoader->addArgument(new Reference($loaderId));

        $cachedLoaderId = $this->namespaceService("_package.$packageName.manifest_loader_cached");
        $this->container->setDefinition($cachedLoaderId, $cachedLoader);

        $versionStrategy = new DefinitionDecorator($this->namespaceService('version_strategy.manifest'));
        $versionStrategy->addArgument(new Reference($cachedLoaderId));

        $versionStrategyId = $this->namespaceService("_package.$packageName.version_strategy");
        $this->container->setDefinition($versionStrategyId, $versionStrategy);

        return $this->createAssetVersionStrategy($packageName, new Reference($versionStrategyId));
    }

    /**
     * @param string $packageName
     * @param Reference $versionStrategy
     * @return Reference
     */
    private function createAssetVersionStrategy($packageName, $versionStrategy)
    {
        $version = new DefinitionDecorator($this->namespaceService('asset.version_strategy'));
        $version->addArgument($versionStrategy);

        $versionId = $this->namespaceService("_package.$packageName.version_strategy_asset");
        $this->container->setDefinition($versionId, $version);

        return new Reference($versionId);
    }

    /**
     * @param string $id
     * @return string
     */
    private function namespaceService($id)
    {
        return $this->alias.'.'.$id;
    }
}


1		<?php
2
3		namespace Rj\FrontendBundle\DependencyInjection;
4
5		use Rj\FrontendBundle\Util\Util;
6		use Symfony\Component\Config\Loader\LoaderInterface;
7		use Symfony\Component\DependencyInjection\ContainerBuilder;
8		use Symfony\Component\DependencyInjection\Definition;
9		use Symfony\Component\DependencyInjection\DefinitionDecorator;
10		use Symfony\Component\DependencyInjection\Reference;
11
12		class AssetExtensionLoader
13		{
14		/**
15		* @var string
16		*/
17		private $alias;
18
19		/**
20		* @var ContainerBuilder
21		*/
22		private $container;
23
24		/**
25		* @param string $alias
26		* @param ContainerBuilder $container
27		*/
28	20	public function __construct($alias, ContainerBuilder $container)
29		{
30	20	$this->alias = $alias;
31	20	$this->container = $container;
32	20	}
33
34		/**
35		* @param array $config
36		* @param LoaderInterface $loader
37		*/
38	20	public function load(array $config, LoaderInterface $loader)
39		{
40	20	$loader->load('asset.yml');
41
42	20	if ($config['override_default_package']) {
43	19	$loader->load('fallback.yml');
44
45	19	$defaultPackage = $this->createPackage('default', array(
46	19	'prefix' => $config['prefix'],
47	19	'manifest' => $config['manifest'],
48		));
49
50	19	$defaultPackageId = $this->getPackageId('default');
51	19	$this->container->setDefinition($defaultPackageId, $defaultPackage);
52
53	19	$fallbackPackage = $this->createFallbackPackage(
54	19	$config['fallback_patterns'],
55	19	new Reference($defaultPackageId)
56		);
57
58	19	$this->container->setDefinition($this->namespaceService('package.fallback'), $fallbackPackage);
59		}
60
61	20	foreach ($config['packages'] as $name => $packageConfig) {
62	10	$packageTag = $this->namespaceService('package.asset');
63	10	$package = $this->createPackage($name, $packageConfig)
64	10	->addTag($packageTag, array('alias' => $name));
65
66	10	$this->container->setDefinition($this->getPackageId($name), $package);
67		}
68	20	}
69
70		/**
71		* @param string $name
72		* @param array $config
73		* @return Definition
74		*/
75	19	private function createPackage($name, array $config)
76		{
77	19	$prefixes = $config['prefix'];
78	19	$isUrl = Util::containsUrl($prefixes);
79
80	19	$packageDefinition = $isUrl
81	4	? new DefinitionDecorator($this->namespaceService('asset.package.url'))
82	19	: new DefinitionDecorator($this->namespaceService('asset.package.path'))
83		;
84
85		return $packageDefinition
86	19	->addArgument($isUrl ? $prefixes : $prefixes[0])
87	19	->addArgument($this->createVersionStrategy($name, $config['manifest']))
88	19	->setPublic(false);
89		}
90
91		/**
92		* @param array $patterns
93		* @param Reference $customDefaultPackage
94		* @return Definition
95		*/
96	19	private function createFallbackPackage(array $patterns, Reference $customDefaultPackage)
97		{
98	19	$packageDefinition = new DefinitionDecorator($this->namespaceService('asset.package.fallback'));
99
100		return $packageDefinition
101	19	->setPublic(false)
102	19	->addArgument($patterns)
103	19	->addArgument($customDefaultPackage);
104		}
105
106		/**
107		* @param string $name
108		* @return string
109		*/
110	19	private function getPackageId($name)
111		{
112	19	return $this->namespaceService("_package.$name");
113		}
114
115		/**
116		* @param string $packageName
117		* @param array $manifest
118		* @return Reference
119		*/
120	19	private function createVersionStrategy($packageName, array $manifest)
121		{
122	19	if ($manifest['enabled']) {
123	4	return $this->createManifestVersionStrategy($packageName, $manifest);
124		}
125
126	17	$versionStrategy = new Reference($this->namespaceService('version_strategy.empty'));;
		0 ignored issues – show Coding Style introduced 2017-06-15 18:54 UTC by Report Bug Copy Issue Report It is generally recommended to place each PHP statement on a line by itself. Let’s take a look at an example: // Bad $a = 5; $b = 6; $c = 7; // Good $a = 5; $b = 6; $c = 7; Loading history...
127
128	17	return $this->createAssetVersionStrategy($packageName, $versionStrategy);
129		}
130
131		/**
132		* @param string $packageName
133		* @param array $config
134		* @return Reference
135		*/
136	4	private function createManifestVersionStrategy($packageName, $config)
137		{
138	4	$loader = new DefinitionDecorator($this->namespaceService('manifest.loader.'.$config['format']));
139		$loader
140	4	->addArgument($config['path'])
141	4	->addArgument($config['root_key'])
142		;
143
144	4	$loaderId = $this->namespaceService("_package.$packageName.manifest_loader");
145	4	$this->container->setDefinition($loaderId, $loader);
146
147	4	$cachedLoader = new DefinitionDecorator($this->namespaceService('manifest.loader.cached'));
148	4	$cachedLoader->addArgument(new Reference($loaderId));
149
150	4	$cachedLoaderId = $this->namespaceService("_package.$packageName.manifest_loader_cached");
151	4	$this->container->setDefinition($cachedLoaderId, $cachedLoader);
152
153	4	$versionStrategy = new DefinitionDecorator($this->namespaceService('version_strategy.manifest'));
154	4	$versionStrategy->addArgument(new Reference($cachedLoaderId));
155
156	4	$versionStrategyId = $this->namespaceService("_package.$packageName.version_strategy");
157	4	$this->container->setDefinition($versionStrategyId, $versionStrategy);
158
159	4	return $this->createAssetVersionStrategy($packageName, new Reference($versionStrategyId));
160		}
161
162		/**
163		* @param string $packageName
164		* @param Reference $versionStrategy
165		* @return Reference
166		*/
167	19	private function createAssetVersionStrategy($packageName, $versionStrategy)
168		{
169	19	$version = new DefinitionDecorator($this->namespaceService('asset.version_strategy'));
170	19	$version->addArgument($versionStrategy);
171
172	19	$versionId = $this->namespaceService("_package.$packageName.version_strategy_asset");
173	19	$this->container->setDefinition($versionId, $version);
174
175	19	return new Reference($versionId);
176		}
177
178		/**
179		* @param string $id
180		* @return string
181		*/
182	19	private function namespaceService($id)
183		{
184	19	return $this->alias.'.'.$id;
185		}
186		}
187

regularjack / frontend-bundle

Pull Request — master (#29)

AssetExtensionLoader::createVersionStrategy() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like