Path - Code Metrics - Inspection of "Improved handling of open_basedir restrictions" - humanmade/backupwordpress - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#967)

by Tom

created 2016-01-23 23:05 UTC

Path C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	428
Duplicated Lines	1.4 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	6
Bugs	0	Features	0

Metric	Value
wmc	77
c	6
b	0
f	0
lcom	1
cbo	1
dl	6
loc	428
rs	5.4715

22 Methods

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

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Path often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Path, and based on these observations, apply Extract Interface, too.

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

			// 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 (#967)

Path C

Complexity

Size/Duplication

Coupling/Cohesion

Importance

22 Methods

How to fix Duplicated Code Complexity

Duplicated Code

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

humanmade / backupwordpress

GitHub Access Token became invalid

Pull Request — master (#967)

Path C

Complexity

Size/Duplication

Coupling/Cohesion

Importance

22 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

1. Pass all data via parameters

2. Create a class that maintains your state

Duplication Side-by-Side

Filter issues like