State - Code Metrics - Inspection of "Allow definition of a timestamp field on states" - spatie/laravel-model-states - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#53)

by Anthony

created 2020-01-04 17:23 UTC

State A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	341
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

Metric	Value
wmc	42
lcom	1
cbo	4
dl	0
loc	341
rs	9.0399
c	0
b	0
f	0

20 Methods

Rating	Name	Size	Complexity
A	__construct()	4	1
A	make()	10	2
A	find()	4	1
A	all()	4	1
A	getMorphClass()	4	1
A	getValue()	4	1
B	resolveStateClass()	24	6
A	resolveStateName()	18	5
A	isOneOf()	12	3
A	equals()	5	1
A	is()	4	1
A	__toString()	4	1
A	transition()	32	5
A	transitionTo()	13	2
A	transitionableStates()	4	1
A	resolveStateMapping()	38	5
A	shouldSetTimestamp()	4	1
A	getTimestampField()	4	1
A	getTimestamp()	6	2
A	jsonSerialize()	4	1

How to fix Complexity

<?php

namespace Spatie\ModelStates;

use Carbon\Carbon;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Collection;
use JsonSerializable;
use ReflectionClass;
use Spatie\ModelStates\Events\StateChanged;
use Spatie\ModelStates\Exceptions\CouldNotPerformTransition;
use Spatie\ModelStates\Exceptions\InvalidConfig;

abstract class State implements JsonSerializable
{
    /**
     * Static cache for generated state maps.
     *
     * @var array
     *
     * @see State::resolveStateMapping
     */
    protected static $generatedMapping = [];

    /** @var \Illuminate\Database\Eloquent\Model */
    protected $model;

    public function __construct(Model $model)
    {
        $this->model = $model;
    }

    /**
     * Create a state object based on a value (classname or name),
     * and optionally provide its constructor arguments.
     *
     * @param string $name
     * @param mixed ...$args
     *
     * @return \Spatie\ModelStates\State
     */
    public static function make(string $name, Model $model): State
    {
        $stateClass = static::resolveStateClass($name);

        if (! is_subclass_of($stateClass, static::class)) {
            throw InvalidConfig::doesNotExtendBaseClass($name, static::class);
        }

        return new $stateClass($model);
    }

    /**
     * Create a state object based on a value (classname or name),
     * and optionally provide its constructor arguments.
     *
     * @param string $name
     * @param mixed ...$args
     *
     * @return \Spatie\ModelStates\State
     */
    public static function find(string $name, Model $model): State
    {
        return static::make($name, $model);
    }

    /**
     * Get all registered state classes.
     *
     * @return \Illuminate\Support\Collection|string[]|static[] A list of class names.
     */
    public static function all(): Collection
    {
        return collect(self::resolveStateMapping());
    }

    /**
     * The value that will be saved in the database.
     *
     * @return string
     */
    public static function getMorphClass(): string
    {
        return static::resolveStateName(static::class);
    }

    /**
     * The value that will be saved in the database.
     *
     * @return string
     */
    public function getValue(): string
    {
        return static::getMorphClass();
    }

    /**
     * Resolve the state class based on a value, for example a stored value in the database.
     *
     * @param string|\Spatie\ModelStates\State $state
     *
     * @return string
     */
    public static function resolveStateClass($state): ?string
    {
        if ($state === null) {
            return null;
        }

        if ($state instanceof State) {
            return get_class($state);
        }

        foreach (static::resolveStateMapping() as $stateClass) {
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
            if (! class_exists($stateClass)) {
                continue;
            }

            // Loose comparison is needed here in order to support non-string values,
            // Laravel casts their database value automatically to strings if we didn't specify the fields in `$casts`.
            if (($stateClass::$name ?? null) == $state) {
                return $stateClass;
            }
        }

        return $state;
    }

    /**
     * Resolve the name of the state, which is the value that will be saved in the database.
     *
     * Possible names are:
     *
     *    - The classname, if no explicit name is provided
     *    - A name provided in the state class as a public static property:
     *      `public static $name = 'dummy'`
     *
     * @param $state
     *
     * @return string|null
     */
    public static function resolveStateName($state): ?string
    {
        if ($state === null) {
            return null;
        }

        if ($state instanceof State) {
            $stateClass = get_class($state);
        } else {
            $stateClass = static::resolveStateClass($state);
        }

        if (class_exists($stateClass) && isset($stateClass::$name)) {
            return $stateClass::$name;
        }

        return $stateClass;
    }

    /**
     * Determine if the current state is one of an arbitrary number of other states.
     * This can be either a classname or a name.
     *
     * @param string|array ...$stateClasses
     *
     * @return bool
     */
    public function isOneOf(...$statesNames): bool
    {
        $statesNames = collect($statesNames)->flatten()->toArray();

        foreach ($statesNames as $statesName) {
            if ($this->equals($statesName)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Determine if the current state equals another.
     * This can be either a classname or a name.
     *
     * @param string|\Spatie\ModelStates\State $state
     *
     * @return bool
     */
    public function equals($state): bool
    {
        return self::resolveStateClass($state)
            === self::resolveStateClass($this);
    }

    /**
     * Determine if the current state equals another.
     * This can be either a classname or a name.
     *
     * @param string|\Spatie\ModelStates\State $state
     *
     * @return bool
     */
    public function is($state): bool
    {
        return $this->equals($state);
    }

    public function __toString(): string
    {
        return static::getMorphClass();
    }

    /**
     * @param string|\Spatie\ModelStates\Transition $transitionClass
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param mixed ...$args
     *
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function transition($transition, ...$args): Model
    {
        if (is_string($transition)) {
            $transition = new $transition($this->model, ...$args);
        }

        if (method_exists($transition, 'canTransition')) {
            if (! $transition->canTransition()) {
                throw CouldNotPerformTransition::notAllowed($this->model, $transition);
            }
        }

        $mutatedModel = app()->call([$transition, 'handle']);

        /*
         * There's a bug with the `finalState` variable:
         *      `$mutatedModel->state`
         * was used, but this is wrong because we cannot determine the model field within this state class.
         * Hence `state` is hardcoded, but that's wrong.
         *
         * @see https://github.com/spatie/laravel-model-states/issues/49
         */
        $finalState = $mutatedModel->state;

        if (! $finalState instanceof State) {
            $finalState = null;
        }

        event(new StateChanged($this, $finalState, $transition, $this->model));

        return $mutatedModel;
    }

    /**
     * @param string|\Spatie\ModelStates\State $state
     * @param mixed ...$args
     *
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function transitionTo($state, ...$args): Model
    {
        if (! method_exists($this->model, 'resolveTransitionClass')) {
            throw InvalidConfig::resolveTransitionNotFound($this->model);
        }

        $transition = $this->model->resolveTransitionClass(
            static::resolveStateClass($this),
            static::resolveStateClass($state)
        );

        return $this->transition($transition, ...$args);
    }

    /**
     * Get the transitionable states from this state.
     *
     * @return array
     */
    public function transitionableStates($field = null): array
    {
        return $this->model->transitionableStates(get_class($this), $field);
    }

    /**
     * This method is used to find all available implementations of a given abstract state class.
     * Finding all implementations can be done in two ways:.
     *
     *    - The developer can define his own mapping directly in abstract state classes
     *      via the `protected $states = []` property
     *    - If no specific mapping was provided, the same directory where the abstract state class lives
     *      is scanned, and all concrete state classes extending the abstract state class will be provided.
     *
     * @return array
     */
    private static function resolveStateMapping(): array
    {
        if (isset(static::$states)) {
            return static::$states;
        }

        if (isset(self::$generatedMapping[static::class])) {
            return self::$generatedMapping[static::class];
        }

        $reflection = new ReflectionClass(static::class);

        ['dirname' => $directory] = pathinfo($reflection->getFileName());


        $files = scandir($directory);

        unset($files[0], $files[1]);

        $namespace = $reflection->getNamespaceName();

        $resolvedStates = [];

        foreach ($files as $file) {
            ['filename' => $className] = pathinfo($file);


            $stateClass = $namespace.'\\'.$className;

            if (! is_subclass_of($stateClass, static::class)) {
                continue;
            }

            $resolvedStates[] = $stateClass;
        }

        self::$generatedMapping[static::class] = $resolvedStates;

        return self::$generatedMapping[static::class];
    }

    public function shouldSetTimestamp() : bool
    {
        return isset(static::$timestamp);
    }

    public function getTimestampField() : ?string
    {
        return static::$timestamp ?? null;
    }

    public function getTimestamp(): ?Carbon
    {
        return $this->shouldSetTimestamp()
            ? $this->model->{$this->getTimestampField()}
            : null;
    }

    public function jsonSerialize()
    {
        return $this->getValue();
    }
}


1			<?php
2
3			namespace Spatie\ModelStates;
4
5			use Carbon\Carbon;
6			use Illuminate\Database\Eloquent\Model;
7			use Illuminate\Support\Collection;
8			use JsonSerializable;
9			use ReflectionClass;
10			use Spatie\ModelStates\Events\StateChanged;
11			use Spatie\ModelStates\Exceptions\CouldNotPerformTransition;
12			use Spatie\ModelStates\Exceptions\InvalidConfig;
13
14			abstract class State implements JsonSerializable
15			{
16			/**
17			* Static cache for generated state maps.
18			*
19			* @var array
20			*
21			* @see State::resolveStateMapping
22			*/
23			protected static $generatedMapping = [];
24
25			/** @var \Illuminate\Database\Eloquent\Model */
26			protected $model;
27
28			public function __construct(Model $model)
29			{
30			$this->model = $model;
31			}
32
33			/**
34			* Create a state object based on a value (classname or name),
35			* and optionally provide its constructor arguments.
36			*
37			* @param string $name
38			* @param mixed ...$args
39			*
40			* @return \Spatie\ModelStates\State
41			*/
42			public static function make(string $name, Model $model): State
43			{
44			$stateClass = static::resolveStateClass($name);
45
46			if (! is_subclass_of($stateClass, static::class)) {
47			throw InvalidConfig::doesNotExtendBaseClass($name, static::class);
48			}
49
50			return new $stateClass($model);
51			}
52
53			/**
54			* Create a state object based on a value (classname or name),
55			* and optionally provide its constructor arguments.
56			*
57			* @param string $name
58			* @param mixed ...$args
59			*
60			* @return \Spatie\ModelStates\State
61			*/
62			public static function find(string $name, Model $model): State
63			{
64			return static::make($name, $model);
65			}
66
67			/**
68			* Get all registered state classes.
69			*
70			* @return \Illuminate\Support\Collection\|string[]\|static[] A list of class names.
71			*/
72			public static function all(): Collection
73			{
74			return collect(self::resolveStateMapping());
75			}
76
77			/**
78			* The value that will be saved in the database.
79			*
80			* @return string
81			*/
82			public static function getMorphClass(): string
83			{
84			return static::resolveStateName(static::class);
85			}
86
87			/**
88			* The value that will be saved in the database.
89			*
90			* @return string
91			*/
92			public function getValue(): string
93			{
94			return static::getMorphClass();
95			}
96
97			/**
98			* Resolve the state class based on a value, for example a stored value in the database.
99			*
100			* @param string\|\Spatie\ModelStates\State $state
101			*
102			* @return string
103			*/
104			public static function resolveStateClass($state): ?string
105			{
106			if ($state === null) {
107			return null;
108			}
109
110			if ($state instanceof State) {
111			return get_class($state);
112			}
113
114			foreach (static::resolveStateMapping() as $stateClass) {
			0 ignored issues – show Bug introduced 2019-09-27 07:39 UTC by Report Bug Copy Issue Report Since `resolveStateMapping()` is declared private, calling it with `static` will lead to errors in possible sub-classes. You can either use `self`, or increase the visibility of `resolveStateMapping()` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return static::getTemperature(); } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { private static function getTemperature() { return "-182 °C"; } } print YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return self::getTemperature(); } } Loading history...
115			if (! class_exists($stateClass)) {
116			continue;
117			}
118
119			// Loose comparison is needed here in order to support non-string values,
120			// Laravel casts their database value automatically to strings if we didn't specify the fields in `$casts`.
121			if (($stateClass::$name ?? null) == $state) {
122			return $stateClass;
123			}
124			}
125
126			return $state;
127			}
128
129			/**
130			* Resolve the name of the state, which is the value that will be saved in the database.
131			*
132			* Possible names are:
133			*
134			* - The classname, if no explicit name is provided
135			* - A name provided in the state class as a public static property:
136			* `public static $name = 'dummy'`
137			*
138			* @param $state
139			*
140			* @return string\|null
141			*/
142			public static function resolveStateName($state): ?string
143			{
144			if ($state === null) {
145			return null;
146			}
147
148			if ($state instanceof State) {
149			$stateClass = get_class($state);
150			} else {
151			$stateClass = static::resolveStateClass($state);
152			}
153
154			if (class_exists($stateClass) && isset($stateClass::$name)) {
155			return $stateClass::$name;
156			}
157
158			return $stateClass;
159			}
160
161			/**
162			* Determine if the current state is one of an arbitrary number of other states.
163			* This can be either a classname or a name.
164			*
165			* @param string\|array ...$stateClasses
166			*
167			* @return bool
168			*/
169			public function isOneOf(...$statesNames): bool
170			{
171			$statesNames = collect($statesNames)->flatten()->toArray();
172
173			foreach ($statesNames as $statesName) {
174			if ($this->equals($statesName)) {
175			return true;
176			}
177			}
178
179			return false;
180			}
181
182			/**
183			* Determine if the current state equals another.
184			* This can be either a classname or a name.
185			*
186			* @param string\|\Spatie\ModelStates\State $state
187			*
188			* @return bool
189			*/
190			public function equals($state): bool
191			{
192			return self::resolveStateClass($state)
193			=== self::resolveStateClass($this);
194			}
195
196			/**
197			* Determine if the current state equals another.
198			* This can be either a classname or a name.
199			*
200			* @param string\|\Spatie\ModelStates\State $state
201			*
202			* @return bool
203			*/
204			public function is($state): bool
205			{
206			return $this->equals($state);
207			}
208
209			public function __toString(): string
210			{
211			return static::getMorphClass();
212			}
213
214			/**
215			* @param string\|\Spatie\ModelStates\Transition $transitionClass
			0 ignored issues – show Documentation introduced 2019-09-27 07:39 UTC by Report Bug Copy Issue Report There is no parameter named `$transitionClass`. Did you maybe mean `$transition`? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. It has, however, found a similar but not annotated parameter which might be a good fit. Consider the following example. The parameter `$ireland` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $ireland */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was changed, but the annotation was not. Loading history...
216			* @param mixed ...$args
217			*
218			* @return \Illuminate\Database\Eloquent\Model
219			*/
220			public function transition($transition, ...$args): Model
221			{
222			if (is_string($transition)) {
223			$transition = new $transition($this->model, ...$args);
224			}
225
226			if (method_exists($transition, 'canTransition')) {
227			if (! $transition->canTransition()) {
228			throw CouldNotPerformTransition::notAllowed($this->model, $transition);
229			}
230			}
231
232			$mutatedModel = app()->call([$transition, 'handle']);
233
234			/*
235			* There's a bug with the `finalState` variable:
236			* `$mutatedModel->state`
237			* was used, but this is wrong because we cannot determine the model field within this state class.
238			* Hence `state` is hardcoded, but that's wrong.
239			*
240			* @see https://github.com/spatie/laravel-model-states/issues/49
241			*/
242			$finalState = $mutatedModel->state;
243
244			if (! $finalState instanceof State) {
245			$finalState = null;
246			}
247
248			event(new StateChanged($this, $finalState, $transition, $this->model));
249
250			return $mutatedModel;
251			}
252
253			/**
254			* @param string\|\Spatie\ModelStates\State $state
255			* @param mixed ...$args
256			*
257			* @return \Illuminate\Database\Eloquent\Model
258			*/
259			public function transitionTo($state, ...$args): Model
260			{
261			if (! method_exists($this->model, 'resolveTransitionClass')) {
262			throw InvalidConfig::resolveTransitionNotFound($this->model);
263			}
264
265			$transition = $this->model->resolveTransitionClass(
266			static::resolveStateClass($this),
267			static::resolveStateClass($state)
268			);
269
270			return $this->transition($transition, ...$args);
271			}
272
273			/**
274			* Get the transitionable states from this state.
275			*
276			* @return array
277			*/
278			public function transitionableStates($field = null): array
279			{
280			return $this->model->transitionableStates(get_class($this), $field);
281			}
282
283			/**
284			* This method is used to find all available implementations of a given abstract state class.
285			* Finding all implementations can be done in two ways:.
286			*
287			* - The developer can define his own mapping directly in abstract state classes
288			* via the `protected $states = []` property
289			* - If no specific mapping was provided, the same directory where the abstract state class lives
290			* is scanned, and all concrete state classes extending the abstract state class will be provided.
291			*
292			* @return array
293			*/
294			private static function resolveStateMapping(): array
295			{
296			if (isset(static::$states)) {
297			return static::$states;
298			}
299
300			if (isset(self::$generatedMapping[static::class])) {
301			return self::$generatedMapping[static::class];
302			}
303
304			$reflection = new ReflectionClass(static::class);
305
306			['dirname' => $directory] = pathinfo($reflection->getFileName());
			0 ignored issues – show Bug introduced 2019-09-27 07:39 UTC by Report Bug Copy Issue Report The variable `$directory` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
307
308			$files = scandir($directory);
309
310			unset($files[0], $files[1]);
311
312			$namespace = $reflection->getNamespaceName();
313
314			$resolvedStates = [];
315
316			foreach ($files as $file) {
317			['filename' => $className] = pathinfo($file);
			0 ignored issues – show Bug introduced 2019-09-27 07:39 UTC by Report Bug Copy Issue Report The variable `$className` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
318
319			$stateClass = $namespace.'\\'.$className;
320
321			if (! is_subclass_of($stateClass, static::class)) {
322			continue;
323			}
324
325			$resolvedStates[] = $stateClass;
326			}
327
328			self::$generatedMapping[static::class] = $resolvedStates;
329
330			return self::$generatedMapping[static::class];
331			}
332
333			public function shouldSetTimestamp() : bool
334			{
335			return isset(static::$timestamp);
336			}
337
338			public function getTimestampField() : ?string
339			{
340			return static::$timestamp ?? null;
341			}
342
343			public function getTimestamp(): ?Carbon
344			{
345			return $this->shouldSetTimestamp()
346			? $this->model->{$this->getTimestampField()}
347			: null;
348			}
349
350			public function jsonSerialize()
351			{
352			return $this->getValue();
353			}
354			}
355

spatie / laravel-model-states

Pull Request — master (#53)

State A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

20 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like