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

Completed

Push — master ( 9b96e2...70e41f )

by Luke

created 2016-11-02 03:25 UTC

MoodleInstallation::assertState() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

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

<?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;

/**
 * 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 {
    /**
     * Configuration file filename.
     *
     * @var string
     */
    const CONFIG_FILENAME = 'config.php';

    /**
     * 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 \ComponentManager\Platform\Platform
     */
    protected $platform;

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

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

    /**
     * Initialiser.
     *
     * @param \ComponentManager\Platform\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 \ComponentManager\Exception\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 \ComponentManager\Exception\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);
        }

        $path = $this->platform->joinPaths([
            $this->rootDirectory,
            static::CONFIG_FILENAME,
        ]);
        if (is_file($path)) {
            require_once $path;

            if (!is_object($CFG)) {
                throw new MoodleException(
                        "The Moodle configuration file \"{$path}\" did not define \$CFG",
// Instead of
$x = "foo $bar $baz";

// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
                        MoodleException::CODE_NOT_CONFIGURED);
            }
        } else {
            /* We don't have a configured site, so we'll have to fake it.
             * 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);

        $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);

        $pluginMgr = core_plugin_manager::instance();

        return $pluginMgr->get_plugin_types();
    }
}


Push — master ( 9b96e2...70e41f )

MoodleInstallation::assertState() 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
18			/**
19			* Moodle installation.
20			*
21			* Facilitates interaction with a Moodle installation. This class should be
22			* used only by the MoodleCommand class. Elsewhere, use the Moodle class
23			* instead. */
24			class MoodleInstallation {
25			/**
26			* Configuration file filename.
27			*
28			* @var string
29			*/
30			const CONFIG_FILENAME = 'config.php';
31
32			/**
33			* Instance state: new.
34			*
35			* The instance has not yet been configured, and is not ready to use.
36			*
37			* @var integer
38			*/
39			const STATE_NEW = 0;
40
41			/**
42			* Instance state: ready for use.
43			*
44			* The instance has been configured and is ready for use.
45			*
46			* @var integer
47			*/
48			const STATE_READY = 1;
49
50			/**
51			* Instance state: disposed.
52			*
53			* The instance was configured, but has since been disposed. It is no longer
54			* usable, and a new instance will need to be created to proceed.
55			*
56			* @var integer
57			*/
58			const STATE_DISPOSED = 2;
59
60			/**
61			* The value of the Moodle $CFG object.
62			*
63			* We have to cache the result of the first call to getConfig() as
64			* constants can be declared within this file, causing nasty warnings.
65			*
66			* @var \stdClass
67			*/
68			protected $config;
69
70			/**
71			* Platform support library.
72			*
73			* @var \ComponentManager\Platform\Platform
74			*/
75			protected $platform;
76
77			/**
78			* Root directory of the Moodle installation.
79			*
80			* @var string
81			*/
82			protected $rootDirectory;
83
84			/**
85			* Instance state.
86			*
87			* @var integer
88			*/
89			protected $state;
90
91			/**
92			* Initialiser.
93			*
94			* @param \ComponentManager\Platform\Platform $platform
95			* @param string $rootDirectory
96			*/
97			public function __construct(Platform $platform, $rootDirectory) {
98			$this->state = static::STATE_NEW;
99
100			$this->platform = $platform;
101			$this->rootDirectory = $rootDirectory;
102			}
103
104			/**
105			* Assert that the instance's state is as expected.
106			*
107			* @param $expected
108			*
109			* @return void
110			*
111			* @throws \ComponentManager\Exception\MoodleException
112			*/
113			protected function assertState($expected) {
114			if ($this->state !== $expected) {
115			throw new MoodleException(
116			sprintf('Expected state "%d", actual state was "%d"', $expected, $this->state),
			0 ignored issues – show Coding Style introduced 2016-11-02 03:30 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 80 characters; contains 99 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
117			MoodleException::CODE_INVALID_STATE);
118			}
119			}
120
121			/**
122			* Require the configuration file.
123			*
124			* @return void
125			*
126			* @throws \ComponentManager\Exception\MoodleException
127			*/
128			public function configure() {
129			$this->assertState(static::STATE_NEW);
130
131			/* This value should be overwritten shortly, either by the definition in
132			* the Moodle instance's configuration or by our own "fake"
133			* configuration used to load the plugin manager. */
134			$CFG = null;
135
136			$constants = [
137			'ABORT_AFTER_CONFIG',
138			'CLI_SCRIPT',
139			'IGNORE_COMPONENT_CACHE',
140			];
141
142			foreach ($constants as $constant) {
143			define($constant, true);
144			}
145
146			$path = $this->platform->joinPaths([
147			$this->rootDirectory,
148			static::CONFIG_FILENAME,
149			]);
150			if (is_file($path)) {
151			require_once $path;
152
153			if (!is_object($CFG)) {
154			throw new MoodleException(
155			"The Moodle configuration file \"{$path}\" did not define \$CFG",
			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 `$path` 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... Coding Style introduced 2016-04-30 16:31 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 80 characters; contains 89 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
156			MoodleException::CODE_NOT_CONFIGURED);
157			}
158			} else {
159			/* We don't have a configured site, so we'll have to fake it.
160			* Only an extremely slim portion of Moodle will function
161			* correctly in this state, as we've not actually done most of
162			* the Moodle setup dance. It seems to be enough to run the
163			* plugin manager. */
164
165			global $CFG;
			0 ignored issues – show Compatibility Best Practice introduced 2016-04-30 16:31 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...
166			$CFG = (object) [
167			'dirroot' => $this->rootDirectory,
168			'dataroot' => $this->platform->createTempDirectory(),
169			'wwwroot' => 'http://localhost',
170			];
171
172			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...
173			}
174
175			$this->config = $CFG;
176			$this->state = static::STATE_READY;
177			}
178
179			public function dispose() {
180			$this->assertState(static::STATE_READY);
181
182			try {
183			$this->platform->removeTempDirectory($this->config->dataroot);
184			} catch (PlatformException $e) {
185			if ($e->getCode() !== PlatformException::CODE_UNKNOWN_TEMP_DIRECTORY) {
			0 ignored issues – show Coding Style introduced 2016-11-02 03:30 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 80 characters; contains 83 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
186			throw $e;
187			}
188			}
189
190			$this->state = static::STATE_DISPOSED;
191			}
192
193			/**
194			* Get plugin types.
195			*
196			* @return string[]
197			*/
198			public function getPluginTypes() {
199			$this->assertState(static::STATE_READY);
200
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			$pluginMgr = core_plugin_manager::instance();
205
206			return $pluginMgr->get_plugin_types();
207			}
208			}
209

LukeCarrier / moodle-componentmgr

Push — master ( 9b96e2...70e41f )

MoodleInstallation::assertState() 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