artabro/site/modules/ProcessWireUpgrade/ProcessWireUpgrade.module

<?php namespace ProcessWire;

/**
 * Tool to display available core and module upgrades for ProcessWire
 *
 * ProcessWire 
 * Copyright (C) 2021 by Ryan Cramer 
 * Licensed under MPL 2.0
 * 
 * https://processwire.com
 *
 */

class ProcessWireUpgrade extends Process {

	/**
	 * Return information about this module (required)
	 *
	 */
	public static function getModuleInfo() {
		return array(
			'title' => 'Upgrades', 
			'summary' => 'Tool that helps you identify and install core and module upgrades.', 
			'version' => 11, 
			'author' => 'Ryan Cramer', 
			'installs' => 'ProcessWireUpgradeCheck', 
			'requires' => 'ProcessWire>=3.0.0',
			'icon' => 'coffee'
		); 
	}

	const debug = false; 
	const pageName = 'upgrades';
	const minVersionPHP = '5.3.8';
	
	/**
	 * Path to /wire/
	 *
	 */
	protected $wirePath = '';

	/**
	 * Temporary path used by installer for download and ZIP extraction
	 *
	 */
	protected $tempPath = '';

	/**
	 * Temporary path used by installer for file storage when file system isn't writable
 	 *
	 */
	protected $cachePath = '';

	/**
	 * Array of renames (oldPath => newPath) scheduled for __destruct
	 *
	 */
	protected $renames = array(); // scheduled renames to occur after page render

	/**
	 * Instance of ProcessWireUpgradeCheck
	 * 
	 * @var ProcessWireUpgradeCheck
	 *
	 */
	protected $checker = null;

	/**
	 * Construct
	 *
	 */
	public function __construct() {
		$this->initPaths();
		parent::__construct();
	}

	/**
	 * API wired
	 * 
	 */
	public function wired() {
		$this->initPaths(); // duplication from construct intended
		parent::wired();
	}

	/**
	 * Initialize and perform access checks
	 *
	 */
	public function init() {
		if($this->config->demo) {
			throw new WireException("This module cannot be used in demo mode");
		}
		if(!$this->user->isSuperuser()) {
			throw new WireException("This module requires superuser");
		}
		set_time_limit(3600); 
		$this->checker = $this->modules->getInstall('ProcessWireUpgradeCheck'); 
		if(!$this->checker) {
			throw new WireException("Please go to Modules and click 'Check for new modules' - this will auto-update ProcessWireUpgrade.");
		}
		parent::init();
	}

	/**
	 * Initialize paths used by this module
	 * 
	 */
	protected function initPaths() {
		$config = $this->wire()->config;
		$this->wirePath = $config->paths->root . 'wire/';
		$this->tempPath = $config->paths->cache . $this->className() . '/';
		$this->cachePath = $config->paths->cache . 'core-upgrade/';
	}

	/**
	 * Get info for either a specific core branch, or for the currently selected core branch
	 * 
	 * @param string $name
	 * @return array
	 *
	 */
	protected function getBranch($name = '') {
		$branches = $this->checker->getCoreBranches(); 
		if(empty($name)) $name = $this->session->getFor($this, 'branch');
		return isset($branches[$name]) ? $branches[$name] : array();
	}

	/**
	 * Set the current core branch
	 * 
	 * @param string $name
	 *
	 */
	protected function setBranch($name) {
		$this->session->setFor($this, 'branch', $name); 
	}

	/**
	 * Preflight checks before listing modules
	 * 
	 * @return string
	 * 
	 */
	protected function preflight() {
		
		$phpVersion = PHP_VERSION;
		
		if(version_compare($phpVersion, self::minVersionPHP) >= 0) {
			// good
		} else {
			$this->error("Please note that your current PHP version ($phpVersion) is not adequate to upgrade to the latest ProcessWire.");
		}

		if(!extension_loaded('pdo_mysql')) {
			$this->error("Your PHP is not compiled with PDO support. PDO is required by ProcessWire.");
		}

		if(!class_exists('\ZipArchive')) {
			$this->warning(
				"Your PHP does not have ZipArchive support. This is required to install core or module upgrades with this tool. " . 
				"You can still use this tool to identify new versions and install them manually."
			);
		}
		
		$upgradePaths = array($this->cachePath, $this->tempPath);

		foreach($upgradePaths as $key => $path) {
			if(!file_exists($path)) unset($upgradePaths[$key]);
		}

		if(count($upgradePaths)) {
			$btn = $this->modules->get('InputfieldButton'); /** @var InputfieldButton $btn */
			$btn->href = "./remove";
			$btn->value = $this->_('Remove');
			$btn->icon = 'trash-o';
			return
				$this->h('Upgrade files are already present. Please remove them before continuing.') . $this->ul($upgradePaths) . 
				$this->p($btn->render());
		}
		
		$lastRefresh = $this->session->getFor($this, 'lastRefresh');
		
		if(!$lastRefresh || $lastRefresh < (time() - 86400)) {
			$btn = $this->refreshButton();
			$btn->value = $this->_('Continue');
			$btn->icon = 'angle-right';
			return
				$this->h('We will load the latest core and module versions from the ProcessWire modules directory.') . 
				$this->p('Please be patient, this may take a few seconds to complete.') . 
				$this->p($btn->render()) .
				$this->lastRefreshInfo(); 
		}

		return '';
	}

	/**
	 * Ask user to select branch or make them remove existing installation files
	 *
	 */
	public function execute() {
		
		$sanitizer = $this->sanitizer;
		$config = $this->config;
		$modules = $this->modules;
		
		$preflight = $this->preflight();
		if($preflight) return $preflight;

		/** @var MarkupAdminDataTable $table */
		$table = $modules->get('MarkupAdminDataTable'); 
		$table->setEncodeEntities(false);
		$table->headerRow(array(
			$this->_('Module title'), 
			$this->_('Module name'), 
			$this->_('Installed'), 
			$this->_('Latest'),
			$this->_('Status'),
			$this->_('Links'),
		));

		$items = $this->checker->getVersions();
		$numPro = 0;
		
		if(count($items)) { 
			foreach($items as $name => $item) {
				if(empty($item['local'])) continue;
				if(empty($item['remote'])) { /* not in directory */ }
				
				$remote = $sanitizer->entities($item['remote']);
				$installer = empty($item['installer']) ? '' : $sanitizer->entities($item['installer']);
				$upgradeLabel = $this->_('Up-to-date'); 
				$links = [];
				
				if($item['new'] > 0) { 
					$upgradeLabel = $this->_('Upgrade available'); 
					$remote = $this->b($remote); 
				} else if($item['new'] < 0) { 
					$upgradeLabel .= '+';
				}
				if(empty($remote)) {
					$remote = "";
					$upgradeLabel = "";
				}
				if(empty($item['branch'])) {
					$upgradeURL = $config->urls->admin . "module/?update=" . ($installer ? $installer : $name);
				} else {
					$upgradeURL = "./check?branch=$item[branch]";
				}
				if($item['new'] > 0) {
					$upgradeLabel = $this->icon('lightbulb-o') . $upgradeLabel;
					$upgrade = $this->a($upgradeURL, $upgradeLabel);
				} else {
					$upgrade = $this->span($upgradeLabel, 'detail');
				}
				$urls = isset($item['urls']) ? $item['urls'] : array();
				foreach($urls as $key => $url) $urls[$key] = $sanitizer->entities($url);
				if(!empty($urls['support'])) {
					$links[] = $this->iconLink('life-ring', $urls['support'], 'Support'); 
				}
				if(!empty($urls['repo']) && strpos($urls['repo'], 'github.com')) {
					$links[] = $this->iconLink('github-alt', $urls['repo'], 'GitHub'); 
				} else if(!empty($urls['repo'])) {
					$links[] = $this->iconLink('info-circle', $urls['repo'], 'Details'); 
				} else if(!empty($item['href'])) {
					$links[] = $this->iconLink('info-circle', $item['href'], 'Info'); 
				}
				if(!empty($urls['dir'])) {
					$links[] = $this->iconLink('share-alt', $urls['dir'], 'Directory'); 
				}
				
				if(empty($remote) && empty($links)) continue;
				
				// else if(!$item['remote']) $upgrade = "<span class='detail'>" . $this->_('Not in directory') . "</span>";
				$icon = empty($item['icon']) ? wireIconMarkup('plug', 'fw') : wireIconMarkup($this->sanitizer->entities($item['icon']), 'fw');
				$title = $icon . ' ' . $sanitizer->entities($item['title']);
				$proLabel = ' ' . $this->span('PRO', 'pro');
				
				if($installer && empty($remote)) {
					$title = $this->tooltip("Upgraded with $installer", $title);
					if(!empty($item['pro'])) $title .= $proLabel;
					
				} else if(!empty($item['pro'])) {
					$title = $this->a($upgradeURL, $title) . $proLabel;
					if($item['new'] > 0) {
						if(!empty($urls['support'])) $upgradeURL = $urls['support'];
						$protip = 'PRO module upgrade available in ProcessWire VIP support board (login required)';
						$upgrade = $this->tooltip($protip, $this->aa($upgradeURL, $upgradeLabel));
						// $title = $this->tooltip($protip, $this->aa($upgradeURL, $title) . $proLabel);
					}
					$numPro++;
					
				} else {
					$title = $this->a($upgradeURL, $title); 
				}
				
				$table->row(array(
					$title,
					$sanitizer->entities($name), 
					$sanitizer->entities($item['local']), 
					$remote,
					$upgrade,
					$this->span(implode(' ', $links), 'links')
				));
			}
		}

		return
			$table->render() . 
			$this->p($this->refreshButton(true)->render()) . 
			$this->lastRefreshInfo();
	}

	/**
	 * Refresh module versions data
	 * 
	 */
	public function executeRefresh() {
		$this->session->setFor($this, 'lastRefresh', time());
		if(method_exists($this->modules, 'resetCache')) $this->modules->resetCache();
		$this->checker->getVersions(true);
		$this->message($this->_('Refreshed module versions data'));
		$this->session->redirect('./');
	}

	/**
	 * Remove existing installation files
	 *
	 */
	public function executeRemove() {
		$paths = array(
			$this->cachePath, 
			$this->tempPath,
		); 
		foreach($paths as $path) {
			if(!file_exists($path)) continue;
			if(wireRmdir($path, true)) {
				$this->session->message(sprintf($this->_('Removed: %s'), $path));
			} else {
				$this->session->error(sprintf($this->_('Permission error removing path (please remove manually): %s'), $path));
			}
		}	
		$this->session->redirect('./'); 
	}

	/**
	 * Check the selected branch and compare to current version to see if user wants to continue
	 *
	 */
	public function executeCheck() {

		$this->coreUpgrade();
		
		$config = $this->config;
		$input = $this->input; 
		$modules = $this->modules;
		
		if(!$config->debug) {
			$this->error(
				"While optional, we recommend that you enable debug mode during the upgrade so that you will see detailed error messages, should they occur. " . 
				"Do this by editing /site/config.php and setting the debug option to true. Example: \$config->debug = true;"
			); 
		}

		$name = $input->get('branch'); 
		if(empty($name)) throw new WireException("No branch selected"); 
		
		$branch = $this->getBranch($name);
		if(!count($branch)) throw new WireException("Unknown branch");
		
		$this->headline("ProcessWire Core ($name)");

		$this->setBranch($name); 
		$result = version_compare($config->version, $branch['version']);

		if($result < 0) { 
			$msg = "The available version ($branch[version]) is newer than the one you currently have ($config->version).";

		} else if($result > 0) {
			$msg = "The available version ($branch[version]) is older than the one you currently have ($config->version).";

		} else {
			$msg = "The available version is the same as the one you currently have.";
		}

		$out = $this->h("Do you want to download and install ProcessWire $branch[name] version $branch[version]?") . $this->p($msg); 
		
		/** @var InputfieldButton $btn */
		$btn = $modules->get('InputfieldButton'); 
		$btn->href = "./download";
		$btn->value = $this->_('Download Now'); 
		$btn->icon = 'cloud-download';
		$out .= $btn->render();

		$btn = $modules->get('InputfieldButton'); 
		$btn->href = "./"; 
		$btn->value = $this->_('Abort'); 
		$btn->icon = 'times-circle';
		$btn->addClass('ui-priority-secondary'); 
		$out .= $btn->render();

		$out .= $this->p("After clicking the download button, be patient, as this may take a minute.", 'detail');

		return $out; 
	}

	/**
	 * Download the selected branch ZIP file
	 *
	 */
	public function executeDownload() {
		
		$branch = $this->getBranch();
		if(empty($branch)) throw new WireException("No branch selected"); 

		wireMkdir($this->tempPath); 
		$http = new WireHttp();
		$this->wire($http);
		$zipfile = $http->download($branch['zipURL'], $this->tempPath . "$branch[name].zip"); 

		if(!$zipfile || !file_exists($zipfile) || !filesize($zipfile)) {
			throw new WireException("Unable to download $branch[zipURL]"); 
		}

		$this->message("Downloaded version $branch[version] (" . number_format(filesize($zipfile)) . " bytes)"); 
		$this->session->redirect('./database'); 
	}

	/**
	 * Export database or instruct them to do it
	 *
	 */
	public function executeDatabase() {
		
		$this->coreUpgrade();
		
		$config = $this->config;
		$input = $this->input; 
		$session = $this->session;
		$modules = $this->modules;

		$session->removeFor($this, 'database'); 
		$branch = $this->getBranch();
		$canBackup = class_exists('\\ProcessWire\\WireDatabaseBackup');

		if($input->get('backup') && $canBackup) {
			$options = array(
				'filename' => $config->dbName . "-" . $config->version . "-" . date('Y-m-d_H-i-s') . ".sql",
				'description' => "Automatic backup made by ProcessWireUpgrade before upgrading from {$config->version} to $branch[version]."
			);
			$backups = $this->database->backups();
			$file = $backups->backup($options); 
			$errors = $backups->errors();
			if(count($errors)) {
				foreach($errors as $error) $this->error($error);
			}
			if($file) {
				clearstatcache();
				$bytes = filesize($file); 
				$file = str_replace($config->paths->root, '/', $file); 
				$this->message("Backup saved to $file ($bytes bytes) - Please note this location should you later need to restore it."); 
				$session->setFor($this, 'database', $file); 
			} else {
				$this->error("Database backup failed"); 
			}
			$session->redirect('./prepare'); 
		}

		$out = $this->h('Database Backup'); 

		if($canBackup) {
			$out .= $this->p('Your version of ProcessWire supports automatic database backups.*');
			
			/** @var InputfieldButton $btn */
			$btn = $modules->get('InputfieldButton'); 
			$btn->href = "./database?backup=1";
			$btn->value = $this->_('Backup Database Now'); 
			$btn->icon = 'database';
			$out .= $btn->render();

			$btn = $modules->get('InputfieldButton'); 
			$btn->href = "./prepare";
			$btn->icon = 'angle-right';
			$btn->value = $this->_('Skip Database Backup'); 
			$btn->addClass('ui-priority-secondary'); 
			$out .= $btn->render();

			$out .= $this->p('*We also recommend creating an independent database backup, for instance with PhpMyAdmin.', 'detail');

		} else {
			$out .= $this->p(
				"Your current version of ProcessWire does not support automatic database backups. " . 
				"We recommend making a backup of database `$config->dbName` using a tool like PhpMyAdmin. " . 
				"Click the button below once you have saved a backup."
			);

			/** @var InputfieldButton $btn */
			$btn = $modules->get('InputfieldButton'); 
			$btn->href = "./prepare";
			$btn->icon = 'angle-right';
			$btn->value = $this->_('Confirm'); 
			$out .= $btn->render();
		}	

		return $this->out($out); 
	}

	/**
	 * Unzip files and prepare them for installation
	 *
	 */
	public function executePrepare() {
		
		$config = $this->config;
		$this->coreUpgrade();

		$error = '';
		$branch = $this->getBranch();
		if(empty($branch)) throw new WireException("No branch selected"); 
		$zipfile = $this->tempPath . "$branch[name].zip"; // site/assets/cache/ProcessWireUpgrade/branch-dev.zip

		if(!file_exists($zipfile)) throw new WireException("Unable to locate ZIP: $zipfile"); 
		$files = wireUnzipFile($zipfile, $this->tempPath); 
		if(!count($files)) $error = "No files were found in $zipfile";

		$oldVersion = $config->version;
		$newVersion = $branch['version'];

		$rootPath = dirname(rtrim($this->wirePath, '/')) . '/'; 
		$rootTempPath = $this->tempPath;  // site/assets/cache/ProcessWireUpgrade/
		$wireTempPath = $this->tempPath . 'wire/'; // site/assets/cache/ProcessWireUpgrade/wire/
		$wireNewName = "wire-$newVersion"; // wire-2.5.0

		if(!$error && !is_dir($wireTempPath)) {
			// adjust paths according to where they were unzipped, as needed
			// need to drill down a level from extracted archive
			// i.e. files[0] may be a dir like /ProcessWire-dev/
			$rootTempPath = $this->tempPath . trim($files[0], '/') . '/';
			$wireTempPath = $rootTempPath . "wire/";
			if(!is_dir($wireTempPath)) $error = "Unable to find /wire/ directory in archive";
		}

		$indexNewName = "index-$newVersion.php"; // index-2.5.0.php
		$htaccessNewName = "htaccess-$newVersion.txt"; // htaccess-2.5.0.txt
		
		$newIndexData = file_get_contents($rootTempPath . 'index.php');
		$newIndexVersion = preg_match('/define\("PROCESSWIRE", (\d+)\);/', $newIndexData, $matches) ? (int) $matches[1] : 0;
		$oldIndexData = file_get_contents($rootPath . 'index.php');
		$oldIndexVersion = preg_match('/define\("PROCESSWIRE", (\d+)\);/', $oldIndexData, $matches) ? (int) $matches[1] : 0;
		$indexIsOk = $newIndexVersion === $oldIndexVersion;
		
		$oldHtaccessData = file_get_contents($rootTempPath . 'htaccess.txt');
		$oldHtaccessVersion = preg_match('/@htaccessVersion\s+(\d+)/', $oldHtaccessData, $matches) ? (int) $matches[1] : 0;
		$newHtaccessData = file_get_contents($rootPath . '.htaccess');
		$newHtaccessVersion = preg_match('/@htaccessVersion\s+(\d+)/', $newHtaccessData, $matches) ? (int) $matches[1] : 0;
		$htaccessIsOk = $oldHtaccessVersion === $newHtaccessVersion;
	
		$rootWritable = is_writable($rootPath) && is_writable($rootPath . "wire/");

		// determine where we will be moving upgrade files to
		if($rootWritable) { 
			// if root path is writable, we can place new dirs/files in the same
			// location as what they are replacing, i.e. /wire/ and /wire-2.5.0/
			$wireNewPath = $rootPath . $wireNewName . "/";
			$htaccessNewFile = $rootPath . $htaccessNewName; 
			$indexNewFile = $rootPath . $indexNewName;

		} else {
			// if root is not writable, we will place dirs/files in /site/assets/cache/core-upgrade/ instead. 
			$cacheUpgradePath = $this->cachePath;
			$cacheUpgradeURL = str_replace($config->paths->root, '/', $cacheUpgradePath); 
			$this->warning(
				"Your file system is not writable, so we are installing files to $cacheUpgradeURL instead. " . 
				"You will have to copy them manually to your web root."
			); 
			wireMkdir($cacheUpgradePath); 
			$wireNewPath = $cacheUpgradePath . 'wire/';
			$htaccessNewFile = $cacheUpgradePath . 'htaccess.txt';
			$indexNewFile = $cacheUpgradePath . 'index.php';
		}

		if(!$error) {
			$this->renameNow($wireTempPath, $wireNewPath); // /temp/path/wire/ => /wire-2.5.0/
			$this->renameNow($rootTempPath . "index.php", $indexNewFile); // /temp/path/index.php => /index-2.5.0.php
			$this->renameNow($rootTempPath . "htaccess.txt", $htaccessNewFile); // /temp/path/htaccess.txt => /htaccess-2.5.0.txt
			// remove /temp/path/ as no longer needed since we've taken everything we need out of it above
			wireRmdir($this->tempPath, true); 
		}

		if($error) throw new WireException($error); 
		
		$wireNewLabel = str_replace($config->paths->root, '/', $wireNewPath); 
		$indexNewLabel = $rootWritable ? basename($indexNewFile) : str_replace($config->paths->root, '/', $indexNewFile); 
		$htaccessNewLabel = $rootWritable ? basename($htaccessNewFile) : str_replace($config->paths->root, '/', $htaccessNewFile);

		$out = 	
			$this->h('Upgrade files copied') . 
			$this->p(
				"We have prepared copies of upgrade files for installation. At this point, " .
				"you may install them yourself by replacing the existing `/wire/` directory with `$wireNewLabel`, " . 
				"and optionally `index.php` with `$indexNewLabel`, and `.htaccess` with `$htaccessNewLabel`. " . 
				($rootWritable ? "Or, since your file system is writable, this tool can install them." : "Full instructions are below.")
			);
		
		$items = array();

		if($indexIsOk) {
			$items[] = "Your `index.php` file appears to be up-to-date, it should be okay to leave your existing one in place.";
		} else {
			$items[] = "Your `index.php` file appears to need an update, check that you haven’t made any site-specific customizations to it before replacing it.";
		}

		if($htaccessIsOk) {
			$items[] = "Your `.htaccess` file appears to be up-to-date, it should be okay to leave your existing one in place.";
		} else {
			$items[] = "Your `.htaccess` file appears to need an update, check for any site-specific customizations before replacing it. You may want to apply updates to it manually.";
		}
		
		$out .= $this->ul($items);

		if($rootWritable) {

			$htaccessNote = '';
			if(!$htaccessIsOk) {
				$htaccessNote = 'Since the `.htaccess` file can often have site-specific customizations, it would be best to handle that one manually, unless you know it is unmodified.';
			}
				
			$out .= 
				$this->h('Want this tool to install the upgrade?') . 
				$this->p("Check the boxes below for what you’d like us to install. $htaccessNote");
			

			/** @var InputfieldSubmit $btn */
			$btn = $this->modules->get('InputfieldSubmit');
			$btn->attr('name', 'submit_install');
			$btn->value = $this->_('Install');
			$btn->icon = 'angle-right';

			$out .= 
				$this->form('./install/', 
					$this->p(
						$this->checkbox('wire', 'Install new core `/wire/` directory', "(old will be renamed to /.wire-$oldVersion/)", true) . 
						$this->checkbox('index', 'Install new `index.php` file', "(old will be renamed to .index-$oldVersion.php)", !$indexIsOk) . 
						$this->checkbox('htaccess', 'Install new `.htaccess` file', "(old will be renamed to .htaccess-$oldVersion)", false) 
					) . 
					$this->p($btn->render())
				);

		} else {
			// root not writable

			$backupInfo = array(
				"/wire" => "/.wire-$oldVersion", 
				"/index.php" => "/.index-$oldVersion.php", 
				"/.htaccess" => "/.htaccess-$oldVersion", 
			);
			
			$renameInfo = array(
				rtrim($wireNewPath, '/') => "/wire",
				"$indexNewFile" => "/index.php", 
				"$htaccessNewFile" => "/.htaccess", 
			);

			$out .= $this->p(
				"Your file system is not writable so we can’t automatically install the upgrade files for you. " . 
				"However, the files are ready for you to move to their destinations."
			);

			$out .= 
				$this->h('Backup your existing files') . 
				$this->p(
					"While optional, we strongly recommend making backups of everything replaced so that you can always revert back to it if needed. " . 
					"We recommend doing this by performing the following file rename operations:"
				);
			
			$items = array();
			foreach($backupInfo as $old => $new) {
				$items[] = "Rename `$old` to `$new`";
			}
			$out .= $this->ul($items);

			$out .= 
				$this->h('Migrate the new files') . 
				$this->p('Now you can migrate the new files, renaming them from their temporary location to their destination.'); 

			$items = array();
			foreach($renameInfo as $old => $new) {
				$old = str_replace($config->paths->root, '/', $old); 
				$items[] = "Rename `$old` to `$new`";
			}
			$out .= 
				$this->ul($items) . 
				$this->p('Once you’ve completed the above steps, your upgrade will be complete.') . 
				$this->completionNotes();
		}

		$out .= $this->p('*In many cases, it is not necessary to upgrade the index.php and .htaccess files since they don’t always change between versions.', 'detail');

		return $this->out($out); 
	}

	/**
	 * Install prepared files
	 *
	 */
	public function executeInstall() {
		
		$this->coreUpgrade();
		
		$input = $this->input;
		$config = $this->config;

		if(!$input->post('submit_install')) throw new WireException('No form received'); 
		
		$branch = $this->getBranch();
		if(empty($branch)) throw new WireException("No branch selected"); 
		
		$oldVersion = $config->version;
		$newVersion = $branch['version'];
		$rootPath = dirname(rtrim($this->wirePath, '/')) . '/'; 
		$renames = array();

		if($input->post('wire')) {
			$renames["wire"] = ".wire-$oldVersion";
			$renames["wire-$newVersion"] = "wire";
		}
		if($input->post('index')) {
			$renames["index.php"] = ".index-$oldVersion.php";
			$renames["index-$newVersion.php"] = "index.php";
		}
		if($input->post('htaccess')) { 
			$renames[".htaccess"] = ".htaccess-$oldVersion";
			$renames["htaccess-$newVersion.txt"] = ".htaccess";
		}

		foreach($renames as $old => $new) {
			$this->renameLater($rootPath . $old, $rootPath . $new); 
		}

		$out = 
			$this->h('Upgrade completed') . 
			$this->p($this->b('Double check that everything works before you leave this page')) . 
			$this->completionNotes();

		return $this->out($out); 
	}

	/**
	 * Completion notes
	 *
	 */
	protected function completionNotes() {
		
		$config = $this->config;
		$branch = $this->getBranch();
		$newVersion = $branch['version']; 
		$oldVersion = $config->version; 
		$dbFile = $this->session->getFor($this, 'database'); 
		$dbNote = '';
		
		if($dbFile) $dbNote = "Your database was backed up to this file:<br />`$dbFile`";
		
		$frontEndLink = $this->aa($config->urls->root, 'front-end'); 
		$adminLink = $this->aa($config->urls->admin, 'admin'); 
		$items = array();

		$items[] = "Test out both the $frontEndLink and $adminLink of your site in full to make sure everything works.";
		$items[] = "Installed files have permission `$config->chmodFile` and directories `$config->chmodDir`. Double check that these are safe with your web host, especially in a shared hosting environment.";

		if($config->debug) {
			$items[] = "For production sites, remember to turn off debug mode once your upgrade is complete.";
		}
		
		$out = $this->ul($items);
	
		$out .= 
			$this->p($this->b('If your upgrade did not work…')) . 
			$this->p(
				'If you encounter fatal error messages (in the front-end or admin links above), hit reload/refresh in that browser tab until it clears (2-3 times). ' . 
				'It may take a few requests for ProcessWire to apply any necessary database schema changes. ' . 
				'Should you determine that the upgrade failed for some reason and you want to revert back to the previous version, ' . 
				'below are the steps to undo what was just applied.'
			) . 
			$this->p('Step 1: Remove the installed updates by renaming or deleting them') . 
			$this->ul(array(
				"Delete `/wire/` directory OR rename it to `/.wire-$newVersion/`",
				"If you replaced the `.htaccess` file: Delete `.htaccess` OR rename it to `.htaccess-$newVersion`", 
				"If you replaced the `index.php` file: Delete `index.php` OR rename it to `.index-$newVersion.php`"
			)) . 
			$this->p('Step 2: Restore backed up files') . 
			$this->ul(array(
				"Rename directory `/.wire-$oldVersion/` to `/wire/`",
				"If applicable: Rename `.htaccess-$oldVersion` to `.htaccess`",
				"If applicable: Rename `.index-$oldVersion.php` to `index.php`",
			));
		
		if($dbNote) $out .= 
			$this->p('Step 3: Restore backed up database (if necessary)') . 
			$this->ul(array($dbNote)); 
			

		return $out;
	}

	/**
	 * Schedule a rename operation, which will occur at __destruct
	 * 
	 * @param string $oldPath
	 * @param string $newPath
	 *
	 */
	protected function renameLater($oldPath, $newPath) {
		$this->renames[$oldPath] = $newPath; 
		$old = basename(rtrim($oldPath, '/')); 
		$new = basename(rtrim($newPath, '/')); 
		$this->message("Rename $old => $new"); 
	}

	/**
	 * Perform a rename now
	 * 
	 * @param string $old
	 * @param string $new
	 * @return bool
	 * @throws WireException
	 *
	 */
	protected function renameNow($old, $new) {

		$result = true; 

		// for labels
		$_old = str_replace($this->config->paths->root, '/', $old); 
		$_new = str_replace($this->config->paths->root, '/', $new); 

		if(!file_exists($old)) {
			$this->error("$_old does not exist"); 
			return $result; 
		}

		if(file_exists($new)) {
			$this->message("$_new already exists (we left it untouched)"); 
			return $result; 
		}
	
		$result = rename($old, $new); 	

		if($result) { 
			$this->message("Renamed $_old => $_new"); 
		} else {
			$this->error("Unable to rename $_old => $_new"); 
			if(basename(rtrim($new, '/')) == 'wire') {
				throw new WireException("Upgrade aborted. Unable to rename $_old => $_new"); 
			}
		}

		return $result; 
	}
	
	protected function coreUpgrade() {
		$this->headline($this->_('Core upgrade')); 
	}

	/**
	 * @param bool $showInHeader
	 * @return InputfieldButton
	 * 
	 */
	protected function refreshButton($showInHeader = false) {
		/** @var InputfieldButton $btn */
		$btn = $this->modules->get('InputfieldButton');
		$btn->href = './refresh';
		$btn->value = $this->_('Refresh');
		$btn->icon = 'refresh';
		if($showInHeader && method_exists($btn, 'showInHeader')) $btn->showInHeader(true);
		return $btn;
	}

	/**
	 * @param bool $paragraph
	 * @return string
	 * 
	 */
	protected function lastRefreshInfo($paragraph = true) {
		$lastRefresh = $this->session->getFor($this, 'lastRefresh');
		$lastRefresh = $lastRefresh ? wireRelativeTimeStr($lastRefresh) : $this->_('N/A');
		$out = sprintf($this->_('Last refresh: %s'), $lastRefresh);
		if($paragraph) $out = $this->p($out, 'detail last-refresh-info');
		return $out;
	}

	/**
	 * Process rename operations
	 *
	 */
	public function __destruct() {
		if(!count($this->renames)) return;
		//$rootPath = dirname(rtrim($this->wirePath, '/')) . '/'; 
		foreach($this->renames as $oldPath => $newPath) {
			if(file_exists($newPath)) {	
				$n = 0;
				do { 
					$newPath2 = $newPath . "-" . (++$n); 
				} while(file_exists($newPath2)); 
				if(rename($newPath, $newPath2)) {
					$this->message("Renamed $newPath => $newPath2");
				}
			}
			$old = basename(rtrim($oldPath, '/')); 
			$new = basename(rtrim($newPath, '/')); 
			if(rename($oldPath, $newPath)) {
				$this->message("Renamed $old => $new"); 
			} else {
				$this->error("Unable to rename $old => $new"); 		
			}
		}
		$this->renames = array();
	}
	
	public function h($str, $h = 2) { return "<h$h>$str</h$h>"; }
	public function p($str, $class = '') { return $class ? "<p class='$class'>$str</p>" : "<p>$str</p>"; }
	public function a($href, $label, $class = '') { return ($class ? "<a class='$class' " : "<a ") . "href='" . $this->sanitizer->entities($href) . "'>$label</a>"; }
	public function aa($href, $label, $class = '') { return str_replace('<a', "<a target='_blank'", $this->a($href, $label, $class)); }
	public function span($str, $class = '') { return $class ? "<span class='$class'>$str</span>" : "<span>$str</span>"; }
	public function b($str, $class = '') { return $class ? "<strong class='$class'>$str</strong>" : "<strong>$str</strong>"; }
	public function ul(array $items) { return "<ul class='bullets'><li>" . implode('</li><li>', $items) . '</li></ul>'; }
	public function form($action, $content) { return "<form action='$action' method='post'>$content</form>"; }
	public function icon($name, $fw = true) { return wireIconMarkup($name, ($fw ? 'fw' : '')); }
	public function iconLink($icon, $href, $tooltip) { return str_replace('<a', "<a title='$tooltip'", $this->aa($href, $this->icon($icon), 'pw-tooltip')); }
	public function tooltip($tooltip, $markup) { return "<span class='pw-tooltip' title='$tooltip'>$markup</span>"; }
	
	public function checkbox($name, $label, $note = '', $checked = false) {
		$adminTheme = $this->wire()->adminTheme;
		$checkboxClass = $adminTheme ? $this->wire()->adminTheme->getClass('input-checkbox') : '';
		$checked = $checked ? 'checked' : '';
		$note = $note ? $this->span($note, 'detail') : '';
		return "<div><label><input type='checkbox' class='$checkboxClass' name='$name' $checked value='1'> $label $note</label></div>";
	}
	
	protected function out($out) {
		if(strpos($out, '`') === false) return $out;
		$out = preg_replace('/[`]([^<\n`]+?)[`]/', '<code>$1</code>', $out);
		return $out;
	}
	
	/**
	 * Install
	 *
	 */
	public function ___install() {

		// create the page our module will be assigned to
		$page = new Page();
		$page->template = 'admin';
		$page->name = self::pageName; 

		// installs to the admin "Setup" menu ... change as you see fit
		$page->parent = $this->pages->get($this->config->adminRootPageID)->child('name=setup');
		$page->process = $this; 

		// we will make the page title the same as our module title
		// but you can make it whatever you want
		$info = self::getModuleInfo();
		$page->title = $info['title'];

		// save the page
		$page->save();

		// tell the user we created this page
		$this->message("Created Page: {$page->path}"); 
	}

	/**
	 * Uninstall
	 *
	 */
	public function ___uninstall() {

		// find the page we installed, locating it by the process field (which has the module ID)
		// it would probably be sufficient just to locate by name, but this is just to be extra sure.
		$moduleID = $this->modules->getModuleID($this); 
		$page = $this->pages->get("template=admin, process=$moduleID, name=" . self::pageName . "|core-upgrade"); 

		if($page->id) {
			// if we found the page, let the user know and delete it
			$this->message("Deleting Page: {$page->path}"); 
			$page->delete();
		}

		wireRmdir($this->tempPath, true); 
	}

}