HasStates::getDefaultStates() - Code Metrics - Inspection of "Extended HasStates with state listing methods" - spatie/laravel-model-states - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#21)

unknown

created 2019-10-15 14:05 UTC

HasStates::getDefaultStates() A

↳ Parent: HasStates

Complexity

Conditions	2
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.9666
c	0
b	0
f	0
cc	2
nc	1
nop	0

<?php

namespace Spatie\ModelStates;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Builder;
use Spatie\ModelStates\Exceptions\InvalidConfig;
use Spatie\ModelStates\Exceptions\CouldNotPerformTransition;

/**
 * @mixin \Illuminate\Database\Eloquent\Model
 */
trait HasStates
{
    /** @var \Spatie\ModelStates\StateConfig[]|null */
    protected static $stateFields = null;

    abstract protected function registerStates(): void;

    public static function bootHasStates(): void
    {
        $serialiseState = function (StateConfig $stateConfig) {
            return function (Model $model) use ($stateConfig) {
                $value = $model->getAttribute($stateConfig->field);

                if ($value === null) {
                    $value = $stateConfig->defaultStateClass;
                }

                if ($value === null) {
                    return;
                }

                $stateClass = $stateConfig->stateClass::resolveStateClass($value);

                if (! is_subclass_of($stateClass, $stateConfig->stateClass)) {
                    throw InvalidConfig::fieldDoesNotExtendState(
                        $stateConfig->field,
                        $stateConfig->stateClass,
                        $stateClass
                    );
                }

                $model->setAttribute(
                    $stateConfig->field,
                    State::resolveStateName($value)
                );
            };
        };

        $unserialiseState = function (StateConfig $stateConfig) {
            return function (Model $model) use ($stateConfig) {
                $stateClass = $stateConfig->stateClass::resolveStateClass($model->getAttribute($stateConfig->field));

                $defaultState = $stateConfig->defaultStateClass
                    ? new $stateConfig->defaultStateClass($model)
                    : null;

                $model->setAttribute(
                    $stateConfig->field,
                    class_exists($stateClass)
                        ? new $stateClass($model)
                        : $defaultState
                );
            };
        };

        foreach (self::getStateConfig() as $stateConfig) {
            static::retrieved($unserialiseState($stateConfig));
            static::created($unserialiseState($stateConfig));
            static::saved($unserialiseState($stateConfig));

            static::updating($serialiseState($stateConfig));
            static::creating($serialiseState($stateConfig));
            static::saving($serialiseState($stateConfig));
        }
    }

    public function initializeHasStates(): void
    {
        foreach (self::getStateConfig() as $stateConfig) {
            if (! $stateConfig->defaultStateClass) {
                continue;
            }

            $this->{$stateConfig->field} = new $stateConfig->defaultStateClass($this);
        }
    }

    public function scopeWhereState(Builder $builder, string $field, $states): Builder
    {
        self::getStateConfig();

        /** @var \Spatie\ModelStates\StateConfig|null $stateConfig */
        $stateConfig = self::getStateConfig()[$field] ?? null;

        if (! $stateConfig) {
            throw InvalidConfig::unknownState($field, $this);
        }

        $abstractStateClass = $stateConfig->stateClass;

        $stateNames = collect((array) $states)->map(function ($state) use ($abstractStateClass) {
            return $abstractStateClass::resolveStateName($state);
        });

        return $builder->whereIn($field, $stateNames);
    }

    public function scopeWhereNotState(Builder $builder, string $field, $states): Builder
    {
        /** @var \Spatie\ModelStates\StateConfig|null $stateConfig */
        $stateConfig = self::getStateConfig()[$field] ?? null;

        if (! $stateConfig) {
            throw InvalidConfig::unknownState($field, $this);
        }

        $stateNames = collect((array) $states)->map(function ($state) use ($stateConfig) {
            return $stateConfig->stateClass::resolveStateName($state);
        });

        return $builder->whereNotIn($field, $stateNames);
    }

    /**
     * @param \Spatie\ModelStates\State|string $state
     * @param string|null $field
     */
    public function transitionTo($state, string $field = null)
    {
        $stateConfig = self::getStateConfig();

        if ($field === null && count($stateConfig) > 1) {
            throw CouldNotPerformTransition::couldNotResolveTransitionField($this);
        }

        $field = $field ?? reset($stateConfig)->field;

        $this->{$field}->transitionTo($state);
    }

    /**
     * @param string $fromClass
     * @param string $toClass
     *
     * @return \Spatie\ModelStates\Transition|string|null
     */
    public function resolveTransitionClass(string $fromClass, string $toClass)
    {
        foreach (static::getStateConfig() as $stateConfig) {
            $transitionClass = $stateConfig->resolveTransition($this, $fromClass, $toClass);

            if ($transitionClass) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                return $transitionClass;
            }
        }

        throw CouldNotPerformTransition::notFound($fromClass, $toClass, $this);
    }

    protected function addState(string $field, string $stateClass): StateConfig
    {
        $stateConfig = new StateConfig($field, $stateClass);

        static::$stateFields[$stateConfig->field] = $stateConfig;

        return $stateConfig;
    }

    /**
     * @return \Spatie\ModelStates\StateConfig[]
     */
    private static function getStateConfig(): array
    {
        if (static::$stateFields === null) {
            static::$stateFields = [];

            (new static)->registerStates();
        }

        return static::$stateFields ?? [];
    }

    /**
     * Get the registered states for the model.
     *
     * @return \Illuminate\Support\Collection
     */
    public static function getStates(): \Illuminate\Support\Collection
    {
        return collect(static::getStateConfig())
            ->map(function($state) {
                return $state->stateClass::all()
                    ->map(function($state) {
                        return new $state(new static);
                    });
            });
    }

    /**
     * Get registered states for a specfic model column.
     *
     * @param  string $column
     * @return \Illuminate\Support\Collection
     */
    public static function getStatesFor(string $column): \Illuminate\Support\Collection
    {
        return static::getStates()->get($column, new \Illuminate\Support\Collection);
    }

    /**
     * Get default states for the model.
     *
     * @return \Illuminate\Support\Collection
     */
    public static function getDefaultStates(): \Illuminate\Support\Collection
    {
        return collect(static::getStateConfig())
            ->map(function($state) {
                return is_null($state->defaultStateClass)
                    ? null
                    : new $state->defaultStateClass(new static);
            });
    }

    /**
     * Get the default state for a specfic model column.
     *
     * @param  string $column
     * @return \Illuminate\Support\Collection|
     */
    public static function getDefaultStateFor(string $column): ?\Spatie\ModelStates\State
    {
        return static::getDefaultStates()->get($column);
    }
}


1			<?php
2
3			namespace Spatie\ModelStates;
4
5			use Illuminate\Database\Eloquent\Model;
6			use Illuminate\Database\Eloquent\Builder;
7			use Spatie\ModelStates\Exceptions\InvalidConfig;
8			use Spatie\ModelStates\Exceptions\CouldNotPerformTransition;
9
10			/**
11			* @mixin \Illuminate\Database\Eloquent\Model
12			*/
13			trait HasStates
14			{
15			/** @var \Spatie\ModelStates\StateConfig[]\|null */
16			protected static $stateFields = null;
17
18			abstract protected function registerStates(): void;
19
20			public static function bootHasStates(): void
21			{
22			$serialiseState = function (StateConfig $stateConfig) {
23			return function (Model $model) use ($stateConfig) {
24			$value = $model->getAttribute($stateConfig->field);
25
26			if ($value === null) {
27			$value = $stateConfig->defaultStateClass;
28			}
29
30			if ($value === null) {
31			return;
32			}
33
34			$stateClass = $stateConfig->stateClass::resolveStateClass($value);
35
36			if (! is_subclass_of($stateClass, $stateConfig->stateClass)) {
37			throw InvalidConfig::fieldDoesNotExtendState(
38			$stateConfig->field,
39			$stateConfig->stateClass,
40			$stateClass
41			);
42			}
43
44			$model->setAttribute(
45			$stateConfig->field,
46			State::resolveStateName($value)
47			);
48			};
49			};
50
51			$unserialiseState = function (StateConfig $stateConfig) {
52			return function (Model $model) use ($stateConfig) {
53			$stateClass = $stateConfig->stateClass::resolveStateClass($model->getAttribute($stateConfig->field));
54
55			$defaultState = $stateConfig->defaultStateClass
56			? new $stateConfig->defaultStateClass($model)
57			: null;
58
59			$model->setAttribute(
60			$stateConfig->field,
61			class_exists($stateClass)
62			? new $stateClass($model)
63			: $defaultState
64			);
65			};
66			};
67
68			foreach (self::getStateConfig() as $stateConfig) {
69			static::retrieved($unserialiseState($stateConfig));
70			static::created($unserialiseState($stateConfig));
71			static::saved($unserialiseState($stateConfig));
72
73			static::updating($serialiseState($stateConfig));
74			static::creating($serialiseState($stateConfig));
75			static::saving($serialiseState($stateConfig));
76			}
77			}
78
79			public function initializeHasStates(): void
80			{
81			foreach (self::getStateConfig() as $stateConfig) {
82			if (! $stateConfig->defaultStateClass) {
83			continue;
84			}
85
86			$this->{$stateConfig->field} = new $stateConfig->defaultStateClass($this);
87			}
88			}
89
90			public function scopeWhereState(Builder $builder, string $field, $states): Builder
91			{
92			self::getStateConfig();
93
94			/** @var \Spatie\ModelStates\StateConfig\|null $stateConfig */
95			$stateConfig = self::getStateConfig()[$field] ?? null;
96
97			if (! $stateConfig) {
98			throw InvalidConfig::unknownState($field, $this);
99			}
100
101			$abstractStateClass = $stateConfig->stateClass;
102
103			$stateNames = collect((array) $states)->map(function ($state) use ($abstractStateClass) {
104			return $abstractStateClass::resolveStateName($state);
105			});
106
107			return $builder->whereIn($field, $stateNames);
108			}
109
110			public function scopeWhereNotState(Builder $builder, string $field, $states): Builder
111			{
112			/** @var \Spatie\ModelStates\StateConfig\|null $stateConfig */
113			$stateConfig = self::getStateConfig()[$field] ?? null;
114
115			if (! $stateConfig) {
116			throw InvalidConfig::unknownState($field, $this);
117			}
118
119			$stateNames = collect((array) $states)->map(function ($state) use ($stateConfig) {
120			return $stateConfig->stateClass::resolveStateName($state);
121			});
122
123			return $builder->whereNotIn($field, $stateNames);
124			}
125
126			/**
127			* @param \Spatie\ModelStates\State\|string $state
128			* @param string\|null $field
129			*/
130			public function transitionTo($state, string $field = null)
131			{
132			$stateConfig = self::getStateConfig();
133
134			if ($field === null && count($stateConfig) > 1) {
135			throw CouldNotPerformTransition::couldNotResolveTransitionField($this);
136			}
137
138			$field = $field ?? reset($stateConfig)->field;
139
140			$this->{$field}->transitionTo($state);
141			}
142
143			/**
144			* @param string $fromClass
145			* @param string $toClass
146			*
147			* @return \Spatie\ModelStates\Transition\|string\|null
148			*/
149			public function resolveTransitionClass(string $fromClass, string $toClass)
150			{
151			foreach (static::getStateConfig() as $stateConfig) {
152			$transitionClass = $stateConfig->resolveTransition($this, $fromClass, $toClass);
153
154			if ($transitionClass) {
			0 ignored issues – show Bug Best Practice introduced 2019-09-27 07:39 UTC by Report Bug Copy Issue Report The expression `$transitionClass` of type `null\|string` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
155			return $transitionClass;
156			}
157			}
158
159			throw CouldNotPerformTransition::notFound($fromClass, $toClass, $this);
160			}
161
162			protected function addState(string $field, string $stateClass): StateConfig
163			{
164			$stateConfig = new StateConfig($field, $stateClass);
165
166			static::$stateFields[$stateConfig->field] = $stateConfig;
167
168			return $stateConfig;
169			}
170
171			/**
172			* @return \Spatie\ModelStates\StateConfig[]
173			*/
174			private static function getStateConfig(): array
175			{
176			if (static::$stateFields === null) {
177			static::$stateFields = [];
178
179			(new static)->registerStates();
180			}
181
182			return static::$stateFields ?? [];
183			}
184
185			/**
186			* Get the registered states for the model.
187			*
188			* @return \Illuminate\Support\Collection
189			*/
190			public static function getStates(): \Illuminate\Support\Collection
191			{
192			return collect(static::getStateConfig())
193			->map(function($state) {
194			return $state->stateClass::all()
195			->map(function($state) {
196			return new $state(new static);
197			});
198			});
199			}
200
201			/**
202			* Get registered states for a specfic model column.
203			*
204			* @param string $column
205			* @return \Illuminate\Support\Collection
206			*/
207			public static function getStatesFor(string $column): \Illuminate\Support\Collection
208			{
209			return static::getStates()->get($column, new \Illuminate\Support\Collection);
210			}
211
212			/**
213			* Get default states for the model.
214			*
215			* @return \Illuminate\Support\Collection
216			*/
217			public static function getDefaultStates(): \Illuminate\Support\Collection
218			{
219			return collect(static::getStateConfig())
220			->map(function($state) {
221			return is_null($state->defaultStateClass)
222			? null
223			: new $state->defaultStateClass(new static);
224			});
225			}
226
227			/**
228			* Get the default state for a specfic model column.
229			*
230			* @param string $column
231			* @return \Illuminate\Support\Collection\|
232			*/
233			public static function getDefaultStateFor(string $column): ?\Spatie\ModelStates\State
234			{
235			return static::getDefaultStates()->get($column);
236			}
237			}
238

spatie / laravel-model-states

Pull Request — master (#21)

HasStates::getDefaultStates() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like