CacheController::confirmFlush() - Code Metrics - Inspection of "Switch travis OR from precise to trusty" - yiisoft/yii2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — prepare-travis-for-js ( a7ee60 )

by Carsten

created 2016-12-01 09:28 UTC

CacheController::confirmFlush() A

↳ Parent: CacheController

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

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

<?php
/**
 * @link http://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 */

namespace yii\console\controllers;

use Yii;
use yii\console\Controller;
use yii\caching\Cache;
use yii\helpers\Console;
use yii\console\Exception;

/**
 * Allows you to flush cache.
 *
 * see list of available components to flush:
 *
 *     yii cache
 *
 * flush particular components specified by their names:
 *
 *     yii cache/flush first second third
 *
 * flush all cache components that can be found in the system
 *
 *     yii cache/flush-all
 *
 * Note that the command uses cache components defined in your console application configuration file. If components
 * configured are different from web application, web application cache won't be cleared. In order to fix it please
 * duplicate web application cache components in console config. You can use any component names.
 *
 * Both APC and OpCache aren't shared between PHP processes so flushing cache from command line has no effect on web.
 * Flushing web cache could be either done by:
 *
 * - Putting a php file under web root and calling it via HTTP
 * - Using [Cachetool](http://gordalina.github.io/cachetool/)
 *
 * @author Alexander Makarov <[email protected]>
 * @author Mark Jebri <[email protected]>
 * @since 2.0
 */
class CacheController extends Controller
{
    /**
     * Lists the caches that can be flushed.
     */
    public function actionIndex()
    {
        $caches = $this->findCaches();

        if (!empty($caches)) {
            $this->notifyCachesCanBeFlushed($caches);
        } else {
            $this->notifyNoCachesFound();
        }
    }

    /**
     * Flushes given cache components.
     * For example,
     *
     * ```
     * # flushes caches specified by their id: "first", "second", "third"
     * yii cache/flush first second third
     * ```
     *
     */
    public function actionFlush()
    {
        $cachesInput = func_get_args();

        if (empty($cachesInput)) {
            throw new Exception('You should specify cache components names');
        }

        $caches = $this->findCaches($cachesInput);
        $cachesInfo = [];

        $foundCaches = array_keys($caches);
        $notFoundCaches = array_diff($cachesInput, array_keys($caches));

        if ($notFoundCaches) {

            $this->notifyNotFoundCaches($notFoundCaches);
        }

        if (!$foundCaches) {

            $this->notifyNoCachesFound();
            return static::EXIT_CODE_NORMAL;
        }

        if (!$this->confirmFlush($foundCaches)) {
$a = canBeFalseAndNull();

// Instead of
if ( ! $a) { }

// Better use one of the explicit versions:
if ($a !== null) { }
if ($a !== false) { }
if ($a !== null && $a !== false) { }
            return static::EXIT_CODE_NORMAL;
        }

        foreach ($caches as $name => $class) {
            $cachesInfo[] = [
                'name' => $name,
                'class' => $class,
                'is_flushed' => Yii::$app->get($name)->flush(),
            ];
        }

        $this->notifyFlushed($cachesInfo);
    }

    /**
     * Flushes all caches registered in the system.
     */
    public function actionFlushAll()
    {
        $caches = $this->findCaches();
        $cachesInfo = [];

        if (empty($caches)) {
            $this->notifyNoCachesFound();
            return static::EXIT_CODE_NORMAL;
        }

        foreach ($caches as $name => $class) {
            $cachesInfo[] = [
                'name' => $name,
                'class' => $class,
                'is_flushed' => Yii::$app->get($name)->flush(),
            ];
        }

        $this->notifyFlushed($cachesInfo);
    }

    /**
     * Clears DB schema cache for a given connection component.
     *
     * ```
     * # clears cache schema specified by component id: "db"
     * yii cache/flush-schema db
     * ```
     *
     * @param string $db id connection component
     * @return int exit code
     * @throws Exception
     * @throws \yii\base\InvalidConfigException
     *
     * @since 2.0.1
     */
    public function actionFlushSchema($db = 'db')
    {
        $connection = Yii::$app->get($db, false);
        if ($connection === null) {
            $this->stdout("Unknown component \"$db\".\n", Console::FG_RED);
            return self::EXIT_CODE_ERROR;
        }

        if (!$connection instanceof \yii\db\Connection) {
            $this->stdout("\"$db\" component doesn't inherit \\yii\\db\\Connection.\n", Console::FG_RED);
            return self::EXIT_CODE_ERROR;
        } elseif (!$this->confirm("Flush cache schema for \"$db\" connection?")) {
$a = canBeFalseAndNull();

// Instead of
if ( ! $a) { }

// Better use one of the explicit versions:
if ($a !== null) { }
if ($a !== false) { }
if ($a !== null && $a !== false) { }
            return static::EXIT_CODE_NORMAL;
        }

        try {
            $schema = $connection->getSchema();
            $schema->refresh();
            $this->stdout("Schema cache for component \"$db\", was flushed.\n\n", Console::FG_GREEN);
        } catch (\Exception $e) {
            $this->stdout($e->getMessage() . "\n\n", Console::FG_RED);
        }
    }

    /**
     * Notifies user that given caches are found and can be flushed.
     * @param array $caches array of cache component classes
     */
    private function notifyCachesCanBeFlushed($caches)
    {
        $this->stdout("The following caches were found in the system:\n\n", Console::FG_YELLOW);

        foreach ($caches as $name => $class) {
            $this->stdout("\t* $name ($class)\n", Console::FG_GREEN);
        }

        $this->stdout("\n");
    }

    /**
     * Notifies user that there was not found any cache in the system.
     */
    private function notifyNoCachesFound()
    {
        $this->stdout("No cache components were found in the system.\n", Console::FG_RED);
    }

    /**
     * Notifies user that given cache components were not found in the system.
     * @param array $cachesNames
     */
    private function notifyNotFoundCaches($cachesNames)
    {
        $this->stdout("The following cache components were NOT found:\n\n", Console::FG_RED);

        foreach ($cachesNames as $name) {
            $this->stdout("\t* $name \n", Console::FG_GREEN);
        }

        $this->stdout("\n");
    }

    /**
     *
     * @param array $caches
     */
    private function notifyFlushed($caches)
    {
        $this->stdout("The following cache components were processed:\n\n", Console::FG_YELLOW);

        foreach ($caches as $cache) {
            $this->stdout("\t* " . $cache['name'] .' (' . $cache['class'] . ')', Console::FG_GREEN);

            if (!$cache['is_flushed']) {
                $this->stdout(" - not flushed\n", Console::FG_RED);
            } else {
                $this->stdout("\n");
            }
        }

        $this->stdout("\n");
    }

    /**
     * Prompts user with confirmation if caches should be flushed.
     * @param array $cachesNames
     * @return bool
     */
    private function confirmFlush($cachesNames)
    {
        $this->stdout("The following cache components will be flushed:\n\n", Console::FG_YELLOW);

        foreach ($cachesNames as $name) {
            $this->stdout("\t* $name \n", Console::FG_GREEN);
        }

        return $this->confirm("\nFlush above cache components?");
    }

    /**
     * Returns array of caches in the system, keys are cache components names, values are class names.
     * @param array $cachesNames caches to be found
     * @return array
     */
    private function findCaches(array $cachesNames = [])
    {
        $caches = [];
        $components = Yii::$app->getComponents();
        $findAll = ($cachesNames === []);

        foreach ($components as $name => $component) {
            if (!$findAll && !in_array($name, $cachesNames)) {
                continue;
            }

            if ($component instanceof Cache) {
                $caches[$name] = get_class($component);
            } elseif (is_array($component) && isset($component['class']) && $this->isCacheClass($component['class'])) {
                $caches[$name] = $component['class'];
            } elseif (is_string($component) && $this->isCacheClass($component)) {
                $caches[$name] = $component;
            }
        }

        return $caches;
    }

    /**
     * Checks if given class is a Cache class.
     * @param string $className class name.
     * @return bool
     */
    private function isCacheClass($className)
    {
        return is_subclass_of($className, Cache::className());
    }
}


1			<?php
2			/**
3			* @link http://www.yiiframework.com/
4			* @copyright Copyright (c) 2008 Yii Software LLC
5			* @license http://www.yiiframework.com/license/
6			*/
7
8			namespace yii\console\controllers;
9
10			use Yii;
11			use yii\console\Controller;
12			use yii\caching\Cache;
13			use yii\helpers\Console;
14			use yii\console\Exception;
15
16			/**
17			* Allows you to flush cache.
18			*
19			* see list of available components to flush:
20			*
21			* yii cache
22			*
23			* flush particular components specified by their names:
24			*
25			* yii cache/flush first second third
26			*
27			* flush all cache components that can be found in the system
28			*
29			* yii cache/flush-all
30			*
31			* Note that the command uses cache components defined in your console application configuration file. If components
32			* configured are different from web application, web application cache won't be cleared. In order to fix it please
33			* duplicate web application cache components in console config. You can use any component names.
34			*
35			* Both APC and OpCache aren't shared between PHP processes so flushing cache from command line has no effect on web.
36			* Flushing web cache could be either done by:
37			*
38			* - Putting a php file under web root and calling it via HTTP
39			* - Using [Cachetool](http://gordalina.github.io/cachetool/)
40			*
41			* @author Alexander Makarov <[email protected]>
42			* @author Mark Jebri <[email protected]>
43			* @since 2.0
44			*/
45			class CacheController extends Controller
46			{
47			/**
48			* Lists the caches that can be flushed.
49			*/
50			public function actionIndex()
51			{
52			$caches = $this->findCaches();
53
54			if (!empty($caches)) {
55			$this->notifyCachesCanBeFlushed($caches);
56			} else {
57			$this->notifyNoCachesFound();
58			}
59			}
60
61			/**
62			* Flushes given cache components.
63			* For example,
64			*
65			* ```
66			* # flushes caches specified by their id: "first", "second", "third"
67			* yii cache/flush first second third
68			* ```
69			*
70			*/
71			public function actionFlush()
72			{
73			$cachesInput = func_get_args();
74
75			if (empty($cachesInput)) {
76			throw new Exception('You should specify cache components names');
77			}
78
79			$caches = $this->findCaches($cachesInput);
80			$cachesInfo = [];
81
82			$foundCaches = array_keys($caches);
83			$notFoundCaches = array_diff($cachesInput, array_keys($caches));
84
85			if ($notFoundCaches) {
			0 ignored issues – show Bug Best Practice introduced 2015-11-20 21:52 UTC by Report Bug Copy Issue Report The expression `$notFoundCaches` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
86			$this->notifyNotFoundCaches($notFoundCaches);
87			}
88
89			if (!$foundCaches) {
			0 ignored issues – show Bug Best Practice introduced 2015-11-20 21:52 UTC by Report Bug Copy Issue Report The expression `$foundCaches` of type `array<integer\|string>` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
90			$this->notifyNoCachesFound();
91			return static::EXIT_CODE_NORMAL;
92			}
93
94			if (!$this->confirmFlush($foundCaches)) {
			0 ignored issues – show Bug Best Practice introduced 2015-11-20 21:52 UTC by Report Bug Copy Issue Report The expression `$this->confirmFlush($foundCaches)` of type `boolean\|null` is loosely compared to `false`; this is ambiguous if the boolean can be false. You might want to explicitly use `!== null` instead. If an expression can have both `false`, and `null` as possible values. It is generally a good practice to always use strict comparison to clearly distinguish between those two values. $a = canBeFalseAndNull(); // Instead of if ( ! $a) { } // Better use one of the explicit versions: if ($a !== null) { } if ($a !== false) { } if ($a !== null && $a !== false) { } Loading history...
95			return static::EXIT_CODE_NORMAL;
96			}
97
98			foreach ($caches as $name => $class) {
99			$cachesInfo[] = [
100			'name' => $name,
101			'class' => $class,
102			'is_flushed' => Yii::$app->get($name)->flush(),
103			];
104			}
105
106			$this->notifyFlushed($cachesInfo);
107			}
108
109			/**
110			* Flushes all caches registered in the system.
111			*/
112			public function actionFlushAll()
113			{
114			$caches = $this->findCaches();
115			$cachesInfo = [];
116
117			if (empty($caches)) {
118			$this->notifyNoCachesFound();
119			return static::EXIT_CODE_NORMAL;
120			}
121
122			foreach ($caches as $name => $class) {
123			$cachesInfo[] = [
124			'name' => $name,
125			'class' => $class,
126			'is_flushed' => Yii::$app->get($name)->flush(),
127			];
128			}
129
130			$this->notifyFlushed($cachesInfo);
131			}
132
133			/**
134			* Clears DB schema cache for a given connection component.
135			*
136			* ```
137			* # clears cache schema specified by component id: "db"
138			* yii cache/flush-schema db
139			* ```
140			*
141			* @param string $db id connection component
142			* @return int exit code
143			* @throws Exception
144			* @throws \yii\base\InvalidConfigException
145			*
146			* @since 2.0.1
147			*/
148			public function actionFlushSchema($db = 'db')
149			{
150			$connection = Yii::$app->get($db, false);
151			if ($connection === null) {
152			$this->stdout("Unknown component \"$db\".\n", Console::FG_RED);
153			return self::EXIT_CODE_ERROR;
154			}
155
156			if (!$connection instanceof \yii\db\Connection) {
157			$this->stdout("\"$db\" component doesn't inherit \\yii\\db\\Connection.\n", Console::FG_RED);
158			return self::EXIT_CODE_ERROR;
159			} elseif (!$this->confirm("Flush cache schema for \"$db\" connection?")) {
			0 ignored issues – show Bug Best Practice introduced 2015-11-20 21:52 UTC by Report Bug Copy Issue Report The expression `$this->confirm("Flush ca...\"{$db}\" connection?")` of type `boolean\|null` is loosely compared to `false`; this is ambiguous if the boolean can be false. You might want to explicitly use `!== null` instead. If an expression can have both `false`, and `null` as possible values. It is generally a good practice to always use strict comparison to clearly distinguish between those two values. $a = canBeFalseAndNull(); // Instead of if ( ! $a) { } // Better use one of the explicit versions: if ($a !== null) { } if ($a !== false) { } if ($a !== null && $a !== false) { } Loading history...
160			return static::EXIT_CODE_NORMAL;
161			}
162
163			try {
164			$schema = $connection->getSchema();
165			$schema->refresh();
166			$this->stdout("Schema cache for component \"$db\", was flushed.\n\n", Console::FG_GREEN);
167			} catch (\Exception $e) {
168			$this->stdout($e->getMessage() . "\n\n", Console::FG_RED);
169			}
170			}
171
172			/**
173			* Notifies user that given caches are found and can be flushed.
174			* @param array $caches array of cache component classes
175			*/
176			private function notifyCachesCanBeFlushed($caches)
177			{
178			$this->stdout("The following caches were found in the system:\n\n", Console::FG_YELLOW);
179
180			foreach ($caches as $name => $class) {
181			$this->stdout("\t* $name ($class)\n", Console::FG_GREEN);
182			}
183
184			$this->stdout("\n");
185			}
186
187			/**
188			* Notifies user that there was not found any cache in the system.
189			*/
190			private function notifyNoCachesFound()
191			{
192			$this->stdout("No cache components were found in the system.\n", Console::FG_RED);
193			}
194
195			/**
196			* Notifies user that given cache components were not found in the system.
197			* @param array $cachesNames
198			*/
199			private function notifyNotFoundCaches($cachesNames)
200			{
201			$this->stdout("The following cache components were NOT found:\n\n", Console::FG_RED);
202
203			foreach ($cachesNames as $name) {
204			$this->stdout("\t* $name \n", Console::FG_GREEN);
205			}
206
207			$this->stdout("\n");
208			}
209
210			/**
211			*
212			* @param array $caches
213			*/
214			private function notifyFlushed($caches)
215			{
216			$this->stdout("The following cache components were processed:\n\n", Console::FG_YELLOW);
217
218			foreach ($caches as $cache) {
219			$this->stdout("\t* " . $cache['name'] .' (' . $cache['class'] . ')', Console::FG_GREEN);
220
221			if (!$cache['is_flushed']) {
222			$this->stdout(" - not flushed\n", Console::FG_RED);
223			} else {
224			$this->stdout("\n");
225			}
226			}
227
228			$this->stdout("\n");
229			}
230
231			/**
232			* Prompts user with confirmation if caches should be flushed.
233			* @param array $cachesNames
234			* @return bool
235			*/
236			private function confirmFlush($cachesNames)
237			{
238			$this->stdout("The following cache components will be flushed:\n\n", Console::FG_YELLOW);
239
240			foreach ($cachesNames as $name) {
241			$this->stdout("\t* $name \n", Console::FG_GREEN);
242			}
243
244			return $this->confirm("\nFlush above cache components?");
245			}
246
247			/**
248			* Returns array of caches in the system, keys are cache components names, values are class names.
249			* @param array $cachesNames caches to be found
250			* @return array
251			*/
252			private function findCaches(array $cachesNames = [])
253			{
254			$caches = [];
255			$components = Yii::$app->getComponents();
256			$findAll = ($cachesNames === []);
257
258			foreach ($components as $name => $component) {
259			if (!$findAll && !in_array($name, $cachesNames)) {
260			continue;
261			}
262
263			if ($component instanceof Cache) {
264			$caches[$name] = get_class($component);
265			} elseif (is_array($component) && isset($component['class']) && $this->isCacheClass($component['class'])) {
266			$caches[$name] = $component['class'];
267			} elseif (is_string($component) && $this->isCacheClass($component)) {
268			$caches[$name] = $component;
269			}
270			}
271
272			return $caches;
273			}
274
275			/**
276			* Checks if given class is a Cache class.
277			* @param string $className class name.
278			* @return bool
279			*/
280			private function isCacheClass($className)
281			{
282			return is_subclass_of($className, Cache::className());
283			}
284			}
285

yiisoft / yii2

Push — prepare-travis-for-js ( a7ee60 )

CacheController::confirmFlush() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like