DebugBar::initDebugBar() - Code Metrics - Inspection of "API SilverStripe 4 compatibility" - lekoala/silverstripe-debugbar - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#47)

by Robbie

created 2017-07-10 04:38 UTC

DebugBar::initDebugBar() C

↳ Parent: DebugBar

Complexity

Conditions	9
Paths	33

Size

Total Lines	63
Code Lines	38

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	63
rs	6.6149
c	0
b	0
f	0
cc	9
eloc	38
nc	33
nop	0

How to fix Long Method

<?php

namespace LeKoala\DebugBar;

use DebugBar\Bridge\MonologCollector;
use DebugBar\DebugBar as BaseDebugBar;
use DebugBar\DataCollector\MemoryCollector;
use DebugBar\DataCollector\PDO\PDOCollector;
use DebugBar\DataCollector\PDO\TraceablePDO;
use DebugBar\DataCollector\PhpInfoCollector;
use DebugBar\Storage\FileStorage;
use Exception;
use LeKoala\DebugBar\Collector\DatabaseCollector;
use LeKoala\DebugBar\Collector\SilverStripeCollector;
use LeKoala\DebugBar\Collector\TimeDataCollector;
use LeKoala\DebugBar\Extension\ControllerExtension;
use LeKoala\DebugBar\Messages\LogFormatter;
use LeKoala\DebugBar\Proxy\DatabaseProxy;
use Psr\Log\LoggerInterface;
use Monolog\Logger;
use ReflectionObject;
use SilverStripe\Admin\LeftAndMain;
use SilverStripe\Control\Controller as BaseController;
use SilverStripe\Control\Director;
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\Core\Injector\Injectable;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\ORM\Connect\PDOConnector;
use SilverStripe\ORM\DB;
use SilverStripe\View\Requirements;

/**
 * A simple helper
 */
class DebugBar
{
    use Configurable;
    use Injectable;

    /**
     * @var DebugBar\DebugBar
     */
    protected static $debugbar;

    /**
     * @var bool
     */
    public static $bufferingEnabled = false;

    /**
     * @var DebugBar\JavascriptRenderer
     */
    protected static $renderer;

    /**
     * @var bool
     */
    protected static $showQueries = false;

    /**
     * @var HTTPRequest
     */
    protected static $request;

    /**
     * Get the Debug Bar instance
     * @return \DebugBar\StandardDebugBar
     * @throws Exception
     * @global array $databaseConfig
     */
    public static function getDebugBar()
    {
        if (self::$debugbar !== null) {
            return self::$debugbar;
        }

        if (!Director::isDev() || self::isDisabled() || self::vendorNotInstalled() ||
            self::notLocalIp() || Director::is_cli() || self::isDevUrl() ||
            (self::isAdminUrl() && !self::config()->enabled_in_admin)
        ) {
            self::$debugbar = false; // no need to check again

            return;
        }

        self::initDebugBar();

        if (!self::$debugbar) {
            throw new Exception("Failed to initialize the DebugBar");
        }

        return self::$debugbar;
    }

    /**
     * Init the debugbar instance
     *
     * @global array $databaseConfig
     * @return DebugBar\StandardDebugBar
     */
    public static function initDebugBar()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

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

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        // Prevent multiple inits
        if (self::$debugbar) {
            return self::$debugbar;
        }

        self::$debugbar = $debugbar = new BaseDebugBar;


        if (isset($_REQUEST['showqueries'])) {
            self::setShowQueries(true);
            echo "The queries above have been run before we started DebugBar";
            echo '<hr>';
            unset($_REQUEST['showqueries']);
        }

        $debugbar->addCollector(new PhpInfoCollector);
        $debugbar->addCollector(new TimeDataCollector);
        $debugbar->addCollector(new MemoryCollector);

        $connector = DB::get_connector();
        if (!self::config()->force_proxy && $connector instanceof PDOConnector) {
            // Use a little bit of magic to replace the pdo instance
            $refObject = new ReflectionObject($connector);
            $refProperty = $refObject->getProperty('pdoConnection');
            $refProperty->setAccessible(true);
            $traceablePdo = new TraceablePDO($refProperty->getValue($connector));
            $refProperty->setValue($connector, $traceablePdo);

            $debugbar->addCollector(new PDOCollector($traceablePdo));
        } else {
            DB::set_conn($db = new DatabaseProxy(DB::get_conn()));
            $db->setShowQueries(self::getShowQueries());
            $debugbar->addCollector(new DatabaseCollector);
        }

        // Add message collector last so other collectors can send messages to the console using it
        $logger = Injector::inst()->get(LoggerInterface::class);
        $logCollector = new MonologCollector($logger, Logger::DEBUG, true, 'messages');
        $logCollector->setFormatter(new LogFormatter);

        $debugbar->addCollector($logCollector);

        // Add some SilverStripe specific infos
        $debugbar->addCollector(new SilverStripeCollector);

        if (self::config()->enable_storage) {
            $debugbar->setStorage(new FileStorage(TEMP_FOLDER . '/debugbar'));
        }

        // Since we buffer everything, why not enable all dev options ?
        if (self::config()->auto_debug) {
            $_REQUEST['debug'] = true;
            $_REQUEST['debug_request'] = true;
        }

        if (isset($_REQUEST['debug']) || isset($_REQUEST['debug_request'])) {
            self::$bufferingEnabled = true;
            ob_start(); // We buffer everything until we have called an action
        }

        return $debugbar;
    }

    public static function clearDebugBar()
    {
        self::$debugbar = null;
    }

    public static function getShowQueries()
    {
        return self::$showQueries;
    }

    public static function setShowQueries($showQueries)
    {
        self::$showQueries = $showQueries;
    }

    public static function includeRequirements()
    {
        $debugbar = self::getDebugBar();

        if (!$debugbar) {
            return;
        }

        // Already called
        if (self::$renderer) {
            return;
        }

        $renderer = $debugbar->getJavascriptRenderer();

        // We don't need the true path since we are going to use Requirements API that appends the BASE_PATH
        $renderer->setBasePath(DEBUGBAR_DIR . '/assets');
        $renderer->setBaseUrl(DEBUGBAR_DIR . '/assets');

        $includeJquery = self::config()->include_jquery;
        // In CMS, jQuery is already included
        if (self::isAdminController()) {
            $includeJquery = false;
        }
        // If jQuery is already included, set to false
        $js = Requirements::backend()->getJavascript();
        foreach ($js as $url) {
            $name = basename($url);
            if ($name == 'jquery.js' || $name == 'jquery.min.js') {
                $includeJquery = false;
                break;
            }
        }

        if ($includeJquery) {
            $renderer->setEnableJqueryNoConflict(true);
        } else {
            $renderer->disableVendor('jquery');
            $renderer->setEnableJqueryNoConflict(false);
        }

        if (DebugBar::config()->enable_storage) {
            $renderer->setOpenHandlerUrl('__debugbar');
        }

        foreach ($renderer->getAssets('css') as $cssFile) {
            Requirements::css(ltrim($cssFile, '/'));
        }

        foreach ($renderer->getAssets('js') as $jsFile) {
            Requirements::javascript(ltrim($jsFile, '/'));
        }

        self::$renderer = $renderer;
    }

    public static function renderDebugBar()
    {
        if (!self::$renderer) {
            return;
        }

        // Requirements may have been cleared (CMS iframes...) or not set (Security...)
        $js = Requirements::backend()->getJavascript();
        if (!array_key_exists('debugbar/assets/debugbar.js', $js)) {
            return;
        }
        $initialize = true;
        if (Director::is_ajax()) {
            $initialize = false;
        }

        $script = self::$renderer->render($initialize);
        return $script;
    }

    /**
     * Determine why DebugBar is disabled
     *
     * @return string
     */
    public static function whyDisabled()
    {
        if (!Director::isDev()) {
            return 'Not in dev mode';
        }
        if (self::isDisabled()) {
            return 'Disabled by a constant or configuration';
        }
        if (self::vendorNotInstalled()) {
            return 'DebugBar is not installed in vendors';
        }
        if (self::notLocalIp()) {
            return 'Not a local ip';
        }
        if (Director::is_cli()) {
            return 'In CLI mode';
        }
        if (self::isDevUrl()) {
            return 'Dev tools';
        }
        if (self::isAdminUrl() && !self::config()->enabled_in_admin) {
            return 'In admin';
        }
        return "I don't know why";
    }

    public static function vendorNotInstalled()
    {
        return !class_exists('DebugBar\\StandardDebugBar');
    }

    public static function notLocalIp()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

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

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if (!self::config()->check_local_ip) {
            return false;
        }
        if (isset($_SERVER['REMOTE_ADDR'])) {
            return !in_array($_SERVER['REMOTE_ADDR'], array('127.0.0.1', '::1', '1'));
        }
        return false;
    }

    public static function isDisabled()
    {
        if (getenv('DEBUGBAR_DISABLE') || static::config()->disabled) {
            return true;
        }
        return false;
    }

    public static function isDevUrl()
    {
        return strpos(self::getRequestUrl(), '/dev/') === 0;
    }

    public static function isAdminUrl()
    {
        return strpos(self::getRequestUrl(), '/admin/') === 0;
    }

    public static function isAdminController()
    {
        if (Controller::curr()) {
            return Controller::curr() instanceof LeftAndMain;
        }
        return self::isAdminUrl();
    }

    /**
     * Avoid triggering data collection for open handler
     *
     * @return boolean
     */
    public static function isDebugBarRequest()
    {
        if ($url = self::getRequestUrl()) {
            return strpos($url, '/__debugbar') === 0;
        }
        return true;
    }

    /**
     * Get request url
     *
     * @return string
     */
    public static function getRequestUrl()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

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

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if (isset($_REQUEST['url'])) {
            return $_REQUEST['url'];
        }
        if (isset($_SERVER['REQUEST_URI'])) {
            return $_SERVER['REQUEST_URI'];
        }
        return '';
    }

    /**
     * Helper to make code cleaner
     *
     * @param callable $callback
     */
    public static function withDebugBar($callback)
    {
        if (self::getDebugBar() && !self::isDebugBarRequest()) {
            $callback(self::getDebugBar());
        }
    }

    /**
     * Set the current request. Is provided by the DebugBarMiddleware.
     *
     * @param HTTPRequest $request
     */
    public static function setRequest(HTTPRequest $request)
    {
        self::$request = $request;
    }

    /**
     * Get the current request
     *
     * @return HTTPRequest
     */
    public static function getRequest()
    {
        if (self::$request) {
            return self::$request;
        }
        // Fall back to trying from the global state
        if (Controller::has_curr()) {
            return Controller::curr()->getRequest();
        }
    }
}


1			<?php
2
3			namespace LeKoala\DebugBar;
4
5			use DebugBar\Bridge\MonologCollector;
6			use DebugBar\DebugBar as BaseDebugBar;
7			use DebugBar\DataCollector\MemoryCollector;
8			use DebugBar\DataCollector\PDO\PDOCollector;
9			use DebugBar\DataCollector\PDO\TraceablePDO;
10			use DebugBar\DataCollector\PhpInfoCollector;
11			use DebugBar\Storage\FileStorage;
12			use Exception;
13			use LeKoala\DebugBar\Collector\DatabaseCollector;
14			use LeKoala\DebugBar\Collector\SilverStripeCollector;
15			use LeKoala\DebugBar\Collector\TimeDataCollector;
16			use LeKoala\DebugBar\Extension\ControllerExtension;
17			use LeKoala\DebugBar\Messages\LogFormatter;
18			use LeKoala\DebugBar\Proxy\DatabaseProxy;
19			use Psr\Log\LoggerInterface;
20			use Monolog\Logger;
21			use ReflectionObject;
22			use SilverStripe\Admin\LeftAndMain;
23			use SilverStripe\Control\Controller as BaseController;
24			use SilverStripe\Control\Director;
25			use SilverStripe\Control\HTTPRequest;
26			use SilverStripe\Core\Config\Configurable;
27			use SilverStripe\Core\Injector\Injectable;
28			use SilverStripe\Core\Injector\Injector;
29			use SilverStripe\ORM\Connect\PDOConnector;
30			use SilverStripe\ORM\DB;
31			use SilverStripe\View\Requirements;
32
33			/**
34			* A simple helper
35			*/
36			class DebugBar
37			{
38			use Configurable;
39			use Injectable;
40
41			/**
42			* @var DebugBar\DebugBar
43			*/
44			protected static $debugbar;
45
46			/**
47			* @var bool
48			*/
49			public static $bufferingEnabled = false;
50
51			/**
52			* @var DebugBar\JavascriptRenderer
53			*/
54			protected static $renderer;
55
56			/**
57			* @var bool
58			*/
59			protected static $showQueries = false;
60
61			/**
62			* @var HTTPRequest
63			*/
64			protected static $request;
65
66			/**
67			* Get the Debug Bar instance
68			* @return \DebugBar\StandardDebugBar
69			* @throws Exception
70			* @global array $databaseConfig
71			*/
72			public static function getDebugBar()
73			{
74			if (self::$debugbar !== null) {
75			return self::$debugbar;
76			}
77
78			if (!Director::isDev() \|\| self::isDisabled() \|\| self::vendorNotInstalled() \|\|
79			self::notLocalIp() \|\| Director::is_cli() \|\| self::isDevUrl() \|\|
80			(self::isAdminUrl() && !self::config()->enabled_in_admin)
81			) {
82			self::$debugbar = false; // no need to check again
			0 ignored issues – show Documentation Bug introduced 2017-07-10 04:48 UTC by Report Bug Copy Issue Report It seems like `false` of type `false` is incompatible with the declared type `object<LeKoala\DebugBar\DebugBar\DebugBar>` of property `$debugbar`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
83			return;
84			}
85
86			self::initDebugBar();
87
88			if (!self::$debugbar) {
89			throw new Exception("Failed to initialize the DebugBar");
90			}
91
92			return self::$debugbar;
93			}
94
95			/**
96			* Init the debugbar instance
97			*
98			* @global array $databaseConfig
99			* @return DebugBar\StandardDebugBar
100			*/
101			public static function initDebugBar()
			0 ignored issues – show Coding Style introduced 2017-07-04 12:14 UTC by Report Bug Copy Issue Report `initDebugBar` uses the super-global variable `$_REQUEST` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
102			{
103			// Prevent multiple inits
104			if (self::$debugbar) {
105			return self::$debugbar;
106			}
107
108			self::$debugbar = $debugbar = new BaseDebugBar;
			0 ignored issues – show Documentation Bug introduced 2017-07-10 04:48 UTC by Report Bug Copy Issue Report It seems like `$debugbar = new \DebugBar\DebugBar()` of type `object<DebugBar\DebugBar>` is incompatible with the declared type `object<LeKoala\DebugBar\DebugBar\DebugBar>` of property `$debugbar`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
109
110			if (isset($_REQUEST['showqueries'])) {
111			self::setShowQueries(true);
112			echo "The queries above have been run before we started DebugBar";
113			echo '<hr>';
114			unset($_REQUEST['showqueries']);
115			}
116
117			$debugbar->addCollector(new PhpInfoCollector);
118			$debugbar->addCollector(new TimeDataCollector);
119			$debugbar->addCollector(new MemoryCollector);
120
121			$connector = DB::get_connector();
122			if (!self::config()->force_proxy && $connector instanceof PDOConnector) {
123			// Use a little bit of magic to replace the pdo instance
124			$refObject = new ReflectionObject($connector);
125			$refProperty = $refObject->getProperty('pdoConnection');
126			$refProperty->setAccessible(true);
127			$traceablePdo = new TraceablePDO($refProperty->getValue($connector));
128			$refProperty->setValue($connector, $traceablePdo);
129
130			$debugbar->addCollector(new PDOCollector($traceablePdo));
131			} else {
132			DB::set_conn($db = new DatabaseProxy(DB::get_conn()));
133			$db->setShowQueries(self::getShowQueries());
134			$debugbar->addCollector(new DatabaseCollector);
135			}
136
137			// Add message collector last so other collectors can send messages to the console using it
138			$logger = Injector::inst()->get(LoggerInterface::class);
139			$logCollector = new MonologCollector($logger, Logger::DEBUG, true, 'messages');
140			$logCollector->setFormatter(new LogFormatter);
141
142			$debugbar->addCollector($logCollector);
143
144			// Add some SilverStripe specific infos
145			$debugbar->addCollector(new SilverStripeCollector);
146
147			if (self::config()->enable_storage) {
148			$debugbar->setStorage(new FileStorage(TEMP_FOLDER . '/debugbar'));
149			}
150
151			// Since we buffer everything, why not enable all dev options ?
152			if (self::config()->auto_debug) {
153			$_REQUEST['debug'] = true;
154			$_REQUEST['debug_request'] = true;
155			}
156
157			if (isset($_REQUEST['debug']) \|\| isset($_REQUEST['debug_request'])) {
158			self::$bufferingEnabled = true;
159			ob_start(); // We buffer everything until we have called an action
160			}
161
162			return $debugbar;
163			}
164
165			public static function clearDebugBar()
166			{
167			self::$debugbar = null;
168			}
169
170			public static function getShowQueries()
171			{
172			return self::$showQueries;
173			}
174
175			public static function setShowQueries($showQueries)
176			{
177			self::$showQueries = $showQueries;
178			}
179
180			public static function includeRequirements()
181			{
182			$debugbar = self::getDebugBar();
183
184			if (!$debugbar) {
185			return;
186			}
187
188			// Already called
189			if (self::$renderer) {
190			return;
191			}
192
193			$renderer = $debugbar->getJavascriptRenderer();
194
195			// We don't need the true path since we are going to use Requirements API that appends the BASE_PATH
196			$renderer->setBasePath(DEBUGBAR_DIR . '/assets');
197			$renderer->setBaseUrl(DEBUGBAR_DIR . '/assets');
198
199			$includeJquery = self::config()->include_jquery;
200			// In CMS, jQuery is already included
201			if (self::isAdminController()) {
202			$includeJquery = false;
203			}
204			// If jQuery is already included, set to false
205			$js = Requirements::backend()->getJavascript();
206			foreach ($js as $url) {
207			$name = basename($url);
208			if ($name == 'jquery.js' \|\| $name == 'jquery.min.js') {
209			$includeJquery = false;
210			break;
211			}
212			}
213
214			if ($includeJquery) {
215			$renderer->setEnableJqueryNoConflict(true);
216			} else {
217			$renderer->disableVendor('jquery');
218			$renderer->setEnableJqueryNoConflict(false);
219			}
220
221			if (DebugBar::config()->enable_storage) {
222			$renderer->setOpenHandlerUrl('__debugbar');
223			}
224
225			foreach ($renderer->getAssets('css') as $cssFile) {
226			Requirements::css(ltrim($cssFile, '/'));
227			}
228
229			foreach ($renderer->getAssets('js') as $jsFile) {
230			Requirements::javascript(ltrim($jsFile, '/'));
231			}
232
233			self::$renderer = $renderer;
234			}
235
236			public static function renderDebugBar()
237			{
238			if (!self::$renderer) {
239			return;
240			}
241
242			// Requirements may have been cleared (CMS iframes...) or not set (Security...)
243			$js = Requirements::backend()->getJavascript();
244			if (!array_key_exists('debugbar/assets/debugbar.js', $js)) {
245			return;
246			}
247			$initialize = true;
248			if (Director::is_ajax()) {
249			$initialize = false;
250			}
251
252			$script = self::$renderer->render($initialize);
253			return $script;
254			}
255
256			/**
257			* Determine why DebugBar is disabled
258			*
259			* @return string
260			*/
261			public static function whyDisabled()
262			{
263			if (!Director::isDev()) {
264			return 'Not in dev mode';
265			}
266			if (self::isDisabled()) {
267			return 'Disabled by a constant or configuration';
268			}
269			if (self::vendorNotInstalled()) {
270			return 'DebugBar is not installed in vendors';
271			}
272			if (self::notLocalIp()) {
273			return 'Not a local ip';
274			}
275			if (Director::is_cli()) {
276			return 'In CLI mode';
277			}
278			if (self::isDevUrl()) {
279			return 'Dev tools';
280			}
281			if (self::isAdminUrl() && !self::config()->enabled_in_admin) {
282			return 'In admin';
283			}
284			return "I don't know why";
285			}
286
287			public static function vendorNotInstalled()
288			{
289			return !class_exists('DebugBar\\StandardDebugBar');
290			}
291
292			public static function notLocalIp()
			0 ignored issues – show Coding Style introduced 2017-07-04 12:14 UTC by Report Bug Copy Issue Report `notLocalIp` uses the super-global variable `$_SERVER` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
293			{
294			if (!self::config()->check_local_ip) {
295			return false;
296			}
297			if (isset($_SERVER['REMOTE_ADDR'])) {
298			return !in_array($_SERVER['REMOTE_ADDR'], array('127.0.0.1', '::1', '1'));
299			}
300			return false;
301			}
302
303			public static function isDisabled()
304			{
305			if (getenv('DEBUGBAR_DISABLE') \|\| static::config()->disabled) {
306			return true;
307			}
308			return false;
309			}
310
311			public static function isDevUrl()
312			{
313			return strpos(self::getRequestUrl(), '/dev/') === 0;
314			}
315
316			public static function isAdminUrl()
317			{
318			return strpos(self::getRequestUrl(), '/admin/') === 0;
319			}
320
321			public static function isAdminController()
322			{
323			if (Controller::curr()) {
324			return Controller::curr() instanceof LeftAndMain;
325			}
326			return self::isAdminUrl();
327			}
328
329			/**
330			* Avoid triggering data collection for open handler
331			*
332			* @return boolean
333			*/
334			public static function isDebugBarRequest()
335			{
336			if ($url = self::getRequestUrl()) {
337			return strpos($url, '/__debugbar') === 0;
338			}
339			return true;
340			}
341
342			/**
343			* Get request url
344			*
345			* @return string
346			*/
347			public static function getRequestUrl()
			0 ignored issues – show Coding Style introduced 2017-07-04 12:14 UTC by Report Bug Copy Issue Report `getRequestUrl` uses the super-global variable `$_REQUEST` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history... Coding Style introduced 2017-07-04 12:14 UTC by Report Bug Copy Issue Report `getRequestUrl` uses the super-global variable `$_SERVER` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
348			{
349			if (isset($_REQUEST['url'])) {
350			return $_REQUEST['url'];
351			}
352			if (isset($_SERVER['REQUEST_URI'])) {
353			return $_SERVER['REQUEST_URI'];
354			}
355			return '';
356			}
357
358			/**
359			* Helper to make code cleaner
360			*
361			* @param callable $callback
362			*/
363			public static function withDebugBar($callback)
364			{
365			if (self::getDebugBar() && !self::isDebugBarRequest()) {
366			$callback(self::getDebugBar());
367			}
368			}
369
370			/**
371			* Set the current request. Is provided by the DebugBarMiddleware.
372			*
373			* @param HTTPRequest $request
374			*/
375			public static function setRequest(HTTPRequest $request)
376			{
377			self::$request = $request;
378			}
379
380			/**
381			* Get the current request
382			*
383			* @return HTTPRequest
384			*/
385			public static function getRequest()
386			{
387			if (self::$request) {
388			return self::$request;
389			}
390			// Fall back to trying from the global state
391			if (Controller::has_curr()) {
392			return Controller::curr()->getRequest();
393			}
394			}
395			}
396

lekoala / silverstripe-debugbar

Pull Request — master (#47)

DebugBar::initDebugBar() C

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like