GateKeeper - Code Metrics - Inspection of "remove ajax activation" - pryley/pollux - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — develop ( 775faa...ae8f25 )

by Paul

created 2017-05-12 15:29 UTC

GateKeeper C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	430
Duplicated Lines	3.72 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	16
loc	430
rs	5.5667
c	1
b	0
f	0
wmc	72
lcom	1
cbo	3

30 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	2
A	init()	0	10	1
B	activatePlugin()	0	16	5
A	ajaxActivatePluginLink()	0	13	2
A	canActivate()	0	4	2
A	deactivate()	0	11	3
B	getDependencyAction()	0	18	5
A	hasDependency()	0	7	3
A	hasValidPHPVersion()	0	4	1
A	hasValidWPVersion()	0	5	1
A	isPluginActive()	0	6	2
A	isPluginDependency()	0	4	1
A	isPluginInstalled()	0	6	1
A	isPluginValid()	0	4	2
A	isPluginVersionValid()	0	14	3
A	printNotices()	0	6	2
A	hasPendingDependencies()	0	9	3
C	setDependencyNotice()	0	27	11
A	addInvalidPHPVersionNotice()	8	8	1
A	addInvalidWPVersionNotice()	8	8	1
A	catchError()	0	12	3
A	getAllPlugins()	0	5	1
A	getMustUsePlugins()	0	11	3
A	getPlugin()	0	7	2
A	getPluginData()	0	13	3
A	getPluginInformation()	0	8	2
A	getPluginLink()	0	14	2
A	getPluginRequirements()	0	9	2
A	getPluginSlug()	0	4	1
A	redirect()	0	9	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like GateKeeper often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use GateKeeper, and based on these observations, apply Extract Interface, too.

<?php

namespace GeminiLabs\Pollux;

use Exception;
use GeminiLabs\Pollux\Config\Config;
use ReflectionClass;

class GateKeeper
{
	/**
	 * [plugin_file_path] => [plugin_name]|[plugin_version]|[plugin_url]
	 */
	const DEPENDENCIES = [
		'meta-box/meta-box.php' => 'Meta Box|4.11|https://wordpress.org/plugins/meta-box/',
	];
	const MIN_PHP_VERSION = '5.6.0';
	const MIN_WORDPRESS_VERSION = '4.7';

	public $errors = [];

	/**
	 * @var Application
	 */
	protected $app;

	/**
	 * @var Notice
	 */
	protected $notice;

	/**
	 * @var string
	 */
	protected $plugin;

	public function __construct( $plugin )
	{
		$this->plugin = $plugin;

		if( $this->canActivate() ) {
			add_action( 'admin_init', array( $this, 'init' ));
		}
		else {
			add_action( 'activated_plugin', array( $this, 'deactivate' ));
			add_action( 'admin_notices',    array( $this, 'deactivate' ));
		}
	}

	public function init()
	{
		$this->app = pollux_app();
		$this->notice = pollux_app()->make( 'Notice' );

		add_action( 'current_screen',                         array( $this, 'activatePlugin' ));
		add_action( 'wp_ajax_pollux/dependency/activate_url', array( $this, 'ajaxActivatePluginLink' ));
		add_action( 'admin_notices',                          array( $this, 'printNotices' ));
		add_action( 'current_screen',                         array( $this, 'setDependencyNotice' ));
	}

	/**
	 * @return void
	 */
	public function activatePlugin()
	{
		$screen = ( new Helper )->getCurrentScreen();
		$plugin = filter_input( INPUT_GET, 'plugin' );
		if( $screen->id != 'settings_page_pollux'
			|| $screen->pagenow != 'options-general.php'
			|| filter_input( INPUT_GET, 'action' ) != 'activate'
		)return;
		check_admin_referer( 'activate-plugin_' . $plugin );
		$result = activate_plugin( $plugin, null, is_network_admin(), true );
		if( is_wp_error( $result )) {
			wp_die( $result->get_error_message() );
		}
		wp_safe_redirect( wp_get_referer() );
		exit;
	}

	/**
	 * @return void
	 */
	public function ajaxActivatePluginLink()
	{
		check_ajax_referer( 'updates' );
		$plugin = filter_input( INPUT_POST, 'plugin' );
		if( !$this->isPluginDependency( $plugin )) {
			wp_send_json_error();
		}
		$actionUrl = self_admin_url( sprintf( 'options-general.php?page=%s&action=activate&plugin=%s', $this->app->id, $plugin ));
		wp_send_json_success([
			'activate_url' => wp_nonce_url( $actionUrl, sprintf( 'activate-plugin_%s', $plugin )),
			filter_input( INPUT_POST, 'type' ) => $plugin,
		]);
	}

	/**
	 * @return bool
	 */
	public function canActivate()
	{
		return $this->hasValidPHPVersion() && $this->hasValidWPVersion();
	}

	/**
	 * @return void
	 * @action activated_plugin
	 * @action admin_notices
	 */
	public function deactivate( $plugin )
	{
		if( $plugin == $this->plugin ) {
			$this->redirect();
		}
		deactivate_plugins( $this->plugin );
		$addNotice = $this->hasValidPHPVersion()
			? 'addInvalidWPVersionNotice'
			: 'addInvalidPHPVersionNotice';
		$this->$addNotice();
	}

	/**
	 * @return void|null
	 */
	public function getDependencyAction()
	{
		if( get_current_screen()->id != 'settings_page_pollux' )return;

		$action = filter_input( INPUT_GET, 'action' );
		$plugin = filter_input( INPUT_GET, 'plugin' );

		if( $action == 'activate' ) {
			$this->activatePlugin( $plugin );

		}
		else if( $action == 'install' ) {
			$this->installPlugin( $plugin );

		}
		else if( filter_input( INPUT_GET, '_error_nonce' )) {
			wp_safe_redirect( remove_query_arg( '_error_nonce' ));
			exit;
		}
	}

	/**
	 * @return bool
	 */
	public function hasDependency( $plugin )
	{
		if( !$this->isPluginDependency( $plugin )) {
			return true;
		}
		return $this->isPluginInstalled( $plugin ) && $this->isPluginValid( $plugin );
	}

	/**
	 * @return bool
	 */
	public function hasValidPHPVersion()
	{
		return version_compare( PHP_VERSION, self::MIN_PHP_VERSION, '>=' );
	}

	/**
	 * @return bool
	 */
	public function hasValidWPVersion()
	{
		global $wp_version;
		return version_compare( $wp_version, self::MIN_WORDPRESS_VERSION, '>=' );
	}

	/**
	 * @return bool
	 */
	public function isPluginActive( $plugin )
	{
		return $this->catchError( $plugin, 'inactive',
			is_plugin_active( $plugin ) || array_key_exists( $plugin, $this->getMustUsePlugins() )
		);
	}

	/**
	 * @return bool
	 */
	public function isPluginDependency( $plugin )
	{
		return array_key_exists( $plugin, static::DEPENDENCIES );
	}

	/**
	 * @return bool
	 */
	public function isPluginInstalled( $plugin )
	{
		return $this->catchError( $plugin, 'not_found',
			array_key_exists( $plugin, $this->getAllPlugins() )
		);
	}

	/**
	 * @return bool
	 */
	public function isPluginValid( $plugin )
	{
		return $this->isPluginActive( $plugin ) && $this->isPluginVersionValid( $plugin );
	}

	/**
	 * @return bool
	 */
	public function isPluginVersionValid( $plugin )
	{
		if( !$this->isPluginDependency( $plugin )) {
			return true;
		}
		if( !$this->isPluginInstalled( $plugin )) {
			return false;
		}
		return $this->catchError( $plugin, 'wrong_version', version_compare(
			$this->getPluginRequirements( $plugin, 'version' ),
			$this->getAllPlugins()[$plugin]['Version'],
			'<='
		));
	}

	/**
	 * @return void
	 */
	public function printNotices()
	{
		foreach( $this->notice->all as $notice ) {
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
			echo $this->notice->generate( $notice );
		}
	}

	/**
	 * @return bool
	 */
	public function hasPendingDependencies()
	{
		foreach( static::DEPENDENCIES as $plugin => $data ) {
			if( !$this->isPluginDependency( $plugin ))continue;
			$this->isPluginActive( $plugin );
			$this->isPluginVersionValid( $plugin );
		}
		return !empty( $this->errors );
	}

	/**
	 * @return void|null
	 */
	public function setDependencyNotice()
	{
		if( get_current_screen()->id != 'settings_page_pollux'
			|| $this->app->config->disable_config
			|| !$this->hasPendingDependencies()
		)return;

		$plugins = '';
		$actions = '';

		foreach( $this->errors as $plugin => $errors ) {
			$plugins .= $this->getPluginLink( $plugin );
			if( in_array( 'not_found', $errors ) && current_user_can( 'install_plugins' )) {
				$actions .= $this->notice->installButton( $this->getPluginRequirements( $plugin ));

			}
			else if( in_array( 'wrong_version', $errors ) && current_user_can( 'update_plugins' )) {
				$actions .= $this->notice->updateButton( $this->getPluginInformation( $plugin ));

			}
			else if( in_array( 'inactive', $errors ) && current_user_can( 'activate_plugins' )) {
				$actions .= $this->notice->activateButton( $this->getPluginInformation( $plugin ));

			}
		}
		$this->notice->addWarning([
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
			sprintf( '<strong>%s</strong> %s', __( 'Pollux requires the latest version of the following plugins:', 'pollux' ), $plugins ),
			$actions,
		]);
	}

	/**
	 * @return void
	 */
	protected function addInvalidPHPVersionNotice()

	{
		$this->notice->addError([
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
			$this->notice->title( __( 'The Pollux plugin was deactivated.', 'pollux' )),
			sprintf( __( 'Sorry, Pollux requires PHP %s or greater in order to work properly (your server is running PHP %s).', 'pollux' ), self::MIN_PHP_VERSION, PHP_VERSION ),
			__( 'Please contact your hosting provider or server administrator to upgrade the version of PHP running on your server, or find an alternate plugin.', 'pollux' ),
		]);
	}

	/**
	 * @return void
	 */
	protected function addInvalidWPVersionNotice()

	{
		$this->notice->addError([
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
			$this->notice->title( __( 'The Pollux plugin was deactivated.', 'pollux' )),
			sprintf( __( 'Sorry, Pollux requires WordPress %s or greater in order to work properly.', 'pollux' ), self::MIN_WORDPRESS_VERSION ),
			$this->notice->button( __( 'Update WordPress', 'pollux' ), self_admin_url( 'update-core.php' )),
		]);
	}

	/**
	 * @param string $error
	 * @param bool $bool
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
	 * @return bool
	 */
	protected function catchError( $plugin, $error, $isValid )
	{
		if( !$isValid ) {
			if( !isset( $this->errors[$plugin] )) {
				$this->errors[$plugin] = [];
			}
			$this->errors[$plugin] = array_keys( array_flip(
				array_merge( $this->errors[$plugin], [$error] )
			));
		}
		return $isValid;
	}

	/**
	 * @return array
	 */
	protected function getAllPlugins()
	{
		require_once ABSPATH . 'wp-admin/includes/plugin.php';
		return array_merge( get_plugins(), $this->getMustUsePlugins() );
	}

	/**
	 * @return array
	 */
	protected function getMustUsePlugins()
	{
		$plugins = get_mu_plugins();
		if( in_array( 'Bedrock Autoloader', array_column( $plugins, 'Name' ))) {
			$autoloadedPlugins = get_site_option( 'bedrock_autoloader' );
			if( !empty( $autoloadedPlugins['plugins'] )) {
				return array_merge( $plugins, $autoloadedPlugins['plugins'] );
			}
		}
		return $plugins;
	}

	/**
	 * @return array|false
	 */
	protected function getPlugin( $plugin )
	{
		if( $this->isPluginInstalled( $plugin )) {
			return $this->getAllPlugins()[$plugin];
		}
		return false;
	}

	/**
	 * @return array|string
	 */
	protected function getPluginData( $plugin, array $data, $key = null )
	{
		$data['plugin'] = $plugin;
		$data['slug'] = $this->getPluginSlug( $plugin );
		$data = array_change_key_case( $data );
		if( is_null( $key )) {
			return $data;
		}
		$key = strtolower( $key );
		return isset( $data[$key] )
			? $data[$key]
			: '';
	}

	/**
	 * @return array|string
	 */
	protected function getPluginInformation( $plugin, $key = null )
	{
		$data = $this->getPlugin( $plugin );
		if( is_array( $data )) {
			return $this->getPluginData( $plugin, $data, $key );
		}
		throw new Exception( sprintf( 'Plugin information not found for: %s', $plugin ));
	}

	/**
	 * @return string
	 */
	protected function getPluginLink( $plugin )
	{
		try {
			$data = $this->getPluginInformation( $plugin );
		}
		catch( Exception $e ) {
			$data = $this->getPluginRequirements( $plugin );
		}
		return sprintf( '<span class="plugin-%s"><a href="%s">%s</a></span>',
			$data['slug'],
			$data['pluginuri'],
			$data['name']
		);
	}

	/**
	 * @return array|string
	 */
	protected function getPluginRequirements( $plugin, $key = null )
	{
		$keys = ['Name', 'Version', 'PluginURI'];
		$index = array_search( $key, $keys, true );
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
		$requirements = $this->isPluginDependency( $plugin )
			? array_pad( explode( '|', static::DEPENDENCIES[$plugin] ), 3, '' )
			: array_fill( 0, 3, '' );
		return $this->getPluginData( $plugin, array_combine( $keys, $requirements ), $key );
	}

	/**
	 * @return string
	 */
	protected function getPluginSlug( $plugin )
	{
		return substr( $plugin, 0, strrpos( $plugin, '/' ));
	}

	/**
	 * @return void
	 */
	protected function redirect()
	{
		wp_safe_redirect( self_admin_url( sprintf( 'plugins.php?plugin_status=%s&paged=%s&s=%s',
			filter_input( INPUT_GET, 'plugin_status' ),
			filter_input( INPUT_GET, 'paged' ),
			filter_input( INPUT_GET, 's' )
		)));
		exit;
	}
}


pryley / pollux