MetadataProvider::reset() - Code Metrics - Inspection of "Cache object map along with metadata" - Algo-Web/POData-Laravel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#143)

by Alex

created 2017-11-17 03:16 UTC

MetadataProvider::reset() A

↳ Parent: MetadataProvider

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace AlgoWeb\PODataLaravel\Providers;

use AlgoWeb\PODataLaravel\Models\MetadataGubbinsHolder;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\Association;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationMonomorphic;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationStubRelationType;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationType;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\EntityFieldType;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\EntityGubbins;
use AlgoWeb\PODataLaravel\Models\ObjectMap\Map;
use Illuminate\Contracts\Container\BindingResolutionException;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\App;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Schema as Schema;
use POData\Providers\Metadata\ResourceEntityType;
use POData\Providers\Metadata\ResourceSet;
use POData\Providers\Metadata\ResourceStreamInfo;
use POData\Providers\Metadata\SimpleMetadataProvider;
use POData\Providers\Metadata\Type\TypeCode;

class MetadataProvider extends MetadataBaseProvider
{
    protected $multConstraints = ['0..1' => ['1'], '1' => ['0..1', '*'], '*' => ['1', '*']];
    protected static $metaNAMESPACE = 'Data';
    protected static $isBooted = false;
    const POLYMORPHIC = 'polyMorphicPlaceholder';
    const POLYMORPHIC_PLURAL = 'polyMorphicPlaceholders';

    /**
     * @var Map The completed object map set at post Implement;
     */
    private $completedObjectMap;

    /**
     * @return \AlgoWeb\PODataLaravel\Models\ObjectMap\Map
     */
    public function getObjectMap()
    {
        return $this->completedObjectMap;
    }

    protected static $afterExtract;
    protected static $afterUnify;
    protected static $afterVerify;
    protected static $afterImplement;

    public static function setAfterExtract(callable $method)
    {
        self::$afterExtract = $method;
    }

    public static function setAfterUnify(callable $method)
    {
        self::$afterUnify = $method;
    }

    public static function setAfterVerify(callable $method)
    {
        self::$afterVerify = $method;
    }

    public static function setAfterImplement(callable $method)
    {
        self::$afterImplement = $method;
    }


    protected $relationHolder;

    public function __construct($app)
    {
        parent::__construct($app);
        $this->relationHolder = new MetadataGubbinsHolder();
        self::$isBooted = false;
    }

    private function extract(array $modelNames)
    {
        $objectMap = new Map();
        foreach ($modelNames as $modelName) {
            try {
                $modelInstance = App::make($modelName);
            } catch (BindingResolutionException $e) {
                // if we can't instantiate modelName for whatever reason, move on
                continue;
            }
            $gubbins = $modelInstance->extractGubbins();
            $isEmpty = 0 === count($gubbins->getFields());
            $inArtisan = $this->isRunningInArtisan();
            if (!($isEmpty && $inArtisan)) {
                $objectMap->addEntity($gubbins);
            }
        }
        if (null != self::$afterExtract) {
            $func = self::$afterExtract;
            $func($objectMap);
        }
        return $objectMap;
    }

    private function unify(Map $objectMap)
    {
        $mgh = $this->getRelationHolder();
        foreach ($objectMap->getEntities() as $entity) {
            $mgh->addEntity($entity);
        }
        $objectMap->setAssociations($mgh->getRelations());
        if (null != self::$afterUnify) {
            $func = self::$afterUnify;
            $func($objectMap);
        }
        return $objectMap;
    }

    private function verify(Map $objectModel)
    {
        $objectModel->isOK();
        if (null != self::$afterVerify) {
            $func = self::$afterVerify;
            $func($objectModel);
        }
    }

    private function implement(Map $objectModel)
    {
        $meta = App::make('metadata');
        $entities = $objectModel->getEntities();
        foreach ($entities as $entity) {
            $baseType = null;
            $className = $entity->getClassName();
            $entityName = $entity->getName();
            $entityType = $meta->addEntityType(new \ReflectionClass($className), $entityName, false, $baseType);
            assert($entityType->hasBaseType() === isset($baseType));
            $entity->setOdataResourceType($entityType);
            $this->implementProperties($entity);
            $meta->addResourceSet($entity->getClassName(), $entityType);
            $meta->oDataEntityMap[$className] = $meta->oDataEntityMap[$entityName];
        }
        $metaCount = count($meta->oDataEntityMap);
        $entityCount = count($entities);
        $expected = 2 * $entityCount;
        assert($metaCount == $expected, 'Expected ' . $expected . ' items, actually got '.$metaCount);

        if (null === $objectModel->getAssociations()) {
            return;
        }
        $assoc = $objectModel->getAssociations();
        $assoc = null === $assoc ? [] : $assoc;
        foreach ($assoc as $association) {
            assert($association->isOk());
            $this->implementAssociationsMonomorphic($objectModel, $association);
        }
        if (null != self::$afterImplement) {
            $func = self::$afterImplement;
            $func($objectModel);
        }
    }

    private function implementAssociationsMonomorphic(Map $objectModel, AssociationMonomorphic $associationUnderHammer)
    {
        $meta = App::make('metadata');
        $first = $associationUnderHammer->getFirst();
        $last = $associationUnderHammer->getLast();
        switch ($associationUnderHammer->getAssociationType()) {
            case AssociationType::NULL_ONE_TO_NULL_ONE():
            case AssociationType::NULL_ONE_TO_ONE():
            case AssociationType::ONE_TO_ONE():

                $meta->addResourceReferenceSinglePropertyBidirectional(
                    $objectModel->getEntities()[$first->getBaseType()]->getOdataResourceType(),
                    $objectModel->getEntities()[$last->getBaseType()]->getOdataResourceType(),
                    $first->getRelationName(),
                    $last->getRelationName()
                );
                break;
            case AssociationType::NULL_ONE_TO_MANY():
            case AssociationType::ONE_TO_MANY():
                if ($first->getMultiplicity()->getValue() == AssociationStubRelationType::MANY) {
                    $oneSide = $last;
                    $manySide = $first;
                } else {
                    $oneSide = $first;
                    $manySide = $last;
                }
                $meta->addResourceReferencePropertyBidirectional(
                    $objectModel->getEntities()[$oneSide->getBaseType()]->getOdataResourceType(),
                    $objectModel->getEntities()[$manySide->getBaseType()]->getOdataResourceType(),
                    $oneSide->getRelationName(),
                    $manySide->getRelationName()
                );
                break;
            case AssociationType::MANY_TO_MANY():

                $meta->addResourceSetReferencePropertyBidirectional(
                    $objectModel->getEntities()[$first->getBaseType()]->getOdataResourceType(),
                    $objectModel->getEntities()[$last->getBaseType()]->getOdataResourceType(),
                    $first->getRelationName(),
                    $last->getRelationName()
                );
        }
    }

    private function implementProperties(EntityGubbins $unifiedEntity)
    {
        $meta = App::make('metadata');
        $odataEntity = $unifiedEntity->getOdataResourceType();
        $keyFields = $unifiedEntity->getKeyFields();
        $fields = $unifiedEntity->getFields();
        foreach ($keyFields as $keyField) {
            $meta->addKeyProperty($odataEntity, $keyField->getName(), $keyField->getEdmFieldType());
        }

        foreach ($fields as $field) {
            if (in_array($field, $keyFields)) {
                continue;
            }
            if ($field->getPrimitiveType() == 'blob') {
                $odataEntity->setMediaLinkEntry(true);
                $streamInfo = new ResourceStreamInfo($field->getName());
                assert($odataEntity->isMediaLinkEntry());
                $odataEntity->addNamedStream($streamInfo);
                continue;
            }
            $meta->addPrimitiveProperty(
                $odataEntity,
                $field->getName(),
                $field->getEdmFieldType(),
                $field->getFieldType() == EntityFieldType::PRIMITIVE_BAG(),
                strval($field->getDefaultValue()),
                $field->getIsNullable()
            );
        }
    }

    /**
     * Bootstrap the application services.  Post-boot.
     *
     * @param mixed $reset
     *
     * @return void
     */
    public function boot($reset = true)
    {
        self::$metaNAMESPACE = env('ODataMetaNamespace', 'Data');
        // If we aren't migrated, there's no DB tables to pull metadata _from_, so bail out early
        try {
            if (!Schema::hasTable(config('database.migrations'))) {
                return;
            }
        } catch (\Exception $e) {
            return;
        }

        assert(false === self::$isBooted, 'Provider booted twice');
        $isCaching = true === $this->getIsCaching();
        $meta = Cache::get('metadata');
        $objectMap = Cache::get('objectmap');
        $hasCache = null != $meta && null != $objectMap;

        if ($isCaching && $hasCache) {
            App::instance('metadata', $meta);
            App::instance('objectmap', $objectMap);

            return;
        }
        $meta = App::make('metadata');
        if (false !== $reset) {
            $this->reset();
        }

        $modelNames = $this->getCandidateModels();
        $objectModel = $this->extract($modelNames);
        $objectModel = $this->unify($objectModel);
        $this->verify($objectModel);
        $this->implement($objectModel);
        $this->completedObjectMap = $objectModel;
        $key = 'metadata';
        $objKey = 'objectmap';
        $this->handlePostBoot($isCaching, $hasCache, $key, $meta);
        $this->handlePostBoot($isCaching, $hasCache, $objKey, $objectModel);
        self::$isBooted = true;
    }

    /**
     * Register the application services.  Boot-time only.
     *
     * @return void
     */
    public function register()
    {
        $this->app->singleton('metadata', function ($app) {

            return new SimpleMetadataProvider('Data', self::$metaNAMESPACE);
        });
        $this->app->singleton('objectmap', function ($app) {

            return new Map();
        });
    }

    /**
     * @return array
     */
    protected function getCandidateModels()
    {
        $classes = $this->getClassMap();
        $ends = [];
        $startName = defined('PODATA_LARAVEL_APP_ROOT_NAMESPACE') ? PODATA_LARAVEL_APP_ROOT_NAMESPACE : 'App';
        foreach ($classes as $name) {
            if (\Illuminate\Support\Str::startsWith($name, $startName)) {
                if (in_array('AlgoWeb\\PODataLaravel\\Models\\MetadataTrait', class_uses($name)) &&
                is_subclass_of($name, '\\Illuminate\\Database\\Eloquent\\Model')) {
                    $ends[] = $name;
                }
            }
        }
        return $ends;
    }

    /**
     * @return MetadataGubbinsHolder
     */
    public function getRelationHolder()
    {
        return $this->relationHolder;
    }

    public function reset()
    {
        self::$isBooted = false;
        self::$afterExtract = null;
        self::$afterUnify = null;
        self::$afterVerify = null;
        self::$afterImplement = null;
    }

    /**
     * Resolve possible reverse relation property names.
     *
     * @param Model $source
     * @param $propName
     * @return null|string
     * @internal param Model $target
     */
    public function resolveReverseProperty(Model $source, $propName)
    {
        assert(is_string($propName), 'Property name must be string');
        $entity = $this->getObjectMap()->resolveEntity(get_class($source));
        if (null === $entity) {
            $msg = 'Source model not defined';
            throw new \InvalidArgumentException($msg);
        }
        $association = $entity->resolveAssociation($propName);
        if (null === $association) {
            return null;
        }
        $isFirst = $propName === $association->getFirst()->getRelationName();
        if (!$isFirst) {
            return $association->getFirst()->getRelationName();
        }

        assert($association instanceof AssociationMonomorphic);
        return $association->getLast()->getRelationName();
    }

    public function isRunningInArtisan()
    {
        return App::runningInConsole() && !App::runningUnitTests();
    }
}


1			<?php
2
3			namespace AlgoWeb\PODataLaravel\Providers;
4
5			use AlgoWeb\PODataLaravel\Models\MetadataGubbinsHolder;
6			use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\Association;
7			use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationMonomorphic;
8			use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationStubRelationType;
9			use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\Associations\AssociationType;
10			use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\EntityFieldType;
11			use AlgoWeb\PODataLaravel\Models\ObjectMap\Entities\EntityGubbins;
12			use AlgoWeb\PODataLaravel\Models\ObjectMap\Map;
13			use Illuminate\Contracts\Container\BindingResolutionException;
14			use Illuminate\Database\Eloquent\Model;
15			use Illuminate\Support\Facades\App;
16			use Illuminate\Support\Facades\Cache;
17			use Illuminate\Support\Facades\Schema as Schema;
18			use POData\Providers\Metadata\ResourceEntityType;
19			use POData\Providers\Metadata\ResourceSet;
20	1		use POData\Providers\Metadata\ResourceStreamInfo;
21			use POData\Providers\Metadata\SimpleMetadataProvider;
22	1		use POData\Providers\Metadata\Type\TypeCode;
23
24			class MetadataProvider extends MetadataBaseProvider
25	1		{
26			protected $multConstraints = ['0..1' => ['1'], '1' => ['0..1', ''], '' => ['1', '*']];
27			protected static $metaNAMESPACE = 'Data';
28	1		protected static $isBooted = false;
29	1		const POLYMORPHIC = 'polyMorphicPlaceholder';
30			const POLYMORPHIC_PLURAL = 'polyMorphicPlaceholders';
31
32			/**
33			* @var Map The completed object map set at post Implement;
34			*/
35			private $completedObjectMap;
36
37			/**
38			* @return \AlgoWeb\PODataLaravel\Models\ObjectMap\Map
39			*/
40			public function getObjectMap()
41			{
42			return $this->completedObjectMap;
43			}
44
45			protected static $afterExtract;
46			protected static $afterUnify;
47			protected static $afterVerify;
48			protected static $afterImplement;
49
50			public static function setAfterExtract(callable $method)
51			{
52			self::$afterExtract = $method;
53			}
54
55			public static function setAfterUnify(callable $method)
56			{
57			self::$afterUnify = $method;
58			}
59
60			public static function setAfterVerify(callable $method)
61			{
62			self::$afterVerify = $method;
63			}
64
65			public static function setAfterImplement(callable $method)
66			{
67			self::$afterImplement = $method;
68			}
69
70
71			protected $relationHolder;
72
73			public function __construct($app)
74			{
75			parent::__construct($app);
76			$this->relationHolder = new MetadataGubbinsHolder();
77			self::$isBooted = false;
78			}
79
80			private function extract(array $modelNames)
81			{
82			$objectMap = new Map();
83			foreach ($modelNames as $modelName) {
84			try {
85			$modelInstance = App::make($modelName);
86			} catch (BindingResolutionException $e) {
87			// if we can't instantiate modelName for whatever reason, move on
88			continue;
89			}
90			$gubbins = $modelInstance->extractGubbins();
91			$isEmpty = 0 === count($gubbins->getFields());
92			$inArtisan = $this->isRunningInArtisan();
93			if (!($isEmpty && $inArtisan)) {
94			$objectMap->addEntity($gubbins);
95			}
96			}
97			if (null != self::$afterExtract) {
98			$func = self::$afterExtract;
99			$func($objectMap);
100			}
101			return $objectMap;
102			}
103
104			private function unify(Map $objectMap)
105			{
106			$mgh = $this->getRelationHolder();
107			foreach ($objectMap->getEntities() as $entity) {
108			$mgh->addEntity($entity);
109			}
110			$objectMap->setAssociations($mgh->getRelations());
111			if (null != self::$afterUnify) {
112			$func = self::$afterUnify;
113			$func($objectMap);
114			}
115			return $objectMap;
116			}
117
118			private function verify(Map $objectModel)
119			{
120			$objectModel->isOK();
121			if (null != self::$afterVerify) {
122			$func = self::$afterVerify;
123			$func($objectModel);
124			}
125			}
126
127			private function implement(Map $objectModel)
128			{
129			$meta = App::make('metadata');
130			$entities = $objectModel->getEntities();
131			foreach ($entities as $entity) {
132			$baseType = null;
133			$className = $entity->getClassName();
134			$entityName = $entity->getName();
135			$entityType = $meta->addEntityType(new \ReflectionClass($className), $entityName, false, $baseType);
136			assert($entityType->hasBaseType() === isset($baseType));
137			$entity->setOdataResourceType($entityType);
138			$this->implementProperties($entity);
139			$meta->addResourceSet($entity->getClassName(), $entityType);
140			$meta->oDataEntityMap[$className] = $meta->oDataEntityMap[$entityName];
141			}
142			$metaCount = count($meta->oDataEntityMap);
143			$entityCount = count($entities);
144			$expected = 2 * $entityCount;
145			assert($metaCount == $expected, 'Expected ' . $expected . ' items, actually got '.$metaCount);
146
147			if (null === $objectModel->getAssociations()) {
148			return;
149			}
150			$assoc = $objectModel->getAssociations();
151			$assoc = null === $assoc ? [] : $assoc;
152			foreach ($assoc as $association) {
153			assert($association->isOk());
154			$this->implementAssociationsMonomorphic($objectModel, $association);
155			}
156			if (null != self::$afterImplement) {
157			$func = self::$afterImplement;
158			$func($objectModel);
159			}
160			}
161
162			private function implementAssociationsMonomorphic(Map $objectModel, AssociationMonomorphic $associationUnderHammer)
163			{
164			$meta = App::make('metadata');
165			$first = $associationUnderHammer->getFirst();
166			$last = $associationUnderHammer->getLast();
167			switch ($associationUnderHammer->getAssociationType()) {
168			case AssociationType::NULL_ONE_TO_NULL_ONE():
169			case AssociationType::NULL_ONE_TO_ONE():
170		View Code Duplication	case AssociationType::ONE_TO_ONE():
			0 ignored issues – show Duplication introduced 2017-09-24 07:01 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
171			$meta->addResourceReferenceSinglePropertyBidirectional(
172			$objectModel->getEntities()[$first->getBaseType()]->getOdataResourceType(),
173			$objectModel->getEntities()[$last->getBaseType()]->getOdataResourceType(),
174			$first->getRelationName(),
175			$last->getRelationName()
176			);
177			break;
178			case AssociationType::NULL_ONE_TO_MANY():
179			case AssociationType::ONE_TO_MANY():
180			if ($first->getMultiplicity()->getValue() == AssociationStubRelationType::MANY) {
181			$oneSide = $last;
182			$manySide = $first;
183			} else {
184			$oneSide = $first;
185			$manySide = $last;
186			}
187			$meta->addResourceReferencePropertyBidirectional(
188			$objectModel->getEntities()[$oneSide->getBaseType()]->getOdataResourceType(),
189			$objectModel->getEntities()[$manySide->getBaseType()]->getOdataResourceType(),
190			$oneSide->getRelationName(),
191			$manySide->getRelationName()
192			);
193			break;
194		View Code Duplication	case AssociationType::MANY_TO_MANY():
			0 ignored issues – show Duplication introduced 2017-09-24 07:01 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
195			$meta->addResourceSetReferencePropertyBidirectional(
196			$objectModel->getEntities()[$first->getBaseType()]->getOdataResourceType(),
197			$objectModel->getEntities()[$last->getBaseType()]->getOdataResourceType(),
198			$first->getRelationName(),
199			$last->getRelationName()
200			);
201			}
202			}
203
204			private function implementProperties(EntityGubbins $unifiedEntity)
205			{
206			$meta = App::make('metadata');
207			$odataEntity = $unifiedEntity->getOdataResourceType();
208			$keyFields = $unifiedEntity->getKeyFields();
209			$fields = $unifiedEntity->getFields();
210			foreach ($keyFields as $keyField) {
211			$meta->addKeyProperty($odataEntity, $keyField->getName(), $keyField->getEdmFieldType());
212			}
213
214			foreach ($fields as $field) {
215			if (in_array($field, $keyFields)) {
216			continue;
217			}
218			if ($field->getPrimitiveType() == 'blob') {
219			$odataEntity->setMediaLinkEntry(true);
220			$streamInfo = new ResourceStreamInfo($field->getName());
221			assert($odataEntity->isMediaLinkEntry());
222			$odataEntity->addNamedStream($streamInfo);
223			continue;
224			}
225			$meta->addPrimitiveProperty(
226			$odataEntity,
227			$field->getName(),
228			$field->getEdmFieldType(),
229			$field->getFieldType() == EntityFieldType::PRIMITIVE_BAG(),
230			strval($field->getDefaultValue()),
231			$field->getIsNullable()
232			);
233			}
234			}
235
236			/**
237			* Bootstrap the application services. Post-boot.
238			*
239			* @param mixed $reset
240			*
241			* @return void
242			*/
243			public function boot($reset = true)
244			{
245			self::$metaNAMESPACE = env('ODataMetaNamespace', 'Data');
246			// If we aren't migrated, there's no DB tables to pull metadata _from_, so bail out early
247			try {
248			if (!Schema::hasTable(config('database.migrations'))) {
249			return;
250			}
251			} catch (\Exception $e) {
252			return;
253			}
254
255			assert(false === self::$isBooted, 'Provider booted twice');
256			$isCaching = true === $this->getIsCaching();
257			$meta = Cache::get('metadata');
258			$objectMap = Cache::get('objectmap');
259			$hasCache = null != $meta && null != $objectMap;
260
261			if ($isCaching && $hasCache) {
262			App::instance('metadata', $meta);
263			App::instance('objectmap', $objectMap);
			1 ignored issue – show Bug introduced 2017-11-16 16:29 UTC by Report Bug Copy Issue Report The method `instance()` does not exist on `Illuminate\Support\Facades\App`. Did you maybe mean `clearResolvedInstance()`? This check marks calls to methods that do not seem to exist on an object. This is most likely the result of a method being renamed without all references to it being renamed likewise. Loading history...
264			return;
265			}
266			$meta = App::make('metadata');
267			if (false !== $reset) {
268			$this->reset();
269			}
270
271			$modelNames = $this->getCandidateModels();
272			$objectModel = $this->extract($modelNames);
273			$objectModel = $this->unify($objectModel);
274			$this->verify($objectModel);
275			$this->implement($objectModel);
276			$this->completedObjectMap = $objectModel;
277			$key = 'metadata';
278			$objKey = 'objectmap';
279			$this->handlePostBoot($isCaching, $hasCache, $key, $meta);
280			$this->handlePostBoot($isCaching, $hasCache, $objKey, $objectModel);
281			self::$isBooted = true;
282			}
283
284			/**
285			* Register the application services. Boot-time only.
286			*
287			* @return void
288			*/
289			public function register()
290			{
291			$this->app->singleton('metadata', function ($app) {
			0 ignored issues – show Unused Code introduced 2016-11-01 11:02 UTC by Report Bug Copy Issue Report The parameter `$app` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
292			return new SimpleMetadataProvider('Data', self::$metaNAMESPACE);
293			});
294			$this->app->singleton('objectmap', function ($app) {
			1 ignored issue – show Unused Code introduced 2017-11-17 03:18 UTC by Report Bug Copy Issue Report The parameter `$app` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
295			return new Map();
296			});
297			}
298
299			/**
300			* @return array
301			*/
302			protected function getCandidateModels()
303			{
304			$classes = $this->getClassMap();
305			$ends = [];
306			$startName = defined('PODATA_LARAVEL_APP_ROOT_NAMESPACE') ? PODATA_LARAVEL_APP_ROOT_NAMESPACE : 'App';
307			foreach ($classes as $name) {
308			if (\Illuminate\Support\Str::startsWith($name, $startName)) {
309			if (in_array('AlgoWeb\\PODataLaravel\\Models\\MetadataTrait', class_uses($name)) &&
310			is_subclass_of($name, '\\Illuminate\\Database\\Eloquent\\Model')) {
311			$ends[] = $name;
312			}
313			}
314			}
315			return $ends;
316			}
317
318			/**
319			* @return MetadataGubbinsHolder
320			*/
321			public function getRelationHolder()
322			{
323			return $this->relationHolder;
324			}
325
326			public function reset()
327			{
328			self::$isBooted = false;
329			self::$afterExtract = null;
330			self::$afterUnify = null;
331			self::$afterVerify = null;
332			self::$afterImplement = null;
333			}
334
335			/**
336			* Resolve possible reverse relation property names.
337			*
338			* @param Model $source
339			* @param $propName
340			* @return null\|string
341			* @internal param Model $target
342			*/
343			public function resolveReverseProperty(Model $source, $propName)
344			{
345			assert(is_string($propName), 'Property name must be string');
346			$entity = $this->getObjectMap()->resolveEntity(get_class($source));
347			if (null === $entity) {
348			$msg = 'Source model not defined';
349			throw new \InvalidArgumentException($msg);
350			}
351			$association = $entity->resolveAssociation($propName);
352			if (null === $association) {
353			return null;
354			}
355			$isFirst = $propName === $association->getFirst()->getRelationName();
356			if (!$isFirst) {
357			return $association->getFirst()->getRelationName();
358			}
359
360			assert($association instanceof AssociationMonomorphic);
361			return $association->getLast()->getRelationName();
362			}
363
364			public function isRunningInArtisan()
365			{
366			return App::runningInConsole() && !App::runningUnitTests();
367			}
368			}
369

Algo-Web / POData-Laravel

Pull Request — master (#143)

MetadataProvider::reset() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like