SiteState::hasExtension() - Code Metrics - Inspection of "Add variants and update the task to use it" - Firesphere/silverstripe-solr-search - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — hans/Index-all-fluent-options ( 53088a )

by Simon

created 2019-09-06 02:05 UTC

SiteState::hasExtension() A

↳ Parent: SiteState

Complexity

Conditions	3
Paths	3

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
eloc	4
nc	3
nop	2
dl	0
loc	9
rs	10
c	1
b	0
f	0

<?php


namespace Firesphere\SolrSearch\States;

use Firesphere\SolrSearch\Compat\FluentExtension;
use Firesphere\SolrSearch\Helpers\FieldResolver;
use ReflectionClass;
use SilverStripe\Core\ClassInfo;
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, otherwise it won't be called.
 * {@see FluentExtension::onBeforeInit()}
 *
 * States, options, etc. are simplified for a more streamlined approach
 *
 * @package Firesphere\SolrSearch\States
 */
abstract class SiteState
{

    /**
     * States that can be applied
     *
     * @var array
     */
    public static $states = [
        'default',
    ];

    /**
     * Variants of SiteState that can be activated
     *
     * @var array
     */
    public static $variants;

    /**
     * @var bool Is this State enabled
     */
    public $enabled = true;

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

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

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

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

    /**
     * Add multiple states
     *
     * @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?
     *
     * @param $class
     * @param $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;
    }


    /**
     * Returns an array of variants.
     *
     * With no arguments, returns all variants
     *
     * With a classname as the first argument, returns the variants that apply to that class
     * (optionally including subclasses)
     *
     * @static
     * @return array - An array of (string)$variantClassName => (Object)$variantInstance pairs
     * @throws \ReflectionException
     */
    public static function variants(): ?array
    {
        // Build up and cache a list of all search variants (subclasses of SearchVariant)
        if (self::$variants === null) {

            $classes = ClassInfo::subclassesFor(static::class);

            $concrete = [];
            foreach ($classes as $variantclass) {
                $ref = new ReflectionClass($variantclass);
                if ($ref->isInstantiable()) {
                    $variant = singleton($variantclass);
                    if ($variant->appliesToEnvironment()) {
                        $concrete[$variantclass] = $variant;
                    }
                }
            }

            self::$variants = $concrete;
        }

        return self::$variants;
    }


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

    /**
     * Activate a site state for indexing
     *
     * @param $state
     * @throws \ReflectionException
     */
    public static function withState($state): void
    {
        /**
         * @var string $variant
         * @var static $instance
         */
        foreach (self::variants() as $variant => $instance) {
            $instance->activateState($state);
        }
    }
}


1			<?php
2
3
4			namespace Firesphere\SolrSearch\States;
5
6			use Firesphere\SolrSearch\Compat\FluentExtension;
7			use Firesphere\SolrSearch\Helpers\FieldResolver;
8			use ReflectionClass;
9			use SilverStripe\Core\ClassInfo;
10			use SilverStripe\ORM\DataObject;
11
12			/**
13			* Class SiteState
14			*
15			* Determine and apply the state of the site currently. This is used at index-time to figure out what state to index.
16			* An example of this is the FluentSearchVariant extension from Fluent.
17			*
18			* Fluent uses the old SearchVariant method, which is actually not that bad a concept. These "Variants", now called
19			* "States" set the state of the site to a required setting for each available state.
20			*
21			* States SHOULD add their own states through an extension, otherwise it won't be called.
22			* {@see FluentExtension::onBeforeInit()}
23			*
24			* States, options, etc. are simplified for a more streamlined approach
25			*
26			* @package Firesphere\SolrSearch\States
27			*/
28			abstract class SiteState
29			{
30
31			/**
32			* States that can be applied
33			*
34			* @var array
35			*/
36			public static $states = [
37			'default',
38			];
39
40			/**
41			* Variants of SiteState that can be activated
42			*
43			* @var array
44			*/
45			public static $variants;
46
47			/**
48			* @var bool Is this State enabled
49			*/
50			public $enabled = true;
51
52			/**
53			* Does this state apply to the current object/environment settings
54			*
55			* @return bool
56			*/
57			public function appliesToEnvironment(): bool
58			{
59			return $this->enabled;
60			}
61
62			/**
63			* Get available states
64			*
65			* @return array
66			*/
67			public static function getStates(): array
68			{
69			return self::$states;
70			}
71
72			/**
73			* Set states
74			*
75			* @param array $states
76			*/
77			public static function setStates(array $states): void
78			{
79			self::$states = $states;
80			}
81
82			/**
83			* Add a state
84			*
85			* @param $state
86			*/
87			public static function addState($state): void
88			{
89			self::$states[] = $state;
90			}
91
92			/**
93			* Add multiple states
94			*
95			* @param array $states
96			*/
97			public static function addStates(array $states): void
98			{
99			self::$states = array_merge(self::$states, $states);
100			}
101
102			/**
103			* Does this class, it's parent (or optionally one of it's children) have the passed extension attached?
104			*
105			* @param $class
106			* @param $extension
107			* @return bool
108			* @throws \ReflectionException
109			*/
110			public static function hasExtension($class, $extension): bool
111			{
112			/** @var DataObject $relatedclass */
113			foreach (FieldResolver::gethierarchy($class) as $relatedclass) {
114			if ($relatedclass::has_extension($extension)) {
115			return true;
116			}
117			}
118			return false;
119			}
120
121
122			/**
123			* Returns an array of variants.
124			*
125			* With no arguments, returns all variants
126			*
127			* With a classname as the first argument, returns the variants that apply to that class
128			* (optionally including subclasses)
129			*
130			* @static
131			* @return array - An array of (string)$variantClassName => (Object)$variantInstance pairs
132			* @throws \ReflectionException
133			*/
134			public static function variants(): ?array
135			{
136			// Build up and cache a list of all search variants (subclasses of SearchVariant)
137			if (self::$variants === null) {
			0 ignored issues – show introduced 2019-09-06 02:10 UTC by Report Bug Copy Issue Report The condition `self::variants === null` is always `false`. Loading history...
138			$classes = ClassInfo::subclassesFor(static::class);
139
140			$concrete = [];
141			foreach ($classes as $variantclass) {
142			$ref = new ReflectionClass($variantclass);
143			if ($ref->isInstantiable()) {
144			$variant = singleton($variantclass);
145			if ($variant->appliesToEnvironment()) {
146			$concrete[$variantclass] = $variant;
147			}
148			}
149			}
150
151			self::$variants = $concrete;
152			}
153
154			return self::$variants;
155			}
156
157
158			/**
159			* Get the current state of every variant
160			*
161			* @static
162			* @return array
163			* @throws \ReflectionException
164			*/
165			public static function currentStates(): array
166			{
167			$state = [];
168			foreach (self::variants() as $variant => $instance) {
169			$state[$variant] = $instance->currentState();
170			}
171			return $state;
172			}
173
174			/**
175			* Activate a site state for indexing
176			*
177			* @param $state
178			* @throws \ReflectionException
179			*/
180			public static function withState($state): void
181			{
182			/**
183			* @var string $variant
184			* @var static $instance
185			*/
186			foreach (self::variants() as $variant => $instance) {
187			$instance->activateState($state);
188			}
189			}
190			}
191

Firesphere / silverstripe-solr-search

Push — hans/Index-all-fluent-options ( 53088a )

SiteState::hasExtension() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like