Path::get_home_path() - Code Metrics - Inspection of "Detect subdir install by comparing home url and si..." - humanmade/backupwordpress - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#977)

by Paul

created 2016-01-27 16:02 UTC

Path::get_home_path() C

↳ Parent: Path

Complexity

Conditions	11
Paths	8

Size

Total Lines	27
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	0	Features	0

Metric	Value
c	4
b	0
f	0
dl	0
loc	27
rs	5.2653
cc	11
eloc	12
nc	8
nop	1

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 ) {


		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 ) ) ) {

			// Handle wordpress installed in a subdirectory
			if ( file_exists( dirname( $site_path ) . '/wp-config.php' ) && ! file_exists( $site_path . '/wp-config.php' ) && file_exists( dirname( $site_path ) . '/index.php' ) ) {
				$home_path = dirname( $site_path );
			} else if ( get_site_url() !== get_home_url() ) {
				$home_path = dirname( $site_path );
			}

			// Handle wp-config.php being above site_path
			if ( file_exists( dirname( $site_path ) . '/wp-config.php' ) && ! file_exists( $site_path . '/wp-config.php' ) && ! file_exists( dirname( $site_path ) . '/index.php' ) ) {
				$home_path = $site_path;
			}

		}

		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 (#977)

Path::get_home_path() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

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 ) {
			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...
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			// Handle wordpress installed in a subdirectory
109			if ( file_exists( dirname( $site_path ) . '/wp-config.php' ) && ! file_exists( $site_path . '/wp-config.php' ) && file_exists( dirname( $site_path ) . '/index.php' ) ) {
110			$home_path = dirname( $site_path );
111			} else if ( get_site_url() !== get_home_url() ) {
112			$home_path = dirname( $site_path );
113			}
114
115			// Handle wp-config.php being above site_path
116			if ( file_exists( dirname( $site_path ) . '/wp-config.php' ) && ! file_exists( $site_path . '/wp-config.php' ) && ! file_exists( dirname( $site_path ) . '/index.php' ) ) {
117			$home_path = $site_path;
118			}
119
120			}
121
122			return wp_normalize_path( untrailingslashit( $home_path ) );
123
124			}
125
126			/**
127			* get the calculated path to the directory where backups will be stored
128			*/
129			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...
130
131			// Calculate the path if needed
132			if ( empty( $this->path ) \|\| ! wp_is_writable( $this->path ) ) {
133			$this->calculate_path();
134			}
135
136			// Ensure the backup directory is protected
137			$this->protect_path();
138
139			return wp_normalize_path( $this->path );
140
141			}
142
143			/**
144			* Set the path directly, overriding the default
145			*
146			* @param $path
147			*/
148			public function set_path( $path ) {
149
150			$this->custom_path = $path;
151
152			// Re-calculate the backup path
153			$this->calculate_path();
154
155			}
156
157			/**
158			* get the calculated path to the directory that will be backed up
159			*/
160			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...
161
162			$root = self::get_home_path();
163
164			if ( defined( 'HMBKP_ROOT' ) && HMBKP_ROOT ) {
165			$root = HMBKP_ROOT;
166			}
167
168			if ( $this->root ) {
169			$root = $this->root;
170			}
171
172			return wp_normalize_path( $root );
173
174			}
175
176			/**
177			* Set the root path directly, overriding the default
178			*
179			* @param $root
180			*/
181			public function set_root( $root ) {
182			$this->root = $root;
183			}
184
185			public function reset_path() {
186			$this->set_path( false );
187			}
188
189			/**
190			* Get the path to the default backup location in wp-content
191			*/
192			public function get_default_path() {
193			return trailingslashit( wp_normalize_path( WP_CONTENT_DIR ) ) . 'backupwordpress-' . substr( HMBKP_SECURE_KEY, 0, 10 ) . '-backups';
194			}
195
196			/**
197			* Get the path to the fallback backup location in uploads
198			*/
199			public function get_fallback_path() {
200
201			$upload_dir = wp_upload_dir();
202
203			return trailingslashit( wp_normalize_path( $upload_dir['basedir'] ) ) . 'backupwordpress-' . substr( HMBKP_SECURE_KEY, 0, 10 ) . '-backups';
204
205			}
206
207			/**
208			* Get the path to the custom backup location if it's been set
209			*/
210			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...
211
212			if ( $this->custom_path ) {
213			return $this->custom_path;
214			}
215
216			if ( defined( 'HMBKP_PATH' ) && wp_is_writable( HMBKP_PATH ) ) {
217			return HMBKP_PATH;
218			}
219
220			return '';
221
222			}
223
224			/**
225			* Builds an array containing existing backups folders.
226			*
227			* @return array
228			*/
229			public function get_existing_paths() {
230
231			if ( false === $default = glob( WP_CONTENT_DIR . '/backupwordpress-*-backups', GLOB_ONLYDIR ) ) {
232			$default = array();
233			}
234
235			$upload_dir = wp_upload_dir();
236
237			if ( false === $fallback = glob( $upload_dir['basedir'] . '/backupwordpress-*-backups', GLOB_ONLYDIR ) ) {
238			$fallback = array();
239			}
240
241			$paths = array_merge( $default, $fallback );
242
243			$paths = array_map( 'wp_normalize_path', $paths );
244
245			return $paths;
246
247			}
248
249			/**
250			* Returns the first existing path if there is one
251			*
252			* @return string Backup path if found empty string if not
253			*/
254			public function get_existing_path() {
255
256			$paths = $this->get_existing_paths();
257
258			if ( ! empty( $paths[0] ) ) {
259			return $paths[0];
260			}
261
262			return '';
263
264			}
265
266			/**
267			* Calculate the backup path and create the directory if it doesn't exist.
268			*
269			* Tries all possible locations and uses the first one possible
270			*
271			* @return
272			*/
273			public function calculate_path() {
274
275			$paths = array();
276
277			// If we have a custom path then try to use it
278			if ( $this->get_custom_path() ) {
279			$paths[] = $this->get_custom_path();
280			}
281
282			// If there is already a backups directory then try to use that
283			if ( $this->get_existing_path() ) {
284			$paths[] = $this->get_existing_path();
285			}
286
287			// If not then default to a new directory in wp-content
288			$paths[] = $this->get_default_path();
289
290			// If that didn't work then fallback to a new directory in uploads
291			$paths[] = $this->get_fallback_path();
292
293			// Loop through possible paths, use the first one that exists/can be created and is writable
294			foreach ( $paths as $path ) {
295			if ( wp_mkdir_p( $path ) && wp_is_writable( $path ) ) { // Also handles fixing perms / directory already exists
296			break;
297			}
298			}
299
300			if ( file_exists( $path ) && wp_is_writable( $path ) ) {
301			$this->path = $path;
			0 ignored issues – show Bug introduced 2016-01-27 16:12 UTC by Report Bug Copy Issue Report The variable `$path` seems to be defined by a `foreach` iteration on line `294`. 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...
302			}
303
304			}
305
306			/**
307			* Protect the directory that backups are stored in
308			*
309			* - Adds an index.html file in an attempt to disable directory browsing
310			* - Adds a .httaccess file to deny direct access if on Apache
311			*
312			* @param string $reset
313			*/
314			public function protect_path( $reset = 'no' ) {
315
316			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...
317
318			// Protect against directory browsing by including an index.html file
319			$index = $this->path . '/index.html';
320
321			if ( 'reset' === $reset && file_exists( $index ) ) {
322			@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...
323			}
324
325			if ( ! file_exists( $index ) && wp_is_writable( $this->path ) ) {
326			file_put_contents( $index, '' );
327			}
328
329			$htaccess = $this->path . '/.htaccess';
330
331			if ( ( 'reset' === $reset ) && file_exists( $htaccess ) ) {
332			@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...
333			}
334
335			// Protect the directory with a .htaccess file on Apache servers
336			if ( $is_apache && function_exists( 'insert_with_markers' ) && ! file_exists( $htaccess ) && wp_is_writable( $this->path ) ) {
337
338			$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...
339			$contents[] = '';
340			$contents[] = '<IfModule mod_rewrite.c>';
341			$contents[] = 'RewriteEngine On';
342			$contents[] = 'RewriteCond %{QUERY_STRING} !key=' . HMBKP_SECURE_KEY;
343			$contents[] = 'RewriteRule (.*) - [F]';
344			$contents[] = '</IfModule>';
345			$contents[] = '';
346
347			file_put_contents( $htaccess, '' );
348
349			insert_with_markers( $htaccess, 'BackUpWordPress', $contents );
350
351			}
352
353			}
354
355			/**
356			* If we have more than one path then move any existing backups to the current path and remove them
357			*/
358			public function merge_existing_paths() {
359
360			$paths = $this->get_existing_paths();
361
362			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...
363			foreach ( $paths as $old_path ) {
364			$this->move_old_backups( $old_path );
365			}
366			}
367
368			}
369
370			/**
371			* Move backup files from an existing directory and the new
372			* location
373			*
374			* @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...
375			*/
376			public function move_old_backups( $from ) {
377
378			if ( ! is_readable( $from ) ) {
379			return;
380			}
381
382			if ( ! wp_is_writable( Path::get_path() ) ) {
383			return;
384			}
385
386			// Move any existing backups
387			if ( $handle = opendir( $from ) ) {
388
389			// Loop through the backup directory
390			while ( false !== ( $file = readdir( $handle ) ) ) {
391
392			// Find all zips
393			if ( 'zip' === pathinfo( $file, PATHINFO_EXTENSION ) ) {
394
395			// Try to move them
396			if ( ! @rename( trailingslashit( $from ) . $file, trailingslashit( Path::get_path() ) . $file ) ) {
397
398
399			// If we can't move them then try to copy them
400			copy( trailingslashit( $from ) . $file, trailingslashit( Path::get_path() ) . $file );
401
402			}
403
404			}
405			}
406
407			closedir( $handle );
408
409			}
410
411			// Delete the old directory if it's inside WP_CONTENT_DIR
412			if ( false !== strpos( $from, WP_CONTENT_DIR ) && $from !== Path::get_path() ) {
413			rmdirtree( $from );
414			}
415
416			}
417
418			/**
419			* Clean any temporary / incomplete backups from the backups directory
420			*/
421			public function cleanup() {
422
423			// Don't cleanup a custom path, who knows what other stuff is there
424			if ( Path::get_path() === $this->get_custom_path() ) {
425			return;
426			}
427
428			foreach ( new CleanUpIterator( new \DirectoryIterator( $this->path ) ) as $file ) {
429
430			if ( $file->isDot() \|\| ! $file->isReadable() \|\| ! $file->isFile() ) {
431			continue;
432			}
433
434			@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...
435
436			}
437
438			}
439
440			}
441
442			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...
443
444			// Don't match index.html,files with zip extension or status logfiles.
445			public function accept() {
446			return ! preg_match( '/(index\.html\|.\.zip\|.-running)/', $this->current() );
447			}
448			}
449

humanmade / backupwordpress

GitHub Access Token became invalid

Pull Request — master (#977)

Path::get_home_path() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

1. Pass all data via parameters

2. Create a class that maintains your state

Duplication Side-by-Side

Filter issues like