[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-admin/includes/ -> class-plugin-upgrader.php (source)

   1  <?php
   2  /**
   3   * Upgrade API: Plugin_Upgrader class
   4   *
   5   * @package WordPress
   6   * @subpackage Upgrader
   7   * @since 4.6.0
   8   */
   9  
  10  /**
  11   * Core class used for upgrading/installing plugins.
  12   *
  13   * It is designed to upgrade/install plugins from a local zip, remote zip URL,
  14   * or uploaded zip 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 Plugin_Upgrader extends WP_Upgrader {
  22  
  23      /**
  24       * Plugin upgrade result.
  25       *
  26       * @since 2.8.0
  27       * @var array|WP_Error $result
  28       *
  29       * @see WP_Upgrader::$result
  30       */
  31      public $result;
  32  
  33      /**
  34       * Whether a bulk upgrade/installation is being performed.
  35       *
  36       * @since 2.9.0
  37       * @var bool $bulk
  38       */
  39      public $bulk = false;
  40  
  41      /**
  42       * New plugin info.
  43       *
  44       * @since 5.5.0
  45       * @var array $new_plugin_data
  46       *
  47       * @see check_package()
  48       */
  49      public $new_plugin_data = array();
  50  
  51      /**
  52       * Initialize the upgrade strings.
  53       *
  54       * @since 2.8.0
  55       */
  56  	public function upgrade_strings() {
  57          $this->strings['up_to_date'] = __( 'The plugin is at the latest version.' );
  58          $this->strings['no_package'] = __( 'Update package not available.' );
  59          /* translators: %s: Package URL. */
  60          $this->strings['downloading_package']  = sprintf( __( 'Downloading update from %s&#8230;' ), '<span class="code">%s</span>' );
  61          $this->strings['unpack_package']       = __( 'Unpacking the update&#8230;' );
  62          $this->strings['remove_old']           = __( 'Removing the old version of the plugin&#8230;' );
  63          $this->strings['remove_old_failed']    = __( 'Could not remove the old plugin.' );
  64          $this->strings['process_failed']       = __( 'Plugin update failed.' );
  65          $this->strings['process_success']      = __( 'Plugin updated successfully.' );
  66          $this->strings['process_bulk_success'] = __( 'Plugins updated successfully.' );
  67      }
  68  
  69      /**
  70       * Initialize the installation strings.
  71       *
  72       * @since 2.8.0
  73       */
  74  	public function install_strings() {
  75          $this->strings['no_package'] = __( 'Installation package not available.' );
  76          /* translators: %s: Package URL. */
  77          $this->strings['downloading_package'] = sprintf( __( 'Downloading installation package from %s&#8230;' ), '<span class="code">%s</span>' );
  78          $this->strings['unpack_package']      = __( 'Unpacking the package&#8230;' );
  79          $this->strings['installing_package']  = __( 'Installing the plugin&#8230;' );
  80          $this->strings['remove_old']          = __( 'Removing the current plugin&#8230;' );
  81          $this->strings['remove_old_failed']   = __( 'Could not remove the current plugin.' );
  82          $this->strings['no_files']            = __( 'The plugin contains no files.' );
  83          $this->strings['process_failed']      = __( 'Plugin installation failed.' );
  84          $this->strings['process_success']     = __( 'Plugin installed successfully.' );
  85          /* translators: 1: Plugin name, 2: Plugin version. */
  86          $this->strings['process_success_specific'] = __( 'Successfully installed the plugin <strong>%1$s %2$s</strong>.' );
  87  
  88          if ( ! empty( $this->skin->overwrite ) ) {
  89              if ( 'update-plugin' === $this->skin->overwrite ) {
  90                  $this->strings['installing_package'] = __( 'Updating the plugin&#8230;' );
  91                  $this->strings['process_failed']     = __( 'Plugin update failed.' );
  92                  $this->strings['process_success']    = __( 'Plugin updated successfully.' );
  93              }
  94  
  95              if ( 'downgrade-plugin' === $this->skin->overwrite ) {
  96                  $this->strings['installing_package'] = __( 'Downgrading the plugin&#8230;' );
  97                  $this->strings['process_failed']     = __( 'Plugin downgrade failed.' );
  98                  $this->strings['process_success']    = __( 'Plugin downgraded successfully.' );
  99              }
 100          }
 101      }
 102  
 103      /**
 104       * Install a plugin package.
 105       *
 106       * @since 2.8.0
 107       * @since 3.7.0 The `$args` parameter was added, making clearing the plugin update cache optional.
 108       *
 109       * @param string $package The full local path or URI of the package.
 110       * @param array  $args {
 111       *     Optional. Other arguments for installing a plugin package. Default empty array.
 112       *
 113       *     @type bool $clear_update_cache Whether to clear the plugin updates cache if successful.
 114       *                                    Default true.
 115       * }
 116       * @return bool|WP_Error True if the installation was successful, false or a WP_Error otherwise.
 117       */
 118  	public function install( $package, $args = array() ) {
 119          $defaults    = array(
 120              'clear_update_cache' => true,
 121              'overwrite_package'  => false, // Do not overwrite files.
 122          );
 123          $parsed_args = wp_parse_args( $args, $defaults );
 124  
 125          $this->init();
 126          $this->install_strings();
 127  
 128          add_filter( 'upgrader_source_selection', array( $this, 'check_package' ) );
 129  
 130          if ( $parsed_args['clear_update_cache'] ) {
 131              // Clear cache so wp_update_plugins() knows about the new plugin.
 132              add_action( 'upgrader_process_complete', 'wp_clean_plugins_cache', 9, 0 );
 133          }
 134  
 135          $this->run(
 136              array(
 137                  'package'           => $package,
 138                  'destination'       => WP_PLUGIN_DIR,
 139                  'clear_destination' => $parsed_args['overwrite_package'],
 140                  'clear_working'     => true,
 141                  'hook_extra'        => array(
 142                      'type'   => 'plugin',
 143                      'action' => 'install',
 144                  ),
 145              )
 146          );
 147  
 148          remove_action( 'upgrader_process_complete', 'wp_clean_plugins_cache', 9 );
 149          remove_filter( 'upgrader_source_selection', array( $this, 'check_package' ) );
 150  
 151          if ( ! $this->result || is_wp_error( $this->result ) ) {
 152              return $this->result;
 153          }
 154  
 155          // Force refresh of plugin update information.
 156          wp_clean_plugins_cache( $parsed_args['clear_update_cache'] );
 157  
 158          if ( $parsed_args['overwrite_package'] ) {
 159              /**
 160               * Fires when the upgrader has successfully overwritten a currently installed
 161               * plugin or theme with an uploaded zip package.
 162               *
 163               * @since 5.5.0
 164               *
 165               * @param string  $package          The package file.
 166               * @param array   $new_plugin_data  The new plugin data.
 167               * @param string  $package_type     The package type (plugin or theme).
 168               */
 169              do_action( 'upgrader_overwrote_package', $package, $this->new_plugin_data, 'plugin' );
 170          }
 171  
 172          return true;
 173      }
 174  
 175      /**
 176       * Upgrade a plugin.
 177       *
 178       * @since 2.8.0
 179       * @since 3.7.0 The `$args` parameter was added, making clearing the plugin update cache optional.
 180       *
 181       * @param string $plugin Path to the plugin file relative to the plugins directory.
 182       * @param array  $args {
 183       *     Optional. Other arguments for upgrading a plugin package. Default empty array.
 184       *
 185       *     @type bool $clear_update_cache Whether to clear the plugin updates cache if successful.
 186       *                                    Default true.
 187       * }
 188       * @return bool|WP_Error True if the upgrade was successful, false or a WP_Error object otherwise.
 189       */
 190  	public function upgrade( $plugin, $args = array() ) {
 191          $defaults    = array(
 192              'clear_update_cache' => true,
 193          );
 194          $parsed_args = wp_parse_args( $args, $defaults );
 195  
 196          $this->init();
 197          $this->upgrade_strings();
 198  
 199          $current = get_site_transient( 'update_plugins' );
 200          if ( ! isset( $current->response[ $plugin ] ) ) {
 201              $this->skin->before();
 202              $this->skin->set_result( false );
 203              $this->skin->error( 'up_to_date' );
 204              $this->skin->after();
 205              return false;
 206          }
 207  
 208          // Get the URL to the zip file.
 209          $r = $current->response[ $plugin ];
 210  
 211          add_filter( 'upgrader_pre_install', array( $this, 'deactivate_plugin_before_upgrade' ), 10, 2 );
 212          add_filter( 'upgrader_pre_install', array( $this, 'active_before' ), 10, 2 );
 213          add_filter( 'upgrader_clear_destination', array( $this, 'delete_old_plugin' ), 10, 4 );
 214          add_filter( 'upgrader_post_install', array( $this, 'active_after' ), 10, 2 );
 215          // There's a Trac ticket to move up the directory for zips which are made a bit differently, useful for non-.org plugins.
 216          // 'source_selection' => array( $this, 'source_selection' ),
 217          if ( $parsed_args['clear_update_cache'] ) {
 218              // Clear cache so wp_update_plugins() knows about the new plugin.
 219              add_action( 'upgrader_process_complete', 'wp_clean_plugins_cache', 9, 0 );
 220          }
 221  
 222          $this->run(
 223              array(
 224                  'package'           => $r->package,
 225                  'destination'       => WP_PLUGIN_DIR,
 226                  'clear_destination' => true,
 227                  'clear_working'     => true,
 228                  'hook_extra'        => array(
 229                      'plugin' => $plugin,
 230                      'type'   => 'plugin',
 231                      'action' => 'update',
 232                  ),
 233              )
 234          );
 235  
 236          // Cleanup our hooks, in case something else does a upgrade on this connection.
 237          remove_action( 'upgrader_process_complete', 'wp_clean_plugins_cache', 9 );
 238          remove_filter( 'upgrader_pre_install', array( $this, 'deactivate_plugin_before_upgrade' ) );
 239          remove_filter( 'upgrader_pre_install', array( $this, 'active_before' ) );
 240          remove_filter( 'upgrader_clear_destination', array( $this, 'delete_old_plugin' ) );
 241          remove_filter( 'upgrader_post_install', array( $this, 'active_after' ) );
 242  
 243          if ( ! $this->result || is_wp_error( $this->result ) ) {
 244              return $this->result;
 245          }
 246  
 247          // Force refresh of plugin update information.
 248          wp_clean_plugins_cache( $parsed_args['clear_update_cache'] );
 249  
 250          // Ensure any future auto-update failures trigger a failure email by removing
 251          // the last failure notification from the list when plugins update successfully.
 252          $past_failure_emails = get_option( 'auto_plugin_theme_update_emails', array() );
 253  
 254          if ( isset( $past_failure_emails[ $plugin ] ) ) {
 255              unset( $past_failure_emails[ $plugin ] );
 256              update_option( 'auto_plugin_theme_update_emails', $past_failure_emails );
 257          }
 258  
 259          return true;
 260      }
 261  
 262      /**
 263       * Bulk upgrade several plugins at once.
 264       *
 265       * @since 2.8.0
 266       * @since 3.7.0 The `$args` parameter was added, making clearing the plugin update cache optional.
 267       *
 268       * @param string[] $plugins Array of paths to plugin files relative to the plugins directory.
 269       * @param array    $args {
 270       *     Optional. Other arguments for upgrading several plugins at once.
 271       *
 272       *     @type bool $clear_update_cache Whether to clear the plugin updates cache if successful. Default true.
 273       * }
 274       * @return array|false An array of results indexed by plugin file, or false if unable to connect to the filesystem.
 275       */
 276  	public function bulk_upgrade( $plugins, $args = array() ) {
 277          $defaults    = array(
 278              'clear_update_cache' => true,
 279          );
 280          $parsed_args = wp_parse_args( $args, $defaults );
 281  
 282          $this->init();
 283          $this->bulk = true;
 284          $this->upgrade_strings();
 285  
 286          $current = get_site_transient( 'update_plugins' );
 287  
 288          add_filter( 'upgrader_clear_destination', array( $this, 'delete_old_plugin' ), 10, 4 );
 289  
 290          $this->skin->header();
 291  
 292          // Connect to the filesystem first.
 293          $res = $this->fs_connect( array( WP_CONTENT_DIR, WP_PLUGIN_DIR ) );
 294          if ( ! $res ) {
 295              $this->skin->footer();
 296              return false;
 297          }
 298  
 299          $this->skin->bulk_header();
 300  
 301          /*
 302           * Only start maintenance mode if:
 303           * - running Multisite and there are one or more plugins specified, OR
 304           * - a plugin with an update available is currently active.
 305           * @todo For multisite, maintenance mode should only kick in for individual sites if at all possible.
 306           */
 307          $maintenance = ( is_multisite() && ! empty( $plugins ) );
 308          foreach ( $plugins as $plugin ) {
 309              $maintenance = $maintenance || ( is_plugin_active( $plugin ) && isset( $current->response[ $plugin ] ) );
 310          }
 311          if ( $maintenance ) {
 312              $this->maintenance_mode( true );
 313          }
 314  
 315          $results = array();
 316  
 317          $this->update_count   = count( $plugins );
 318          $this->update_current = 0;
 319          foreach ( $plugins as $plugin ) {
 320              $this->update_current++;
 321              $this->skin->plugin_info = get_plugin_data( WP_PLUGIN_DIR . '/' . $plugin, false, true );
 322  
 323              if ( ! isset( $current->response[ $plugin ] ) ) {
 324                  $this->skin->set_result( 'up_to_date' );
 325                  $this->skin->before();
 326                  $this->skin->feedback( 'up_to_date' );
 327                  $this->skin->after();
 328                  $results[ $plugin ] = true;
 329                  continue;
 330              }
 331  
 332              // Get the URL to the zip file.
 333              $r = $current->response[ $plugin ];
 334  
 335              $this->skin->plugin_active = is_plugin_active( $plugin );
 336  
 337              $result = $this->run(
 338                  array(
 339                      'package'           => $r->package,
 340                      'destination'       => WP_PLUGIN_DIR,
 341                      'clear_destination' => true,
 342                      'clear_working'     => true,
 343                      'is_multi'          => true,
 344                      'hook_extra'        => array(
 345                          'plugin' => $plugin,
 346                      ),
 347                  )
 348              );
 349  
 350              $results[ $plugin ] = $this->result;
 351  
 352              // Prevent credentials auth screen from displaying multiple times.
 353              if ( false === $result ) {
 354                  break;
 355              }
 356          } // End foreach $plugins.
 357  
 358          $this->maintenance_mode( false );
 359  
 360          // Force refresh of plugin update information.
 361          wp_clean_plugins_cache( $parsed_args['clear_update_cache'] );
 362  
 363          /** This action is documented in wp-admin/includes/class-wp-upgrader.php */
 364          do_action(
 365              'upgrader_process_complete',
 366              $this,
 367              array(
 368                  'action'  => 'update',
 369                  'type'    => 'plugin',
 370                  'bulk'    => true,
 371                  'plugins' => $plugins,
 372              )
 373          );
 374  
 375          $this->skin->bulk_footer();
 376  
 377          $this->skin->footer();
 378  
 379          // Cleanup our hooks, in case something else does a upgrade on this connection.
 380          remove_filter( 'upgrader_clear_destination', array( $this, 'delete_old_plugin' ) );
 381  
 382          // Ensure any future auto-update failures trigger a failure email by removing
 383          // the last failure notification from the list when plugins update successfully.
 384          $past_failure_emails = get_option( 'auto_plugin_theme_update_emails', array() );
 385  
 386          foreach ( $results as $plugin => $result ) {
 387              // Maintain last failure notification when plugins failed to update manually.
 388              if ( ! $result || is_wp_error( $result ) || ! isset( $past_failure_emails[ $plugin ] ) ) {
 389                  continue;
 390              }
 391  
 392              unset( $past_failure_emails[ $plugin ] );
 393          }
 394  
 395          update_option( 'auto_plugin_theme_update_emails', $past_failure_emails );
 396  
 397          return $results;
 398      }
 399  
 400      /**
 401       * Check a source package to be sure it contains a plugin.
 402       *
 403       * This function is added to the {@see 'upgrader_source_selection'} filter by
 404       * Plugin_Upgrader::install().
 405       *
 406       * @since 3.3.0
 407       *
 408       * @global WP_Filesystem_Base $wp_filesystem WordPress filesystem subclass.
 409       *
 410       * @param string $source The path to the downloaded package source.
 411       * @return string|WP_Error The source as passed, or a WP_Error object
 412       *                         if no plugins were found.
 413       */
 414  	public function check_package( $source ) {
 415          global $wp_filesystem;
 416  
 417          $this->new_plugin_data = array();
 418  
 419          if ( is_wp_error( $source ) ) {
 420              return $source;
 421          }
 422  
 423          $working_directory = str_replace( $wp_filesystem->wp_content_dir(), trailingslashit( WP_CONTENT_DIR ), $source );
 424          if ( ! is_dir( $working_directory ) ) { // Sanity check, if the above fails, let's not prevent installation.
 425              return $source;
 426          }
 427  
 428          // Check that the folder contains at least 1 valid plugin.
 429          $files = glob( $working_directory . '*.php' );
 430          if ( $files ) {
 431              foreach ( $files as $file ) {
 432                  $info = get_plugin_data( $file, false, false );
 433                  if ( ! empty( $info['Name'] ) ) {
 434                      $this->new_plugin_data = $info;
 435                      break;
 436                  }
 437              }
 438          }
 439  
 440          if ( empty( $this->new_plugin_data ) ) {
 441              return new WP_Error( 'incompatible_archive_no_plugins', $this->strings['incompatible_archive'], __( 'No valid plugins were found.' ) );
 442          }
 443  
 444          $requires_php = isset( $info['RequiresPHP'] ) ? $info['RequiresPHP'] : null;
 445          $requires_wp  = isset( $info['RequiresWP'] ) ? $info['RequiresWP'] : null;
 446  
 447          if ( ! is_php_version_compatible( $requires_php ) ) {
 448              $error = sprintf(
 449                  /* translators: 1: Current PHP version, 2: Version required by the uploaded plugin. */
 450                  __( 'The PHP version on your server is %1$s, however the uploaded plugin requires %2$s.' ),
 451                  phpversion(),
 452                  $requires_php
 453              );
 454  
 455              return new WP_Error( 'incompatible_php_required_version', $this->strings['incompatible_archive'], $error );
 456          }
 457  
 458          if ( ! is_wp_version_compatible( $requires_wp ) ) {
 459              $error = sprintf(
 460                  /* translators: 1: Current WordPress version, 2: Version required by the uploaded plugin. */
 461                  __( 'Your WordPress version is %1$s, however the uploaded plugin requires %2$s.' ),
 462                  $GLOBALS['wp_version'],
 463                  $requires_wp
 464              );
 465  
 466              return new WP_Error( 'incompatible_wp_required_version', $this->strings['incompatible_archive'], $error );
 467          }
 468  
 469          return $source;
 470      }
 471  
 472      /**
 473       * Retrieve the path to the file that contains the plugin info.
 474       *
 475       * This isn't used internally in the class, but is called by the skins.
 476       *
 477       * @since 2.8.0
 478       *
 479       * @return string|false The full path to the main plugin file, or false.
 480       */
 481  	public function plugin_info() {
 482          if ( ! is_array( $this->result ) ) {
 483              return false;
 484          }
 485          if ( empty( $this->result['destination_name'] ) ) {
 486              return false;
 487          }
 488  
 489          // Ensure to pass with leading slash.
 490          $plugin = get_plugins( '/' . $this->result['destination_name'] );
 491          if ( empty( $plugin ) ) {
 492              return false;
 493          }
 494  
 495          // Assume the requested plugin is the first in the list.
 496          $pluginfiles = array_keys( $plugin );
 497  
 498          return $this->result['destination_name'] . '/' . $pluginfiles[0];
 499      }
 500  
 501      /**
 502       * Deactivates a plugin before it is upgraded.
 503       *
 504       * Hooked to the {@see 'upgrader_pre_install'} filter by Plugin_Upgrader::upgrade().
 505       *
 506       * @since 2.8.0
 507       * @since 4.1.0 Added a return value.
 508       *
 509       * @param bool|WP_Error $return Upgrade offer return.
 510       * @param array         $plugin Plugin package arguments.
 511       * @return bool|WP_Error The passed in $return param or WP_Error.
 512       */
 513  	public function deactivate_plugin_before_upgrade( $return, $plugin ) {
 514  
 515          if ( is_wp_error( $return ) ) { // Bypass.
 516              return $return;
 517          }
 518  
 519          // When in cron (background updates) don't deactivate the plugin, as we require a browser to reactivate it.
 520          if ( wp_doing_cron() ) {
 521              return $return;
 522          }
 523  
 524          $plugin = isset( $plugin['plugin'] ) ? $plugin['plugin'] : '';
 525          if ( empty( $plugin ) ) {
 526              return new WP_Error( 'bad_request', $this->strings['bad_request'] );
 527          }
 528  
 529          if ( is_plugin_active( $plugin ) ) {
 530              // Deactivate the plugin silently, Prevent deactivation hooks from running.
 531              deactivate_plugins( $plugin, true );
 532          }
 533  
 534          return $return;
 535      }
 536  
 537      /**
 538       * Turns on maintenance mode before attempting to background update an active plugin.
 539       *
 540       * Hooked to the {@see 'upgrader_pre_install'} filter by Plugin_Upgrader::upgrade().
 541       *
 542       * @since 5.4.0
 543       *
 544       * @param bool|WP_Error $return Upgrade offer return.
 545       * @param array         $plugin Plugin package arguments.
 546       * @return bool|WP_Error The passed in $return param or WP_Error.
 547       */
 548  	public function active_before( $return, $plugin ) {
 549          if ( is_wp_error( $return ) ) {
 550              return $return;
 551          }
 552  
 553          // Only enable maintenance mode when in cron (background update).
 554          if ( ! wp_doing_cron() ) {
 555              return $return;
 556          }
 557  
 558          $plugin = isset( $plugin['plugin'] ) ? $plugin['plugin'] : '';
 559  
 560          // Only run if plugin is active.
 561          if ( ! is_plugin_active( $plugin ) ) {
 562              return $return;
 563          }
 564  
 565          // Change to maintenance mode. Bulk edit handles this separately.
 566          if ( ! $this->bulk ) {
 567              $this->maintenance_mode( true );
 568          }
 569  
 570          return $return;
 571      }
 572  
 573      /**
 574       * Turns off maintenance mode after upgrading an active plugin.
 575       *
 576       * Hooked to the {@see 'upgrader_post_install'} filter by Plugin_Upgrader::upgrade().
 577       *
 578       * @since 5.4.0
 579       *
 580       * @param bool|WP_Error $return Upgrade offer return.
 581       * @param array         $plugin Plugin package arguments.
 582       * @return bool|WP_Error The passed in $return param or WP_Error.
 583       */
 584  	public function active_after( $return, $plugin ) {
 585          if ( is_wp_error( $return ) ) {
 586              return $return;
 587          }
 588  
 589          // Only disable maintenance mode when in cron (background update).
 590          if ( ! wp_doing_cron() ) {
 591              return $return;
 592          }
 593  
 594          $plugin = isset( $plugin['plugin'] ) ? $plugin['plugin'] : '';
 595  
 596          // Only run if plugin is active
 597          if ( ! is_plugin_active( $plugin ) ) {
 598              return $return;
 599          }
 600  
 601          // Time to remove maintenance mode. Bulk edit handles this separately.
 602          if ( ! $this->bulk ) {
 603              $this->maintenance_mode( false );
 604          }
 605  
 606          return $return;
 607      }
 608  
 609      /**
 610       * Deletes the old plugin during an upgrade.
 611       *
 612       * Hooked to the {@see 'upgrader_clear_destination'} filter by
 613       * Plugin_Upgrader::upgrade() and Plugin_Upgrader::bulk_upgrade().
 614       *
 615       * @since 2.8.0
 616       *
 617       * @global WP_Filesystem_Base $wp_filesystem WordPress filesystem subclass.
 618       *
 619       * @param bool|WP_Error $removed            Whether the destination was cleared.
 620       *                                          True on success, WP_Error on failure.
 621       * @param string        $local_destination  The local package destination.
 622       * @param string        $remote_destination The remote package destination.
 623       * @param array         $plugin             Extra arguments passed to hooked filters.
 624       * @return bool|WP_Error
 625       */
 626  	public function delete_old_plugin( $removed, $local_destination, $remote_destination, $plugin ) {
 627          global $wp_filesystem;
 628  
 629          if ( is_wp_error( $removed ) ) {
 630              return $removed; // Pass errors through.
 631          }
 632  
 633          $plugin = isset( $plugin['plugin'] ) ? $plugin['plugin'] : '';
 634          if ( empty( $plugin ) ) {
 635              return new WP_Error( 'bad_request', $this->strings['bad_request'] );
 636          }
 637  
 638          $plugins_dir     = $wp_filesystem->wp_plugins_dir();
 639          $this_plugin_dir = trailingslashit( dirname( $plugins_dir . $plugin ) );
 640  
 641          if ( ! $wp_filesystem->exists( $this_plugin_dir ) ) { // If it's already vanished.
 642              return $removed;
 643          }
 644  
 645          // If plugin is in its own directory, recursively delete the directory.
 646          // Base check on if plugin includes directory separator AND that it's not the root plugin folder.
 647          if ( strpos( $plugin, '/' ) && $this_plugin_dir !== $plugins_dir ) {
 648              $deleted = $wp_filesystem->delete( $this_plugin_dir, true );
 649          } else {
 650              $deleted = $wp_filesystem->delete( $plugins_dir . $plugin );
 651          }
 652  
 653          if ( ! $deleted ) {
 654              return new WP_Error( 'remove_old_failed', $this->strings['remove_old_failed'] );
 655          }
 656  
 657          return true;
 658      }
 659  }


Generated: Wed Aug 12 01:00:03 2020 Cross-referenced by PHPXref 0.7.1