AutoMappingPass::bundleDir() - Code Metrics - Inspection of "Add support of inheritance for relay-mutation-inpu..." - overblog/GraphQLBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#423)

unknown

created 2018-11-23 10:17 UTC

AutoMappingPass::bundleDir() A

↳ Parent: AutoMappingPass

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Overblog\GraphQLBundle\DependencyInjection\Compiler;

use GraphQL\Type\Definition\Type;
use Overblog\GraphQLBundle\Definition\Resolver\AliasedInterface;
use Overblog\GraphQLBundle\Definition\Resolver\MutationInterface;
use Overblog\GraphQLBundle\Definition\Resolver\ResolverInterface;
use Overblog\GraphQLBundle\OverblogGraphQLBundle;
use Symfony\Component\Config\Resource\DirectoryResource;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerAwareInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\Finder\Finder;

class AutoMappingPass implements CompilerPassInterface
{
    const SERVICE_SUBCLASS_TAG_MAPPING = [
        MutationInterface::class => 'overblog_graphql.mutation',
        ResolverInterface::class => 'overblog_graphql.resolver',
        Type::class => TypeTaggedServiceMappingPass::TAG_NAME,
    ];

    public function process(ContainerBuilder $container)
    {
        $enabled = $container->getParameter('overblog_graphql.auto_mapping.enabled');
        // enabled auto mapping for all bundles and custom dirs ?
        if ($enabled) {
            $directories = $container->getParameter('overblog_graphql.auto_mapping.directories');
            $bundles = $container->getParameter('kernel.bundles');
            $directories = \array_merge(
                \array_map(
                    function ($class) {
                        $bundleDir = $this->bundleDir($class);

                        return $bundleDir.'/GraphQL';
                    },
                    $bundles
                ),
                $directories
            );
            // add app dir
            if ($container->hasParameter('kernel.root_dir')) {
                $directories[] = $container->getParameter('kernel.root_dir').'/GraphQL';
            }
        } else {
            // enabled auto mapping only for this bundle
            $directories = [$this->bundleDir(OverblogGraphQLBundle::class).'/GraphQL'];
        }
        $directoryList = [];

        foreach ($directories as $directory) {
            list($reflectionClasses, $directories) = $this->reflectionClassesFromDirectory($directory);
            $directoryList = \array_merge($directoryList, $directories);
            $this->addServicesDefinitions($container, $reflectionClasses);
        }

        foreach ($directoryList as $directory => $v) {
            $directory = \realpath($directory);
            $container->addResource(new DirectoryResource($directory, '/\.php$/'));
        }
    }

    /**
     * @param ContainerBuilder   $container
     * @param \ReflectionClass[] $reflectionClasses
     */
    private function addServicesDefinitions(ContainerBuilder $container, array $reflectionClasses)
    {
        foreach ($reflectionClasses as $reflectionClass) {
            $this->addServiceDefinition($container, $reflectionClass);
        }
    }

    private function addServiceDefinition(ContainerBuilder $container, \ReflectionClass $reflectionClass)
    {
        $className = $reflectionClass->getName();

        $definition = $container->setDefinition($className, new Definition($className));
        $definition->setPublic(false);
        $definition->setAutowired(true);
        if (\is_subclass_of($definition->getClass(), ContainerAwareInterface::class)) {

            $definition->addMethodCall('setContainer', [new Reference('service_container')]);
        }
        $this->addDefinitionTags($definition, $reflectionClass);
    }

    private function addDefinitionTags(Definition $definition, \ReflectionClass $reflectionClass)
    {
        foreach (self::SERVICE_SUBCLASS_TAG_MAPPING as $subclass => $tagName) {
            if (!$reflectionClass->isSubclassOf($subclass)) {
                continue;
            }

            if (Type::class !== $subclass) {
                $publicReflectionMethods = $reflectionClass->getMethods(\ReflectionMethod::IS_PUBLIC);
                $isAliased = $reflectionClass->implementsInterface(AliasedInterface::class);
                foreach ($publicReflectionMethods as $publicReflectionMethod) {
                    if ('__construct' === $publicReflectionMethod->name || $isAliased && 'getAliases' === $publicReflectionMethod->name) {
                        continue;
                    }
                    $definition->addTag($tagName, ['method' => $publicReflectionMethod->name]);
                }
            } else {
                $definition->addTag($tagName);
            }
        }
    }

    private function subclass($class)
    {
        $interfaces = \array_keys(self::SERVICE_SUBCLASS_TAG_MAPPING);

        foreach ($interfaces as $interface) {
            if (\is_a($class, $interface, true)) {
                return $interface;
            }
        }

        return false;
    }

    /**
     * Gets the classes reflection of class in the given directory.
     *
     * @param string $directory
     *
     * @return array
     */
    private function reflectionClassesFromDirectory($directory)
    {
        $classes = [];
        $directoryList = [];
        $includedFiles = [];
        $reflectionClasses = [];

        $finder = new Finder();
        try {
            $finder->in($directory)->files()->name('*.php');
        } catch (\InvalidArgumentException $e) {
            return [$reflectionClasses, $directoryList];
        }

        foreach ($finder as $file) {
            $directoryList[$file->getPath()] = true;
            $sourceFile = $file->getRealpath();
            if (!\preg_match('(^phar:)i', $sourceFile)) {
                $sourceFile = \realpath($sourceFile);
            }

            require_once $sourceFile;
            $includedFiles[$sourceFile] = true;
        }

        $declared = \get_declared_classes();
        foreach ($declared as $className) {
            $subclass = $this->subclass($className);
            if (false === $subclass) {
                continue;
            }
            $reflectionClass = new \ReflectionClass($className);
            $reflectionClasses[$className] = $reflectionClass;
            $sourceFile = $reflectionClass->getFileName();

            if ($reflectionClass->isAbstract()) {
                continue;
            }

            if (isset($includedFiles[$sourceFile])) {
                $classes[$className] = true;
            }
        }

        return [\array_intersect_key($reflectionClasses, $classes), $directoryList];
    }

    private function bundleDir($bundleClass)
    {
        $bundle = new \ReflectionClass($bundleClass);
        $bundleDir = \dirname($bundle->getFileName());

        return $bundleDir;
    }
}


1			<?php
2
3			namespace Overblog\GraphQLBundle\DependencyInjection\Compiler;
4
5			use GraphQL\Type\Definition\Type;
6			use Overblog\GraphQLBundle\Definition\Resolver\AliasedInterface;
7			use Overblog\GraphQLBundle\Definition\Resolver\MutationInterface;
8			use Overblog\GraphQLBundle\Definition\Resolver\ResolverInterface;
9			use Overblog\GraphQLBundle\OverblogGraphQLBundle;
10			use Symfony\Component\Config\Resource\DirectoryResource;
11			use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
12			use Symfony\Component\DependencyInjection\ContainerAwareInterface;
13			use Symfony\Component\DependencyInjection\ContainerBuilder;
14			use Symfony\Component\DependencyInjection\Definition;
15			use Symfony\Component\DependencyInjection\Reference;
16			use Symfony\Component\Finder\Finder;
17
18			class AutoMappingPass implements CompilerPassInterface
19			{
20			const SERVICE_SUBCLASS_TAG_MAPPING = [
21			MutationInterface::class => 'overblog_graphql.mutation',
22			ResolverInterface::class => 'overblog_graphql.resolver',
23			Type::class => TypeTaggedServiceMappingPass::TAG_NAME,
24			];
25
26			public function process(ContainerBuilder $container)
27			{
28			$enabled = $container->getParameter('overblog_graphql.auto_mapping.enabled');
29			// enabled auto mapping for all bundles and custom dirs ?
30			if ($enabled) {
31			$directories = $container->getParameter('overblog_graphql.auto_mapping.directories');
32			$bundles = $container->getParameter('kernel.bundles');
33			$directories = \array_merge(
34			\array_map(
35			function ($class) {
36			$bundleDir = $this->bundleDir($class);
37
38			return $bundleDir.'/GraphQL';
39			},
40			$bundles
41			),
42			$directories
43			);
44			// add app dir
45			if ($container->hasParameter('kernel.root_dir')) {
46			$directories[] = $container->getParameter('kernel.root_dir').'/GraphQL';
47			}
48			} else {
49			// enabled auto mapping only for this bundle
50			$directories = [$this->bundleDir(OverblogGraphQLBundle::class).'/GraphQL'];
51			}
52			$directoryList = [];
53
54			foreach ($directories as $directory) {
55			list($reflectionClasses, $directories) = $this->reflectionClassesFromDirectory($directory);
56			$directoryList = \array_merge($directoryList, $directories);
57			$this->addServicesDefinitions($container, $reflectionClasses);
58			}
59
60			foreach ($directoryList as $directory => $v) {
61			$directory = \realpath($directory);
62			$container->addResource(new DirectoryResource($directory, '/\.php$/'));
63			}
64			}
65
66			/**
67			* @param ContainerBuilder $container
68			* @param \ReflectionClass[] $reflectionClasses
69			*/
70			private function addServicesDefinitions(ContainerBuilder $container, array $reflectionClasses)
71			{
72			foreach ($reflectionClasses as $reflectionClass) {
73			$this->addServiceDefinition($container, $reflectionClass);
74			}
75			}
76
77			private function addServiceDefinition(ContainerBuilder $container, \ReflectionClass $reflectionClass)
78			{
79			$className = $reflectionClass->getName();
			0 ignored issues – show Bug introduced 2017-05-02 14:02 UTC by Report Bug Copy Issue Report Consider using `$reflectionClass->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
80			$definition = $container->setDefinition($className, new Definition($className));
81			$definition->setPublic(false);
82			$definition->setAutowired(true);
83			if (\is_subclass_of($definition->getClass(), ContainerAwareInterface::class)) {
			0 ignored issues – show Bug introduced 2017-05-02 11:59 UTC by Report Bug Copy Issue Report Due to PHP Bug #53727, `is_subclass_of` might return inconsistent results on some PHP versions if `\Symfony\Component\Depen...erAwareInterface::class` can be an interface. If so, you could instead use `ReflectionClass::implementsInterface`. Loading history...
84			$definition->addMethodCall('setContainer', [new Reference('service_container')]);
85			}
86			$this->addDefinitionTags($definition, $reflectionClass);
87			}
88
89			private function addDefinitionTags(Definition $definition, \ReflectionClass $reflectionClass)
90			{
91			foreach (self::SERVICE_SUBCLASS_TAG_MAPPING as $subclass => $tagName) {
92			if (!$reflectionClass->isSubclassOf($subclass)) {
93			continue;
94			}
95
96			if (Type::class !== $subclass) {
97			$publicReflectionMethods = $reflectionClass->getMethods(\ReflectionMethod::IS_PUBLIC);
98			$isAliased = $reflectionClass->implementsInterface(AliasedInterface::class);
99			foreach ($publicReflectionMethods as $publicReflectionMethod) {
100			if ('__construct' === $publicReflectionMethod->name \|\| $isAliased && 'getAliases' === $publicReflectionMethod->name) {
101			continue;
102			}
103			$definition->addTag($tagName, ['method' => $publicReflectionMethod->name]);
104			}
105			} else {
106			$definition->addTag($tagName);
107			}
108			}
109			}
110
111			private function subclass($class)
112			{
113			$interfaces = \array_keys(self::SERVICE_SUBCLASS_TAG_MAPPING);
114
115			foreach ($interfaces as $interface) {
116			if (\is_a($class, $interface, true)) {
117			return $interface;
118			}
119			}
120
121			return false;
122			}
123
124			/**
125			* Gets the classes reflection of class in the given directory.
126			*
127			* @param string $directory
128			*
129			* @return array
130			*/
131			private function reflectionClassesFromDirectory($directory)
132			{
133			$classes = [];
134			$directoryList = [];
135			$includedFiles = [];
136			$reflectionClasses = [];
137
138			$finder = new Finder();
139			try {
140			$finder->in($directory)->files()->name('*.php');
141			} catch (\InvalidArgumentException $e) {
142			return [$reflectionClasses, $directoryList];
143			}
144
145			foreach ($finder as $file) {
146			$directoryList[$file->getPath()] = true;
147			$sourceFile = $file->getRealpath();
148			if (!\preg_match('(^phar:)i', $sourceFile)) {
149			$sourceFile = \realpath($sourceFile);
150			}
151
152			require_once $sourceFile;
153			$includedFiles[$sourceFile] = true;
154			}
155
156			$declared = \get_declared_classes();
157			foreach ($declared as $className) {
158			$subclass = $this->subclass($className);
159			if (false === $subclass) {
160			continue;
161			}
162			$reflectionClass = new \ReflectionClass($className);
163			$reflectionClasses[$className] = $reflectionClass;
164			$sourceFile = $reflectionClass->getFileName();
165
166			if ($reflectionClass->isAbstract()) {
167			continue;
168			}
169
170			if (isset($includedFiles[$sourceFile])) {
171			$classes[$className] = true;
172			}
173			}
174
175			return [\array_intersect_key($reflectionClasses, $classes), $directoryList];
176			}
177
178			private function bundleDir($bundleClass)
179			{
180			$bundle = new \ReflectionClass($bundleClass);
181			$bundleDir = \dirname($bundle->getFileName());
182
183			return $bundleDir;
184			}
185			}
186

overblog / GraphQLBundle

Scrutinizer GitHub App not installed

Pull Request — master (#423)

AutoMappingPass::bundleDir() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like