SiteState::withState() - Code Metrics - Firesphere/silverstripe-search - Measure and Improve Code Quality continuously with Scrutinizer

SiteState::withState() A
last analyzed 2023-11-13 23:19 UTC

↳ Parent: SiteState

Complexity

Conditions	4
Paths	4

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
eloc	5
nc	4
nop	1
dl	0
loc	11
rs	10
c	1
b	0
f	0

<?php
/**
 * class SiteState|Firesphere\SearchBackend\States\SiteState Base implementation of SiteState to be used by e.g.
 * the Fluent extension
 *
 * @package Firesphere\Search\Backend
 * @author Simon `Firesphere` Erkelens; Marco `Sheepy` Hermo
 * @copyright Copyright (c) 2018 - now() Firesphere & Sheepy
 */

namespace Firesphere\SearchBackend\States;

use Firesphere\SearchBackend\Helpers\FieldResolver;
use Firesphere\SearchBackend\Interfaces\SiteStateInterface;
use ReflectionClass;
use ReflectionException;
use SilverStripe\Core\ClassInfo;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\Core\Injector\Injectable;
use SilverStripe\ORM\DataObject;

/**
 * Class SiteState
 *
 * Determine and apply the state of the site currently. This is used at index-time to figure out what state to index.
 * An example of this is the FluentSearchVariant extension from Fluent.
 *
 * Fluent uses the old SearchVariant method, which is actually not that bad a concept. These "Variants", now called
 * "States" set the state of the site to a required setting for each available state.
 *
 * States SHOULD add their own states through an extension of this class and implement {@link SiteStateInterface},
 * otherwise it won't be called.
 * {@link FluentIndexExtension::onBeforeInit()}
 *
 * States, options, etc. are simplified for a more streamlined approach
 *
 * @package Firesphere\Search\Backend
 */
abstract class SiteState
{
    use Configurable;
    use Injectable;

    public const DEFAULT_STATE = 'default';
    /**
     * States that can be applied
     *
     * @var array
     */
    public static $states = [
        self::DEFAULT_STATE,
    ];
    /**
     * Variants of SiteState that can be activated
     *
     * @var array
     */
    public static $variants = [];
    /**
     * @var array Default states
     */
    protected static $defaultStates = [];
    /**
     * @var bool Is this State enabled
     */
    public $enabled = true;
    /**
     * @var string current state
     */
    protected $state;

    /**
     * Get available states
     *
     * @static
     * @return array
     */
    public static function getStates(): array
    {
        return self::$states;
    }

    /**
     * Set states
     *
     * @static
     * @param array $states
     */
    public static function setStates(array $states): void
    {
        self::$states = $states;
    }

    /**
     * Add a state
     *
     * @static
     * @param $state
     */
    public static function addState($state): void
    {
        self::$states[] = $state;
    }

    /**
     * Add multiple states
     *
     * @static
     * @param array $states
     */
    public static function addStates(array $states): void
    {
        self::$states = array_merge(self::$states, $states);
    }

    /**
     * Does this class, it's parent (or optionally one of it's children) have the passed extension attached?
     *
     * @static
     * @param string $class
     * @param string $extension
     * @return bool
     * @throws ReflectionException
     */
    public static function hasExtension($class, $extension): bool
    {
        /** @var DataObject $relatedclass */
        foreach (FieldResolver::gethierarchy($class) as $relatedclass) {
            if ($relatedclass::has_extension($extension)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Get the current state of every variant
     *
     * @static
     * @return array
     * @throws ReflectionException
     */
    public static function currentStates(): array
    {
        foreach (self::variants() as $variant => $instance) {
            self::$defaultStates[$variant] = $instance->currentState();
        }

        return self::$defaultStates;
    }

    /**
     * Returns an array of variants.
     *
     * @static
     * @param bool $force Force updating the variants
     * @return array - An array of (string)$variantClassName => (Object)$variantInstance pairs
     * @throws ReflectionException
     */
    public static function variants($force = false): array
    {
        // Build up and cache a list of all search variants (subclasses of SearchVariant)
        if (empty(self::$variants) || $force) {
            $classes = ClassInfo::subclassesFor(static::class);

            foreach ($classes as $variantclass) {
                self::isApplicable($variantclass);
            }
        }

        return self::$variants;
    }

    /**
     * Is this extension applied and instantiable, and should it be applied to
     * the current state of the site
     *
     * @static
     * @param $variantClass
     * @return bool
     * @throws ReflectionException
     */
    public static function isApplicable($variantClass): bool
    {
        $ref = new ReflectionClass($variantClass);
        if ($ref->isInstantiable()) {
            /** @var SiteState $variant */
            $variant = singleton($variantClass);
            if ($variant->appliesToEnvironment() && $variant->isEnabled()) {
                self::$variants[$variantClass] = $variant;

                return true;
            }
        }

        return false;
    }

    /**
     * Does this state apply to the current object/environment settings
     *
     * @return bool
     */
    public function appliesToEnvironment(): bool
    {
        return $this->enabled;
    }

    /**
     * Is this state enabled
     *
     * @return bool
     */
    public function isEnabled(): bool
    {
        return $this->enabled;
    }

    /**
     * Set the state to whatever is required. Most commonly true
     *
     * @param bool $enabled
     */
    public function setEnabled(bool $enabled): void
    {
        $this->enabled = $enabled;
    }

    /**
     * Activate a site state for indexing
     *
     * @param $state
     * @throws ReflectionException
     */
    public static function withState($state): void
    {
        /**
         * @var string $variant
         * @var SiteStateInterface $instance
         */
        foreach (self::variants() as $variant => $instance) {
            if ($state === self::DEFAULT_STATE) {
                $instance->setDefaultState(self::$defaultStates[$variant]);
            } elseif ($instance->stateIsApplicable($state)) {
                $instance->activateState($state);
            }
        }
    }

    /**
     * Alter the query for each instance
     *
     * @param BaseQuery $query
filter:
    dependency_paths: ["lib/*"]
     * @throws ReflectionException
     */
    public static function alterQuery(&$query): void
    {
        /**
         * @var string $variant
         * @var SiteStateInterface $instance
         */
        foreach (self::variants() as $variant => $instance) {
            $instance->updateQuery($query);
        }
    }

    /**
     * Get the states set as default
     *
     * @return array
     */
    public static function getDefaultStates(): array
    {
        return self::$defaultStates;
    }

    /**
     * Set the default states
     *
     * @param array $defaultStates
     */
    public static function setDefaultStates(array $defaultStates): void
    {
        self::$defaultStates = $defaultStates;
    }
}


1			<?php
2			/**
3			* class SiteState\|Firesphere\SearchBackend\States\SiteState Base implementation of SiteState to be used by e.g.
4			* the Fluent extension
5			*
6			* @package Firesphere\Search\Backend
7			* @author Simon `Firesphere` Erkelens; Marco `Sheepy` Hermo
8			* @copyright Copyright (c) 2018 - now() Firesphere & Sheepy
9			*/
10
11			namespace Firesphere\SearchBackend\States;
12
13			use Firesphere\SearchBackend\Helpers\FieldResolver;
14			use Firesphere\SearchBackend\Interfaces\SiteStateInterface;
15			use ReflectionClass;
16			use ReflectionException;
17			use SilverStripe\Core\ClassInfo;
18			use SilverStripe\Core\Config\Configurable;
19			use SilverStripe\Core\Injector\Injectable;
20			use SilverStripe\ORM\DataObject;
21
22			/**
23			* Class SiteState
24			*
25			* Determine and apply the state of the site currently. This is used at index-time to figure out what state to index.
26			* An example of this is the FluentSearchVariant extension from Fluent.
27			*
28			* Fluent uses the old SearchVariant method, which is actually not that bad a concept. These "Variants", now called
29			* "States" set the state of the site to a required setting for each available state.
30			*
31			* States SHOULD add their own states through an extension of this class and implement {@link SiteStateInterface},
32			* otherwise it won't be called.
33			* {@link FluentIndexExtension::onBeforeInit()}
34			*
35			* States, options, etc. are simplified for a more streamlined approach
36			*
37			* @package Firesphere\Search\Backend
38			*/
39			abstract class SiteState
40			{
41			use Configurable;
42			use Injectable;
43
44			public const DEFAULT_STATE = 'default';
45			/**
46			* States that can be applied
47			*
48			* @var array
49			*/
50			public static $states = [
51			self::DEFAULT_STATE,
52			];
53			/**
54			* Variants of SiteState that can be activated
55			*
56			* @var array
57			*/
58			public static $variants = [];
59			/**
60			* @var array Default states
61			*/
62			protected static $defaultStates = [];
63			/**
64			* @var bool Is this State enabled
65			*/
66			public $enabled = true;
67			/**
68			* @var string current state
69			*/
70			protected $state;
71
72			/**
73			* Get available states
74			*
75			* @static
76			* @return array
77			*/
78			public static function getStates(): array
79			{
80			return self::$states;
81			}
82
83			/**
84			* Set states
85			*
86			* @static
87			* @param array $states
88			*/
89			public static function setStates(array $states): void
90			{
91			self::$states = $states;
92			}
93
94			/**
95			* Add a state
96			*
97			* @static
98			* @param $state
99			*/
100			public static function addState($state): void
101			{
102			self::$states[] = $state;
103			}
104
105			/**
106			* Add multiple states
107			*
108			* @static
109			* @param array $states
110			*/
111			public static function addStates(array $states): void
112			{
113			self::$states = array_merge(self::$states, $states);
114			}
115
116			/**
117			* Does this class, it's parent (or optionally one of it's children) have the passed extension attached?
118			*
119			* @static
120			* @param string $class
121			* @param string $extension
122			* @return bool
123			* @throws ReflectionException
124			*/
125			public static function hasExtension($class, $extension): bool
126			{
127			/** @var DataObject $relatedclass */
128			foreach (FieldResolver::gethierarchy($class) as $relatedclass) {
129			if ($relatedclass::has_extension($extension)) {
130			return true;
131			}
132			}
133
134			return false;
135			}
136
137			/**
138			* Get the current state of every variant
139			*
140			* @static
141			* @return array
142			* @throws ReflectionException
143			*/
144			public static function currentStates(): array
145			{
146			foreach (self::variants() as $variant => $instance) {
147			self::$defaultStates[$variant] = $instance->currentState();
148			}
149
150			return self::$defaultStates;
151			}
152
153			/**
154			* Returns an array of variants.
155			*
156			* @static
157			* @param bool $force Force updating the variants
158			* @return array - An array of (string)$variantClassName => (Object)$variantInstance pairs
159			* @throws ReflectionException
160			*/
161			public static function variants($force = false): array
162			{
163			// Build up and cache a list of all search variants (subclasses of SearchVariant)
164			if (empty(self::$variants) \|\| $force) {
165			$classes = ClassInfo::subclassesFor(static::class);
166
167			foreach ($classes as $variantclass) {
168			self::isApplicable($variantclass);
169			}
170			}
171
172			return self::$variants;
173			}
174
175			/**
176			* Is this extension applied and instantiable, and should it be applied to
177			* the current state of the site
178			*
179			* @static
180			* @param $variantClass
181			* @return bool
182			* @throws ReflectionException
183			*/
184			public static function isApplicable($variantClass): bool
185			{
186			$ref = new ReflectionClass($variantClass);
187			if ($ref->isInstantiable()) {
188			/** @var SiteState $variant */
189			$variant = singleton($variantClass);
190			if ($variant->appliesToEnvironment() && $variant->isEnabled()) {
191			self::$variants[$variantClass] = $variant;
192
193			return true;
194			}
195			}
196
197			return false;
198			}
199
200			/**
201			* Does this state apply to the current object/environment settings
202			*
203			* @return bool
204			*/
205			public function appliesToEnvironment(): bool
206			{
207			return $this->enabled;
208			}
209
210			/**
211			* Is this state enabled
212			*
213			* @return bool
214			*/
215			public function isEnabled(): bool
216			{
217			return $this->enabled;
218			}
219
220			/**
221			* Set the state to whatever is required. Most commonly true
222			*
223			* @param bool $enabled
224			*/
225			public function setEnabled(bool $enabled): void
226			{
227			$this->enabled = $enabled;
228			}
229
230			/**
231			* Activate a site state for indexing
232			*
233			* @param $state
234			* @throws ReflectionException
235			*/
236			public static function withState($state): void
237			{
238			/**
239			* @var string $variant
240			* @var SiteStateInterface $instance
241			*/
242			foreach (self::variants() as $variant => $instance) {
243			if ($state === self::DEFAULT_STATE) {
244			$instance->setDefaultState(self::$defaultStates[$variant]);
245			} elseif ($instance->stateIsApplicable($state)) {
246			$instance->activateState($state);
247			}
248			}
249			}
250
251			/**
252			* Alter the query for each instance
253			*
254			* @param BaseQuery $query
			0 ignored issues – show Bug introduced 2023-10-20 08:31 UTC by Report Bug Copy Issue Report The type `Firesphere\SearchBackend\States\BaseQuery` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
255			* @throws ReflectionException
256			*/
257			public static function alterQuery(&$query): void
258			{
259			/**
260			* @var string $variant
261			* @var SiteStateInterface $instance
262			*/
263			foreach (self::variants() as $variant => $instance) {
264			$instance->updateQuery($query);
265			}
266			}
267
268			/**
269			* Get the states set as default
270			*
271			* @return array
272			*/
273			public static function getDefaultStates(): array
274			{
275			return self::$defaultStates;
276			}
277
278			/**
279			* Set the default states
280			*
281			* @param array $defaultStates
282			*/
283			public static function setDefaultStates(array $defaultStates): void
284			{
285			self::$defaultStates = $defaultStates;
286			}
287			}
288

Firesphere / silverstripe-search

SiteState::withState() A last analyzed 2023-11-13 23:19 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

SiteState::withState() A
last analyzed 2023-11-13 23:19 UTC