Path - Code Metrics - Inspection of "Takes logic from core get_home_path" - humanmade/backupwordpress - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#988)

by Paul

created 2016-02-08 15:47 UTC

Path C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	429
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	9
Bugs	0	Features	0

Metric	Value
wmc	73
c	9
b	0
f	0
lcom	1
cbo	1
dl	0
loc	429
rs	5.5447

22 Methods

Rating	Name	Size	Complexity
A	__construct()	1	1
A	__clone()	1	1
A	__wakeup()	1	1
A	get_path()	3	1
A	get_root()	3	1
A	get_instance()	8	2
B	get_home_path()	26	6
A	get_calculated_path()	13	3
A	set_path()	8	1
A	get_calculated_root()	15	4
A	set_root()	3	1
A	reset_path()	3	1
A	get_default_path()	3	1
A	get_fallback_path()	7	1
A	get_custom_path()	13	4
A	get_existing_paths()	19	3
A	get_existing_path()	11	2
C	calculate_path()	32	8
C	protect_path()	40	11
B	merge_existing_paths()	11	5
D	move_old_backups()	41	9
B	cleanup()	18	6

How to fix Complexity

<?php

namespace HM\BackUpWordPress;

/**
 * Manages both the backup path and site root
 *
 * Handles calculating & protecting the directory that backups will be stored in
 * as well as the directory that is being backed up
 */
class Path {

	/**
	 * The path to the directory that backup files are stored in
	 *
	 * @var string $this->path
	 */
	private $path;

	/**
	 * The path to the directory that will be backed up
	 *
	 * @var string $this->root
	 */
	private $root;

	/**
	 * The path to the directory that backup files are stored in
	 *
	 * @var string $this->path
	 */
	private $custom_path;

	/**
	 * Contains the instantiated Path instance
	 *
	 * @var Path $this->instance
	 */
	private static $instance;

	/**
	 * Protected constructor to prevent creating a new instance of the
	 * *Singleton* via the `new` operator from outside of this class.
	 */
	protected function __construct() {}

	/**
	 * Private clone method to prevent cloning of the instance of the
	 * *Singleton* instance.
	 */
	private function __clone() {}

	/**
	 * Private unserialize method to prevent unserializing of the *Singleton*
	 * instance.
	 */
	private function __wakeup() {}

	/**
	 * Returns the *Singleton* instance of this class.
	 *
	 * @staticvar Path $instance The *Singleton* instances of this class.
	 *
	 * @return Path The *Singleton* instance.
	 */
	public static function get_instance() {

		if ( ! ( self::$instance instanceof Path ) ) {
			self::$instance = new Path();
		}

		return self::$instance;
	}

	/**
	 * Convenience method for quickly grabbing the path
	 */
	public static function get_path() {

		return self::get_instance()->get_calculated_path();
	}

	/**
	 * Convenience method for quickly grabbing the root
	 */
	public static function get_root() {

		return self::get_instance()->get_calculated_root();
	}

	/**
	 * Calculate the path to the site "home" directory.
	 *
	 * The home directory is the path equivalent to the home_url. That is,
	 * the path to the true root of the website. In situations where WordPress is
	 * installed in a subdirectory the home path is different to ABSPATH
	 *
	 * @param string $site_path The site_path to use when calculating the home path, defaults to ABSPATH
	 */
	public static function get_home_path( $site_path = ABSPATH ) {
// 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 ( defined( 'HMBKP_ROOT' ) && HMBKP_ROOT ) {
			return wp_normalize_path( HMBKP_ROOT );
		}

		$home_path = $site_path;

		if ( path_in_php_open_basedir( dirname( $site_path ) ) ) {

			$home    = set_url_scheme( get_option( 'home' ), 'http' );
			$siteurl = set_url_scheme( get_option( 'siteurl' ), 'http' );
			if ( ! empty( $home ) && 0 !== strcasecmp( $home, $siteurl ) ) {
				$wp_path_rel_to_home = str_ireplace( $home, '', $siteurl ); /* $siteurl - $home */
				$pos = strripos( str_replace( '\\', '/', $_SERVER['SCRIPT_FILENAME'] ), trailingslashit( $wp_path_rel_to_home ) );
				$home_path = substr( $_SERVER['SCRIPT_FILENAME'], 0, $pos );
				$home_path = trailingslashit( $home_path );
			} else {
				$home_path = ABSPATH;
			}

		}

		return wp_normalize_path( untrailingslashit( $home_path ) );

	}

	/**
	 * get the calculated path to the directory where backups will be stored
	 */
	private function get_calculated_path() {


		// Calculate the path if needed
		if ( empty( $this->path ) || ! wp_is_writable( $this->path ) ) {
			$this->calculate_path();
		}

		// Ensure the backup directory is protected
		$this->protect_path();

		return wp_normalize_path( $this->path );

	}

	/**
	 * Set the path directly, overriding the default
	 *
	 * @param $path
	 */
	public function set_path( $path ) {

		$this->custom_path = $path;

		// Re-calculate the backup path
		$this->calculate_path();

	}

	/**
	 * get the calculated path to the directory that will be backed up
	 */
	private function get_calculated_root() {


		$root = self::get_home_path();

		if ( defined( 'HMBKP_ROOT' ) && HMBKP_ROOT ) {
			$root = HMBKP_ROOT;
		}

		if ( $this->root ) {
			$root = $this->root;
		}

		return wp_normalize_path( $root );

	}

	/**
	 * Set the root path directly, overriding the default
	 *
	 * @param $root
	 */
	public function set_root( $root ) {
		$this->root = $root;
	}

	public function reset_path() {
		$this->set_path( false );
	}

	/**
	 * Get the path to the default backup location in wp-content
	 */
	public function get_default_path() {
		return trailingslashit( wp_normalize_path( WP_CONTENT_DIR ) ) . 'backupwordpress-' . substr( HMBKP_SECURE_KEY, 0, 10 ) . '-backups';
	}

	/**
	 * Get the path to the fallback backup location in uploads
	 */
	public function get_fallback_path() {

		$upload_dir = wp_upload_dir();

		return trailingslashit( wp_normalize_path( $upload_dir['basedir'] ) ) . 'backupwordpress-' . substr( HMBKP_SECURE_KEY, 0, 10 ) . '-backups';

	}

	/**
	 * Get the path to the custom backup location if it's been set
	 */
	public function get_custom_path() {


		if ( $this->custom_path ) {
			return $this->custom_path;
		}

		if ( defined( 'HMBKP_PATH' ) && wp_is_writable( HMBKP_PATH ) ) {
			return HMBKP_PATH;
		}

		return '';

	}

	/**
	 * Builds an array containing existing backups folders.
	 *
	 * @return array
	 */
	public function get_existing_paths() {

		if ( false === $default = glob( WP_CONTENT_DIR . '/backupwordpress-*-backups', GLOB_ONLYDIR ) ) {
			$default = array();
		}

		$upload_dir = wp_upload_dir();

		if ( false === $fallback = glob( $upload_dir['basedir'] . '/backupwordpress-*-backups', GLOB_ONLYDIR ) ) {
			$fallback = array();
		}

		$paths = array_merge( $default, $fallback );

        $paths = array_map( 'wp_normalize_path', $paths );

		return $paths;

	}

	/**
	 * Returns the first existing path if there is one
	 *
	 * @return string Backup path if found empty string if not
	 */
	public function get_existing_path() {

		$paths = $this->get_existing_paths();

		if ( ! empty( $paths[0] ) ) {
			return $paths[0];
		}

		return '';

	}

	/**
	 * Calculate the backup path and create the directory if it doesn't exist.
	 *
	 * Tries all possible locations and uses the first one possible
	 *
	 * @return
	 */
	public function calculate_path() {

		$paths = array();

		// If we have a custom path then try to use it
		if ( $this->get_custom_path() ) {
			$paths[] = $this->get_custom_path();
		}

		// If there is already a backups directory then try to use that
		if ( $this->get_existing_path() ) {
			$paths[] = $this->get_existing_path();
		}

		// If not then default to a new directory in wp-content
		$paths[] = $this->get_default_path();

		// If that didn't work then fallback to a new directory in uploads
		$paths[] = $this->get_fallback_path();

		// Loop through possible paths, use the first one that exists/can be created and is writable
		foreach ( $paths as $path ) {
			if ( wp_mkdir_p( $path ) && wp_is_writable( $path ) ) { // Also handles fixing perms / directory already exists
				break;
			}
		}

		if ( file_exists( $path ) && wp_is_writable( $path ) ) {
			$this->path = $path;
foreach ($a as $b) {
}

// $b is defined here only if $a has elements, for example if $a is array()
// then $b would not be defined here. To avoid that, we recommend to set a
// default value for $b.


// Better
$b = 0; // or whatever default makes sense in your context
foreach ($a as $b) {
}

// $b is now guaranteed to be defined here.
		}

	}

	/**
	 * Protect the directory that backups are stored in
	 *
	 * - Adds an index.html file in an attempt to disable directory browsing
	 * - Adds a .httaccess file to deny direct access if on Apache
	 *
	 * @param string $reset
	 */
	public function protect_path( $reset = 'no' ) {

		global $is_apache;
function myFunction($a, $b) {
    // Do something
}

		// Protect against directory browsing by including an index.html file
		$index = $this->path . '/index.html';

		if ( 'reset' === $reset && file_exists( $index ) ) {
			@unlink( $index );
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
		}

		if ( ! file_exists( $index ) && wp_is_writable( $this->path ) ) {
			file_put_contents( $index, '' );
		}

		$htaccess = $this->path . '/.htaccess';

		if ( ( 'reset' === $reset ) && file_exists( $htaccess ) ) {
			@unlink( $htaccess );
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
		}

		// Protect the directory with a .htaccess file on Apache servers
		if ( $is_apache && function_exists( 'insert_with_markers' ) && ! file_exists( $htaccess ) && wp_is_writable( $this->path ) ) {

			$contents[] = '# ' . sprintf( __( 'This %s file ensures that other people cannot download your backup files.', 'backupwordpress' ), '.htaccess' );
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
			$contents[] = '';
			$contents[] = '<IfModule mod_rewrite.c>';
			$contents[] = 'RewriteEngine On';
			$contents[] = 'RewriteCond %{QUERY_STRING} !key=' . HMBKP_SECURE_KEY;
			$contents[] = 'RewriteRule (.*) - [F]';
			$contents[] = '</IfModule>';
			$contents[] = '';

			file_put_contents( $htaccess, '' );

			insert_with_markers( $htaccess, 'BackUpWordPress', $contents );

		}

	}

	/**
	 * If we have more than one path then move any existing backups to the current path and remove them
	 */
	public function merge_existing_paths() {

		$paths = $this->get_existing_paths();

		if ( ( $paths && $this->get_custom_path() ) || count( $paths ) > 1 ) {

			foreach ( $paths as $old_path ) {
				$this->move_old_backups( $old_path );
			}
		}

	}

	/**
	 * Move backup files from an existing directory and the new
	 * location
	 *
	 * @param string $path 	The path to move the backups from
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
	 */
	public function move_old_backups( $from ) {

		if ( ! is_readable( $from ) ) {
			return;
		}

		if ( ! wp_is_writable( Path::get_path() ) ) {
			return;
		}

		// Move any existing backups
		if ( $handle = opendir( $from ) ) {

			// Loop through the backup directory
			while ( false !== ( $file = readdir( $handle ) ) ) {

				// Find all zips
				if ( 'zip' === pathinfo( $file, PATHINFO_EXTENSION ) ) {

					// Try to move them
					if ( ! @rename( trailingslashit( $from ) . $file, trailingslashit( Path::get_path() ) . $file ) ) {


						// If we can't move them then try to copy them
						copy( trailingslashit( $from ) . $file, trailingslashit( Path::get_path() ) . $file );

					}

				}
			}

			closedir( $handle );

		}

		// Delete the old directory if it's inside WP_CONTENT_DIR
		if ( false !== strpos( $from, WP_CONTENT_DIR ) && $from !== Path::get_path() ) {
			rmdirtree( $from );
		}

	}

	/**
	 * Clean any temporary / incomplete backups from the backups directory
	 */
	public function cleanup() {

		// Don't cleanup a custom path, who knows what other stuff is there
		if ( Path::get_path() === $this->get_custom_path() ) {
			return;
		}

		foreach ( new CleanUpIterator( new \DirectoryIterator( $this->path ) ) as $file ) {

			if ( $file->isDot() || ! $file->isReadable() || ! $file->isFile() ) {
				continue;
			}

			@unlink( $file->getPathname() );
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}

		}

	}

}

class CleanUpIterator extends \FilterIterator {


	// Don't match index.html,files with zip extension or status logfiles.
	public function accept() {
		return ! preg_match( '/(index\.html|.*\.zip|.*-running)/', $this->current() );
	}
}


GitHub Access Token became invalid

Pull Request — master (#988)

Path C

Complexity

Size/Duplication

Coupling/Cohesion

Importance

22 Methods

How to fix Complexity

Complex Class

1. Pass all data via parameters

2. Create a class that maintains your state

1			<?php
2
3			namespace HM\BackUpWordPress;
4
5			/**
6			* Manages both the backup path and site root
7			*
8			* Handles calculating & protecting the directory that backups will be stored in
9			* as well as the directory that is being backed up
10			*/
11			class Path {
12
13			/**
14			* The path to the directory that backup files are stored in
15			*
16			* @var string $this->path
17			*/
18			private $path;
19
20			/**
21			* The path to the directory that will be backed up
22			*
23			* @var string $this->root
24			*/
25			private $root;
26
27			/**
28			* The path to the directory that backup files are stored in
29			*
30			* @var string $this->path
31			*/
32			private $custom_path;
33
34			/**
35			* Contains the instantiated Path instance
36			*
37			* @var Path $this->instance
38			*/
39			private static $instance;
40
41			/**
42			* Protected constructor to prevent creating a new instance of the
43			* Singleton via the `new` operator from outside of this class.
44			*/
45			protected function __construct() {}
46
47			/**
48			* Private clone method to prevent cloning of the instance of the
49			* Singleton instance.
50			*/
51			private function __clone() {}
52
53			/**
54			* Private unserialize method to prevent unserializing of the Singleton
55			* instance.
56			*/
57			private function __wakeup() {}
58
59			/**
60			* Returns the Singleton instance of this class.
61			*
62			* @staticvar Path $instance The Singleton instances of this class.
63			*
64			* @return Path The Singleton instance.
65			*/
66			public static function get_instance() {
67
68			if ( ! ( self::$instance instanceof Path ) ) {
69			self::$instance = new Path();
70			}
71
72			return self::$instance;
73			}
74
75			/**
76			* Convenience method for quickly grabbing the path
77			*/
78			public static function get_path() {
			0 ignored issues – show Documentation introduced 2015-11-21 01:52 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...
79			return self::get_instance()->get_calculated_path();
80			}
81
82			/**
83			* Convenience method for quickly grabbing the root
84			*/
85			public static function get_root() {
			0 ignored issues – show Documentation introduced 2015-11-21 01:52 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...
86			return self::get_instance()->get_calculated_root();
87			}
88
89			/**
90			* Calculate the path to the site "home" directory.
91			*
92			* The home directory is the path equivalent to the home_url. That is,
93			* the path to the true root of the website. In situations where WordPress is
94			* installed in a subdirectory the home path is different to ABSPATH
95			*
96			* @param string $site_path The site_path to use when calculating the home path, defaults to ABSPATH
97			*/
98			public static function get_home_path( $site_path = ABSPATH ) {
			1 ignored issue – show Documentation introduced 2015-11-21 01:52 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... Coding Style introduced 2016-02-08 15:49 UTC by Report Bug Copy Issue Report `get_home_path` 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...
99
100			if ( defined( 'HMBKP_ROOT' ) && HMBKP_ROOT ) {
101			return wp_normalize_path( HMBKP_ROOT );
102			}
103
104			$home_path = $site_path;
105
106			if ( path_in_php_open_basedir( dirname( $site_path ) ) ) {
107
108			$home = set_url_scheme( get_option( 'home' ), 'http' );
109			$siteurl = set_url_scheme( get_option( 'siteurl' ), 'http' );
110			if ( ! empty( $home ) && 0 !== strcasecmp( $home, $siteurl ) ) {
111			$wp_path_rel_to_home = str_ireplace( $home, '', $siteurl ); /* $siteurl - $home */
112			$pos = strripos( str_replace( '\\', '/', $_SERVER['SCRIPT_FILENAME'] ), trailingslashit( $wp_path_rel_to_home ) );
113			$home_path = substr( $_SERVER['SCRIPT_FILENAME'], 0, $pos );
114			$home_path = trailingslashit( $home_path );
115			} else {
116			$home_path = ABSPATH;
117			}
118
119			}
120
121			return wp_normalize_path( untrailingslashit( $home_path ) );
122
123			}
124
125			/**
126			* get the calculated path to the directory where backups will be stored
127			*/
128			private function get_calculated_path() {
			0 ignored issues – show Documentation introduced 2015-11-21 01:52 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...
129
130			// Calculate the path if needed
131			if ( empty( $this->path ) \|\| ! wp_is_writable( $this->path ) ) {
132			$this->calculate_path();
133			}
134
135			// Ensure the backup directory is protected
136			$this->protect_path();
137
138			return wp_normalize_path( $this->path );
139
140			}
141
142			/**
143			* Set the path directly, overriding the default
144			*
145			* @param $path
146			*/
147			public function set_path( $path ) {
148
149			$this->custom_path = $path;
150
151			// Re-calculate the backup path
152			$this->calculate_path();
153
154			}
155
156			/**
157			* get the calculated path to the directory that will be backed up
158			*/
159			private function get_calculated_root() {
			0 ignored issues – show Documentation introduced 2015-11-21 01:52 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...
160
161			$root = self::get_home_path();
162
163			if ( defined( 'HMBKP_ROOT' ) && HMBKP_ROOT ) {
164			$root = HMBKP_ROOT;
165			}
166
167			if ( $this->root ) {
168			$root = $this->root;
169			}
170
171			return wp_normalize_path( $root );
172
173			}
174
175			/**
176			* Set the root path directly, overriding the default
177			*
178			* @param $root
179			*/
180			public function set_root( $root ) {
181			$this->root = $root;
182			}
183
184			public function reset_path() {
185			$this->set_path( false );
186			}
187
188			/**
189			* Get the path to the default backup location in wp-content
190			*/
191			public function get_default_path() {
192			return trailingslashit( wp_normalize_path( WP_CONTENT_DIR ) ) . 'backupwordpress-' . substr( HMBKP_SECURE_KEY, 0, 10 ) . '-backups';
193			}
194
195			/**
196			* Get the path to the fallback backup location in uploads
197			*/
198			public function get_fallback_path() {
199
200			$upload_dir = wp_upload_dir();
201
202			return trailingslashit( wp_normalize_path( $upload_dir['basedir'] ) ) . 'backupwordpress-' . substr( HMBKP_SECURE_KEY, 0, 10 ) . '-backups';
203
204			}
205
206			/**
207			* Get the path to the custom backup location if it's been set
208			*/
209			public function get_custom_path() {
			0 ignored issues – show Documentation introduced 2015-11-21 01:52 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...
210
211			if ( $this->custom_path ) {
212			return $this->custom_path;
213			}
214
215			if ( defined( 'HMBKP_PATH' ) && wp_is_writable( HMBKP_PATH ) ) {
216			return HMBKP_PATH;
217			}
218
219			return '';
220
221			}
222
223			/**
224			* Builds an array containing existing backups folders.
225			*
226			* @return array
227			*/
228			public function get_existing_paths() {
229
230			if ( false === $default = glob( WP_CONTENT_DIR . '/backupwordpress-*-backups', GLOB_ONLYDIR ) ) {
231			$default = array();
232			}
233
234			$upload_dir = wp_upload_dir();
235
236			if ( false === $fallback = glob( $upload_dir['basedir'] . '/backupwordpress-*-backups', GLOB_ONLYDIR ) ) {
237			$fallback = array();
238			}
239
240			$paths = array_merge( $default, $fallback );
241
242			$paths = array_map( 'wp_normalize_path', $paths );
243
244			return $paths;
245
246			}
247
248			/**
249			* Returns the first existing path if there is one
250			*
251			* @return string Backup path if found empty string if not
252			*/
253			public function get_existing_path() {
254
255			$paths = $this->get_existing_paths();
256
257			if ( ! empty( $paths[0] ) ) {
258			return $paths[0];
259			}
260
261			return '';
262
263			}
264
265			/**
266			* Calculate the backup path and create the directory if it doesn't exist.
267			*
268			* Tries all possible locations and uses the first one possible
269			*
270			* @return
271			*/
272			public function calculate_path() {
273
274			$paths = array();
275
276			// If we have a custom path then try to use it
277			if ( $this->get_custom_path() ) {
278			$paths[] = $this->get_custom_path();
279			}
280
281			// If there is already a backups directory then try to use that
282			if ( $this->get_existing_path() ) {
283			$paths[] = $this->get_existing_path();
284			}
285
286			// If not then default to a new directory in wp-content
287			$paths[] = $this->get_default_path();
288
289			// If that didn't work then fallback to a new directory in uploads
290			$paths[] = $this->get_fallback_path();
291
292			// Loop through possible paths, use the first one that exists/can be created and is writable
293			foreach ( $paths as $path ) {
294			if ( wp_mkdir_p( $path ) && wp_is_writable( $path ) ) { // Also handles fixing perms / directory already exists
295			break;
296			}
297			}
298
299			if ( file_exists( $path ) && wp_is_writable( $path ) ) {
300			$this->path = $path;
			0 ignored issues – show Bug introduced 2016-02-08 15:49 UTC by Report Bug Copy Issue Report The variable `$path` seems to be defined by a `foreach` iteration on line `293`. Are you sure the iterator is never empty, otherwise this variable is not defined? It seems like you are relying on a variable being defined by an iteration: foreach ($a as $b) { } // $b is defined here only if $a has elements, for example if $a is array() // then $b would not be defined here. To avoid that, we recommend to set a // default value for $b. // Better $b = 0; // or whatever default makes sense in your context foreach ($a as $b) { } // $b is now guaranteed to be defined here. Loading history...
301			}
302
303			}
304
305			/**
306			* Protect the directory that backups are stored in
307			*
308			* - Adds an index.html file in an attempt to disable directory browsing
309			* - Adds a .httaccess file to deny direct access if on Apache
310			*
311			* @param string $reset
312			*/
313			public function protect_path( $reset = 'no' ) {
314
315			global $is_apache;
			1 ignored issue – show Compatibility Best Practice introduced 2015-11-21 01:52 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...
316
317			// Protect against directory browsing by including an index.html file
318			$index = $this->path . '/index.html';
319
320			if ( 'reset' === $reset && file_exists( $index ) ) {
321			@unlink( $index );
			0 ignored issues – show Security Best Practice introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
322			}
323
324			if ( ! file_exists( $index ) && wp_is_writable( $this->path ) ) {
325			file_put_contents( $index, '' );
326			}
327
328			$htaccess = $this->path . '/.htaccess';
329
330			if ( ( 'reset' === $reset ) && file_exists( $htaccess ) ) {
331			@unlink( $htaccess );
			0 ignored issues – show Security Best Practice introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
332			}
333
334			// Protect the directory with a .htaccess file on Apache servers
335			if ( $is_apache && function_exists( 'insert_with_markers' ) && ! file_exists( $htaccess ) && wp_is_writable( $this->path ) ) {
336
337			$contents[] = '# ' . sprintf( __( 'This %s file ensures that other people cannot download your backup files.', 'backupwordpress' ), '.htaccess' );
			0 ignored issues – show Coding Style Comprehensibility introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report `$contents` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$contents = array();` before regardless. Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code. Let’s take a look at an example: foreach ($collection as $item) { $myArray['foo'] = $item->getFoo(); if ($item->hasBar()) { $myArray['bar'] = $item->getBar(); } // do something with $myArray } As you can see in this example, the array `$myArray` is initialized the first time when the foreach loop is entered. You can also see that the value of the `bar` key is only written conditionally; thus, its value might result from a previous iteration. This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization `$myArray = array()` either outside or inside the foreach loop. Loading history...
338			$contents[] = '';
339			$contents[] = '<IfModule mod_rewrite.c>';
340			$contents[] = 'RewriteEngine On';
341			$contents[] = 'RewriteCond %{QUERY_STRING} !key=' . HMBKP_SECURE_KEY;
342			$contents[] = 'RewriteRule (.*) - [F]';
343			$contents[] = '</IfModule>';
344			$contents[] = '';
345
346			file_put_contents( $htaccess, '' );
347
348			insert_with_markers( $htaccess, 'BackUpWordPress', $contents );
349
350			}
351
352			}
353
354			/**
355			* If we have more than one path then move any existing backups to the current path and remove them
356			*/
357			public function merge_existing_paths() {
358
359			$paths = $this->get_existing_paths();
360
361			if ( ( $paths && $this->get_custom_path() ) \|\| count( $paths ) > 1 ) {
			0 ignored issues – show Bug Best Practice introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report The expression `$paths` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
362			foreach ( $paths as $old_path ) {
363			$this->move_old_backups( $old_path );
364			}
365			}
366
367			}
368
369			/**
370			* Move backup files from an existing directory and the new
371			* location
372			*
373			* @param string $path The path to move the backups from
			0 ignored issues – show Bug introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report There is no parameter named `$path`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
374			*/
375			public function move_old_backups( $from ) {
376
377			if ( ! is_readable( $from ) ) {
378			return;
379			}
380
381			if ( ! wp_is_writable( Path::get_path() ) ) {
382			return;
383			}
384
385			// Move any existing backups
386			if ( $handle = opendir( $from ) ) {
387
388			// Loop through the backup directory
389			while ( false !== ( $file = readdir( $handle ) ) ) {
390
391			// Find all zips
392			if ( 'zip' === pathinfo( $file, PATHINFO_EXTENSION ) ) {
393
394			// Try to move them
395			if ( ! @rename( trailingslashit( $from ) . $file, trailingslashit( Path::get_path() ) . $file ) ) {
396
397
398			// If we can't move them then try to copy them
399			copy( trailingslashit( $from ) . $file, trailingslashit( Path::get_path() ) . $file );
400
401			}
402
403			}
404			}
405
406			closedir( $handle );
407
408			}
409
410			// Delete the old directory if it's inside WP_CONTENT_DIR
411			if ( false !== strpos( $from, WP_CONTENT_DIR ) && $from !== Path::get_path() ) {
412			rmdirtree( $from );
413			}
414
415			}
416
417			/**
418			* Clean any temporary / incomplete backups from the backups directory
419			*/
420			public function cleanup() {
421
422			// Don't cleanup a custom path, who knows what other stuff is there
423			if ( Path::get_path() === $this->get_custom_path() ) {
424			return;
425			}
426
427			foreach ( new CleanUpIterator( new \DirectoryIterator( $this->path ) ) as $file ) {
428
429			if ( $file->isDot() \|\| ! $file->isReadable() \|\| ! $file->isFile() ) {
430			continue;
431			}
432
433			@unlink( $file->getPathname() );
			0 ignored issues – show Security Best Practice introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
434
435			}
436
437			}
438
439			}
440
441			class CleanUpIterator extends \FilterIterator {
			0 ignored issues – show Coding Style Compatibility introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report PSR1 recommends that each class should be in its own file to aid autoloaders. Having each class in a dedicated file usually plays nice with PSR autoloaders and is therefore a well established practice. If you use other autoloaders, you might not want to follow this rule. Loading history...
442
443			// Don't match index.html,files with zip extension or status logfiles.
444			public function accept() {
445			return ! preg_match( '/(index\.html\|.\.zip\|.-running)/', $this->current() );
446			}
447			}
448

humanmade / backupwordpress

GitHub Access Token became invalid

Pull Request — master (#988)

Path C

Complexity

Size/Duplication

Coupling/Cohesion

Importance

22 Methods

How to fix Complexity

Complex Class

1. Pass all data via parameters

2. Create a class that maintains your state

Duplication Side-by-Side

Filter issues like