Core_Upgrader::upgrade() - Code Metrics - ntwb/wordpress - Measure and Improve Code Quality continuously with Scrutinizer

Core_Upgrader::upgrade() F
last analyzed 2017-06-24 04:06 UTC

↳ Parent: Core_Upgrader

Complexity

Conditions	38
Paths	2882

Size

Total Lines	163
Code Lines	98

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	38
eloc	98
nc	2882
nop	2
dl	0
loc	163
rs	2
c	0
b	0
f	0

How to fix Long Method Complexity

<?php
/**
 * Upgrade API: Core_Upgrader class
 *
 * @package WordPress
 * @subpackage Upgrader
 * @since 4.6.0
 */

/**
 * Core class used for updating core.
 *
 * It allows for WordPress to upgrade itself in combination with
 * the wp-admin/includes/update-core.php file.
 *
 * @since 2.8.0
 * @since 4.6.0 Moved to its own file from wp-admin/includes/class-wp-upgrader.php.
 *
 * @see WP_Upgrader
 */
class Core_Upgrader extends WP_Upgrader {

	/**
	 * Initialize the upgrade strings.
	 *
	 * @since 2.8.0
	 * @access public
	 */
	public function upgrade_strings() {
		$this->strings['up_to_date'] = __('WordPress is at the latest version.');
		$this->strings['locked'] = __('Another update is currently in progress.');
		$this->strings['no_package'] = __('Update package not available.');
		$this->strings['downloading_package'] = __('Downloading update from <span class="code">%s</span>&#8230;');
		$this->strings['unpack_package'] = __('Unpacking the update&#8230;');
		$this->strings['copy_failed'] = __('Could not copy files.');
		$this->strings['copy_failed_space'] = __('Could not copy files. You may have run out of disk space.' );
		$this->strings['start_rollback'] = __( 'Attempting to roll back to previous version.' );
		$this->strings['rollback_was_required'] = __( 'Due to an error during updating, WordPress has rolled back to your previous version.' );
	}

	/**
	 * Upgrade WordPress core.
	 *
	 * @since 2.8.0
	 * @access public
	 *
	 * @global WP_Filesystem_Base $wp_filesystem Subclass
	 * @global callable           $_wp_filesystem_direct_method
	 *
	 * @param object $current Response object for whether WordPress is current.
	 * @param array  $args {
	 *        Optional. Arguments for upgrading WordPress core. Default empty array.
	 *
	 *        @type bool $pre_check_md5    Whether to check the file checksums before
	 *                                     attempting the upgrade. Default true.
	 *        @type bool $attempt_rollback Whether to attempt to rollback the chances if
	 *                                     there is a problem. Default false.
	 *        @type bool $do_rollback      Whether to perform this "upgrade" as a rollback.
	 *                                     Default false.
	 * }
	 * @return null|false|WP_Error False or WP_Error on failure, null on success.

	 */
	public function upgrade( $current, $args = array() ) {
		global $wp_filesystem;

		include( ABSPATH . WPINC . '/version.php' ); // $wp_version;

		$start_time = time();

		$defaults = array(
			'pre_check_md5'    => true,
			'attempt_rollback' => false,
			'do_rollback'      => false,
			'allow_relaxed_file_ownership' => false,
		);
		$parsed_args = wp_parse_args( $args, $defaults );

		$this->init();
		$this->upgrade_strings();

		// Is an update available?
		if ( !isset( $current->response ) || $current->response == 'latest' )
			return new WP_Error('up_to_date', $this->strings['up_to_date']);

		$res = $this->fs_connect( array( ABSPATH, WP_CONTENT_DIR ), $parsed_args['allow_relaxed_file_ownership'] );
		if ( ! $res || is_wp_error( $res ) ) {
			return $res;
		}

		$wp_dir = trailingslashit($wp_filesystem->abspath());

		$partial = true;
		if ( $parsed_args['do_rollback'] )
			$partial = false;
		elseif ( $parsed_args['pre_check_md5'] && ! $this->check_files() )
			$partial = false;

		/*
		 * If partial update is returned from the API, use that, unless we're doing
		 * a reinstall. If we cross the new_bundled version number, then use
		 * the new_bundled zip. Don't though if the constant is set to skip bundled items.
		 * If the API returns a no_content zip, go with it. Finally, default to the full zip.
		 */
		if ( $parsed_args['do_rollback'] && $current->packages->rollback )
			$to_download = 'rollback';
		elseif ( $current->packages->partial && 'reinstall' != $current->response && $wp_version == $current->partial_version && $partial )

			$to_download = 'partial';
		elseif ( $current->packages->new_bundled && version_compare( $wp_version, $current->new_bundled, '<' )
			&& ( ! defined( 'CORE_UPGRADE_SKIP_NEW_BUNDLED' ) || ! CORE_UPGRADE_SKIP_NEW_BUNDLED ) )
			$to_download = 'new_bundled';
		elseif ( $current->packages->no_content )
			$to_download = 'no_content';
		else
			$to_download = 'full';

		// Lock to prevent multiple Core Updates occurring
		$lock = WP_Upgrader::create_lock( 'core_updater', 15 * MINUTE_IN_SECONDS );
		if ( ! $lock ) {
			return new WP_Error( 'locked', $this->strings['locked'] );
		}

		$download = $this->download_package( $current->packages->$to_download );
		if ( is_wp_error( $download ) ) {
			WP_Upgrader::release_lock( 'core_updater' );
			return $download;
		}

		$working_dir = $this->unpack_package( $download );
		if ( is_wp_error( $working_dir ) ) {
			WP_Upgrader::release_lock( 'core_updater' );
			return $working_dir;
		}

		// Copy update-core.php from the new version into place.
		if ( !$wp_filesystem->copy($working_dir . '/wordpress/wp-admin/includes/update-core.php', $wp_dir . 'wp-admin/includes/update-core.php', true) ) {
			$wp_filesystem->delete($working_dir, true);
			WP_Upgrader::release_lock( 'core_updater' );
			return new WP_Error( 'copy_failed_for_update_core_file', __( 'The update cannot be installed because we will be unable to copy some files. This is usually due to inconsistent file permissions.' ), 'wp-admin/includes/update-core.php' );
		}
		$wp_filesystem->chmod($wp_dir . 'wp-admin/includes/update-core.php', FS_CHMOD_FILE);

		require_once( ABSPATH . 'wp-admin/includes/update-core.php' );

		if ( ! function_exists( 'update_core' ) ) {
			WP_Upgrader::release_lock( 'core_updater' );
			return new WP_Error( 'copy_failed_space', $this->strings['copy_failed_space'] );
		}

		$result = update_core( $working_dir, $wp_dir );

		// In the event of an issue, we may be able to roll back.
		if ( $parsed_args['attempt_rollback'] && $current->packages->rollback && ! $parsed_args['do_rollback'] ) {
			$try_rollback = false;
			if ( is_wp_error( $result ) ) {
				$error_code = $result->get_error_code();
				/*
				 * Not all errors are equal. These codes are critical: copy_failed__copy_dir,
				 * mkdir_failed__copy_dir, copy_failed__copy_dir_retry, and disk_full.
				 * do_rollback allows for update_core() to trigger a rollback if needed.
				 */
				if ( false !== strpos( $error_code, 'do_rollback' ) )
					$try_rollback = true;
				elseif ( false !== strpos( $error_code, '__copy_dir' ) )
					$try_rollback = true;
				elseif ( 'disk_full' === $error_code )
					$try_rollback = true;
			}

			if ( $try_rollback ) {
				/** This filter is documented in wp-admin/includes/update-core.php */
				apply_filters( 'update_feedback', $result );

				/** This filter is documented in wp-admin/includes/update-core.php */
				apply_filters( 'update_feedback', $this->strings['start_rollback'] );

				$rollback_result = $this->upgrade( $current, array_merge( $parsed_args, array( 'do_rollback' => true ) ) );

				$original_result = $result;
				$result = new WP_Error( 'rollback_was_required', $this->strings['rollback_was_required'], (object) array( 'update' => $original_result, 'rollback' => $rollback_result ) );
			}
		}

		/** This action is documented in wp-admin/includes/class-wp-upgrader.php */
		do_action( 'upgrader_process_complete', $this, array( 'action' => 'update', 'type' => 'core' ) );

		// Clear the current updates
		delete_site_transient( 'update_core' );

		if ( ! $parsed_args['do_rollback'] ) {
			$stats = array(
				'update_type'      => $current->response,
				'success'          => true,
				'fs_method'        => $wp_filesystem->method,
				'fs_method_forced' => defined( 'FS_METHOD' ) || has_filter( 'filesystem_method' ),
				'fs_method_direct' => !empty( $GLOBALS['_wp_filesystem_direct_method'] ) ? $GLOBALS['_wp_filesystem_direct_method'] : '',
				'time_taken'       => time() - $start_time,
				'reported'         => $wp_version,
				'attempted'        => $current->version,
			);

			if ( is_wp_error( $result ) ) {
				$stats['success'] = false;
				// Did a rollback occur?
				if ( ! empty( $try_rollback ) ) {
					$stats['error_code'] = $original_result->get_error_code();
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
					$stats['error_data'] = $original_result->get_error_data();
					// Was the rollback successful? If not, collect its error too.
					$stats['rollback'] = ! is_wp_error( $rollback_result );
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
					if ( is_wp_error( $rollback_result ) ) {
						$stats['rollback_code'] = $rollback_result->get_error_code();
						$stats['rollback_data'] = $rollback_result->get_error_data();
					}
				} else {
					$stats['error_code'] = $result->get_error_code();
					$stats['error_data'] = $result->get_error_data();
				}
			}

			wp_version_check( $stats );
		}

		WP_Upgrader::release_lock( 'core_updater' );

		return $result;
	}

	/**
	 * Determines if this WordPress Core version should update to an offered version or not.
	 *
	 * @since 3.7.0
	 * @access public
	 *
	 * @static
	 *
	 * @param string $offered_ver The offered version, of the format x.y.z.
	 * @return bool True if we should update to the offered version, otherwise false.
	 */
	public static function should_update_to_version( $offered_ver ) {
		include( ABSPATH . WPINC . '/version.php' ); // $wp_version; // x.y.z

		$current_branch = implode( '.', array_slice( preg_split( '/[.-]/', $wp_version  ), 0, 2 ) ); // x.y

		$new_branch     = implode( '.', array_slice( preg_split( '/[.-]/', $offered_ver ), 0, 2 ) ); // x.y
		$current_is_development_version = (bool) strpos( $wp_version, '-' );

		// Defaults:
		$upgrade_dev   = true;
		$upgrade_minor = true;
		$upgrade_major = false;

		// WP_AUTO_UPDATE_CORE = true (all), 'minor', false.
		if ( defined( 'WP_AUTO_UPDATE_CORE' ) ) {
			if ( false === WP_AUTO_UPDATE_CORE ) {
				// Defaults to turned off, unless a filter allows it
				$upgrade_dev = $upgrade_minor = $upgrade_major = false;
			} elseif ( true === WP_AUTO_UPDATE_CORE ) {
				// ALL updates for core
				$upgrade_dev = $upgrade_minor = $upgrade_major = true;
			} elseif ( 'minor' === WP_AUTO_UPDATE_CORE ) {
				// Only minor updates for core
				$upgrade_dev = $upgrade_major = false;
				$upgrade_minor = true;
			}
		}

		// 1: If we're already on that version, not much point in updating?
		if ( $offered_ver == $wp_version )
			return false;

		// 2: If we're running a newer version, that's a nope
		if ( version_compare( $wp_version, $offered_ver, '>' ) )
			return false;

		$failure_data = get_site_option( 'auto_core_update_failed' );
		if ( $failure_data ) {
			// If this was a critical update failure, cannot update.
			if ( ! empty( $failure_data['critical'] ) )
				return false;

			// Don't claim we can update on update-core.php if we have a non-critical failure logged.
			if ( $wp_version == $failure_data['current'] && false !== strpos( $offered_ver, '.1.next.minor' ) )
				return false;

			// Cannot update if we're retrying the same A to B update that caused a non-critical failure.
			// Some non-critical failures do allow retries, like download_failed.
			// 3.7.1 => 3.7.2 resulted in files_not_writable, if we are still on 3.7.1 and still trying to update to 3.7.2.
			if ( empty( $failure_data['retry'] ) && $wp_version == $failure_data['current'] && $offered_ver == $failure_data['attempted'] )
				return false;
		}

		// 3: 3.7-alpha-25000 -> 3.7-alpha-25678 -> 3.7-beta1 -> 3.7-beta2
		if ( $current_is_development_version ) {

			/**
			 * Filters whether to enable automatic core updates for development versions.
			 *
			 * @since 3.7.0
			 *
			 * @param bool $upgrade_dev Whether to enable automatic updates for
			 *                          development versions.
			 */
			if ( ! apply_filters( 'allow_dev_auto_core_updates', $upgrade_dev ) )
				return false;
			// Else fall through to minor + major branches below.
		}

		// 4: Minor In-branch updates (3.7.0 -> 3.7.1 -> 3.7.2 -> 3.7.4)
		if ( $current_branch == $new_branch ) {

			/**
			 * Filters whether to enable minor automatic core updates.
			 *
			 * @since 3.7.0
			 *
			 * @param bool $upgrade_minor Whether to enable minor automatic core updates.
			 */
			return apply_filters( 'allow_minor_auto_core_updates', $upgrade_minor );
		}

		// 5: Major version updates (3.7.0 -> 3.8.0 -> 3.9.1)
		if ( version_compare( $new_branch, $current_branch, '>' ) ) {

			/**
			 * Filters whether to enable major automatic core updates.
			 *
			 * @since 3.7.0
			 *
			 * @param bool $upgrade_major Whether to enable major automatic core updates.
			 */
			return apply_filters( 'allow_major_auto_core_updates', $upgrade_major );
		}

		// If we're not sure, we don't want it
		return false;
	}

	/**
	 * Compare the disk file checksums against the expected checksums.
	 *
	 * @since 3.7.0
	 * @access public
	 *
	 * @global string $wp_version
	 * @global string $wp_local_package
	 *
	 * @return bool True if the checksums match, otherwise false.
	 */
	public function check_files() {
		global $wp_version, $wp_local_package;

		$checksums = get_core_checksums( $wp_version, isset( $wp_local_package ) ? $wp_local_package : 'en_US' );

		if ( ! is_array( $checksums ) )
			return false;

		foreach ( $checksums as $file => $checksum ) {
			// Skip files which get updated
			if ( 'wp-content' == substr( $file, 0, 10 ) )
				continue;
			if ( ! file_exists( ABSPATH . $file ) || md5_file( ABSPATH . $file ) !== $checksum )
				return false;
		}

		return true;
	}
}


Core_Upgrader::upgrade() F
last analyzed 2017-06-24 04:06 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

1		<?php
2		/**
3		* Upgrade API: Core_Upgrader class
4		*
5		* @package WordPress
6		* @subpackage Upgrader
7		* @since 4.6.0
8		*/
9
10		/**
11		* Core class used for updating core.
12		*
13		* It allows for WordPress to upgrade itself in combination with
14		* the wp-admin/includes/update-core.php file.
15		*
16		* @since 2.8.0
17		* @since 4.6.0 Moved to its own file from wp-admin/includes/class-wp-upgrader.php.
18		*
19		* @see WP_Upgrader
20		*/
21		class Core_Upgrader extends WP_Upgrader {
22
23		/**
24		* Initialize the upgrade strings.
25		*
26		* @since 2.8.0
27		* @access public
28		*/
29	View Code Duplication	public function upgrade_strings() {
30		$this->strings['up_to_date'] = __('WordPress is at the latest version.');
31		$this->strings['locked'] = __('Another update is currently in progress.');
32		$this->strings['no_package'] = __('Update package not available.');
33		$this->strings['downloading_package'] = __('Downloading update from <span class="code">%s</span>…');
34		$this->strings['unpack_package'] = __('Unpacking the update…');
35		$this->strings['copy_failed'] = __('Could not copy files.');
36		$this->strings['copy_failed_space'] = __('Could not copy files. You may have run out of disk space.' );
37		$this->strings['start_rollback'] = __( 'Attempting to roll back to previous version.' );
38		$this->strings['rollback_was_required'] = __( 'Due to an error during updating, WordPress has rolled back to your previous version.' );
39		}
40
41		/**
42		* Upgrade WordPress core.
43		*
44		* @since 2.8.0
45		* @access public
46		*
47		* @global WP_Filesystem_Base $wp_filesystem Subclass
48		* @global callable $_wp_filesystem_direct_method
49		*
50		* @param object $current Response object for whether WordPress is current.
51		* @param array $args {
52		* Optional. Arguments for upgrading WordPress core. Default empty array.
53		*
54		* @type bool $pre_check_md5 Whether to check the file checksums before
55		* attempting the upgrade. Default true.
56		* @type bool $attempt_rollback Whether to attempt to rollback the chances if
57		* there is a problem. Default false.
58		* @type bool $do_rollback Whether to perform this "upgrade" as a rollback.
59		* Default false.
60		* }
61		* @return null\|false\|WP_Error False or WP_Error on failure, null on success.
		0 ignored issues – show Documentation introduced 2017-06-24 04:04 UTC by Report Bug Copy Issue Report Should the return type not be `WP_Error\|boolean\|string\|null`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
62		*/
63		public function upgrade( $current, $args = array() ) {
64		global $wp_filesystem;
65
66		include( ABSPATH . WPINC . '/version.php' ); // $wp_version;
67
68		$start_time = time();
69
70		$defaults = array(
71		'pre_check_md5' => true,
72		'attempt_rollback' => false,
73		'do_rollback' => false,
74		'allow_relaxed_file_ownership' => false,
75		);
76		$parsed_args = wp_parse_args( $args, $defaults );
77
78		$this->init();
79		$this->upgrade_strings();
80
81		// Is an update available?
82		if ( !isset( $current->response ) \|\| $current->response == 'latest' )
83		return new WP_Error('up_to_date', $this->strings['up_to_date']);
84
85		$res = $this->fs_connect( array( ABSPATH, WP_CONTENT_DIR ), $parsed_args['allow_relaxed_file_ownership'] );
86		if ( ! $res \|\| is_wp_error( $res ) ) {
87		return $res;
88		}
89
90		$wp_dir = trailingslashit($wp_filesystem->abspath());
91
92		$partial = true;
93		if ( $parsed_args['do_rollback'] )
94		$partial = false;
95		elseif ( $parsed_args['pre_check_md5'] && ! $this->check_files() )
96		$partial = false;
97
98		/*
99		* If partial update is returned from the API, use that, unless we're doing
100		* a reinstall. If we cross the new_bundled version number, then use
101		* the new_bundled zip. Don't though if the constant is set to skip bundled items.
102		* If the API returns a no_content zip, go with it. Finally, default to the full zip.
103		*/
104		if ( $parsed_args['do_rollback'] && $current->packages->rollback )
105		$to_download = 'rollback';
106		elseif ( $current->packages->partial && 'reinstall' != $current->response && $wp_version == $current->partial_version && $partial )
		0 ignored issues – show Bug introduced 2016-06-29 09:21 UTC by Report Bug Copy Issue Report The variable `$wp_version` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
107		$to_download = 'partial';
108		elseif ( $current->packages->new_bundled && version_compare( $wp_version, $current->new_bundled, '<' )
109		&& ( ! defined( 'CORE_UPGRADE_SKIP_NEW_BUNDLED' ) \|\| ! CORE_UPGRADE_SKIP_NEW_BUNDLED ) )
110		$to_download = 'new_bundled';
111		elseif ( $current->packages->no_content )
112		$to_download = 'no_content';
113		else
114		$to_download = 'full';
115
116		// Lock to prevent multiple Core Updates occurring
117		$lock = WP_Upgrader::create_lock( 'core_updater', 15 * MINUTE_IN_SECONDS );
118		if ( ! $lock ) {
119		return new WP_Error( 'locked', $this->strings['locked'] );
120		}
121
122		$download = $this->download_package( $current->packages->$to_download );
123		if ( is_wp_error( $download ) ) {
124		WP_Upgrader::release_lock( 'core_updater' );
125		return $download;
126		}
127
128		$working_dir = $this->unpack_package( $download );
129		if ( is_wp_error( $working_dir ) ) {
130		WP_Upgrader::release_lock( 'core_updater' );
131		return $working_dir;
132		}
133
134		// Copy update-core.php from the new version into place.
135		if ( !$wp_filesystem->copy($working_dir . '/wordpress/wp-admin/includes/update-core.php', $wp_dir . 'wp-admin/includes/update-core.php', true) ) {
136		$wp_filesystem->delete($working_dir, true);
137		WP_Upgrader::release_lock( 'core_updater' );
138		return new WP_Error( 'copy_failed_for_update_core_file', __( 'The update cannot be installed because we will be unable to copy some files. This is usually due to inconsistent file permissions.' ), 'wp-admin/includes/update-core.php' );
139		}
140		$wp_filesystem->chmod($wp_dir . 'wp-admin/includes/update-core.php', FS_CHMOD_FILE);
141
142		require_once( ABSPATH . 'wp-admin/includes/update-core.php' );
143
144		if ( ! function_exists( 'update_core' ) ) {
145		WP_Upgrader::release_lock( 'core_updater' );
146		return new WP_Error( 'copy_failed_space', $this->strings['copy_failed_space'] );
147		}
148
149		$result = update_core( $working_dir, $wp_dir );
150
151		// In the event of an issue, we may be able to roll back.
152		if ( $parsed_args['attempt_rollback'] && $current->packages->rollback && ! $parsed_args['do_rollback'] ) {
153		$try_rollback = false;
154		if ( is_wp_error( $result ) ) {
155		$error_code = $result->get_error_code();
156		/*
157		* Not all errors are equal. These codes are critical: copy_failed__copy_dir,
158		* mkdir_failed__copy_dir, copy_failed__copy_dir_retry, and disk_full.
159		* do_rollback allows for update_core() to trigger a rollback if needed.
160		*/
161		if ( false !== strpos( $error_code, 'do_rollback' ) )
162		$try_rollback = true;
163		elseif ( false !== strpos( $error_code, '__copy_dir' ) )
164		$try_rollback = true;
165		elseif ( 'disk_full' === $error_code )
166		$try_rollback = true;
167		}
168
169		if ( $try_rollback ) {
170		/** This filter is documented in wp-admin/includes/update-core.php */
171		apply_filters( 'update_feedback', $result );
172
173		/** This filter is documented in wp-admin/includes/update-core.php */
174		apply_filters( 'update_feedback', $this->strings['start_rollback'] );
175
176		$rollback_result = $this->upgrade( $current, array_merge( $parsed_args, array( 'do_rollback' => true ) ) );
177
178		$original_result = $result;
179		$result = new WP_Error( 'rollback_was_required', $this->strings['rollback_was_required'], (object) array( 'update' => $original_result, 'rollback' => $rollback_result ) );
180		}
181		}
182
183		/** This action is documented in wp-admin/includes/class-wp-upgrader.php */
184		do_action( 'upgrader_process_complete', $this, array( 'action' => 'update', 'type' => 'core' ) );
185
186		// Clear the current updates
187		delete_site_transient( 'update_core' );
188
189		if ( ! $parsed_args['do_rollback'] ) {
190		$stats = array(
191		'update_type' => $current->response,
192		'success' => true,
193		'fs_method' => $wp_filesystem->method,
194		'fs_method_forced' => defined( 'FS_METHOD' ) \|\| has_filter( 'filesystem_method' ),
195		'fs_method_direct' => !empty( $GLOBALS['_wp_filesystem_direct_method'] ) ? $GLOBALS['_wp_filesystem_direct_method'] : '',
196		'time_taken' => time() - $start_time,
197		'reported' => $wp_version,
198		'attempted' => $current->version,
199		);
200
201		if ( is_wp_error( $result ) ) {
202		$stats['success'] = false;
203		// Did a rollback occur?
204		if ( ! empty( $try_rollback ) ) {
205		$stats['error_code'] = $original_result->get_error_code();
		0 ignored issues – show Bug introduced 2016-06-29 09:21 UTC by Report Bug Copy Issue Report The variable `$original_result` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
206		$stats['error_data'] = $original_result->get_error_data();
207		// Was the rollback successful? If not, collect its error too.
208		$stats['rollback'] = ! is_wp_error( $rollback_result );
		0 ignored issues – show Bug introduced 2016-06-29 09:21 UTC by Report Bug Copy Issue Report The variable `$rollback_result` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
209		if ( is_wp_error( $rollback_result ) ) {
210		$stats['rollback_code'] = $rollback_result->get_error_code();
211		$stats['rollback_data'] = $rollback_result->get_error_data();
212		}
213		} else {
214		$stats['error_code'] = $result->get_error_code();
215		$stats['error_data'] = $result->get_error_data();
216		}
217		}
218
219		wp_version_check( $stats );
220		}
221
222		WP_Upgrader::release_lock( 'core_updater' );
223
224		return $result;
225		}
226
227		/**
228		* Determines if this WordPress Core version should update to an offered version or not.
229		*
230		* @since 3.7.0
231		* @access public
232		*
233		* @static
234		*
235		* @param string $offered_ver The offered version, of the format x.y.z.
236		* @return bool True if we should update to the offered version, otherwise false.
237		*/
238		public static function should_update_to_version( $offered_ver ) {
239		include( ABSPATH . WPINC . '/version.php' ); // $wp_version; // x.y.z
240
241		$current_branch = implode( '.', array_slice( preg_split( '/[.-]/', $wp_version ), 0, 2 ) ); // x.y
		0 ignored issues – show Bug introduced 2016-06-29 09:21 UTC by Report Bug Copy Issue Report The variable `$wp_version` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
242		$new_branch = implode( '.', array_slice( preg_split( '/[.-]/', $offered_ver ), 0, 2 ) ); // x.y
243		$current_is_development_version = (bool) strpos( $wp_version, '-' );
244
245		// Defaults:
246		$upgrade_dev = true;
247		$upgrade_minor = true;
248		$upgrade_major = false;
249
250		// WP_AUTO_UPDATE_CORE = true (all), 'minor', false.
251		if ( defined( 'WP_AUTO_UPDATE_CORE' ) ) {
252		if ( false === WP_AUTO_UPDATE_CORE ) {
253		// Defaults to turned off, unless a filter allows it
254		$upgrade_dev = $upgrade_minor = $upgrade_major = false;
255		} elseif ( true === WP_AUTO_UPDATE_CORE ) {
256		// ALL updates for core
257		$upgrade_dev = $upgrade_minor = $upgrade_major = true;
258		} elseif ( 'minor' === WP_AUTO_UPDATE_CORE ) {
259		// Only minor updates for core
260		$upgrade_dev = $upgrade_major = false;
261		$upgrade_minor = true;
262		}
263		}
264
265		// 1: If we're already on that version, not much point in updating?
266		if ( $offered_ver == $wp_version )
267		return false;
268
269		// 2: If we're running a newer version, that's a nope
270		if ( version_compare( $wp_version, $offered_ver, '>' ) )
271		return false;
272
273		$failure_data = get_site_option( 'auto_core_update_failed' );
274		if ( $failure_data ) {
275		// If this was a critical update failure, cannot update.
276		if ( ! empty( $failure_data['critical'] ) )
277		return false;
278
279		// Don't claim we can update on update-core.php if we have a non-critical failure logged.
280		if ( $wp_version == $failure_data['current'] && false !== strpos( $offered_ver, '.1.next.minor' ) )
281		return false;
282
283		// Cannot update if we're retrying the same A to B update that caused a non-critical failure.
284		// Some non-critical failures do allow retries, like download_failed.
285		// 3.7.1 => 3.7.2 resulted in files_not_writable, if we are still on 3.7.1 and still trying to update to 3.7.2.
286		if ( empty( $failure_data['retry'] ) && $wp_version == $failure_data['current'] && $offered_ver == $failure_data['attempted'] )
287		return false;
288		}
289
290		// 3: 3.7-alpha-25000 -> 3.7-alpha-25678 -> 3.7-beta1 -> 3.7-beta2
291		if ( $current_is_development_version ) {
292
293		/**
294		* Filters whether to enable automatic core updates for development versions.
295		*
296		* @since 3.7.0
297		*
298		* @param bool $upgrade_dev Whether to enable automatic updates for
299		* development versions.
300		*/
301		if ( ! apply_filters( 'allow_dev_auto_core_updates', $upgrade_dev ) )
302		return false;
303		// Else fall through to minor + major branches below.
304		}
305
306		// 4: Minor In-branch updates (3.7.0 -> 3.7.1 -> 3.7.2 -> 3.7.4)
307		if ( $current_branch == $new_branch ) {
308
309		/**
310		* Filters whether to enable minor automatic core updates.
311		*
312		* @since 3.7.0
313		*
314		* @param bool $upgrade_minor Whether to enable minor automatic core updates.
315		*/
316		return apply_filters( 'allow_minor_auto_core_updates', $upgrade_minor );
317		}
318
319		// 5: Major version updates (3.7.0 -> 3.8.0 -> 3.9.1)
320		if ( version_compare( $new_branch, $current_branch, '>' ) ) {
321
322		/**
323		* Filters whether to enable major automatic core updates.
324		*
325		* @since 3.7.0
326		*
327		* @param bool $upgrade_major Whether to enable major automatic core updates.
328		*/
329		return apply_filters( 'allow_major_auto_core_updates', $upgrade_major );
330		}
331
332		// If we're not sure, we don't want it
333		return false;
334		}
335
336		/**
337		* Compare the disk file checksums against the expected checksums.
338		*
339		* @since 3.7.0
340		* @access public
341		*
342		* @global string $wp_version
343		* @global string $wp_local_package
344		*
345		* @return bool True if the checksums match, otherwise false.
346		*/
347		public function check_files() {
348		global $wp_version, $wp_local_package;
349
350		$checksums = get_core_checksums( $wp_version, isset( $wp_local_package ) ? $wp_local_package : 'en_US' );
351
352		if ( ! is_array( $checksums ) )
353		return false;
354
355		foreach ( $checksums as $file => $checksum ) {
356		// Skip files which get updated
357		if ( 'wp-content' == substr( $file, 0, 10 ) )
358		continue;
359		if ( ! file_exists( ABSPATH . $file ) \|\| md5_file( ABSPATH . $file ) !== $checksum )
360		return false;
361		}
362
363		return true;
364		}
365		}
366

ntwb / wordpress

Core_Upgrader::upgrade() F last analyzed 2017-06-24 04:06 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

Core_Upgrader::upgrade() F
last analyzed 2017-06-24 04:06 UTC