Temporary - Code Metrics - consolidation/robo - Measure and Improve Code Quality continuously with Scrutinizer

Temporary A
last analyzed 2020-08-27 17:44 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	38
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

Metric	Value
wmc	3
lcom	1
cbo	3
dl	0
loc	38
rs	10
c	0
b	0
f	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	getCollection()	0	11	2
A	complete()	0	9	1

<?php

namespace Robo\Collection;

/**
 * The temporary collection keeps track of the global collection of
 * temporary cleanup tasks in instances where temporary-generating
 * tasks are executed directly via their run() method, rather than
 * as part of a collection.
 *
 * In general, temporary-generating tasks should always be run in
 * a collection, as the cleanup functions registered with the
 * Temporary collection will not run until requested.
 *
 * Since the results could be undefined if cleanup functions were called
 * at arbitrary times during a program's execution, cleanup should only
 * be done immeidately prior to program termination, when there is no
 * danger of cleaning up after some unrelated task.
 *
 * An application need never use Temporary directly, save to
 * call Temporary::wrap() inside loadTasks or loadShortcuts, and
 * to call Temporary::complete() immediately prior to terminating.
 * This is recommended, but not required; this function will be
 * registered as a shutdown function, and called on termination.
 */
class Temporary
{

    /**
     * @var \Robo\Collection\Collection
     */
    private static $collection;

    /**
     * Provides direct access to the collection of temporaries, if necessary.
     *
     * @return \Robo\Collection\Collection
     */
    public static function getCollection()
    {
        if (!static::$collection) {
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
            static::$collection = \Robo\Robo::getContainer()->get('collection');
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
            register_shutdown_function(function () {
                static::complete();
            });
        }

        return static::$collection;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
    }

    /**
     * Call the complete method of all of the registered objects.
     */
    public static function complete()
    {
        // Run the collection of tasks. This will also run the
        // completion tasks.
        $collection = static::getCollection();
        $collection->run();
        // Make sure that our completion functions do not run twice.
        $collection->reset();
    }
}


1			<?php
2
3			namespace Robo\Collection;
4
5			/**
6			* The temporary collection keeps track of the global collection of
7			* temporary cleanup tasks in instances where temporary-generating
8			* tasks are executed directly via their run() method, rather than
9			* as part of a collection.
10			*
11			* In general, temporary-generating tasks should always be run in
12			* a collection, as the cleanup functions registered with the
13			* Temporary collection will not run until requested.
14			*
15			* Since the results could be undefined if cleanup functions were called
16			* at arbitrary times during a program's execution, cleanup should only
17			* be done immeidately prior to program termination, when there is no
18			* danger of cleaning up after some unrelated task.
19			*
20			* An application need never use Temporary directly, save to
21			* call Temporary::wrap() inside loadTasks or loadShortcuts, and
22			* to call Temporary::complete() immediately prior to terminating.
23			* This is recommended, but not required; this function will be
24			* registered as a shutdown function, and called on termination.
25			*/
26			class Temporary
27			{
28
29			/**
30			* @var \Robo\Collection\Collection
31			*/
32			private static $collection;
33
34			/**
35			* Provides direct access to the collection of temporaries, if necessary.
36			*
37			* @return \Robo\Collection\Collection
38			*/
39			public static function getCollection()
40			{
41			if (!static::$collection) {
			0 ignored issues – show Bug introduced 2016-09-13 23:40 UTC by Report Bug Copy Issue Report Since `$collection` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$collection` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
42			static::$collection = \Robo\Robo::getContainer()->get('collection');
			0 ignored issues – show Bug introduced 2016-09-13 23:40 UTC by Report Bug Copy Issue Report Since `$collection` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$collection` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
43			register_shutdown_function(function () {
44			static::complete();
45			});
46			}
47
48			return static::$collection;
			0 ignored issues – show Bug introduced 2016-09-13 23:40 UTC by Report Bug Copy Issue Report Since `$collection` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$collection` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
49			}
50
51			/**
52			* Call the complete method of all of the registered objects.
53			*/
54			public static function complete()
55			{
56			// Run the collection of tasks. This will also run the
57			// completion tasks.
58			$collection = static::getCollection();
59			$collection->run();
60			// Make sure that our completion functions do not run twice.
61			$collection->reset();
62			}
63			}
64

consolidation / robo

Temporary A last analyzed 2020-08-27 17:44 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

2 Methods

Duplication Side-by-Side

Filter issues like

Temporary A
last analyzed 2020-08-27 17:44 UTC