MoodleInstallation::getMissingPluginDependencies() - Code Metrics - Inspection of "wip" - LukeCarrier/moodle-componentmgr - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — verify-deps ( 5e31a2 )

by Luke

created 2018-03-07 11:51 UTC

MoodleInstallation::getMissingPluginDependencies() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

/**
 * Moodle component manager.
 *
 * @author Luke Carrier <[email protected]>
 * @copyright 2016 Luke Carrier
 * @license GPL-3.0+
 */

namespace ComponentManager;

use ComponentManager\Exception\MoodleException;
use ComponentManager\Exception\PlatformException;
use ComponentManager\Platform\Platform;
use core_plugin_manager;
use stdClass;

/**
 * Moodle installation.
 *
 * Facilitates interaction with a Moodle installation. This class should be
 * used only by the MoodleCommand class. Elsewhere, use the Moodle class
 * instead. */
class MoodleInstallation {
    /**
     * Instance state: new.
     *
     * The instance has not yet been configured, and is not ready to use.
     *
     * @var integer
     */
    const STATE_NEW = 0;

    /**
     * Instance state: ready for use.
     *
     * The instance has been configured and is ready for use.
     *
     * @var integer
     */
    const STATE_READY = 1;

    /**
     * Instance state: disposed.
     *
     * The instance was configured, but has since been disposed. It is no longer
     * usable, and a new instance will need to be created to proceed.
     *
     * @var integer
     */
    const STATE_DISPOSED = 2;

    /**
     * The value of the Moodle $CFG object.
     *
     * We have to cache the result of the first call to getConfig() as
     * constants can be declared within this file, causing nasty warnings.
     *
     * @var stdClass
     */
    protected $config;

    /**
     * Platform support library.
     *
     * @var Platform
     */
    protected $platform;

    /**
     * Root directory of the Moodle installation.
     *
     * @var string
     */
    protected $rootDirectory;

    /**
     * Instance state.
     *
     * @var integer
     */
    protected $state;

    /**
     * Initialiser.
     *
     * @param Platform $platform
     * @param string   $rootDirectory
     */
    public function __construct(Platform $platform, $rootDirectory) {
        $this->state = static::STATE_NEW;

        $this->platform      = $platform;
        $this->rootDirectory = $rootDirectory;
    }

    /**
     * Assert that the instance's state is as expected.
     *
     * @param $expected
     *
     * @return void
     *
     * @throws MoodleException
     */
    protected function assertState($expected) {
        if ($this->state !== $expected) {
            throw new MoodleException(
                    sprintf('Expected state "%d", actual state was "%d"', $expected, $this->state),
                    MoodleException::CODE_INVALID_STATE);
        }
    }

    /**
     * Require the configuration file.
     *
     * @return void
     *
     * @throws MoodleException
     */
    public function configure() {
        $this->assertState(static::STATE_NEW);

        /* This value should be overwritten shortly, either by the definition in
         * the Moodle instance's configuration or by our own "fake"
         * configuration used to load the plugin manager. */
        $CFG = null;

        $constants = [
            'ABORT_AFTER_CONFIG',
            'CLI_SCRIPT',
            'IGNORE_COMPONENT_CACHE',
        ];

        foreach ($constants as $constant) {
            define($constant, true);
        }

        /* Only an extremely slim portion of Moodle will function correctly in
         * this state, as we've not actually done most of the Moodle setup
         * dance. It seems to be enough to run the plugin manager. */

        global $CFG;
function myFunction($a, $b) {
    // Do something
}
        $CFG = (object) [
            'dirroot'  => $this->rootDirectory,
            'dataroot' => $this->platform->createTempDirectory(),
            'wwwroot'  => 'http://localhost',
        ];

        require_once "{$CFG->dirroot}/lib/setup.php";
// Instead of
$x = "foo $bar $baz";

// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);

        $this->config = $CFG;
        $this->state  = static::STATE_READY;
    }

    public function dispose() {
        $this->assertState(static::STATE_READY);

        try {
            $this->platform->removeTempDirectory($this->config->dataroot);
        } catch (PlatformException $e) {
            if ($e->getCode() !== PlatformException::CODE_UNKNOWN_TEMP_DIRECTORY) {
                throw $e;
            }
        }

        $this->state = static::STATE_DISPOSED;
    }

    /**
     * Get plugin types.
     *
     * @return string[]
     */
    public function getPluginTypes() {
        $this->assertState(static::STATE_READY);

        $pluginMgr = $this->makePluginManager();
        return $pluginMgr->get_plugin_types();
    }

    /**
     * Get missing plugin dependencies.
     *
     * @return
     */
    public function getMissingPluginDependencies() {

        $this->assertState(static::STATE_READY);

        $pluginMgr = $this->makePluginManager();
        return $pluginMgr->missing_dependencies();
    }

    /**
     * Obtain the singleton instance of the Moodle plugin manager.
     *
     * @return core_plugin_manager
     */
    protected function makePluginManager() {
        $CFG = $this->config;
        require_once "{$CFG->dirroot}/lib/classes/plugin_manager.php";
// Instead of
$x = "foo $bar $baz";

// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);

        return core_plugin_manager::instance();
    }
}


Push — verify-deps ( 5e31a2 )

MoodleInstallation::getMissingPluginDependencies() A

Complexity

Size

Duplication

Code Coverage

Importance

1. Pass all data via parameters

2. Create a class that maintains your state

1			<?php
2
3			/**
4			* Moodle component manager.
5			*
6			* @author Luke Carrier <[email protected]>
7			* @copyright 2016 Luke Carrier
8			* @license GPL-3.0+
9			*/
10
11			namespace ComponentManager;
12
13			use ComponentManager\Exception\MoodleException;
14			use ComponentManager\Exception\PlatformException;
15			use ComponentManager\Platform\Platform;
16			use core_plugin_manager;
17			use stdClass;
18
19			/**
20			* Moodle installation.
21			*
22			* Facilitates interaction with a Moodle installation. This class should be
23			* used only by the MoodleCommand class. Elsewhere, use the Moodle class
24			* instead. */
25			class MoodleInstallation {
26			/**
27			* Instance state: new.
28			*
29			* The instance has not yet been configured, and is not ready to use.
30			*
31			* @var integer
32			*/
33			const STATE_NEW = 0;
34
35			/**
36			* Instance state: ready for use.
37			*
38			* The instance has been configured and is ready for use.
39			*
40			* @var integer
41			*/
42			const STATE_READY = 1;
43
44			/**
45			* Instance state: disposed.
46			*
47			* The instance was configured, but has since been disposed. It is no longer
48			* usable, and a new instance will need to be created to proceed.
49			*
50			* @var integer
51			*/
52			const STATE_DISPOSED = 2;
53
54			/**
55			* The value of the Moodle $CFG object.
56			*
57			* We have to cache the result of the first call to getConfig() as
58			* constants can be declared within this file, causing nasty warnings.
59			*
60			* @var stdClass
61			*/
62			protected $config;
63
64			/**
65			* Platform support library.
66			*
67			* @var Platform
68			*/
69			protected $platform;
70
71			/**
72			* Root directory of the Moodle installation.
73			*
74			* @var string
75			*/
76			protected $rootDirectory;
77
78			/**
79			* Instance state.
80			*
81			* @var integer
82			*/
83			protected $state;
84
85			/**
86			* Initialiser.
87			*
88			* @param Platform $platform
89			* @param string $rootDirectory
90			*/
91			public function __construct(Platform $platform, $rootDirectory) {
92			$this->state = static::STATE_NEW;
93
94			$this->platform = $platform;
95			$this->rootDirectory = $rootDirectory;
96			}
97
98			/**
99			* Assert that the instance's state is as expected.
100			*
101			* @param $expected
102			*
103			* @return void
104			*
105			* @throws MoodleException
106			*/
107			protected function assertState($expected) {
108			if ($this->state !== $expected) {
109			throw new MoodleException(
110			sprintf('Expected state "%d", actual state was "%d"', $expected, $this->state),
111			MoodleException::CODE_INVALID_STATE);
112			}
113			}
114
115			/**
116			* Require the configuration file.
117			*
118			* @return void
119			*
120			* @throws MoodleException
121			*/
122			public function configure() {
123			$this->assertState(static::STATE_NEW);
124
125			/* This value should be overwritten shortly, either by the definition in
126			* the Moodle instance's configuration or by our own "fake"
127			* configuration used to load the plugin manager. */
128			$CFG = null;
129
130			$constants = [
131			'ABORT_AFTER_CONFIG',
132			'CLI_SCRIPT',
133			'IGNORE_COMPONENT_CACHE',
134			];
135
136			foreach ($constants as $constant) {
137			define($constant, true);
138			}
139
140			/* Only an extremely slim portion of Moodle will function correctly in
141			* this state, as we've not actually done most of the Moodle setup
142			* dance. It seems to be enough to run the plugin manager. */
143
144			global $CFG;
			0 ignored issues – show Compatibility Best Practice introduced 2018-03-07 12:02 UTC by Report Bug Copy Issue Report Use of `global` functionality is not recommended; it makes your code harder to test, and less reusable. Instead of relying on `global` state, we recommend one of these alternatives: 1. Pass all data via parameters function myFunction($a, $b) { // Do something } 2. Create a class that maintains your state class MyClass { private $a; private $b; public function __construct($a, $b) { $this->a = $a; $this->b = $b; } public function myFunction() { // Do something } } Loading history...
145			$CFG = (object) [
146			'dirroot' => $this->rootDirectory,
147			'dataroot' => $this->platform->createTempDirectory(),
148			'wwwroot' => 'http://localhost',
149			];
150
151			require_once "{$CFG->dirroot}/lib/setup.php";
			0 ignored issues – show Coding Style Best Practice introduced 2016-04-30 16:31 UTC by Report Bug Copy Issue Report As per coding-style, please use concatenation or `sprintf` for the variable `$CFG` instead of interpolation. It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of $x = "foo $bar $baz"; // Better use either $x = "foo " . $bar . " " . $baz; $x = sprintf("foo %s %s", $bar, $baz); Loading history...
152
153			$this->config = $CFG;
154			$this->state = static::STATE_READY;
155			}
156
157			public function dispose() {
158			$this->assertState(static::STATE_READY);
159
160			try {
161			$this->platform->removeTempDirectory($this->config->dataroot);
162			} catch (PlatformException $e) {
163			if ($e->getCode() !== PlatformException::CODE_UNKNOWN_TEMP_DIRECTORY) {
164			throw $e;
165			}
166			}
167
168			$this->state = static::STATE_DISPOSED;
169			}
170
171			/**
172			* Get plugin types.
173			*
174			* @return string[]
175			*/
176			public function getPluginTypes() {
177			$this->assertState(static::STATE_READY);
178
179			$pluginMgr = $this->makePluginManager();
180			return $pluginMgr->get_plugin_types();
181			}
182
183			/**
184			* Get missing plugin dependencies.
185			*
186			* @return
187			*/
188			public function getMissingPluginDependencies() {
			0 ignored issues – show Documentation introduced 2018-03-07 12:13 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
189			$this->assertState(static::STATE_READY);
190
191			$pluginMgr = $this->makePluginManager();
192			return $pluginMgr->missing_dependencies();
193			}
194
195			/**
196			* Obtain the singleton instance of the Moodle plugin manager.
197			*
198			* @return core_plugin_manager
199			*/
200			protected function makePluginManager() {
201			$CFG = $this->config;
202			require_once "{$CFG->dirroot}/lib/classes/plugin_manager.php";
			0 ignored issues – show Coding Style Best Practice introduced 2016-04-30 16:31 UTC by Report Bug Copy Issue Report As per coding-style, please use concatenation or `sprintf` for the variable `$CFG` instead of interpolation. It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of $x = "foo $bar $baz"; // Better use either $x = "foo " . $bar . " " . $baz; $x = sprintf("foo %s %s", $bar, $baz); Loading history...
203
204			return core_plugin_manager::instance();
205			}
206			}
207

LukeCarrier / moodle-componentmgr

Push — verify-deps ( 5e31a2 )

MoodleInstallation::getMissingPluginDependencies() A

Complexity

Size

Duplication

Code Coverage

Importance

1. Pass all data via parameters

2. Create a class that maintains your state

Duplication Side-by-Side

Filter issues like