FluentDriver::getClassFromFile() - Code Metrics - Inspection of "[FEATURE] Allow loading mappings from paths" - laravel-doctrine/fluent - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 1.1 (#41)

unknown

created 2016-10-24 17:49 UTC

FluentDriver::getClassFromFile() C

↳ Parent: FluentDriver

Complexity

Conditions	14
Paths	98

Size

Total Lines	58
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	210

Importance

Changes

Metric	Value
dl	0
loc	58
ccs	0
cts	0
cp	0
rs	6.4881
c	0
b	0
f	0
cc	14
eloc	19
nc	98
nop	1
crap	210

How to fix Long Method Complexity

<?php

namespace LaravelDoctrine\Fluent;

use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
use Doctrine\ORM\Mapping\Builder\ClassMetadataBuilder;
use Doctrine\ORM\Mapping\MappingException;
use InvalidArgumentException;
use LaravelDoctrine\Fluent\Builders\Builder;
use LaravelDoctrine\Fluent\Mappers\MapperSet;

class FluentDriver implements MappingDriver
{
    /**
     * @var MapperSet
     */
    protected $mappers;

    /**
     * @var callable
     */
    protected $fluentFactory;

    /**
     * Initializes a new FileDriver that looks in the given path(s) for mapping
     * documents and operates in the specified operating mode.
     *
     * @param string[]|null $mappings
     * @param string[]|null $paths
     *
     * @throws \Doctrine\ORM\Mapping\MappingException
     */
    public function __construct($mappings, $paths)
    {
        $this->fluentFactory = function (ClassMetadata $metadata) {
            return new Builder(new ClassMetadataBuilder($metadata));
        };

        $this->mappers = new MapperSet();

        if ($mappings !== null) {
            $this->addMappings($mappings);
        }

        if ($paths !== null) {
            $this->addPaths($paths);
        }
    }

    /**
     * Loads the metadata for the specified class into the provided container.
     *
     * @param string        $className
     * @param ClassMetadata $metadata
     */
    public function loadMetadataForClass($className, ClassMetadata $metadata)
    {
        $this->mappers->getMapperFor($className)->map(
            $this->getFluent($metadata)
        );
    }

    /**
     * Gets the names of all mapped classes known to this driver.
     *
     * @throws MappingException
     *
     * @return string[] The names of all mapped classes known to this driver.
     */
    public function getAllClassNames()
    {
        return $this->mappers->getClassNames();
    }

    /**
     * Returns whether the class with the specified name should have its metadata loaded.
     * This is only the case if it is either mapped as an Entity or a MappedSuperclass.
     *
     * @param string $className
     *
     * @return bool
     */
    public function isTransient($className)
    {
        return
            !$this->mappers->hasMapperFor($className) ||
            $this->mappers->getMapperFor($className)->isTransient();
    }

    /**
     * @param string[] $mappings
     */
    public function addMappings(array $mappings = [])
    {
        foreach ($mappings as $class) {
            if (!class_exists($class)) {
                throw new InvalidArgumentException("Mapping class [{$class}] does not exist");
            }

            $mapping = new $class();

            if (!$mapping instanceof Mapping) {
                throw new InvalidArgumentException("Mapping class [{$class}] should implement ".Mapping::class);
            }

            $this->addMapping($mapping);
        }
    }

    /**
     * @param Mapping $mapping
     *
     * @throws MappingException
     */
    public function addMapping(Mapping $mapping)
    {
        $this->mappers->add($mapping);
    }

    /**
     * @return MapperSet
     */
    public function getMappers()
    {
        return $this->mappers;
    }

    /**
     * Add mappings from an array of folders.
     *
     * @param string[] $paths
     *
     * @throws MappingException
     */
    public function addPaths($paths)
    {
        foreach ($paths as $path) {
            if (!is_dir($path)) {
                throw MappingException::fileMappingDriversRequireConfiguredDirectoryPath($path);
            }

            $iterator = new \RecursiveIteratorIterator(
                new \RecursiveDirectoryIterator($path),
                \RecursiveIteratorIterator::LEAVES_ONLY
            );

            foreach ($iterator as $file) {
                if ($file->getBasename('.php') == $file->getBasename()) {
                    continue;
                }

                $sourceFile = realpath($file->getPathName());
                $className = $this->getClassFromFile($sourceFile);
                $this->addMapping(new $className());
            }
        }
    }

    /**
     * Get the FQN of a class from a source file.
     *
     * @param $pathToFile
     *
     * @return string
     */
    private function getClassFromFile($pathToFile)
    {
        //http://jarretbyrne.com/2015/06/197/
        //Grab the contents of the file
        $contents = file_get_contents($pathToFile);

        //Start with a blank namespace and class
        $namespace = $class = '';

        //Set helper values to know that we have found the namespace/class token and need to collect the string values after them
        $getting_namespace = $getting_class = false;

        //Go through each token and evaluate it as necessary
        foreach (token_get_all($contents) as $token) {

            //If this token is the namespace declaring, then flag that the next tokens will be the namespace name
            if (is_array($token) && $token[0] == T_NAMESPACE) {
                $getting_namespace = true;
            }

            //If this token is the class declaring, then flag that the next tokens will be the class name
            if (is_array($token) && $token[0] == T_CLASS) {
                $getting_class = true;
            }

            //While we're grabbing the namespace name...
            if ($getting_namespace === true) {

                //If the token is a string or the namespace separator...
                if (is_array($token) && in_array($token[0], [T_STRING, T_NS_SEPARATOR])) {

                    //Append the token's value to the name of the namespace
                    $namespace .= $token[1];
                } elseif ($token === ';') {

                    //If the token is the semicolon, then we're done with the namespace declaration
                    $getting_namespace = false;
                }
            }

            //While we're grabbing the class name...
            if ($getting_class === true) {

                //If the token is a string, it's the name of the class
                if (is_array($token) && $token[0] == T_STRING) {

                    //Store the token's value as the class name
                    $class = $token[1];

                    //Got what we need, stope here
                    break;
                }
            }
        }

        //Build the fully-qualified class name and return it
        return $namespace ? $namespace.'\\'.$class : $class;
    }

    /**
     * Override the default Fluent factory method with a custom one.
     * Use this to implement your own Fluent builder.
     * The method will receive a ClassMetadata object as its only argument.
     *
     * @param callable $factory
     */
    public function setFluentFactory(callable $factory)
    {
        $this->fluentFactory = $factory;
    }

    /**
     * @param ClassMetadata $metadata
     *
     * @return Fluent
     */
    protected function getFluent(ClassMetadata $metadata)
    {
        return call_user_func($this->fluentFactory, $metadata);
    }
}


1		<?php
2
3		namespace LaravelDoctrine\Fluent;
4
5		use Doctrine\Common\Persistence\Mapping\ClassMetadata;
6		use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
7		use Doctrine\ORM\Mapping\Builder\ClassMetadataBuilder;
8		use Doctrine\ORM\Mapping\MappingException;
9		use InvalidArgumentException;
10		use LaravelDoctrine\Fluent\Builders\Builder;
11		use LaravelDoctrine\Fluent\Mappers\MapperSet;
12
13		class FluentDriver implements MappingDriver
14		{
15		/**
16		* @var MapperSet
17		*/
18		protected $mappers;
19
20		/**
21		* @var callable
22		*/
23		protected $fluentFactory;
24
25		/**
26		* Initializes a new FileDriver that looks in the given path(s) for mapping
27		* documents and operates in the specified operating mode.
28		*
29		* @param string[]\|null $mappings
30		* @param string[]\|null $paths
31		*
32		* @throws \Doctrine\ORM\Mapping\MappingException
33	4	*/
34	4	public function __construct($mappings, $paths)
35		{
36		$this->fluentFactory = function (ClassMetadata $metadata) {
37	92	return new Builder(new ClassMetadataBuilder($metadata));
38	92	};
39	92
40		$this->mappers = new MapperSet();
41
42		if ($mappings !== null) {
43		$this->addMappings($mappings);
44		}
45
46		if ($paths !== null) {
47	6	$this->addPaths($paths);
48		}
49	6	}
50	5
51	5	/**
52	5	* Loads the metadata for the specified class into the provided container.
53		*
54		* @param string $className
55		* @param ClassMetadata $metadata
56		*/
57		public function loadMetadataForClass($className, ClassMetadata $metadata)
58		{
59		$this->mappers->getMapperFor($className)->map(
60	12	$this->getFluent($metadata)
61		);
62	12	}
63
64		/**
65		* Gets the names of all mapped classes known to this driver.
66		*
67		* @throws MappingException
68		*
69		* @return string[] The names of all mapped classes known to this driver.
70		*/
71		public function getAllClassNames()
72		{
73	4	return $this->mappers->getClassNames();
74		}
75
76	4	/**
77	4	* Returns whether the class with the specified name should have its metadata loaded.
78		* This is only the case if it is either mapped as an Entity or a MappedSuperclass.
79		*
80		* @param string $className
81		*
82		* @return bool
83	92	*/
84		public function isTransient($className)
85	92	{
86	82	return
87	1	!$this->mappers->hasMapperFor($className) \|\|
88		$this->mappers->getMapperFor($className)->isTransient();
89		}
90	81
91		/**
92	81	* @param string[] $mappings
93	1	*/
94		public function addMappings(array $mappings = [])
95		{
96	80	foreach ($mappings as $class) {
97	92	if (!class_exists($class)) {
98	92	throw new InvalidArgumentException("Mapping class [{$class}] does not exist");
99		}
100
101		$mapping = new $class();
102
103		if (!$mapping instanceof Mapping) {
104		throw new InvalidArgumentException("Mapping class [{$class}] should implement ".Mapping::class);
105		}
106	87
107		$this->addMapping($mapping);
108	87	}
109	87	}
110
111		/**
112		* @param Mapping $mapping
113		*
114	5	* @throws MappingException
115		*/
116	5	public function addMapping(Mapping $mapping)
117		{
118		$this->mappers->add($mapping);
119		}
120
121		/**
122		* @return MapperSet
123		*/
124		public function getMappers()
125		{
126	1	return $this->mappers;
127		}
128	1
129	1	/**
130		* Add mappings from an array of folders.
131		*
132		* @param string[] $paths
133		*
134		* @throws MappingException
135	5	*/
136		public function addPaths($paths)
137	5	{
138		foreach ($paths as $path) {
139		if (!is_dir($path)) {
140		throw MappingException::fileMappingDriversRequireConfiguredDirectoryPath($path);
141		}
142
143		$iterator = new \RecursiveIteratorIterator(
144		new \RecursiveDirectoryIterator($path),
145		\RecursiveIteratorIterator::LEAVES_ONLY
146		);
147
148		foreach ($iterator as $file) {
149		if ($file->getBasename('.php') == $file->getBasename()) {
150		continue;
151		}
152
153		$sourceFile = realpath($file->getPathName());
154		$className = $this->getClassFromFile($sourceFile);
155		$this->addMapping(new $className());
156		}
157		}
158		}
159
160		/**
161		* Get the FQN of a class from a source file.
162		*
163		* @param $pathToFile
164		*
165		* @return string
166		*/
167		private function getClassFromFile($pathToFile)
168		{
169		//http://jarretbyrne.com/2015/06/197/
170		//Grab the contents of the file
171		$contents = file_get_contents($pathToFile);
172
173		//Start with a blank namespace and class
174		$namespace = $class = '';
175
176		//Set helper values to know that we have found the namespace/class token and need to collect the string values after them
177		$getting_namespace = $getting_class = false;
178
179		//Go through each token and evaluate it as necessary
180		foreach (token_get_all($contents) as $token) {
181
182		//If this token is the namespace declaring, then flag that the next tokens will be the namespace name
183		if (is_array($token) && $token[0] == T_NAMESPACE) {
184		$getting_namespace = true;
185		}
186
187		//If this token is the class declaring, then flag that the next tokens will be the class name
188		if (is_array($token) && $token[0] == T_CLASS) {
189		$getting_class = true;
190		}
191
192		//While we're grabbing the namespace name...
193		if ($getting_namespace === true) {
194
195		//If the token is a string or the namespace separator...
196		if (is_array($token) && in_array($token[0], [T_STRING, T_NS_SEPARATOR])) {
197
198		//Append the token's value to the name of the namespace
199		$namespace .= $token[1];
200		} elseif ($token === ';') {
201
202		//If the token is the semicolon, then we're done with the namespace declaration
203		$getting_namespace = false;
204		}
205		}
206
207		//While we're grabbing the class name...
208		if ($getting_class === true) {
209
210		//If the token is a string, it's the name of the class
211		if (is_array($token) && $token[0] == T_STRING) {
212
213		//Store the token's value as the class name
214		$class = $token[1];
215
216		//Got what we need, stope here
217		break;
218		}
219		}
220		}
221
222		//Build the fully-qualified class name and return it
223		return $namespace ? $namespace.'\\'.$class : $class;
224		}
225
226		/**
227		* Override the default Fluent factory method with a custom one.
228		* Use this to implement your own Fluent builder.
229		* The method will receive a ClassMetadata object as its only argument.
230		*
231		* @param callable $factory
232		*/
233		public function setFluentFactory(callable $factory)
234		{
235		$this->fluentFactory = $factory;
236		}
237
238		/**
239		* @param ClassMetadata $metadata
240		*
241		* @return Fluent
242		*/
243		protected function getFluent(ClassMetadata $metadata)
244		{
245		return call_user_func($this->fluentFactory, $metadata);
246		}
247		}
248

laravel-doctrine / fluent

Pull Request — 1.1 (#41)

FluentDriver::getClassFromFile() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like