').html(title),
+ cache: false,
+ content: $content.html(),
+ closeable: true,
+ width: 450,
+ style: customRevertPopoverClass,
+ placement: 'left-bottom'
+ });
+
+ $link.on('hidden.webui.popover', function () {
+ $link.webuiPopover('destroy');
+ });
+
+ $link.webuiPopover('show');
+ }
+
+ function fillPopup($link, data) {
+ var $popupContent = $('.webui-popover-' + customRevertPopoverClass + ' .webui-popover-content');
+ $popupContent.html(data.body);
+
+ $('.webui-popover-' + customRevertPopoverClass).on('click', cancelButtonSelector, function (e) {
+ $link.webuiPopover('destroy');
+ return false;
+ });
+ }
+
+ var customCompatibilityPopoverClass = "versionpress-compatibility-popover"; // used to identify the popover later
+
+ $('.plugin-install .vp-compatibility').each(function () {
+ var $label = $(this);
+ var $parentCard = $label.parents('.plugin-card');
+ var $originalCompatibilityColumn = $parentCard.find('.column-compatibility');
+ var $vpCompatibilityColumn = $originalCompatibilityColumn.clone().empty();
+
+ $label.detach().appendTo($vpCompatibilityColumn);
+ $originalCompatibilityColumn.after($vpCompatibilityColumn);
+ $label.find('.hide-without-js').show();
+ });
+
+ function showCompatibilityPopup($element, $button, buttonText) {
+ if ($element.hasClass('vp-compatible')) {
+ return;
+ }
+ var pluginName = $element.data('plugin-name');
+ var incompatible = $element.hasClass('vp-incompatible');
+ var title = incompatible ? 'This will not end well' : 'Warning';
+ var content = '
' + pluginName + '' +
+ (incompatible ? ' is not compatible' : ' was not yet tested') + ' with VersionPress.
' +
+ '
Learn more
';
+ var buttons = '';
+
+ $button.webuiPopover({
+ title: title,
+ cache: false,
+ content: content + buttons,
+ closeable: true,
+ width: 450,
+ style: customCompatibilityPopoverClass,
+ placement: 'auto'
+ });
+
+ $button.on('click', function(e) {
+ e.stopImmediatePropagation();
+
+ $('.webui-popover-' + customCompatibilityPopoverClass).on('click', '.vp-cancel', function (e) {
+ $button.webuiPopover('hide');
+ return false;
+ });
+
+ return false;
+ });
+ }
+
+ $('.plugin-install .vp-compatibility').each(function () {
+ var $el = $(this);
+ var $list = $(this).closest('.plugin-card');
+ var $installButton = $list.find('.install-now');
+
+ showCompatibilityPopup($el, $installButton, 'Install');
+ });
+
+ $('.plugins .vp-compatibility').each(function () {
+ var $el = $(this);
+ var $list = $(this).closest('tr');
+ var $activateButton = $list.find('.activate a');
+
+ showCompatibilityPopup($el, $activateButton, 'Activate');
+ });
+});
diff --git a/mu-plugins/versionpress/admin/public/web.config b/mu-plugins/versionpress/admin/public/web.config
new file mode 100644
index 0000000..6e212f3
--- /dev/null
+++ b/mu-plugins/versionpress/admin/public/web.config
@@ -0,0 +1,10 @@
+
+
+
+
+
+
+
+
+
diff --git a/mu-plugins/versionpress/admin/system-info.php b/mu-plugins/versionpress/admin/system-info.php
new file mode 100644
index 0000000..f536a68
--- /dev/null
+++ b/mu-plugins/versionpress/admin/system-info.php
@@ -0,0 +1,98 @@
+
';
+ echo esc_html(var_export($array, true));
+ echo '';
+
+ break;
+
+ case 'tc':
+ \Tracy\Debugger::dump($array);
+ break;
+ }
+}
+
+?>
+
+
+
+
+
+
+
+
System info
+
+
Quick overview of this WordPress installation for VersionPress purposes.
+
+
+
+
+
+
Quick summary
+
+
+
+
Git
+
+
+
Permissions
+
+
+
WordPress
+
+
+
+
Server environment / PHP info
+
+
diff --git a/mu-plugins/versionpress/admin/undo.php b/mu-plugins/versionpress/admin/undo.php
new file mode 100644
index 0000000..90bcf01
--- /dev/null
+++ b/mu-plugins/versionpress/admin/undo.php
@@ -0,0 +1,77 @@
+resolve(VersionPressServices::GIT_REPOSITORY);
+/** @var Reverter $reverter */
+$reverter = $versionPressContainer->resolve(VersionPressServices::REVERTER);
+/** @var CommitMessageParser $commitMessageParser */
+$commitMessageParser = $versionPressContainer->resolve(VersionPressServices::COMMIT_MESSAGE_PARSER);
+
+$canRevert = $reverter->canRevert();
+$commit = $repository->getCommit($_GET['commit']);
+$changeInfo = $commitMessageParser->parse($commit->getMessage());
+
+$method = $_GET['method'];
+
+$title = ($method == 'undo')
+ ? "
Undo {$changeInfo->getChangeDescription()} ?
"
+ : "
Roll back to {$commit->getDate()->format('d-M-y H:i:s')} ?
";
+
+$message = "
+
+ For Developer Preview releases, please have a backup.
+
+ Learn more about reverts.
+
+
";
+
+$errors = (!$canRevert ? "
+
+ uncommitted changes in your WordPress directory.
" : "");
+
+$proceedUrl = add_query_arg([
+ 'action' => 'vp_' . $method,
+ 'commit' => $commit->getHash(),
+ '_wpnonce' => wp_create_nonce('vp_revert')
+], admin_url('admin.php'));
+
+$buttonProceed = "
Proceed ";
+$buttonCancel = "
Cancel ";
+
+$body = "
+
+ {$message}
+ {$errors}
+
+ {$buttonProceed}
+ {$buttonCancel}
+
+
+ ";
+
+if (vp_is_ajax()) {
+ $response = new stdClass();
+ $response->body = $body;
+ echo json_encode($response);
+ wp_die();
+} else {
+ echo "
{$title} ";
+ echo $body;
+}
diff --git a/mu-plugins/versionpress/bootstrap.php b/mu-plugins/versionpress/bootstrap.php
new file mode 100644
index 0000000..a07d686
--- /dev/null
+++ b/mu-plugins/versionpress/bootstrap.php
@@ -0,0 +1,83 @@
+resolve(VersionPressServices::DB_SCHEMA);
+ $committer = $versionPressContainer->resolve(VersionPressServices::COMMITTER);
+
+ $rules = $dbSchemaInfo->getRulesForFrequentlyWrittenEntities();
+
+ vp_save_frequently_written_entities($rules);
+
+ $committer->commit();
+}
+
+function vp_save_frequently_written_entities($rules)
+{
+ global $versionPressContainer;
+
+ /**
+ * @var DbSchemaInfo $dbSchemaInfo
+ * @var Database $database
+ * @var WpdbMirrorBridge $wpdbMirrorBridge
+ * @var StorageFactory $storageFactory
+ */
+ $dbSchemaInfo = $versionPressContainer->resolve(VersionPressServices::DB_SCHEMA);
+ $database = $versionPressContainer->resolve(VersionPressServices::DATABASE);
+ $wpdbMirrorBridge = $versionPressContainer->resolve(VersionPressServices::WPDB_MIRROR_BRIDGE);
+ $storageFactory = $versionPressContainer->resolve(VersionPressServices::STORAGE_FACTORY);
+
+ foreach ($rules as $entityName => $rulesWithInterval) {
+ $storageFactory->getStorage($entityName)->ignoreFrequentlyWrittenEntities = false;
+
+ $table = $dbSchemaInfo->getPrefixedTableName($entityName);
+
+ foreach ($rulesWithInterval as $ruleAndInterval) {
+ $restriction = QueryLanguageUtils::createSqlRestrictionFromRule($ruleAndInterval['rule']);
+ $sql = "SELECT * FROM $table WHERE $restriction";
+
+ $results = $database->get_results($sql, ARRAY_A);
+ foreach ($results as $data) {
+ $wpdbMirrorBridge->update($table, $data, $data);
+ }
+ }
+ }
+}
+
+function vp_enable_maintenance()
+{
+ $maintenance_string = '';
+ file_put_contents(ABSPATH . '.maintenance', $maintenance_string);
+}
+
+function vp_disable_maintenance()
+{
+ FileSystem::remove(ABSPATH . '.maintenance');
+}
+
+function vp_is_ajax()
+{
+ return isset($_SERVER['HTTP_X_REQUESTED_WITH']) && $_SERVER['HTTP_X_REQUESTED_WITH'] === 'XMLHttpRequest';
+}
+
+function vp_verify_nonce($name)
+{
+ if (!wp_verify_nonce(@$_REQUEST['_wpnonce'], $name)) {
+ wp_die(
+ '
' . __('Cheatin’ uh?') . ' ' .
+ '
' . __('Or maybe it\'s just a long time since you opened previous page. In this case please try it again.') . '
', // @codingStandardsIgnoreLine
+ 403
+ );
+ }
+}
+
+function vp_check_permissions()
+{
+ if (!current_user_can('manage_options')) {
+ wp_die(
+ '
' . __('Cheatin’ uh?') . ' ' .
+ '
' . __('You are not allowed to access VersionPress.') . '
',
+ 403
+ );
+ }
+}
+
+/**
+ * Multiple methods of disabling output buffering.
+ * @see http://www.binarytides.com/php-output-content-browser-realtime-buffering/
+ */
+function vp_disable_output_buffering()
+{
+ // Turn off output buffering
+ ini_set('output_buffering', 'off');
+ // Turn off PHP output compression
+ ini_set('zlib.output_compression', false);
+
+ // Flush (send) the output buffer and turn off output buffering
+ /** @noinspection PhpUsageOfSilenceOperatorInspection */
+ while (@ob_end_flush()) {
+ ;
+ }
+
+ // Implicitly flush the buffer(s)
+ ini_set('implicit_flush', true);
+ ob_implicit_flush(true);
+
+ //prevent apache from buffering it for deflate/gzip
+ header("Content-type: text/plain");
+ header('Cache-Control: no-cache'); // recommended to prevent caching of event data.
+
+ for ($i = 0; $i < 1000; $i++) {
+ echo ' ';
+ }
+
+ ob_flush();
+ flush();
+}
+
+/**
+ * Function used by Synchronizer - see `schema.yml`. It restores the `wp_posts.comment_count` column after sync.
+ *
+ * @param Database $database
+ */
+function vp_fix_comments_count($database)
+{
+ $sql = "update {$database->prefix}posts set comment_count =
+ (select count(*) from {$database->prefix}comments
+ where comment_post_ID = {$database->prefix}posts.ID and comment_approved = 1
+ );";
+
+ $database->query($sql);
+}
+
+/**
+ * Function used by Synchronizer - see `schema.yml`. It restores the `wp_term_taxonomy.count` column after sync.
+ *
+ * @param Database $database
+ */
+function vp_fix_posts_count($database)
+{
+ $sql = "update {$database->term_taxonomy} tt set tt.count =
+ (select count(*) from {$database->term_relationships} tr where tr.term_taxonomy_id = tt.term_taxonomy_id);";
+ $database->query($sql);
+}
+
+function vp_update_table_ddl_scripts(DbSchemaInfo $dbSchemaInfo, TableSchemaStorage $tableSchemaStorage)
+{
+ $tableSchemaStorage->deleteAll();
+
+ $entityNames = $dbSchemaInfo->getAllEntityNames();
+ foreach ($entityNames as $entityName) {
+ $table = $dbSchemaInfo->getPrefixedTableName($entityName);
+ $tableSchemaStorage->saveSchema($table);
+ }
+
+ $referenceDetails = $dbSchemaInfo->getAllMnReferences();
+ foreach ($referenceDetails as $referenceDetail) {
+ $table = $dbSchemaInfo->getPrefixedTableName($referenceDetail['junction-table']);
+ $tableSchemaStorage->saveSchema($table);
+ }
+}
+
+function vp_load_hooks_files()
+{
+ $plugins = wp_get_active_and_valid_plugins();
+
+ foreach ($plugins as $pluginFile) {
+ $pluginDir = dirname($pluginFile);
+ $pluginName = basename($pluginDir);
+ $hooksFile = \VersionPress\Actions\PluginDefinitionDiscovery::getPathForPlugin($pluginName, 'hooks.php');
+
+ if ($hooksFile) {
+ require_once $hooksFile;
+ }
+ }
+}
diff --git a/mu-plugins/versionpress/log/.gitignore b/mu-plugins/versionpress/log/.gitignore
new file mode 100644
index 0000000..e5394dc
--- /dev/null
+++ b/mu-plugins/versionpress/log/.gitignore
@@ -0,0 +1,7 @@
+# Ignore everything
+*
+
+# But not these...
+!.gitignore
+!.htaccess
+!web.config
\ No newline at end of file
diff --git a/mu-plugins/versionpress/public-functions.php b/mu-plugins/versionpress/public-functions.php
new file mode 100644
index 0000000..029165f
--- /dev/null
+++ b/mu-plugins/versionpress/public-functions.php
@@ -0,0 +1,29 @@
+forceChangeInfo. It will be replaced by less "invasive" function - Commmitter will
+ * have multiple equiqalent sources (not only Mirror).
+ *
+ * @param string $scope
+ * @param string $action
+ * @param string $id
+ * @param array $tags
+ * @param array $files
+ */
+function vp_force_action($scope, $action, $id = '', $tags = [], $files = [])
+{
+ global $versionPressContainer;
+ /** @var Committer $committer */
+ $committer = $versionPressContainer->resolve(VersionPressServices::COMMITTER);
+ /** @var ActionsInfoProvider $actionsInfoProvider */
+ $actionsInfoProvider = $versionPressContainer->resolve(VersionPressServices::ACTIONSINFO_PROVIDER_ACTIVE_PLUGINS);
+ $actionsInfo = $actionsInfoProvider->getActionsInfo($scope);
+
+ $changeInfo = new TrackedChangeInfo($scope, $actionsInfo, $action, $id, $tags, $files);
+ $committer->forceChangeInfo($changeInfo);
+}
diff --git a/mu-plugins/versionpress/setup-hooks.php b/mu-plugins/versionpress/setup-hooks.php
new file mode 100644
index 0000000..bfc5d9f
--- /dev/null
+++ b/mu-plugins/versionpress/setup-hooks.php
@@ -0,0 +1,924 @@
+resolve(VersionPressServices::COMMITTER);
+ /** @var Mirror $mirror */
+ $mirror = $versionPressContainer->resolve(VersionPressServices::MIRROR);
+ /** @var DbSchemaInfo $dbSchemaInfo */
+ $dbSchemaInfo = $versionPressContainer->resolve(VersionPressServices::DB_SCHEMA);
+ /** @var VpidRepository $vpidRepository */
+ $vpidRepository = $versionPressContainer->resolve(VersionPressServices::VPID_REPOSITORY);
+ /** @var WpdbMirrorBridge $wpdbMirrorBridge */
+ $wpdbMirrorBridge = $versionPressContainer->resolve(VersionPressServices::WPDB_MIRROR_BRIDGE);
+ /** @var \VersionPress\Database\Database $database */
+ $database = $versionPressContainer->resolve(VersionPressServices::DATABASE);
+ /** @var ActionsInfoProvider $actionsInfoProvider */
+ $actionsInfoProvider = $versionPressContainer->resolve(VersionPressServices::ACTIONSINFO_PROVIDER_ACTIVE_PLUGINS);
+
+
+
+ if (!function_exists('get_plugins')) {
+ require_once ABSPATH . 'wp-admin/includes/plugin.php';
+ }
+
+ vp_load_hooks_files();
+
+ add_filter('update_feedback', function () {
+ touch(ABSPATH . 'versionpress.maintenance');
+ });
+
+ WordPressMissingFunctions::pipeAction('_core_updated_successfully', 'vp_wordpress_updated');
+
+ add_action('activated_plugin', function ($pluginFile) {
+ $plugins = get_plugins();
+ $pluginName = $plugins[$pluginFile]['Name'];
+ do_action('vp_plugin_changed', 'activate', $pluginFile, $pluginName);
+ });
+
+ add_action('deactivated_plugin', function ($pluginFile) {
+ $plugins = get_plugins();
+ $pluginName = $plugins[$pluginFile]['Name'];
+ do_action('vp_plugin_changed', 'deactivate', $pluginFile, $pluginName);
+ });
+
+ add_action('upgrader_process_complete', function ($upgrader, $hook_extra) {
+ if ($hook_extra['type'] === 'theme') {
+ $themes = (isset($hook_extra['bulk']) && $hook_extra['bulk'] === true)
+ ? $hook_extra['themes']
+ : [$upgrader->result['destination_name']];
+
+ foreach ($themes as $stylesheet) {
+ $themeName = wp_get_theme($stylesheet)->get('Name');
+ if ($themeName === $stylesheet && isset($upgrader->skin->api, $upgrader->skin->api->name)) {
+ $themeName = $upgrader->skin->api->name;
+ }
+
+ // action can be "install" or "update", see WP_Upgrader and search for `'hook_extra' =>`
+ $action = $hook_extra['action'];
+ do_action('vp_theme_changed', $action, $stylesheet, $themeName);
+ }
+ }
+
+ if (!($hook_extra['type'] === 'plugin' && $hook_extra['action'] === 'update')) {
+ return; // handled by different hook
+ }
+
+ if (isset($hook_extra['bulk']) && $hook_extra['bulk'] === true) {
+ $pluginFiles = $hook_extra['plugins'];
+ } else {
+ $pluginFiles = [$hook_extra['plugin']];
+ }
+
+ $plugins = get_plugins();
+
+ foreach ($pluginFiles as $pluginFile) {
+ $pluginName = $plugins[$pluginFile]['Name'];
+ do_action('vp_plugin_changed', 'update', $pluginFile, $pluginName);
+ }
+ }, 10, 2);
+
+ add_filter('upgrader_pre_install', function ($_, $hook_extra) {
+ if (!(isset($hook_extra['type']) && $hook_extra['type'] === 'plugin' && $hook_extra['action'] === 'install')) {
+ return;
+ }
+
+ $pluginsBeforeInstallation = get_plugins();
+ $postInstallHook = function ($_, $hook_extra) use ($pluginsBeforeInstallation, &$postInstallHook) {
+ if (!($hook_extra['type'] === 'plugin' && $hook_extra['action'] === 'install')) {
+ return;
+ }
+
+ wp_cache_delete('plugins', 'plugins');
+ $pluginsAfterInstallation = get_plugins();
+ $installedPlugins = array_diff_key($pluginsAfterInstallation, $pluginsBeforeInstallation);
+
+ foreach ($installedPlugins as $pluginFile => $plugin) {
+ do_action('vp_plugin_changed', 'install', $pluginFile, $plugin['Name']);
+ }
+
+ remove_filter('upgrader_post_install', $postInstallHook);
+ };
+
+ add_filter('upgrader_post_install', $postInstallHook, 10, 2);
+ }, 10, 2);
+
+ add_filter('upgrader_pre_download', function ($reply, $_, $upgrader) use ($committer) {
+ if (!isset($upgrader->skin->language_update)) {
+ return $reply;
+ }
+
+ $languages = get_available_languages();
+
+ $postInstallHook = function ($_, $hook_extra) use ($committer, $languages, &$postInstallHook) {
+ if (!isset($hook_extra['language_update_type'])) {
+ return;
+ }
+
+ $type = $hook_extra['language_update_type'];
+ $languageCode = $hook_extra['language_update']->language;
+ $name = $type === "core" ? null : $hook_extra['language_update']->slug;
+ $action = in_array($languageCode, $languages) ? "update" : "install";
+
+ do_action('vp_translation_changed', $action, $languageCode, $type, $name);
+
+ remove_filter('upgrader_post_install', $postInstallHook);
+ };
+
+ add_filter('upgrader_post_install', $postInstallHook, 10, 2);
+ return false;
+ }, 10, 3);
+
+ add_action('switch_theme', function () use ($committer) {
+ if (defined('WP_CLI') && WP_CLI) {
+ wp_remote_get(admin_url());
+ } else {
+ $committer->disableCommit(); // the change will be committed on next load
+ }
+ });
+
+ add_action('after_switch_theme', function () use ($committer) {
+ $theme = wp_get_theme();
+ $stylesheet = $theme->get_stylesheet();
+ $themeName = $theme->get('Name');
+
+ do_action('vp_theme_changed', 'switch', $stylesheet, $themeName);
+ });
+
+ function _vp_get_language_name_by_code($code)
+ {
+ require_once(ABSPATH . 'wp-admin/includes/translation-install.php');
+
+ $translations = wp_get_available_translations();
+ return isset($translations[$code])
+ ? $translations[$code]['native_name']
+ : 'English (United States)';
+ }
+
+ add_action('add_option_WPLANG', function ($option, $value) use ($committer) {
+ $defaultLanguage = defined('WPLANG') ? WPLANG : '';
+ if ($value === $defaultLanguage) {
+ return; // It's just submitted settings form without changing language
+ }
+
+ do_action('vp_translation_changed', 'activate', $value);
+ }, 10, 2);
+
+ add_action('update_option_WPLANG', function ($oldValue, $newValue) use ($committer) {
+ do_action('vp_translation_changed', 'activate', $newValue);
+ }, 10, 2);
+
+ add_action('wp_update_nav_menu_item', function ($menu_id, $menu_item_db_id) use ($committer) {
+ $key = 'menu-item-' . $menu_item_db_id;
+ if (defined('DOING_AJAX') && DOING_AJAX && isset($_POST['action']) && $_POST['action'] === 'add-menu-item') {
+ $committer->postponeCommit($key);
+ $committer->commit();
+ } elseif (isset($_POST['action']) && $_POST['action'] === 'update') {
+ $committer->usePostponedChangeInfos($key);
+ }
+ }, 10, 2);
+
+ add_action('pre_delete_term', function ($termId, $taxonomy) use ($committer, $vpidRepository, $dbSchemaInfo, $actionsInfoProvider) {
+ $termVpid = $vpidRepository->getVpidForEntity('term', $termId);
+ $term = get_term($termId, $taxonomy);
+ $termEntityInfo = $dbSchemaInfo->getEntityInfo('term');
+ $actionsInfo = $actionsInfoProvider->getActionsInfo('term');
+
+ $changeInfo = new EntityChangeInfo($termEntityInfo, $actionsInfo, 'delete', $termVpid, ['VP-Term-Name' => $term->name, 'VP-Term-Taxonomy' => $taxonomy]);
+ $committer->forceChangeInfo($changeInfo);
+ }, 10, 2);
+
+ add_filter('wp_save_image_editor_file', function ($saved, $filename, $image, $mime_type, $post_id) use ($vpidRepository, $committer, $dbSchemaInfo, $actionsInfoProvider) {
+ $vpid = $vpidRepository->getVpidForEntity('post', $post_id);
+ $post = get_post($post_id);
+ $actionsInfo = $actionsInfoProvider->getActionsInfo('post');
+
+ $changeInfo = new EntityChangeInfo($dbSchemaInfo->getEntityInfo('post'), $actionsInfo, 'update', $vpid, ['VP-Post-Type' => $post->post_type, 'VP-Post-Title' => $post->post_title]);
+ $committer->forceChangeInfo($changeInfo);
+ }, 10, 5);
+
+ add_filter('plugin_install_action_links', function ($links, $plugin) {
+ $compatibility = CompatibilityChecker::testCompatibilityBySlug($plugin['slug']);
+ if ($compatibility === CompatibilityResult::COMPATIBLE) {
+ $cssClass = 'vp-compatible';
+ $compatibilityAdjective = 'Compatible';
+ } elseif ($compatibility === CompatibilityResult::INCOMPATIBLE) {
+ $cssClass = 'vp-incompatible';
+ // @codingStandardsIgnoreLine
+ $compatibilityAdjective = '
Incompatible ';
+ } else {
+ $cssClass = 'vp-untested';
+ // @codingStandardsIgnoreLine
+ $compatibilityAdjective = '
Untested ';
+ }
+
+ // @codingStandardsIgnoreLine
+ $compatibilityNotice = '
%s with VersionPress';
+ $links[] = sprintf($compatibilityNotice, $cssClass, $plugin['name'], $compatibilityAdjective);
+
+ return $links;
+ }, 10, 2);
+
+ add_filter('plugin_row_meta', function ($plugin_meta, $plugin_file, $plugin_data, $status) {
+ if ($status === "dropins") {
+ return $plugin_meta;
+ }
+ $compatibility = CompatibilityChecker::testCompatibilityByPluginFile($plugin_file);
+ if ($compatibility === CompatibilityResult::COMPATIBLE) {
+ $cssClass = 'vp-compatible';
+ $compatibilityAdjective = 'Compatible';
+ } elseif ($compatibility === CompatibilityResult::INCOMPATIBLE) {
+ $cssClass = 'vp-incompatible';
+ // @codingStandardsIgnoreLine
+ $compatibilityAdjective = '
Incompatible ';
+ } elseif ($compatibility === CompatibilityResult::UNTESTED) {
+ $cssClass = 'vp-untested';
+ // @codingStandardsIgnoreLine
+ $compatibilityAdjective = '
Untested ';
+ } else {
+ return $plugin_meta;
+ }
+
+ // @codingStandardsIgnoreLine
+ $compatibilityNotice = '
%s with VersionPress';
+ $plugin_meta[] = sprintf($compatibilityNotice, $cssClass, $plugin_data['Name'], $compatibilityAdjective);
+
+ return $plugin_meta;
+ }, 10, 4);
+
+ add_filter('plugin_action_links', function ($actions, $plugin_file) {
+ $compatibility = CompatibilityChecker::testCompatibilityByPluginFile($plugin_file);
+
+ if (isset($actions['activate'])) {
+ if ($compatibility === CompatibilityResult::UNTESTED) {
+ $actions['activate'] = "
$actions[activate] ";
+ } elseif ($compatibility === CompatibilityResult::INCOMPATIBLE) {
+ $actions['activate'] = "
$actions[activate] ";
+ }
+ }
+ return $actions;
+ }, 10, 2);
+
+ add_action('vp_revert', function ($modifiedFiles) {
+ // We have to flush the rewrite rules in the next request, because
+ // in the current one the changed rewrite rules are not yet effective.
+ set_transient('vp_flush_rewrite_rules', 1);
+ vp_flush_regenerable_options();
+
+ // Update composer dependencies
+ if (array_search('composer.lock', $modifiedFiles) || array_search('composer.json', $modifiedFiles)) {
+ putenv('COMPOSER_HOME=' . VP_PROJECT_ROOT . '/vendor/bin/composer');
+ $originalCwd = getcwd();
+ chdir(VP_PROJECT_ROOT);
+
+ $input = new \Symfony\Component\Console\Input\ArrayInput(['command' => 'install']);
+ $output = new \Symfony\Component\Console\Output\NullOutput();
+ $application = new \Composer\Console\Application();
+ $application->setAutoExit(false); // prevent `$application->run` method from exitting the script
+ $application->run($input, $output);
+ $application->getComposer();
+ chdir($originalCwd);
+ }
+ });
+
+ add_action('pre_delete_term', function ($term, $taxonomy) use ($database, $wpdbMirrorBridge) {
+ if (!is_taxonomy_hierarchical($taxonomy)) {
+ return;
+ }
+
+ $term = get_term($term, $taxonomy);
+ if (is_wp_error($term)) {
+ return;
+ }
+
+ $wpdbMirrorBridge->update($database->term_taxonomy, ['parent' => $term->parent], ['parent' => $term->term_id]);
+ }, 10, 2);
+
+ add_action('before_delete_post', function ($postId) use ($database, $wpdbMirrorBridge) {
+ // Fixing bug in WP (#34803) and WP-CLI (#2246);
+ $post = get_post($postId);
+ if (!is_wp_error($post) && $post->post_type === 'nav_menu_item') {
+ $newParent = get_post_meta($post->ID, '_menu_item_menu_item_parent', true);
+ $wpdbMirrorBridge->update(
+ $database->postmeta,
+ ['meta_value' => $newParent],
+ ['meta_key' => '_menu_item_menu_item_parent', 'meta_value' => $post->ID]
+ );
+ $database->update(
+ $database->postmeta,
+ ['meta_value' => $newParent],
+ ['meta_key' => '_menu_item_menu_item_parent', 'meta_value' => $post->ID]
+ );
+ }
+ });
+
+ //----------------------------------------
+ // URL and WP-CLI "hooks"
+ //----------------------------------------
+
+ $requestDetector = new \VersionPress\Utils\RequestDetector();
+
+ if ($requestDetector->isThemeDeleteRequest()) {
+ $themeIds = $requestDetector->getThemeStylesheets();
+ foreach ($themeIds as $stylesheet) {
+ $themeName = wp_get_theme($stylesheet)->get('Name');
+ do_action('vp_theme_changed', 'delete', $stylesheet, $themeName);
+ }
+ }
+
+ if ($requestDetector->isPluginDeleteRequest()) {
+ $pluginNames = $requestDetector->getPluginNames();
+ $plugins = get_plugins();
+
+ foreach ($pluginNames as $plugin) {
+ do_action('vp_plugin_changed', 'delete', $plugin, $plugins[$plugin]['Name']);
+ }
+ }
+
+ if ($requestDetector->isCoreLanguageUninstallRequest()) {
+ $languageCode = $requestDetector->getLanguageCode();
+ do_action('vp_translation_changed', 'uninstall', $languageCode);
+ }
+
+ if (basename($_SERVER['PHP_SELF']) === 'theme-editor.php' && isset($_GET['updated']) && $_GET['updated'] === 'true') {
+ $stylesheet = $_GET['theme'];
+ $themeName = wp_get_theme($stylesheet)->get('Name');
+
+ do_action('vp_theme_changed', 'update', $stylesheet, $themeName);
+ }
+
+ if (basename($_SERVER['PHP_SELF']) === 'plugin-editor.php' &&
+ ((isset($_POST['action']) && $_POST['action'] === 'update') || isset($_GET['liveupdate'])
+ )
+ ) {
+ $committer->disableCommit();
+ }
+
+ if (basename($_SERVER['PHP_SELF']) === 'plugin-editor.php' && isset($_GET['a']) && $_GET['a'] === 'te') {
+ if (!function_exists('get_plugins')) {
+ require_once ABSPATH . 'wp-admin/includes/plugin.php';
+ }
+
+ $editedFile = $_GET['file'];
+ $editedFilePathParts = preg_split("~[/\\\\]~", $editedFile);
+ $plugins = get_plugins();
+ $pluginNames = array_keys($plugins);
+ $bestRank = 0;
+ $bestMatch = "";
+
+ foreach ($pluginNames as $plugin) {
+ $rank = 0;
+ $pluginPathParts = preg_split("~[/\\\\]~", $plugin);
+ $maxEqualParts = min(count($editedFilePathParts), count($pluginPathParts));
+
+ for ($part = 0; $part < $maxEqualParts; $part++) {
+ if ($editedFilePathParts[$part] !== $pluginPathParts[$part]) {
+ break;
+ }
+ $rank += 1;
+ }
+
+ if ($rank > $bestRank) {
+ $bestRank = $rank;
+ $bestMatch = $plugin;
+ }
+ }
+
+ do_action('vp_plugin_changed', 'update', $bestMatch, $plugins[$bestMatch]['Name']);
+ }
+
+ add_filter('cron_schedules', function ($schedules) use ($dbSchemaInfo) {
+ $intervals = $dbSchemaInfo->getIntervalsForFrequentlyWrittenEntities();
+
+ foreach ($intervals as $interval) {
+ if (isset($schedules[$interval])) {
+ continue;
+ }
+
+ $seconds = strtotime($interval, 0);
+ $schedules[$interval] = [
+ 'interval' => $seconds,
+ 'display' => $interval
+ ];
+ }
+
+ return $schedules;
+ });
+
+ $r = $dbSchemaInfo->getRulesForFrequentlyWrittenEntities();
+ $groupedByInterval = [];
+ foreach ($r as $entityName => $rules) {
+ foreach ($rules as $rule) {
+ $groupedByInterval[$rule['interval']][$entityName][] = $rule;
+ }
+ }
+
+ foreach ($groupedByInterval as $interval => $allRulesInInterval) {
+ $actionName = "vp_commit_frequently_written_entities_$interval";
+ if (!wp_next_scheduled($actionName)) {
+ wp_schedule_event(time(), $interval, $actionName);
+ }
+
+ add_action($actionName, function () use ($allRulesInInterval) {
+ vp_save_frequently_written_entities($allRulesInInterval);
+ });
+ }
+
+ if (!function_exists('get_plugins')) {
+ require_once ABSPATH . 'wp-admin/includes/plugin.php';
+ }
+
+ register_shutdown_function([$committer, 'commit']);
+}
+
+//----------------------------------
+// Activation and deactivation
+//----------------------------------
+
+register_activation_hook(VERSIONPRESS_PLUGIN_FILE, 'vp_activate');
+register_deactivation_hook(VERSIONPRESS_PLUGIN_FILE, 'vp_deactivate');
+add_action('admin_post_cancel_deactivation', 'vp_admin_post_cancel_deactivation');
+add_action('admin_post_confirm_deactivation', 'vp_admin_post_confirm_deactivation');
+add_action('send_headers', 'vp_send_headers');
+
+if (get_transient('vp_just_activated')) {
+ add_filter('gettext', 'vp_gettext_filter_plugin_activated', 10, 3);
+}
+// uninstallation is handled in uninstall.php
+
+/**
+ * We hook to `gettext` filter to update the "plugin activated" message with a link
+ * to VP initializer. See [WP-66].
+ *
+ * @param string $translation Translated text.
+ * @param string $text Text to translate.
+ * @param string $domain Text domain. Unique identifier for retrieving translated strings.
+ * @return string
+ */
+function vp_gettext_filter_plugin_activated($translation, $text, $domain)
+{
+ if ($text == 'Plugin
activated .' && get_transient('vp_just_activated')) {
+ delete_transient('vp_just_activated');
+ // @codingStandardsIgnoreLine
+ return 'VersionPress activated.
Continue here to start tracking the site.';
+ } else {
+ return $translation;
+ }
+}
+
+/**
+ * Activates the plugin from a WordPress point of view. Note that for VersionPress
+ * to become fully active, the Initializer needs to be run.
+ *
+ * @see Initializer
+ */
+function vp_activate()
+{
+ WpConfigSplitter::split(WordPressMissingFunctions::getWpConfigPath());
+ set_transient('vp_just_activated', '1', 10);
+}
+
+/**
+ * Deactivation is a two-step process with a warning screen. See
+ * `vp_admin_post_cancel_deactivation()` and `vp_admin_post_confirm_deactivation()`
+ *
+ * @see vp_admin_post_confirm_deactivation()
+ * @see vp_admin_post_cancel_deactivation()
+ */
+function vp_deactivate()
+{
+ if (defined('WP_CLI') || !VersionPress::isActive()) {
+ vp_admin_post_confirm_deactivation();
+ } else {
+ wp_safe_redirect(admin_url('admin.php?page=versionpress/admin/deactivate.php'));
+ die();
+ }
+}
+
+/**
+ * Handles a situation where user canceled the deactivation
+ */
+function vp_admin_post_cancel_deactivation()
+{
+ wp_safe_redirect(admin_url('plugins.php'));
+ exit();
+}
+
+/**
+ * Most of the actual deactivation work is done here. Called either as a response
+ * to the user confirming the deactivation on `?page=versionpress/admin/deactivate.php`
+ * or is called directly from vp_deactivate() if the confirmation screen was not necessary.
+ */
+function vp_admin_post_confirm_deactivation()
+{
+ //nonce verification is performed according to 'deactivate-plugin_versionpress/versionpress.php'
+ // as a standard deactivation token for which nonce is generated
+ if (!defined('WP_CLI')) {
+ vp_verify_nonce('deactivate-plugin_versionpress/versionpress.php');
+ vp_check_permissions();
+ }
+
+ define('VP_DEACTIVATING', true);
+
+ if (WpdbReplacer::isReplaced()) {
+ WpdbReplacer::restoreOriginal();
+ }
+
+ if (file_exists(VERSIONPRESS_ACTIVATION_FILE)) {
+ FileSystem::remove(VERSIONPRESS_ACTIVATION_FILE);
+ }
+
+ $filesChangedByDeactivation = [
+ ["type" => "path", "path" => VP_VPDB_DIR . "/*"],
+ ["type" => "path", "path" => ABSPATH . WPINC . "/wp-db.php"],
+ ["type" => "path", "path" => ABSPATH . WPINC . "/wp-db.php.original"],
+ ["type" => "path", "path" => ABSPATH . "/.gitattributes"],
+ ];
+
+ vp_force_action('versionpress', 'deactivate', null, [], $filesChangedByDeactivation);
+
+ MergeDriverInstaller::uninstallMergeDriver(VP_PROJECT_ROOT, VERSIONPRESS_PLUGIN_DIR, VP_VPDB_DIR);
+
+ deactivate_plugins("versionpress/versionpress.php", true);
+
+ if (defined('WP_ADMIN')) {
+ wp_safe_redirect(admin_url("plugins.php"));
+ exit();
+ }
+}
+
+function vp_send_headers()
+{
+ if (isset($_GET['init_versionpress']) && !VersionPress::isActive()) {
+ vp_disable_output_buffering();
+ }
+}
+
+add_action('admin_notices', 'vp_activation_nag', 4 /* WP update nag is 3, we are just one step less important :) */);
+
+/**
+ * Displays the activation nag
+ */
+function vp_activation_nag()
+{
+
+ if (VersionPress::isActive() ||
+ get_current_screen()->id == "toplevel_page_versionpress" ||
+ get_current_screen()->id == "versionpress/admin/index" ||
+ get_current_screen()->id == "versionpress/admin/deactivate"
+ ) {
+ return;
+ }
+
+ if (get_transient('vp_just_activated')) {
+ return;
+ }
+
+ // @codingStandardsIgnoreLine
+ echo "
";
+}
+
+add_action("after_plugin_row_versionpress/versionpress.php", 'vp_display_activation_notice', 10, 2);
+
+function vp_display_activation_notice($file, $plugin_data)
+{
+ if (VersionPress::isActive()) {
+ return;
+ }
+
+ $wp_list_table = _get_list_table('WP_Plugins_List_Table');
+ $activationUrl = menu_page_url('versionpress', false);
+ // @codingStandardsIgnoreStart
+ echo '
';
+}
+
+
+add_filter('wp_insert_post_data', 'vp_generate_post_guid', '99', 2);
+add_filter('wp_insert_attachment_data', 'vp_generate_post_guid', '99', 2);
+/**
+ * Creates random GUID that is not based on URL
+ *
+ * @param array $data Sanitized post data
+ * @param array $postarr Raw post data
+ * @return array
+ */
+function vp_generate_post_guid($data, $postarr)
+{
+ if (!VersionPress::isActive()) {
+ return $data;
+ }
+
+ if (empty($postarr['ID'])) { // it's insert not update
+ $protocol = is_ssl() ? 'https://' : 'http://';
+ $data['guid'] = $protocol . IdUtil::newUuid();
+ }
+
+ return $data;
+}
+
+
+//----------------------------------
+// Menu
+//----------------------------------
+
+
+add_action('admin_menu', 'vp_admin_menu');
+
+function vp_admin_menu()
+{
+ add_menu_page(
+ 'VersionPress',
+ 'VersionPress',
+ 'manage_options',
+ 'versionpress',
+ 'versionpress_page',
+ null,
+ 0.001234987
+ );
+
+ // Support for PHP files that should not appear in the menu but should still be accessible via URL
+ // like `/wp-admin/admin.php?page=versionpress/admin/xyz.php`
+ //
+ // We need to add it to $_registered_pages, see http://blog.wpessence.com/wordpress-admin-page-without-menu-item/
+
+ $directAccessPages = [
+ 'deactivate.php',
+ 'system-info.php',
+ 'undo.php',
+ 'index.php'
+ ];
+
+ global $_registered_pages;
+ foreach ($directAccessPages as $directAccessPage) {
+ $menu_slug = plugin_basename("versionpress/admin/$directAccessPage");
+ $hookname = get_plugin_page_hookname($menu_slug, '');
+ $_registered_pages[$hookname] = true;
+ }
+}
+
+function versionpress_page()
+{
+ require_once(VERSIONPRESS_PLUGIN_DIR . '/admin/index.php');
+}
+
+add_action('admin_action_vp_show_undo_confirm', 'vp_show_undo_confirm');
+
+function vp_show_undo_confirm()
+{
+ if (vp_is_ajax()) {
+ require_once(VERSIONPRESS_PLUGIN_DIR . '/admin/undo.php');
+ } else {
+ // @codingStandardsIgnoreLine
+ wp_safe_redirect(admin_url('admin.php?page=versionpress/admin/undo.php&method=' . $_GET['method'] . '&commit=' . $_GET['commit']));
+ exit();
+ }
+}
+
+add_action('admin_action_vp_undo', 'vp_undo');
+
+function vp_undo()
+{
+ _vp_revert('undo');
+}
+
+add_action('admin_action_vp_rollback', 'vp_rollback');
+
+function vp_rollback()
+{
+ _vp_revert('rollback');
+}
+
+function _vp_revert($reverterMethod)
+{
+ global $versionPressContainer;
+
+ vp_verify_nonce('vp_revert');
+ vp_check_permissions();
+
+ $commitHash = $_GET['commit'];
+
+ if (!preg_match('/^[0-9a-f]+$/', $commitHash)) {
+ exit();
+ }
+
+ /** @var Reverter $reverter */
+ $reverter = $versionPressContainer->resolve(VersionPressServices::REVERTER);
+
+ vp_enable_maintenance();
+ $revertStatus = call_user_func([$reverter, $reverterMethod], [$commitHash]);
+ vp_disable_maintenance();
+ $adminPage = menu_page_url('versionpress', false);
+
+ if ($revertStatus !== RevertStatus::OK) {
+ wp_safe_redirect(add_query_arg('error', $revertStatus, $adminPage));
+ } else {
+ wp_safe_redirect($adminPage);
+ }
+ exit();
+}
+
+if (VersionPress::isActive()) {
+ add_action('admin_bar_menu', 'vp_admin_bar_warning');
+}
+
+function vp_admin_bar_warning(WP_Admin_Bar $adminBar)
+{
+ if (!current_user_can('manage_options')) {
+ return;
+ }
+
+ // @codingStandardsIgnoreStart
+ $adminBarText = "
VersionPress running ";
+ $popoverTitle = "Note";
+ $popoverText = "
You are running VersionPress " . VersionPress::getVersion() . " which is a Developer Preview release . As such, it might not fully support certain workflows, 3rd party plugins, hosts etc.We recommend that you keep a safe backup of the site at all times
";
+ $popoverText .= "
Learn more about VersionPress releases
";
+
+ $adminBar->add_node([
+ 'id' => 'vp-running',
+ 'title' => "
$adminBarText
+ ",
+ 'parent' => 'top-secondary'
+ ]);
+ // @codingStandardsIgnoreEnd
+}
+
+//----------------------------------
+// AJAX handling
+//----------------------------------
+
+add_action('wp_ajax_hide_vp_welcome_panel', 'vp_ajax_hide_vp_welcome_panel');
+
+function vp_ajax_hide_vp_welcome_panel()
+{
+ update_user_meta(get_current_user_id(), VersionPressOptions::USER_META_SHOW_WELCOME_PANEL, "0");
+ die(); // this is required to return a proper result
+}
+
+add_action('wp_ajax_vp_show_undo_confirm', 'vp_show_undo_confirm');
+
+//----------------------------------
+// CSS & JS
+//----------------------------------
+
+add_action('admin_enqueue_scripts', 'vp_enqueue_styles_and_scripts');
+add_action('wp_enqueue_scripts', 'vp_enqueue_styles_and_scripts');
+function vp_enqueue_styles_and_scripts()
+{
+ if (is_admin_bar_showing()) {
+ $vpVersion = VersionPress::getVersion();
+ wp_enqueue_style(
+ 'versionpress_popover_style',
+ plugins_url('admin/public/css/jquery.webui-popover.min.css', VERSIONPRESS_PLUGIN_FILE),
+ [],
+ $vpVersion
+ );
+ wp_enqueue_style(
+ 'versionpress_popover_custom_style',
+ plugins_url('admin/public/css/popover-custom.css', VERSIONPRESS_PLUGIN_FILE),
+ [],
+ $vpVersion
+ );
+
+ wp_enqueue_script('jquery');
+ wp_enqueue_script(
+ 'versionpress_popover_script',
+ plugins_url('admin/public/js/jquery.webui-popover.min.js', VERSIONPRESS_PLUGIN_FILE),
+ array('jquery'),
+ $vpVersion
+ );
+ }
+}
+
+add_action('admin_enqueue_scripts', 'vp_enqueue_admin_styles_and_scripts');
+function vp_enqueue_admin_styles_and_scripts()
+{
+ $vpVersion = VersionPress::getVersion();
+ wp_enqueue_style(
+ 'versionpress_admin_style',
+ plugins_url('admin/public/css/style.css', VERSIONPRESS_PLUGIN_FILE),
+ [],
+ $vpVersion
+ );
+
+ wp_enqueue_style(
+ 'versionpress_admin_icons',
+ plugins_url('admin/public/icons/style.css', VERSIONPRESS_PLUGIN_FILE),
+ [],
+ $vpVersion
+ );
+
+ wp_enqueue_script(
+ 'versionpress_admin_script',
+ plugins_url('admin/public/js/vp-admin.js', VERSIONPRESS_PLUGIN_FILE),
+ [],
+ $vpVersion
+ );
+}
+
+//---------------------------------
+// API
+//---------------------------------
+add_action('rest_api_init', 'versionpress_api_init');
+function versionpress_api_init()
+{
+ global $versionPressContainer;
+ $gitRepository = $versionPressContainer->resolve(VersionPressServices::GIT_REPOSITORY);
+ $reverter = $versionPressContainer->resolve(VersionPressServices::REVERTER);
+ $synchronizationProcess = $versionPressContainer->resolve(VersionPressServices::SYNCHRONIZATION_PROCESS);
+ $commitMessageParser = $versionPressContainer->resolve(VersionPressServices::COMMIT_MESSAGE_PARSER);
+
+ $vpApi = new VersionPressApi($gitRepository, $reverter, $synchronizationProcess, $commitMessageParser);
+ $vpApi->registerRoutes();
+}
diff --git a/mu-plugins/versionpress/src/Actions/ActionsDefinitionRepository.php b/mu-plugins/versionpress/src/Actions/ActionsDefinitionRepository.php
new file mode 100644
index 0000000..e9dd4b1
--- /dev/null
+++ b/mu-plugins/versionpress/src/Actions/ActionsDefinitionRepository.php
@@ -0,0 +1,84 @@
+directory = $directory;
+ $this->gitRepository = $gitRepository;
+ }
+
+ public function getAllDefinitionFiles()
+ {
+ return new \GlobIterator($this->directory . '/*-actions.yml', \FilesystemIterator::CURRENT_AS_PATHNAME);
+ }
+
+ public function saveActionsFileForPlugin($pluginFile)
+ {
+ $pluginSlug = basename(dirname($pluginFile));
+ $actionsFile = PluginDefinitionDiscovery::getPathForPlugin($pluginSlug, 'actions.yml');
+
+ if (!$actionsFile) {
+ return;
+ }
+
+ $targetFile = $this->getActionsFileName($pluginSlug);
+ FileSystem::copy($actionsFile, $targetFile);
+ }
+
+ public function restoreAllActionsFilesFromHistory()
+ {
+ FileSystem::removeContent($this->directory);
+
+ $this->restoreActionFilesByWildcard(WP_PLUGIN_DIR . '/*/.versionpress/actions.yml');
+ $this->restoreActionFilesByWildcard(WP_CONTENT_DIR . '/.versionpress/plugins/*/actions.yml');
+
+ $this->saveActionsFileForPlugin('versionpress/versionpress.php');
+ }
+
+ private function sanitizePluginName($pluginName)
+ {
+ return str_replace('/', '---', $pluginName);
+ }
+
+ private function getActionsFileName($plugin)
+ {
+ return $this->directory . '/' . $this->sanitizePluginName($plugin) . '-actions.yml';
+ }
+
+ private function restoreActionFilesByWildcard($definitionFilesWildcard)
+ {
+ $modifications = $this->gitRepository->getFileModifications($definitionFilesWildcard);
+
+ $deletions = array_filter($modifications, function ($modification) {
+ return $modification['status'] !== 'D';
+ });
+
+ $lastDeletions = ArrayUtils::unique($deletions, function ($modification) {
+ return $modification['path'];
+ });
+
+ foreach ($lastDeletions as $deletion) {
+ $fileContent = $this->gitRepository->getFileInRevision($deletion['path'], $deletion['commit']);
+ $plugin = basename(dirname(dirname($deletion['path'])));
+
+ $targetFile = $this->getActionsFileName($plugin);
+ file_put_contents($targetFile, $fileContent);
+ }
+ }
+}
diff --git a/mu-plugins/versionpress/src/Actions/ActionsInfo.php b/mu-plugins/versionpress/src/Actions/ActionsInfo.php
new file mode 100644
index 0000000..860cdec
--- /dev/null
+++ b/mu-plugins/versionpress/src/Actions/ActionsInfo.php
@@ -0,0 +1,101 @@
+ [ priority => 10, message => Created %VP-Post-Type% '%VP-Post-Title%' ],
+ * update => [ priority => 12, message => Updated %VP-Post-Type% '%VP-Post-Title%' ],
+ * ]
+ *
+ * @var array
+ */
+ private $actions;
+
+ /**
+ * Tags in given scope. For example `VP-Post-Title`, `VP-Post-Type` etc.
+ * It is a map where key is a name of the tag and value is column from which will be the value automatically saved.
+ * The value can by also `/` for values that are added in a filter.
+ *
+ * Example:
+ * [
+ * VP-Post-Title => post_title,
+ * VP-Comment-PostTitle => /
+ * ]
+ *
+ * @var array
+ */
+ private $tags;
+
+ /**
+ * Useful for meta-entities. Name of tag where the VPID of parent entity is saved.
+ *
+ * @var string|null
+ */
+ private $parentIdTag;
+
+ public function __construct($scope, $actions, $tags = [], $parentIdTag = null)
+ {
+ $this->scope = $scope;
+ $this->actions = $actions;
+ $this->tags = $tags;
+ $this->parentIdTag = $parentIdTag;
+ }
+
+
+ public function getTags()
+ {
+ return $this->tags;
+ }
+
+ public function getDescription($action, $vpid, $tags)
+ {
+ if (!isset($this->actions[$action])) {
+ return null;
+ }
+
+ $message = $this->actions[$action]['message'];
+
+ foreach ($tags as $tag => $value) {
+ $message = str_replace("%{$tag}%", $value, $message);
+ }
+
+ $message = str_replace('%VPID%', $vpid, $message);
+ $message = ucfirst($message);
+
+ return apply_filters("vp_action_description_{$this->scope}", $message, $action, $vpid, $tags);
+ }
+
+ public function getActionPriority($action)
+ {
+ return $this->actions[$action]['priority'];
+ }
+
+ public function getTagContainingParentId()
+ {
+ return $this->parentIdTag;
+ }
+
+ public function getActions()
+ {
+ return $this->actions;
+ }
+}
diff --git a/mu-plugins/versionpress/src/Actions/ActionsInfoProvider.php b/mu-plugins/versionpress/src/Actions/ActionsInfoProvider.php
new file mode 100644
index 0000000..681eb2e
--- /dev/null
+++ b/mu-plugins/versionpress/src/Actions/ActionsInfoProvider.php
@@ -0,0 +1,56 @@
+ &$scopeDefinition) {
+ foreach ($scopeDefinition['actions'] as &$action) {
+ if (is_string($action)) {
+ $action = ['message' => $action, 'priority' => self::DEFAULT_PRIORITY];
+ }
+
+ if (!isset($action['priority'])) {
+ $action['priority'] = self::DEFAULT_PRIORITY;
+ }
+ }
+
+ $actions = $scopeDefinition['actions'];
+ $tags = @$scopeDefinition['tags'] ?: [];
+ $parentIdTag = @$scopeDefinition['parent-id-tag'];
+
+ $this->actionsInfoMap[$scope] = new ActionsInfo($scope, $actions, $tags, $parentIdTag);
+ }
+ }
+
+ public function getActionsInfo($scope)
+ {
+ return $this->actionsInfoMap[$scope];
+ }
+
+ public function getAllActionsInfo()
+ {
+ return $this->actionsInfoMap;
+ }
+}
diff --git a/mu-plugins/versionpress/src/Actions/PluginDefinitionDiscovery.php b/mu-plugins/versionpress/src/Actions/PluginDefinitionDiscovery.php
new file mode 100644
index 0000000..209a3d2
--- /dev/null
+++ b/mu-plugins/versionpress/src/Actions/PluginDefinitionDiscovery.php
@@ -0,0 +1,43 @@
+gitRepository = $gitRepository;
+ $this->reverter = $reverter;
+ $this->synchronizationProcess = $synchronizationProcess;
+ $this->commitMessageParser = $commitMessageParser;
+ }
+
+ /**
+ * Register the VersionPress related routes
+ */
+ public function registerRoutes()
+ {
+ $this->registerRestRoute('/commits', [
+ 'methods' => WP_REST_Server::READABLE,
+ 'callback' => [$this, 'getCommits'],
+ 'args' => [
+ 'page' => [
+ 'default' => '0'
+ ],
+ 'query' => [
+ 'default' => []
+ ]
+ ]
+ ]);
+
+ $this->registerRestRoute('/undo', [
+ 'methods' => WP_REST_Server::READABLE,
+ 'callback' => $this->handleAsAdminSectionRoute('undoCommits'),
+ 'args' => [
+ 'commits' => [
+ 'required' => true
+ ]
+ ]
+ ]);
+
+ $this->registerRestRoute('/rollback', [
+ 'methods' => WP_REST_Server::READABLE,
+ 'callback' => $this->handleAsAdminSectionRoute('rollbackToCommit'),
+ 'args' => [
+ 'commit' => [
+ 'required' => true
+ ]
+ ]
+ ]);
+
+ $this->registerRestRoute('/can-revert', [
+ 'methods' => WP_REST_Server::READABLE,
+ 'callback' => [$this, 'canRevert']
+ ]);
+
+ $this->registerRestRoute('/diff', [
+ 'methods' => WP_REST_Server::READABLE,
+ 'callback' => [$this, 'getDiff'],
+ 'args' => [
+ 'commit' => [
+ 'default' => null
+ ]
+ ]
+ ]);
+
+ $this->registerRestRoute('/display-welcome-panel', [
+ 'methods' => WP_REST_Server::READABLE,
+ 'callback' => [$this, 'displayWelcomePanel']
+ ]);
+
+ $this->registerRestRoute('/hide-welcome-panel', [
+ 'methods' => WP_REST_Server::CREATABLE,
+ 'callback' => $this->handleAsAdminSectionRoute('hideWelcomePanel')
+ ]);
+
+ $this->registerRestRoute('/should-update', [
+ 'methods' => WP_REST_Server::READABLE,
+ 'callback' => [$this, 'shouldUpdate']
+ ]);
+
+ $this->registerRestRoute('/git-status', [
+ 'methods' => WP_REST_Server::READABLE,
+ 'callback' => [$this, 'getGitStatus']
+ ]);
+
+ $this->registerRestRoute('/commit', [
+ 'methods' => WP_REST_Server::CREATABLE,
+ 'callback' => $this->handleAsAdminSectionRoute('commit'),
+ 'args' => [
+ 'commit-message' => [
+ 'required' => true
+ ]
+ ]
+ ]);
+
+ $this->registerRestRoute('/discard-changes', [
+ 'methods' => WP_REST_Server::CREATABLE,
+ 'callback' => $this->handleAsAdminSectionRoute('discardChanges')
+ ]);
+
+ $this->registerRestRoute('/autocomplete-config', [
+ 'methods' => WP_REST_Server::READABLE,
+ 'callback' => $this->handleAsAdminSectionRoute('getAutocompleteConfig')
+ ]);
+ }
+
+ private function registerRestRoute($route, $args = [], $override = false)
+ {
+ $args['callback'] = $this->handleErrorOutput($args['callback']);
+ if (!isset($args['permission_callback'])) {
+ $args['permission_callback'] = [$this, 'checkPermissions'];
+ }
+ return register_rest_route(self::NAMESPACE_VP, $route, $args, $override);
+ }
+
+ /**
+ * Adds WP_ADMIN constant before route handling function is called. Routes calls are than evaluated as called
+ * in admin section of WordPress even if the routes are called using AJAX (WordPress native function is_admin()
+ * evaluates call correctly.
+ *
+ * @param string $routeHandler
+ * @return \Closure
+ */
+ private function handleAsAdminSectionRoute($routeHandler)
+ {
+ return function (WP_REST_Request $request) use ($routeHandler) {
+ if (!defined('WP_ADMIN')) {
+ define('WP_ADMIN', true);
+ }
+ return $this->$routeHandler($request);
+ };
+ }
+
+ /**
+ * Prevents unexpected output from displaying to output, adds it to the response json instead.
+ *
+ * @param callable|string $routeHandler
+ * @return \Closure
+ */
+ private function handleErrorOutput($routeHandler)
+ {
+ return function (WP_REST_Request $request) use ($routeHandler) {
+ ob_start();
+ /** @var WP_REST_Response|WP_Error $response */
+ $response = is_callable($routeHandler)
+ ? $routeHandler($request)
+ : $this->$routeHandler($request);
+
+ $data = ($response instanceof WP_Error)
+ ? $response->get_error_data()
+ : $response->get_data();
+
+ $responseArr = [
+ '__VP__' => true,
+ 'data' => $data
+ ];
+
+ if (ob_get_length() > 0) {
+ $bufferContents = ob_get_clean();
+ $data['phpBuffer'] = $bufferContents;
+ }
+
+ if ($response instanceof WP_Error) {
+ $response->add_data($responseArr);
+ } else {
+ $response->set_data($responseArr);
+ }
+
+ return $response;
+ };
+ }
+
+ /**
+ * @param WP_REST_Request $request
+ * @return WP_REST_Response|WP_Error
+ */
+ public function getCommits(WP_REST_Request $request)
+ {
+ $gitLogPaginator = new GitLogPaginator($this->gitRepository);
+
+ $query = urldecode(stripslashes($request['query']));
+ $rules = QueryLanguageUtils::createRulesFromQueries([$query]);
+ $gitLogQuery = !empty($rules)
+ ? QueryLanguageUtils::createGitLogQueryFromRule($rules[0])
+ : '';
+ $gitLogPaginator->setQuery($gitLogQuery);
+ $gitLogPaginator->setCommitsPerPage(25);
+
+ $page = intval($request['page']);
+ $commits = $gitLogPaginator->getPage($page);
+
+ if (empty($commits)) {
+ return new WP_Error('notice', 'No more commits to show.', ['status' => 404]);
+ }
+
+ $initialCommitHash = $this->getInitialCommitHash();
+
+ $isChildOfInitialCommit = $this->gitRepository->wasCreatedAfter($commits[0]->getHash(), $initialCommitHash);
+ $isFirstCommit = $page === 0;
+
+ $result = [];
+ foreach ($commits as $commit) {
+ $isChildOfInitialCommit = $isChildOfInitialCommit && $this->gitRepository->wasCreatedAfter($commit->getHash(), $initialCommitHash);
+ $canUndoCommit = $isChildOfInitialCommit && !$commit->isMerge();
+ $canRollbackToThisCommit = !$isFirstCommit &&
+ ($isChildOfInitialCommit || $commit->getHash() === $initialCommitHash);
+
+ $changeInfo = $this->commitMessageParser->parse($commit->getMessage());
+ $isEnabled = $isChildOfInitialCommit || $commit->getHash() === $initialCommitHash;
+
+ $skipVpdbFiles = $changeInfo->getChangeInfoList()[0] instanceof TrackedChangeInfo;
+ $fileChanges = $this->getFileChanges($commit, $skipVpdbFiles);
+
+ $environment = $changeInfo instanceof ChangeInfoEnvelope ? $changeInfo->getEnvironment() : '?';
+ $changeInfoList = $changeInfo instanceof ChangeInfoEnvelope ? $changeInfo->getChangeInfoList() : [];
+
+ $result[] = [
+ "hash" => $commit->getHash(),
+ "date" => $commit->getDate()->format('c'),
+ "message" => $changeInfo->getChangeDescription(),
+ "parentHashes" => $commit->getParentHashes(),
+ "canUndo" => $canUndoCommit,
+ "canRollback" => $canRollbackToThisCommit,
+ "isEnabled" => $isEnabled,
+ "isInitial" => $commit->getHash() === $initialCommitHash,
+ "isMerge" => $commit->isMerge(),
+ "environment" => $environment,
+ "changes" => array_values(array_filter(array_merge(
+ $this->convertChangeInfoList($changeInfoList),
+ $fileChanges
+ ))),
+ "author" => [
+ "name" => $commit->getAuthorName(),
+ "email" => $commit->getAuthorEmail(),
+ "avatar" => get_avatar_url($commit->getAuthorEmail())
+ ]
+ ];
+ $isFirstCommit = false;
+ }
+ return new WP_REST_Response([
+ 'pages' => $gitLogPaginator->getPrettySteps($page),
+ 'commits' => $result
+ ]);
+ }
+
+ /**
+ * @param WP_REST_Request $request
+ * @return WP_REST_Response|WP_Error
+ */
+ public function undoCommits(WP_REST_Request $request)
+ {
+ $commitHashes = explode(',', $request['commits']);
+
+ $initialCommitHash = $this->getInitialCommitHash();
+
+ foreach ($commitHashes as $commitHash) {
+ $log = $this->gitRepository->log($commitHash);
+ if (!preg_match('/^[0-9a-f]+$/', $commitHash) || count($log) === 0) {
+ return new WP_Error('error', 'Invalid commit hash', ['status' => 404]);
+ }
+ if ($log[0]->isMerge()) {
+ return new WP_Error('error', 'Cannot undo merge commit', ['status' => 403]);
+ }
+ if (!$this->gitRepository->wasCreatedAfter($commitHash, $initialCommitHash)) {
+ return new WP_Error('error', 'Cannot undo changes before initial commit', ['status' => 403]);
+ }
+ }
+
+ return $this->revertCommits('undo', $commitHashes);
+ }
+
+ /**
+ * @param WP_REST_Request $request
+ * @return WP_REST_Response|WP_Error
+ */
+ public function rollbackToCommit(WP_REST_Request $request)
+ {
+ $commitHash = $request['commit'];
+
+ $initialCommitHash = $this->getInitialCommitHash();
+
+ $log = $this->gitRepository->log($commitHash);
+ if (!preg_match('/^[0-9a-f]+$/', $commitHash) || count($log) === 0) {
+ return new WP_Error('error', 'Invalid commit hash', ['status' => 404]);
+ }
+ if (!$this->gitRepository->wasCreatedAfter($commitHash, $initialCommitHash) &&
+ $log[0]->getHash() !== $initialCommitHash
+ ) {
+ return new WP_Error('error', 'Cannot roll back before initial commit', ['status' => 403]);
+ }
+ if ($log[0]->getHash() === $this->gitRepository->getLastCommitHash()) {
+ return new WP_Error(
+ 'error',
+ 'Nothing to commit. Current state is the same as the one you want rollback to.',
+ ['status' => 403]
+ );
+ }
+
+ return $this->revertCommits('rollback', [$commitHash]);
+ }
+
+ /**
+ * @return WP_REST_Response|WP_Error
+ */
+ public function canRevert()
+ {
+ return new WP_REST_Response($this->reverter->canRevert());
+ }
+
+ /**
+ * @param string $reverterMethod
+ * @param array $commits
+ * @return WP_REST_Response|WP_Error
+ */
+ public function revertCommits($reverterMethod, $commits)
+ {
+ vp_enable_maintenance();
+ $revertStatus = call_user_func([$this->reverter, $reverterMethod], $commits);
+ vp_disable_maintenance();
+
+ if ($revertStatus !== RevertStatus::OK) {
+ return $this->getError($revertStatus);
+ }
+ return new WP_REST_Response(true);
+ }
+
+ /**
+ * Returns diff of given commit.
+ * If there's provided no commit hash, returns diff of working directory and HEAD.
+ *
+ * @param WP_REST_Request $request
+ * @return WP_REST_Response|WP_Error
+ */
+ public function getDiff(WP_REST_Request $request)
+ {
+ $commitHash = $request['commit'];
+
+ if (!preg_match('/^[0-9a-f]*$/', $commitHash)) {
+ return new WP_Error(
+ 'error',
+ 'Invalid commit hash',
+ ['status' => 404]
+ );
+ }
+
+ $diff = $this->gitRepository->getDiff($commitHash);
+
+ if (strlen($diff) > 50 * 1024) { // 50 kB is maximum size for diff (see WP-49)
+ return new WP_Error(
+ 'error',
+ 'The diff is too large to show here. Please use some Git client. Thank you.',
+ ['status' => 403]
+ );
+ }
+
+ return new WP_REST_Response(['diff' => $diff]);
+ }
+
+ /**
+ * @return WP_REST_Response
+ */
+ public function displayWelcomePanel()
+ {
+ $showWelcomePanel = get_user_meta(
+ get_current_user_id(),
+ VersionPressOptions::USER_META_SHOW_WELCOME_PANEL,
+ true
+ );
+ return new WP_REST_Response($showWelcomePanel === "");
+ }
+
+ /**
+ * @return WP_REST_Response
+ */
+ public function hideWelcomePanel()
+ {
+ update_user_meta(get_current_user_id(), VersionPressOptions::USER_META_SHOW_WELCOME_PANEL, "0");
+ return new WP_REST_Response(null, 204);
+ }
+
+ public function shouldUpdate(WP_REST_Request $request)
+ {
+ global $versionPressContainer;
+ /** @var GitRepository $repository */
+ $repository = $versionPressContainer->resolve(VersionPressServices::GIT_REPOSITORY);
+
+ $latestCommit = $request['latestCommit'];
+
+ $query = urldecode(stripslashes($request['query']));
+ $rules = QueryLanguageUtils::createRulesFromQueries([$query]);
+ $gitLogQuery = !empty($rules)
+ ? QueryLanguageUtils::createGitLogQueryFromRule($rules[0])
+ : '';
+ $repoLatestCommit = $repository->getLastCommitHash($gitLogQuery);
+
+ return new WP_REST_Response([
+ "update" => $repository->wasCreatedAfter($repoLatestCommit, $latestCommit),
+ "cleanWorkingDirectory" => $repository->isCleanWorkingDirectory()
+ ]);
+ }
+
+ /**
+ * Returns list of files with modification types.
+ *
+ * Example:
+ * [
+ * ["A", "some-file.txt"],
+ * ["M", "other-file.txt"]
+ * ]
+ *
+ * Modification types:
+ * ?? - untracked file
+ * A - added file
+ * M - modified file
+ * D - deleted file
+ *
+ * @return WP_REST_Response
+ */
+ public function getGitStatus()
+ {
+ global $versionPressContainer;
+ /** @var GitRepository $repository */
+ $repository = $versionPressContainer->resolve(VersionPressServices::GIT_REPOSITORY);
+
+ return new WP_REST_Response($repository->getStatus(true));
+ }
+
+ /**
+ * Creates manual commit. Adds everything to stage.
+ *
+ * @param WP_REST_Request $request
+ * @return WP_REST_Response|WP_Error
+ */
+ public function commit(WP_REST_Request $request)
+ {
+ $currentUser = wp_get_current_user();
+ if ($currentUser->ID === 0) {
+ return new WP_Error(
+ 'error',
+ 'You don\'t have permission to do this.',
+ ['status' => 403]
+ );
+ }
+
+ /** @noinspection PhpUndefinedFieldInspection */
+ $authorName = $currentUser->display_name;
+ /** @noinspection PhpUndefinedFieldInspection */
+ $authorEmail = $currentUser->user_email;
+
+ $this->gitRepository->stageAll();
+
+ $status = $this->gitRepository->getStatus(true);
+ if (ArrayUtils::any($status, function ($fileStatus) {
+ $vpdbName = basename(VP_VPDB_DIR);
+ return Strings::contains($fileStatus[1], $vpdbName);
+ })
+ ) {
+ $this->updateDatabase($status);
+ }
+
+ $commitMessage = new CommitMessage($request['commit-message']);
+ $changeInfoEnvelope = new ChangeInfoEnvelope([new UntrackedChangeInfo($commitMessage)]);
+
+ $this->gitRepository->commit($changeInfoEnvelope->getCommitMessage(), $authorName, $authorEmail);
+ return new WP_REST_Response(true);
+ }
+
+ private function updateDatabase($status)
+ {
+ $fullDiff = $this->gitRepository->getDiff();
+
+ $diffFiles = explode('diff --git', $fullDiff);
+
+ $vpdbName = basename(VP_VPDB_DIR);
+ $vpidRegex = "/([\\da-f]{32})/i";
+ $optionRegex = "/.*{$vpdbName}[\\/\\\\]options[\\/\\\\].+[\\/\\\\](.+)\\.ini/i";
+
+ $entitiesToSynchronize = [];
+
+ foreach ($diffFiles as $diff) {
+ $firstLine = substr($diff, 0, strpos($diff, "\n"));
+ $parent = null;
+
+ if (preg_match($optionRegex, $firstLine, $matches)) {
+ $entitiesToSynchronize[] = ['vp_id' => $matches[1], 'parent' => null];
+ } elseif (preg_match($vpidRegex, $firstLine, $matches)) {
+ $parent = $matches[1];
+ }
+
+ preg_match_all($vpidRegex, $diff, $vpidMatches);
+
+ foreach ($vpidMatches[1] as $match) {
+ $entitiesToSynchronize[] = ['vp_id' => $match, 'parent' => $parent];
+ }
+ }
+
+ $entitiesToSynchronize = array_unique($entitiesToSynchronize, SORT_REGULAR);
+ $this->synchronizationProcess->synchronize($entitiesToSynchronize);
+ }
+
+ /**
+ * Discards all changes in working directory.
+ * @return WP_REST_Response
+ */
+ public function discardChanges()
+ {
+ global $versionPressContainer;
+ /** @var GitRepository $repository */
+ $repository = $versionPressContainer->resolve(VersionPressServices::GIT_REPOSITORY);
+
+ $result = $repository->clearWorkingDirectory();
+
+ return new WP_REST_Response($result);
+ }
+
+ /**
+ * Returns current WP configuration for autocomplete component.
+ * @return WP_REST_Response
+ */
+ public function getAutocompleteConfig()
+ {
+ global $versionPressContainer;
+ /** @var ActionsInfoProvider $actionsInfoProvider */
+ $actionsInfoProvider = $versionPressContainer->resolve(VersionPressServices::ACTIONSINFO_PROVIDER_ACTIVE_PLUGINS);
+
+ $config = AutocompleteUtils::createAutocompleteConfig($actionsInfoProvider);
+
+ return new WP_REST_Response($config);
+ }
+
+ /**
+ * @param string $status
+ * @return WP_Error
+ */
+ public function getError($status)
+ {
+ $errors = [
+ RevertStatus::MERGE_CONFLICT => [
+ 'class' => 'error',
+ 'message' => 'Error: Overwritten changes can not be reverted.',
+ 'status' => 403
+ ],
+ RevertStatus::NOTHING_TO_COMMIT => [
+ 'class' => 'updated',
+ 'message' => 'There was nothing to commit. Current state is the same as the one you want rollback to.',
+ 'status' => 403
+ ],
+ RevertStatus::VIOLATED_REFERENTIAL_INTEGRITY => [
+ 'class' => 'error',
+ 'message' => 'Error: Objects with missing references cannot be restored. ' .
+ 'For example we cannot restore comment where the related post was deleted.',
+ 'status' => 403
+ ],
+ RevertStatus::REVERTING_MERGE_COMMIT => [
+ 'class' => 'error',
+ 'message' => 'Error: It is not possible to undo merge commit.',
+ 'status' => 403
+ ],
+ ];
+
+ $error = $errors[$status];
+ return new WP_Error(
+ $error['class'],
+ $error['message'],
+ ['status' => $error['status']]
+ );
+ }
+
+ /**
+ * @param WP_REST_Request $request
+ * @return WP_Error|bool
+ */
+ public function checkPermissions(WP_REST_Request $request)
+ {
+ return !VERSIONPRESS_REQUIRE_API_AUTH || current_user_can('manage_options')
+ ? true
+ : new WP_Error(
+ 'error',
+ 'You don\'t have permission to do this.',
+ ['status' => 403]
+ );
+ }
+
+ private function convertChangeInfoList($getChangeInfoList)
+ {
+ return array_map([$this, 'convertChangeInfo'], $getChangeInfoList);
+ }
+
+ private function convertChangeInfo($changeInfo)
+ {
+ if ($changeInfo instanceof UntrackedChangeInfo) {
+ return null;
+ }
+
+ /** @var TrackedChangeInfo $changeInfo */
+
+ $change = [
+ 'type' => $changeInfo->getScope(),
+ 'action' => $changeInfo->getAction(),
+ 'tags' => $changeInfo->getCustomTags(),
+ ];
+
+ if ($changeInfo instanceof EntityChangeInfo) {
+ $change['name'] = $changeInfo->getId();
+ }
+
+ if ($changeInfo->getScope() === 'plugin') {
+ $pluginTags = $changeInfo->getCustomTags();
+ $pluginName = $pluginTags['VP-Plugin-Name'];
+ $change['name'] = $pluginName;
+ }
+
+ if ($changeInfo->getScope() === 'theme') {
+ $themeTags = $changeInfo->getCustomTags();
+ $themeName = $themeTags['VP-Theme-Name'];
+ $change['name'] = $themeName;
+ }
+
+ if ($changeInfo->getScope() === 'wordpress') {
+ $change['name'] = $changeInfo->getId();
+ }
+
+ if ($changeInfo->getScope() === 'versionpress' && ($changeInfo->getAction() === 'undo' || $changeInfo->getAction() === 'rollback')) {
+ $commit = $this->gitRepository->getCommit($changeInfo->getId());
+ $change['tags']['VP-Commit-Details'] = [
+ 'message' => $commit->getMessage()->getUnprefixedSubject(),
+ 'date' => $commit->getDate()->format(\DateTime::ISO8601)
+ ];
+ }
+
+ return $change;
+ }
+
+ /**
+ * @param Commit $commit
+ * @param bool $skipVpdbFiles
+ * @return array
+ */
+ private function getFileChanges(Commit $commit, $skipVpdbFiles)
+ {
+ $changedFiles = $commit->getChangedFiles();
+
+ if ($skipVpdbFiles) {
+ $changedFiles = array_filter($changedFiles, function ($changedFile) {
+ $path = str_replace('\\', '/', realpath(VP_PROJECT_ROOT) . '/' . $changedFile['path']);
+ $vpdbPath = str_replace('\\', '/', realpath(VP_VPDB_DIR));
+
+ return !Strings::startsWith($path, $vpdbPath);
+ });
+ }
+
+ $fileChanges = array_map(function ($changedFile) {
+ $status = $changedFile['status'];
+ $filename = $changedFile['path'];
+
+ return [
+ 'type' => 'file',
+ 'action' => $status === 'A' ? 'add' : ($status === 'M' ? 'modify' : 'delete'),
+ 'name' => $filename,
+ ];
+ }, $changedFiles);
+
+ return $fileChanges;
+ }
+
+ /**
+ * @return string
+ */
+ private function getInitialCommitHash()
+ {
+ $preActivationHash = trim(file_get_contents(VERSIONPRESS_ACTIVATION_FILE));
+ if (empty($preActivationHash)) {
+ return $this->gitRepository->getInitialCommit()->getHash();
+ }
+ return $this->gitRepository->getChildCommit($preActivationHash);
+ }
+}
diff --git a/mu-plugins/versionpress/src/ChangeInfos/BulkChangeInfo.php b/mu-plugins/versionpress/src/ChangeInfos/BulkChangeInfo.php
new file mode 100644
index 0000000..c901df0
--- /dev/null
+++ b/mu-plugins/versionpress/src/ChangeInfos/BulkChangeInfo.php
@@ -0,0 +1,102 @@
+changeInfos = $changeInfos;
+ $this->count = $this->countUniqueChanges($changeInfos);
+ }
+
+ public function getCommitMessage()
+ {
+ throw new NotSupportedException("Commit message is created in ChangeInfoEnvelope from original objects");
+ }
+
+ /**
+ * Returns original ChangeInfo objects.
+ *
+ * @return TrackedChangeInfo[]
+ */
+ public function getChangeInfos()
+ {
+ return $this->changeInfos;
+ }
+
+ public function getChangeDescription()
+ {
+ $entityName = $this->getScope();
+ $action = $this->getAction();
+
+ if ($this->count === 1) {
+ $defaultDescription = $this->changeInfos[0]->getChangeDescription();
+ } else {
+ $defaultDescription = sprintf(
+ "%s %d %s",
+ Strings::capitalize(StringUtils::verbToPastTense($action)),
+ $this->count,
+ StringUtils::pluralize($entityName)
+ );
+ }
+
+ $tags = array_map(function (TrackedChangeInfo $changeInfo) {
+ return $changeInfo->getCustomTags();
+ }, $this->changeInfos);
+
+ return apply_filters("vp_bulk_change_description_{$entityName}", $defaultDescription, $action, $this->count, $tags);
+ }
+
+ public function getAction()
+ {
+ return $this->changeInfos[0]->getAction();
+ }
+
+ public function getScope()
+ {
+ return $this->changeInfos[0]->getScope();
+ }
+
+ public function getPriority()
+ {
+ return $this->changeInfos[0]->getPriority();
+ }
+
+ /**
+ * @param TrackedChangeInfo[] $changeInfos
+ * @return int
+ */
+ private function countUniqueChanges($changeInfos)
+ {
+ if (!($changeInfos[0] instanceof EntityChangeInfo)) {
+ return count($changeInfos);
+ }
+
+ /** @var EntityChangeInfo[] $changeInfos */
+ $numberOfUniqueChanges = 0;
+ $uniqueEntities = [];
+
+ foreach ($changeInfos as $changeInfo) {
+ if (!in_array($changeInfo->getId(), $uniqueEntities)) {
+ $numberOfUniqueChanges += 1;
+ $uniqueEntities[] = $changeInfo->getId();
+ }
+ }
+
+ return $numberOfUniqueChanges;
+ }
+}
diff --git a/mu-plugins/versionpress/src/ChangeInfos/ChangeInfo.php b/mu-plugins/versionpress/src/ChangeInfos/ChangeInfo.php
new file mode 100644
index 0000000..496f63f
--- /dev/null
+++ b/mu-plugins/versionpress/src/ChangeInfos/ChangeInfo.php
@@ -0,0 +1,41 @@
+changeInfoList = $changeInfoList;
+ $this->version = $version === null ? VersionPress::getVersion() : $version;
+ $this->environment = $environment ?: VersionPress::getEnvironment();
+ }
+
+ /**
+ * Creates a commit message from this ChangeInfo. Used by Committer.
+ *
+ * @see Committer::commit()
+ * @return CommitMessage
+ */
+ public function getCommitMessage()
+ {
+ $subject = $this->getChangeDescription();
+
+ $bodies = [];
+ foreach ($this->getSortedChangeInfoList() as $changeInfo) {
+ $bodies[] = $changeInfo->getCommitMessage()->getBody();
+ }
+
+ $body = join("\n\n", $bodies);
+ $body .= sprintf("\n\n%s: %s", self::VP_VERSION_TAG, $this->version);
+ $body .= sprintf("\n%s: %s", self::VP_ENVIRONMENT_TAG, $this->environment);
+
+ return new CommitMessage($subject, $body);
+ }
+
+ /**
+ * Text displayed in the main VersionPress table (see admin/index.php). Also used
+ * to construct commit message subject (first line) when the commit is first
+ * physically created.
+ *
+ * @return string
+ */
+ public function getChangeDescription()
+ {
+ $changeList = $this->getReorganizedInfoList();
+ $firstChangeDescription = $changeList[0]->getChangeDescription();
+ return $firstChangeDescription;
+ }
+
+ /**
+ * Returns all ChangeInfo objects encapsulated in ChangeInfoEnvelope.
+ *
+ * @return TrackedChangeInfo[]
+ */
+ public function getChangeInfoList()
+ {
+ return $this->changeInfoList;
+ }
+
+ /**
+ * Returns sorted list of ChangeInfo objects with bulk actions encapsulated into BulkChangeInfo objects.
+ *
+ * @return TrackedChangeInfo[]
+ */
+ public function getReorganizedInfoList()
+ {
+ return $this->sortChangeInfoList($this->groupBulkActions($this->changeInfoList));
+ }
+
+ /**
+ * @return null|string
+ */
+ public function getEnvironment()
+ {
+ return $this->environment;
+ }
+
+ /**
+ * @return TrackedChangeInfo[]
+ */
+ private function getSortedChangeInfoList()
+ {
+ return $this->sortChangeInfoList($this->changeInfoList);
+ }
+
+ private static function containsVersion($lastBody)
+ {
+ return Strings::startsWith($lastBody, self::VP_VERSION_TAG);
+ }
+
+ private static function extractTag($tag, $lastBody)
+ {
+ $tmpMessage = new CommitMessage("", $lastBody);
+ return $tmpMessage->getVersionPressTag($tag);
+ }
+
+ /**
+ * @param TrackedChangeInfo[] $changeInfoList
+ * @return TrackedChangeInfo[]
+ */
+ private function sortChangeInfoList($changeInfoList)
+ {
+ ArrayUtils::stablesort($changeInfoList, function ($changeInfo1, $changeInfo2) {
+ /** @var TrackedChangeInfo|BulkChangeInfo $changeInfo1 */
+ /** @var TrackedChangeInfo|BulkChangeInfo $changeInfo2 */
+
+ return $changeInfo1->getPriority() - $changeInfo2->getPriority();
+ });
+
+ return $changeInfoList;
+ }
+
+ private function groupBulkActions($changeInfoList)
+ {
+ $groupedChangeInfos = ArrayUtils::mapreduce($changeInfoList, function (ChangeInfo $item, $mapEmit) {
+ if ($item instanceof TrackedChangeInfo) {
+ $key = "{$item->getScope()}/{$item->getAction()}";
+ $mapEmit($key, $item);
+ } else {
+ $mapEmit(spl_object_hash($item), $item);
+ }
+ }, function ($key, $items, $reduceEmit) {
+ /** @var TrackedChangeInfo[] $items */
+ if (count($items) > 1) {
+ $reduceEmit(new BulkChangeInfo($items));
+ } else {
+ $reduceEmit($items[0]);
+ }
+ });
+
+ $changeInfos = [];
+ foreach ($groupedChangeInfos as $changeInfoGroup) {
+ if (is_array($changeInfoGroup)) {
+ foreach ($changeInfoGroup as $changeInfo) {
+ $changeInfos[] = $changeInfo;
+ }
+ } else {
+ $changeInfos[] = $changeInfoGroup;
+ }
+ }
+
+ return $changeInfos;
+ }
+
+ public function getPriority()
+ {
+ // There are never envelopes inside an envelope; therefore, the priority is irrelevant.
+ return 0;
+ }
+}
diff --git a/mu-plugins/versionpress/src/ChangeInfos/ChangeInfoFactory.php b/mu-plugins/versionpress/src/ChangeInfos/ChangeInfoFactory.php
new file mode 100644
index 0000000..54f317a
--- /dev/null
+++ b/mu-plugins/versionpress/src/ChangeInfos/ChangeInfoFactory.php
@@ -0,0 +1,54 @@
+dbSchema = $dbSchema;
+ $this->actionsInfoProvider = $actionsInfoProvider;
+ }
+
+ public function createEntityChangeInfo($entity, $entityName, $action, $customTags = [], $customFiles = [])
+ {
+ $entityInfo = $this->dbSchema->getEntityInfo($entityName);
+ $vpid = $entity[$entityInfo->vpidColumnName];
+
+ $actionsInfo = $this->actionsInfoProvider->getActionsInfo($entityName);
+
+ $automaticallySavedTags = $actionsInfo->getTags();
+ $tags = ChangeInfoUtils::extractTags($automaticallySavedTags, $entity, $entity);
+ $tags = array_merge($tags, $customTags);
+
+ $defaultPriority = $actionsInfo->getActionPriority($action);
+ $priority = apply_filters("vp_action_priority_{$entityName}", $defaultPriority, $action, $vpid, $entity);
+
+ return new EntityChangeInfo($entityInfo, $actionsInfo, $action, $vpid, $tags, $customFiles, $priority);
+ }
+
+ public function createTrackedChangeInfo($scope, $action, $id = null, $tags = [], $files = [])
+ {
+ $actionsInfo = $this->actionsInfoProvider->getActionsInfo($scope);
+ $defaultPriority = $actionsInfo->getActionPriority($action);
+ $priority = apply_filters("vp_action_priority_{$scope}", $defaultPriority, $action, $id);
+
+ return new TrackedChangeInfo($scope, $actionsInfo, $action, $id, $tags, $files, $priority);
+ }
+}
diff --git a/mu-plugins/versionpress/src/ChangeInfos/ChangeInfoUtils.php b/mu-plugins/versionpress/src/ChangeInfos/ChangeInfoUtils.php
new file mode 100644
index 0000000..e020659
--- /dev/null
+++ b/mu-plugins/versionpress/src/ChangeInfos/ChangeInfoUtils.php
@@ -0,0 +1,35 @@
+ $field) {
+ if (isset($newEntity[$field])) {
+ $extractedTags[$tagName] = $newEntity[$field];
+ } elseif (isset($oldEntity[$field])) {
+ $extractedTags[$tagName] = $oldEntity[$field];
+ }
+ }
+
+ return $extractedTags;
+ }
+
+ public static function changeInfoRepresentsEntity($changeInfo, $entityName)
+ {
+ return $changeInfo instanceof EntityChangeInfo && $changeInfo->getScope() === $entityName;
+ }
+}
diff --git a/mu-plugins/versionpress/src/ChangeInfos/CommitMessageParser.php b/mu-plugins/versionpress/src/ChangeInfos/CommitMessageParser.php
new file mode 100644
index 0000000..dd8a8d0
--- /dev/null
+++ b/mu-plugins/versionpress/src/ChangeInfos/CommitMessageParser.php
@@ -0,0 +1,86 @@
+dbSchema = $dbSchema;
+ $this->actionsInfoProvider = $actionsInfoProvider;
+ }
+
+ /**
+ * @param CommitMessage $commitMessage
+ * @return ChangeInfoEnvelope
+ */
+ public function parse(CommitMessage $commitMessage)
+ {
+ $fullBody = $commitMessage->getBody();
+ $splittedBodies = explode("\n\n", $fullBody);
+ $lastBody = $splittedBodies[count($splittedBodies) - 1];
+ $changeInfoList = [];
+ $version = null;
+ $environment = null;
+
+ if (self::containsVersion($lastBody)) {
+ $version = self::extractTag(ChangeInfoEnvelope::VP_VERSION_TAG, $lastBody);
+ $environment = self::extractTag(ChangeInfoEnvelope::VP_ENVIRONMENT_TAG, $lastBody);
+ array_pop($splittedBodies);
+ }
+
+ if (!self::isTrackedChangeInfo($fullBody)) {
+ return new ChangeInfoEnvelope([new UntrackedChangeInfo($commitMessage)], $version, $environment);
+ }
+
+ foreach ($splittedBodies as $body) {
+ $partialCommitMessage = new CommitMessage("", $body);
+
+ $actionTag = $partialCommitMessage->getVersionPressTag(TrackedChangeInfo::ACTION_TAG);
+ list($scope, $action, $id) = array_pad(explode('/', $actionTag, 3), 3, null);
+
+ $tags = $partialCommitMessage->getVersionPressTags();
+ unset($tags[TrackedChangeInfo::ACTION_TAG]);
+
+ $actionsInfo = $this->actionsInfoProvider->getActionsInfo($scope);
+
+ if ($this->dbSchema->isEntity($scope)) {
+ $entityInfo = $this->dbSchema->getEntityInfo($scope);
+ $changeInfoList[] = new EntityChangeInfo($entityInfo, $actionsInfo, $action, $id, $tags, []);
+ } else {
+ $changeInfoList[] = new TrackedChangeInfo($scope, $actionsInfo, $action, $id, $tags, []);
+ }
+ }
+
+ return new ChangeInfoEnvelope($changeInfoList, $version, $environment);
+ }
+
+ private static function containsVersion($lastBody)
+ {
+ return Strings::startsWith($lastBody, ChangeInfoEnvelope::VP_VERSION_TAG);
+ }
+
+ private static function extractTag($tag, $commitMessageBody)
+ {
+ $tmpMessage = new CommitMessage("", $commitMessageBody);
+ return $tmpMessage->getVersionPressTag($tag);
+ }
+
+ private static function isTrackedChangeInfo($body)
+ {
+ return Strings::startsWith($body, TrackedChangeInfo::ACTION_TAG);
+ }
+}
diff --git a/mu-plugins/versionpress/src/ChangeInfos/EntityChangeInfo.php b/mu-plugins/versionpress/src/ChangeInfos/EntityChangeInfo.php
new file mode 100644
index 0000000..a2de9b7
--- /dev/null
+++ b/mu-plugins/versionpress/src/ChangeInfos/EntityChangeInfo.php
@@ -0,0 +1,80 @@
+entityName, $actionsInfo, $action, $entityId, $customTags, $customFiles, $priority);
+ $this->entityInfo = $entityInfo;
+ $this->actionsInfo = $actionsInfo;
+ }
+
+ public function getScope()
+ {
+ return $this->entityInfo->entityName;
+ }
+
+ public function getChangedFiles()
+ {
+ $change = [
+ "type" => "storage-file",
+ "entity" => $this->getScope(),
+ "id" => $this->getId(),
+ "parent-id" => $this->getParentId()
+ ];
+
+ return array_merge([$change], parent::getChangedFiles());
+ }
+
+ /**
+ * Used by meta-entity storages as a performance optimalization.
+ * For example EntityChangeInfo representing change in postmeta returns VPID of the related post.
+ *
+ * @return string|null
+ */
+ public function getParentId()
+ {
+ if ($this->entityInfo->parentReference) {
+ $tagContainingParentId = $this->actionsInfo->getTagContainingParentId();
+
+ return $this->getCustomTags()[$tagContainingParentId];
+ }
+
+ return null;
+ }
+}
diff --git a/mu-plugins/versionpress/src/ChangeInfos/TrackedChangeInfo.php b/mu-plugins/versionpress/src/ChangeInfos/TrackedChangeInfo.php
new file mode 100644
index 0000000..640e8eb
--- /dev/null
+++ b/mu-plugins/versionpress/src/ChangeInfos/TrackedChangeInfo.php
@@ -0,0 +1,204 @@
+scope = $scope;
+ $this->actionsInfo = $actionsInfo;
+ $this->action = $action;
+ $this->id = $id;
+ $this->customTags = $customTags;
+ $this->customFiles = $customFiles;
+ $this->priority = $priority;
+ }
+
+ public function getCommitMessage()
+ {
+ return new CommitMessage($this->getChangeDescription(), $this->getCommitMessageBody());
+ }
+
+ /**
+ * Constructs commit message body, which is typically a couple of lines of VP tags.
+ *
+ * General algorithm is defined in this base class and the subclasses
+ * only need to provide content for VP-Action tag and an array of custom VP tags.
+ *
+ * @see getActionTagValue()
+ * @see getCustomTags()
+ *
+ * @return string
+ */
+ private function getCommitMessageBody()
+ {
+ $actionTag = $this->getActionTagValue();
+
+ $tags = [];
+ if ($actionTag) {
+ $tags[self::ACTION_TAG] = $actionTag;
+ }
+
+ $customTags = $this->getCustomTags();
+ $tags = array_merge($tags, $customTags);
+
+ $body = "";
+ foreach ($tags as $tagName => $tagValue) {
+ $body .= "$tagName: $tagValue\n";
+ }
+ return $body;
+ }
+
+ /**
+ * Text displayed in the main VersionPress table (see admin/index.php). Also used
+ * to construct commit message subject (first line) when the commit is first
+ * physically created.
+ *
+ * @return string
+ */
+ public function getChangeDescription()
+ {
+ if (empty($this->commitMessageSubject)) {
+ $this->commitMessageSubject = $this->actionsInfo->getDescription($this->getAction(), $this->getId(), $this->getCustomTags());
+
+ // Backward compatibility - displaying update message for old edit actions
+ if ($this->commitMessageSubject === null && $this->getAction() === 'edit') {
+ $this->commitMessageSubject = $this->actionsInfo->getDescription('update', $this->getId(), $this->getCustomTags());
+ }
+ }
+
+ return $this->commitMessageSubject;
+ }
+
+ /**
+ * Object type, the first part of the VP-Action tag value.
+ *
+ * For example, when objectType is "post", the VP-Action tag will be something like "post/update/VPID123".
+ *
+ * @return string
+ */
+ public function getScope()
+ {
+ return $this->scope;
+ }
+
+ /**
+ * The action done on the object type, for instance "install" or "activate" if the object was a plugin.
+ * Action is always part of VP-Action tag as the second segment.
+ *
+ * @return string
+ */
+ public function getAction()
+ {
+ return $this->action;
+ }
+
+ public function getId()
+ {
+ return $this->id;
+ }
+
+ public function getPriority()
+ {
+ return $this->priority;
+ }
+
+ /**
+ * Used to construct a commit message body, subclasses provide a string for the VP-Action tag value
+ * using this method.
+ *
+ * @see getCommitMessageBody()
+ * @return string
+ */
+ protected function getActionTagValue()
+ {
+ $actionTagValue = "{$this->getScope()}/{$this->getAction()}";
+
+ if ($this->id) {
+ $actionTagValue .= "/{$this->getId()}";
+ }
+
+ return $actionTagValue;
+ }
+
+ /**
+ * Used to construct a commit message body, subclasses provide an array of VP tags
+ * using this method. If they don't need custom tags, they return an empty array.
+ *
+ * @see getCommitMessageBody()
+ * @return array
+ */
+ public function getCustomTags()
+ {
+ return $this->customTags;
+ }
+
+ /**
+ * Reports changes in files that relate to this ChangeInfo. Used by {@see Committer::stageRelatedFiles()}.
+ *
+ * Path specifications are either pointers to storage files based on entity name and VPID
+ * or a concrete path (optionally with wildcards).
+ *
+ * An example:
+ *
+ * [
+ * ['type' => 'storage-file', 'entity' => 'post', 'id' => VPID, 'parent-id' => null],
+ * ['type' => 'storage-file', 'entity' => 'usermeta', 'id' => VPID, 'parent-id' => user-VPID],
+ * ['type' => 'all-storage-files', 'entity' => 'option'],
+ * ['type' => 'path', 'path' => '/var/www/wp/example.txt'],
+ * ['type' => 'path', 'path' => '/var/www/wp/folder/*']
+ * ]
+ *
+ * @return array
+ */
+ public function getChangedFiles()
+ {
+ return $this->customFiles;
+ }
+}
diff --git a/mu-plugins/versionpress/src/ChangeInfos/UntrackedChangeInfo.php b/mu-plugins/versionpress/src/ChangeInfos/UntrackedChangeInfo.php
new file mode 100644
index 0000000..ce17771
--- /dev/null
+++ b/mu-plugins/versionpress/src/ChangeInfos/UntrackedChangeInfo.php
@@ -0,0 +1,38 @@
+commitMessage = $commitMessage;
+ }
+
+ public function getCommitMessage()
+ {
+ return $this->commitMessage;
+ }
+
+ public function getChangeDescription()
+ {
+ return $this->commitMessage->getUnprefixedSubject();
+ }
+
+ public function getPriority()
+ {
+ return 0;
+ }
+}
diff --git a/mu-plugins/versionpress/src/Cli/SilentUpgraderSkin.php b/mu-plugins/versionpress/src/Cli/SilentUpgraderSkin.php
new file mode 100644
index 0000000..aec980e
--- /dev/null
+++ b/mu-plugins/versionpress/src/Cli/SilentUpgraderSkin.php
@@ -0,0 +1,22 @@
+in_color()) {
+ // All additional args need to be prepended, see #1279
+ $args = ['color' => null] + $args;
+ }
+
+ // For commands that were run under root - #1049
+ $args = ['allow-root' => null] + $args;
+
+ foreach ($args as $name => $value) {
+ if (is_int($name)) { // positional argument
+ $cliCommand .= " " . ProcessUtils::escapeshellarg($value);
+ } elseif ($value !== null) {
+ $cliCommand .= " --$name=" . ProcessUtils::escapeshellarg($value);
+ } else {
+ $cliCommand .= " --$name";
+ }
+ }
+
+ return self::exec($cliCommand, $cwd);
+ }
+
+ /**
+ * Executes a command, optionally in a specified working directory.
+ *
+ * @param string $command
+ * @param string|null $cwd
+ * @return Process
+ */
+ public static function exec($command, $cwd = null)
+ {
+ // Changing env variables for debugging
+ // If we run another wp-cli command from our command, it breaks and never continues (with xdebug).
+ // So we need to turn xdebug off for all "nested" commands.
+ if (isset($_SERVER["XDEBUG_CONFIG"])) {
+ $env = $_SERVER;
+ unset($env["XDEBUG_CONFIG"]);
+ } else {
+ $env = null;
+ }
+
+ $process = new Process($command, $cwd, $env);
+ $process->run();
+ return $process;
+ }
+
+ /**
+ * Asks user a question, offers an array of values and returns what he/she entered. The first value
+ * in the `$values` array is the default one, used if the user just ENTERs the question or types
+ * in some random value. The $assoc_args array may be given as the third parameter, in which case
+ * it behaves like in WP_CLI::confirm() and will return 'y' is such value is in $values,
+ * or the default value.
+ *
+ * Inspired by WP_CLI::confirm() that can only do "yes" / "no" and cannot really return "no"
+ * (it just exits in such case).
+ *
+ * @param string $question
+ * @param array $values e.g. ["y", "n"] or ["1", "2", "3"]
+ * @param array $assoc_args If $assoc_args contain 'yes' and $values contain 'y', it will be automatically answered.
+ * (Similar behavior to WP_CLI::confirm().)
+ * @return string The answer
+ */
+ public static function cliQuestion($question, $values, $assoc_args = [])
+ {
+
+ if (isset($assoc_args['yes'])) {
+ return in_array('y', $values) ? 'y' : $values[0];
+ }
+
+ fwrite(STDOUT, $question . " [" . implode('/', $values) . "] ");
+ $answer = trim(fgets(STDIN));
+
+ if (!in_array($answer, $values)) {
+ $answer = $values[0];
+ }
+
+ return $answer;
+ }
+
+ public static function warning($message)
+ {
+ WP_CLI::log(Colors::colorize('%YWarning: %n' . $message));
+ }
+
+ /**
+ * WP-CLI args are always strings. This method restores the original type.
+ *
+ * @param string $value
+ * @return bool|int|float|string
+ */
+ public static function fixTypeOfValue($value)
+ {
+ if (is_numeric($value)) {
+ return $value + 0;
+ }
+
+ if (strtolower($value) === 'true') {
+ return true;
+ }
+
+ if (strtolower($value) === 'false') {
+ return false;
+ }
+
+ return $value;
+ }
+}
diff --git a/mu-plugins/versionpress/src/Cli/vp-composer.php b/mu-plugins/versionpress/src/Cli/vp-composer.php
new file mode 100644
index 0000000..694188d
--- /dev/null
+++ b/mu-plugins/versionpress/src/Cli/vp-composer.php
@@ -0,0 +1,169 @@
+pluginsThemesTransient, $this->getPackages());
+ }
+
+ /**
+ * Commits all changes made by Composer.
+ *
+ * @subcommand commit-composer-changes
+ */
+ public function commitComposerChanges($args, $assoc_args)
+ {
+ if (!VersionPress::isActive()) {
+ WP_CLI::error('VersionPress is not active. Changes will be not committed.');
+ }
+
+ $pluginsAndThemesBeforeUpdate = get_transient($this->pluginsThemesTransient);
+ delete_transient($this->pluginsThemesTransient);
+ $currentPluginsAndThemes = $this->getPackages();
+
+ $plugins = array_merge($pluginsAndThemesBeforeUpdate['plugins'], $currentPluginsAndThemes['plugins']);
+ $themes = array_merge($pluginsAndThemesBeforeUpdate['themes'], $currentPluginsAndThemes['themes']);
+
+ $changes = $this->detectChanges();
+ $installedPackages = $changes['installed'];
+ $removedPackages = $changes['removed'];
+ $updatedPackages = $changes['updated'];
+
+ $this->forceRelatedActions('install', $installedPackages, $plugins, $themes);
+ $this->forceRelatedActions('delete', $removedPackages, $plugins, $themes);
+ $this->forceRelatedActions('update', $updatedPackages, $plugins, $themes);
+ }
+
+ private function detectChanges()
+ {
+ $currentComposerLock = file_get_contents(VP_PROJECT_ROOT . '/composer.lock');
+
+ $process = new Process(VP_GIT_BINARY . ' show HEAD:composer.lock', VP_PROJECT_ROOT);
+ $process->run();
+
+ $previousComposerLock = $process->getOutput();
+
+ $currentPackages = $this->getPackagesFromLockFile($currentComposerLock);
+ $previousPackages = $this->getPackagesFromLockFile($previousComposerLock);
+
+ $installedPackages = array_diff_key($currentPackages, $previousPackages);
+ $removedPackages = array_diff_key($previousPackages, $currentPackages);
+
+ $packagesWithChangedVersion = array_filter(
+ array_intersect_key($currentPackages, $previousPackages),
+ function ($package) use ($previousPackages) {
+ return $package['version'] !== $previousPackages[$package['name']]['version'];
+ }
+ );
+
+ return [
+ 'installed' => $installedPackages,
+ 'removed' => $removedPackages,
+ 'updated' => $packagesWithChangedVersion,
+ ];
+ }
+
+ private function getPackagesFromLockFile($lockFileContent)
+ {
+ $lockFile = json_decode($lockFileContent, true);
+ return array_combine(
+ array_column($lockFile['packages'], 'name'),
+ array_map(function ($package) {
+ return [
+ 'name' => $package['name'],
+ 'version' => $package['version'],
+ 'type' => $package['type'],
+ 'homepage' => @$package['homepage'] ?: null,
+ ];
+ }, $lockFile['packages'])
+ );
+ }
+
+ private function getPackages()
+ {
+ return ['plugins' => get_plugins(), 'themes' => wp_get_themes()];
+ }
+
+ private function getPluginFileAndName($fullPackageName, $plugins)
+ {
+ list($vendor, $packageName) = explode('/', $fullPackageName);
+
+ foreach ($plugins as $pluginFile => $plugin) {
+ list($pluginDirectory) = explode('/', $pluginFile, 2);
+
+ if ($packageName === $pluginDirectory) {
+ return ['plugin-file' => $pluginFile, 'name' => $plugin['Name']];
+ }
+ }
+
+ return null;
+ }
+
+ private function getThemeStylesheetAndName($fullPackageName, $themes)
+ {
+ list($vendor, $packageName) = explode('/', $fullPackageName);
+
+ foreach ($themes as $themeName => $theme) {
+ /** @var $theme \WP_Theme */
+ if ($packageName === $themeName) {
+ return ['stylesheet' => $theme->get_stylesheet(), 'name' => $theme->get('Name')];
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * @param string $action install or delete or update
+ * @param array $packages
+ * @param array $plugins
+ * @param array $themes
+ */
+ private function forceRelatedActions($action, $packages, $plugins, $themes)
+ {
+ foreach ($packages as $package) {
+ if ($package['type'] === 'wordpress-plugin') {
+ $fileAndName = $this->getPluginFileAndName($package['name'], $plugins);
+ do_action('vp_plugin_changed', $action, $fileAndName['plugin-file'], $fileAndName['name']);
+ } elseif ($package['type'] === 'wordpress-theme') {
+ $stylesheetAndName = $this->getThemeStylesheetAndName($package['name'], $themes);
+ do_action('vp_theme_changed', $stylesheetAndName['stylesheet'], $stylesheetAndName['name']);
+ } elseif ($package['type'] === 'wordpress-core') {
+ do_action('vp_wordpress_updated', $package['version']);
+ } else {
+ $composerFiles = [
+ ["type" => "path", "path" => VP_PROJECT_ROOT . '/composer.json'],
+ ["type" => "path", "path" => VP_PROJECT_ROOT . '/composer.lock']
+ ];
+
+ vp_force_action('composer', $action, $package['name'], [], $composerFiles);
+ }
+ }
+ }
+}
+
+if (defined('WP_CLI') && WP_CLI) {
+ WP_CLI::add_command('vp-composer', VPComposerCommand::class);
+}
diff --git a/mu-plugins/versionpress/src/Cli/vp-internal.php b/mu-plugins/versionpress/src/Cli/vp-internal.php
new file mode 100644
index 0000000..b8aee6c
--- /dev/null
+++ b/mu-plugins/versionpress/src/Cli/vp-internal.php
@@ -0,0 +1,335 @@
+resolve(VersionPressServices::ACTIONS_DEFINITION_REPOSITORY);
+ $actionsDefinitionRepository->restoreAllActionsFilesFromHistory();
+
+ // Truncate tables
+ /** @var Database $database */
+ $database = $versionPressContainer->resolve(VersionPressServices::DATABASE);
+ /** @var DbSchemaInfo $dbSchema */
+ $dbSchema = $versionPressContainer->resolve(VersionPressServices::DB_SCHEMA);
+
+ $tables = array_map(function ($entityName) use ($dbSchema) {
+ return $dbSchema->getPrefixedTableName($entityName);
+ }, array_merge($dbSchema->getAllEntityNames(), array_map(function ($referenceDetails) {
+ return $referenceDetails['junction-table'];
+ }, $dbSchema->getAllMnReferences())));
+
+
+ $tables = array_filter($tables, function ($table) use ($database) {
+ return $table !== $database->options;
+ });
+
+ foreach ($tables as $table) {
+ $truncateCmd = "TRUNCATE TABLE `$table`";
+ @$database->query($truncateCmd); // Intentional @ - not existing table is ok for us but TRUNCATE ends with error
+ }
+
+ // Create VersionPress tables
+ /** @var \VersionPress\Initialization\Initializer $initializer */
+ $initializer = $versionPressContainer->resolve(VersionPressServices::INITIALIZER);
+ $initializer->createVersionPressTables();
+
+ WP_CLI::success("VersionPress tables created");
+
+
+ // Install Custom merge driver
+
+ MergeDriverInstaller::installMergeDriver(VP_PROJECT_ROOT, VERSIONPRESS_PLUGIN_DIR, VP_VPDB_DIR);
+ WP_CLI::success("Git merge driver added");
+
+
+ // Run synchronization
+
+ /** @var SynchronizationProcess $syncProcess */
+ $syncProcess = $versionPressContainer->resolve(VersionPressServices::SYNCHRONIZATION_PROCESS);
+ $syncProcess->synchronizeAll();
+ WP_CLI::success("Database synchronized");
+
+ VPCommandUtils::runWpCliCommand('vp-internal', 'flush-regenerable-values', ['require' => __FILE__]);
+ }
+
+ /**
+ * @subcommand flush-regenerable-values
+ */
+ public function flushRegenerableValues()
+ {
+ vp_flush_regenerable_options();
+ $this->flushRewriteRules();
+ }
+
+ /**
+ * Finishes the update with new version
+ *
+ * @subcommand finish-update
+ */
+ public function finishUpdate($args, $assoc_args)
+ {
+ global $versionPressContainer;
+ activate_plugins("versionpress/versionpress.php");
+ WP_CLI::success('Re-activated VersionPress');
+
+ /** @var ActionsDefinitionRepository $actionsDefinitionRepository */
+ $actionsDefinitionRepository = $versionPressContainer->resolve(VersionPressServices::ACTIONS_DEFINITION_REPOSITORY);
+ $actionsDefinitionRepository->restoreAllActionsFilesFromHistory();
+
+ /** @var Initializer $initializer */
+ $initializer = $versionPressContainer->resolve(VersionPressServices::INITIALIZER);
+ $initializer->initializeVersionPress(true);
+
+ WP_CLI::success('VersionPress is tracking your site');
+ }
+
+ /**
+ * Turns on or off the maintenance mode.
+ *
+ * ## OPTIONS
+ *
+ *
+ * : Desired state of maintenance mode. Possible values are 'on' or 'off'.
+ *
+ */
+ public function maintenance($args)
+ {
+ $mode = $args[0];
+ if ($mode === 'on') {
+ vp_enable_maintenance();
+ } else {
+ vp_disable_maintenance();
+ }
+ }
+
+ /**
+ * Finishes `vp push`
+ *
+ * @subcommand finish-push
+ *
+ */
+ public function finishPush($args, $assoc_args)
+ {
+ global $versionPressContainer;
+
+ // Update working copy
+ $resetCommand = "git reset --hard";
+ $process = VPCommandUtils::exec($resetCommand);
+ if (!$process->isSuccessful()) {
+ WP_CLI::error("Working directory couldn't be reset");
+ }
+
+ // Install current Composer dependencies
+ if (file_exists(VP_PROJECT_ROOT . '/composer.json')) {
+ $process = VPCommandUtils::exec('composer install', VP_PROJECT_ROOT);
+ if ($process->isSuccessful()) {
+ WP_CLI::success('Installed Composer dependencies');
+ } else {
+ WP_CLI::error('Composer dependencies could not be restored.');
+ }
+ }
+
+ /** @var ActionsDefinitionRepository $actionsDefinitionRepository */
+ $actionsDefinitionRepository = $versionPressContainer->resolve(VersionPressServices::ACTIONS_DEFINITION_REPOSITORY);
+ $actionsDefinitionRepository->restoreAllActionsFilesFromHistory();
+
+ // Run synchronization
+ /** @var SynchronizationProcess $syncProcess */
+ $syncProcess = $versionPressContainer->resolve(VersionPressServices::SYNCHRONIZATION_PROCESS);
+ $syncProcess->synchronizeAll();
+
+ vp_flush_regenerable_options();
+ vp_disable_maintenance();
+ $this->flushRewriteRules();
+ vp_enable_maintenance();
+ }
+
+ private function flushRewriteRules()
+ {
+ set_transient('vp_flush_rewrite_rules', 1);
+ /**
+ * @see VPCommand::flushRewriteRules
+ */
+ wp_remote_get(get_home_url());
+ }
+
+ /**
+ * Gets `id` of an entity from `vp_id` table
+ *
+ * ## OPTIONS
+ *
+ * --vpid=
+ *
+ * @subcommand get-entity-id
+ *
+ *
+ */
+ public function getEntityId($args = [], $assoc_args = [])
+ {
+ global $versionPressContainer;
+ /** @var Database $database */
+ $database = $versionPressContainer->resolve(VersionPressServices::DATABASE);
+ $sql = "SELECT ID FROM " . $database->vp_id . " WHERE vp_id=UNHEX('" . $assoc_args["vpid"] . "')";
+ $newId = $database->get_col($sql);
+ if (isset($newId[0])) {
+ echo $newId[0];
+ }
+ }
+
+ /**
+ * Gets `vp_id` Guid of an entity from id and entity name
+ *
+ * ## OPTIONS
+ *
+ * --id=
+ *
+ * --name=
+ *
+ * @subcommand get-entity-vpid
+ *
+ *
+ */
+ public function getEntityVpid($args = [], $assoc_args = [])
+ {
+ global $versionPressContainer;
+ /** @var wpdb $wpdb */
+ $wpdb = $versionPressContainer->resolve(VersionPressServices::WPDB);
+ /** @var VpidRepository $vpIdRepository */
+ $vpIdRepository = $versionPressContainer->resolve(VersionPressServices::VPID_REPOSITORY);
+ echo $vpIdRepository->getVpidForEntity($assoc_args["name"], $assoc_args["id"]);
+ }
+
+ /**
+ * Sets or updates constant or variable in wp-config.php
+ *
+ * ## OPTIONS
+ *
+ *
+ * : Name of constant or variable that will be changed.
+ *
+ *
+ * : Desired value. Supported types are: string, int, float and bool.
+ *
+ * [--plain]
+ * : The value will be used as is - without type detection, quoting etc.
+ *
+ * [--variable]
+ * : Will set a variable instead of constant. Useful for $table_prefix.
+ *
+ * [--common]
+ * : The constant / variable will be set in wp-config.common.php.
+ *
+ * @subcommand update-config
+ *
+ *
+ * @when before_wp_load
+ */
+ public function updateConfig($args = [], $assoc_args = [])
+ {
+ require_once __DIR__ . '/VPCommandUtils.php';
+ require_once __DIR__ . '/../Initialization/WpConfigSplitter.php';
+ require_once __DIR__ . '/../Utils/WpConfigEditor.php';
+ require_once __DIR__ . '/../Utils/WordPressMissingFunctions.php';
+
+ $wpConfigPath = WordPressMissingFunctions::getWpConfigPath();
+ $updateCommonConfig = isset($assoc_args['common']);
+
+ if ($updateCommonConfig) {
+ $wpConfigPath = dirname($wpConfigPath) . '/' . WpConfigSplitter::COMMON_CONFIG_NAME;
+ }
+
+ if ($wpConfigPath === false) {
+ WP_CLI::error('Config file does not exist. Please run `wp core config` first.');
+ }
+
+ $constantOrVariableName = $args[0];
+ $isVariable = isset($assoc_args['variable']);
+ $usePlainValue = isset($assoc_args['plain']);
+ $value = $usePlainValue ? $args[1] : VPCommandUtils::fixTypeOfValue($args[1]);
+
+ $wpConfigEditor = new WpConfigEditor($wpConfigPath, $updateCommonConfig);
+
+ try {
+ if ($isVariable) {
+ $wpConfigEditor->updateConfigVariable($constantOrVariableName, $value, $usePlainValue);
+ } else {
+ $wpConfigEditor->updateConfigConstant($constantOrVariableName, $value, $usePlainValue);
+ }
+ } catch (\Exception $e) {
+ WP_CLI::error('Cannot find place for defining the ' . ($isVariable ? 'variable' : 'constant') .
+ '. Config was probably edited manually.');
+ }
+ }
+
+ /**
+ * Used before pull
+ *
+ * @subcommand commit-frequently-written-entities
+ */
+ public function commitFrequentlyWrittenEntities($args = [], $assoc_args = [])
+ {
+ vp_commit_all_frequently_written_entities();
+ }
+}
+
+if (defined('WP_CLI') && WP_CLI) {
+ WP_CLI::add_command('vp-internal', VPInternalCommand::class);
+}
diff --git a/mu-plugins/versionpress/src/Cli/vp.php b/mu-plugins/versionpress/src/Cli/vp.php
new file mode 100644
index 0000000..6a647bd
--- /dev/null
+++ b/mu-plugins/versionpress/src/Cli/vp.php
@@ -0,0 +1,1333 @@
+
+ * : The name of the constant to set.
+ * VP_GIT_BINARY: Absolute path to the git binary.
+ * VP_WP_CLI_BINARY: Absolute path to the WP-CLI binary.
+ * VP_PROJECT_ROOT: Absolute path to the root of your project (typically
+ * where is the .git directory)
+ * VP_VPDB_DIR: Absolute path to directory where VersionPress saves
+ * versioned database data.
+ *
+ * []
+ * : The new value. If missing, just prints out current value.
+ *
+ */
+ public function config($args, $assoc_args)
+ {
+ /**
+ * common: will be saved into wp-config.common.php
+ * type: type of constant
+ * absolute-path: will be saved as-is
+ * dynamic-path: part of the path (to wp-config.php) will be replaced with __DIR__ constant
+ */
+ $allowedConstants = [
+ 'VP_GIT_BINARY' => [
+ 'common' => false,
+ 'type' => 'absolute-path',
+ ],
+ 'VP_WP_CLI_BINARY' => [
+ 'common' => false,
+ 'type' => 'absolute-path',
+ ],
+ 'VP_PROJECT_ROOT' => [
+ 'common' => true,
+ 'type' => 'dynamic-path',
+ 'root' => dirname(\WP_CLI\Utils\locate_wp_config()),
+ ],
+ 'VP_VPDB_DIR' => [
+ 'common' => true,
+ 'type' => 'dynamic-path',
+ 'root' => dirname(\WP_CLI\Utils\locate_wp_config()),
+ ],
+ ];
+
+ $constant = $args[0];
+
+ if (!isset($allowedConstants[$constant])) {
+ WP_CLI::log($constant);
+ WP_CLI::error("Cannot configure constant '{$constant}'");
+ }
+
+ if (count($args) === 1) {
+ if (defined($constant)) {
+ WP_CLI::print_value(constant($constant));
+ return;
+ }
+
+ WP_CLI::error("Constant '{$constant}' is not defined.");
+ }
+
+ $value = $args[1];
+ $isCommon = $allowedConstants[$constant]['common'];
+ $valueType = $allowedConstants[$constant]['type'];
+
+ $updateConfigArgs = $args;
+
+ if ($valueType === 'dynamic-path') {
+ $root = $allowedConstants[$constant]['root'];
+ $fullPath = realpath($value);
+
+ if ($fullPath === false) {
+ WP_CLI::error('Path ' . var_export($value, true) . ' does not exist');
+ }
+
+ $relativePath = PathUtils::getRelativePath($root, $fullPath);
+ $updateConfigArgs[1] = '__DIR__' . ($relativePath === '' ? '' : " . '/$relativePath'");
+ $updateConfigArgs['plain'] = null;
+ }
+
+ if ($valueType === 'absolute-path') {
+ if (!file_exists($value)) {
+ WP_CLI::error('Path ' . var_export($value, true) . ' does not exist');
+ }
+ }
+
+ if ($isCommon) {
+ $updateConfigArgs['common'] = null;
+ }
+
+ $process = $this->runVPInternalCommand('update-config', $updateConfigArgs);
+ WP_CLI::log($process->getConsoleOutput());
+ }
+
+ /**
+ * Checks if VersionPress requirements are met.
+ *
+ * @subcommand check-requirements
+ *
+ * @when before_wp_load
+ */
+ public function checkRequirements($args, $assoc_args)
+ {
+
+ defined('SHORTINIT') or define('SHORTINIT', true);
+
+ $wpConfigPath = \WP_CLI\Utils\locate_wp_config();
+
+ $this->requireWpConfig($wpConfigPath, WpConfigSplitter::COMMON_CONFIG_NAME);
+
+ require_once __DIR__ . '/../../bootstrap.php';
+
+ $this->checkVpRequirements($assoc_args, RequirementsChecker::ENVIRONMENT);
+ }
+
+ /**
+ * Starts tracking the site
+ *
+ * [--yes]
+ * : Answer yes to the confirmation message.
+ *
+ */
+ public function activate($args, $assoc_args)
+ {
+ global $versionPressContainer;
+ if (VersionPress::isActive()) {
+ WP_CLI::error('VersionPress is already fully activated.');
+ return;
+ }
+
+ $this->checkVpRequirements($assoc_args, RequirementsChecker::SITE);
+
+ /**
+ * @var Initializer $initializer
+ */
+ $initializer = $versionPressContainer->resolve(VersionPressServices::INITIALIZER);
+ $initializer->onProgressChanged[] = 'WP_CLI::log';
+ $initializer->initializeVersionPress();
+
+ WP_CLI::line('');
+
+ if (VersionPress::isActive()) {
+ WP_CLI::success('VersionPress is fully activated.');
+ } else {
+ WP_CLI::error('Something went wrong. Please try the activation again.');
+ }
+ }
+
+ /**
+ * Restores a WP site from Git repo / working directory.
+ *
+ * ## OPTIONS
+ *
+ * --siteurl=
+ * : The address of the restored site.
+ *
+ * [--yes]
+ * : Answer yes to the confirmation message.
+ *
+ * ## DESCRIPTION
+ *
+ * The command will then do the following:
+ *
+ * * Drops all tables tracked by VersionPress.
+ * * Recreates and fill them with data from repository.
+ *
+ * If you just cloned the site from another repository, run `wp core config` first.
+ *
+ *
+ * @subcommand restore-site
+ *
+ * @when before_wp_load
+ */
+ public function restoreSite($args, $assoc_args)
+ {
+
+ if (file_exists(getcwd() . '/composer.json')) {
+ $proc = proc_open("composer install", [1 => ["pipe","w"], ["pipe","w"]], $_);
+ $result = proc_close($proc);
+ if ($result !== 0) {
+ WP_CLI::error('Composer dependencies could not be restored.');
+ }
+ }
+
+ defined('SHORTINIT') or define('SHORTINIT', true);
+
+ require_once __DIR__ . '/../Initialization/WpConfigSplitter.php';
+
+ $wpConfigPath = \WP_CLI\Utils\locate_wp_config();
+
+ $this->requireWpConfig($wpConfigPath, WpConfigSplitter::COMMON_CONFIG_NAME);
+ require_once __DIR__ . '/../../bootstrap.php';
+
+ if (!VersionPress::isActive()) {
+ WP_CLI::error('Unfortunately, this site was not tracked by VersionPress.
+ Therefore, it cannot be restored.');
+ }
+
+ // Check if the site is installed
+ $process = VPCommandUtils::runWpCliCommand('core', 'is-installed');
+ if ($process->isSuccessful()) {
+ $this->checkVpRequirements($assoc_args, RequirementsChecker::ENVIRONMENT);
+ WP_CLI::confirm(
+ "It looks like the site is OK. Do you really want to run the 'restore-site' command?",
+ $assoc_args
+ );
+ }
+
+ $url = $assoc_args['siteurl'];
+
+ // Update URLs in wp-config.php
+ define('VP_INDEX_DIR', dirname(\WP_CLI\Utils\locate_wp_config())); // just for the following method
+ $this->setConfigUrl('WP_CONTENT_URL', 'WP_CONTENT_DIR', ABSPATH . 'wp-content', $url);
+ $this->setConfigUrl('WP_PLUGIN_URL', 'WP_PLUGIN_DIR', WP_CONTENT_DIR . '/plugins', $url);
+ $this->setConfigUrl('WP_HOME', 'VP_INDEX_DIR', VP_PROJECT_ROOT, $url);
+
+ defined('WP_PLUGIN_DIR') || define('WP_PLUGIN_DIR', WP_CONTENT_DIR . '/plugins');
+
+ WpConfigSplitter::ensureCommonConfigInclude($wpConfigPath);
+
+ // Disable VersionPress tracking for a while
+ WpdbReplacer::restoreOriginal();
+ unlink(VERSIONPRESS_ACTIVATION_FILE);
+
+ // Create or empty database
+ $this->prepareDatabase($assoc_args);
+
+
+ // Create WP tables.
+ // The only important thing is site URL, all else will be rewritten later during synchronization.
+ $installArgs = [
+ 'url' => $url,
+ 'title' => 'x',
+ 'admin_user' => 'x',
+ 'admin_password' => 'x',
+ 'admin_email' => 'x@example.com',
+ ];
+
+ if (version_compare(WP_CLI_VERSION, '0.22.0', '>=')) {
+ $installArgs['skip-email'] = null;
+ }
+
+ $process = VPCommandUtils::runWpCliCommand('core', 'install', $installArgs);
+ if (!$process->isSuccessful()) {
+ WP_CLI::log("Failed creating database tables");
+ WP_CLI::error($process->getConsoleOutput());
+ } else {
+ WP_CLI::success("Database tables created");
+ }
+
+ // Restores "wp-db.php", "wp-db.php.original" and ".active" - enables VP
+ $resetCmd = 'git reset --hard';
+
+ $process = VPCommandUtils::exec($resetCmd);
+ if (!$process->isSuccessful()) {
+ WP_CLI::log("Could not clean working directory");
+ WP_CLI::error($process->getConsoleOutput());
+ }
+
+ // Fail-safe for gitignored WordPress
+ if (!WpdbReplacer::isReplaced()) {
+ WpdbReplacer::replaceMethods();
+ }
+
+ /* We need correct value in the `active_plugins` option before the synchronization run.
+ * Without this option VersionPress doesn't know which schema.yml files it should load and consequently which
+ * DB entities it should synchronize.
+ */
+ $activePluginsOption = IniSerializer::deserialize(file_get_contents(VP_VPDB_DIR . '/options/ac/active_plugins.ini'));
+ $activePlugins = json_encode(unserialize($activePluginsOption['active_plugins']['option_value']));
+
+ VPCommandUtils::runWpCliCommand('option', 'update', ['active_plugins', $activePlugins, 'autoload' => 'yes', 'format' => 'json', 'skip-plugins' => null]);
+
+ // The next couple of the steps need to be done after WP is fully loaded; we use `finish-restore-site` for that
+ // The main reason for this is that we need properly set WP_CONTENT_DIR constant for reading from storages
+ $process = $this->runVPInternalCommand('finish-restore-site');
+ WP_CLI::log($process->getConsoleOutput());
+ if (!$process->isSuccessful()) {
+ WP_CLI::error("Could not finish site restore");
+ }
+ }
+
+ /**
+ * Prepares an empty database - creates it if it doesn't exist or drops its WP tables if it does.
+ * Prompt will be displayed if the tables are going to be dropped, unless 'yes' is provided
+ * as part of $assoc_args.
+ *
+ * @param array $assoc_args
+ */
+ private function prepareDatabase($assoc_args)
+ {
+
+ $process = VPCommandUtils::runWpCliCommand('db', 'create');
+
+ if ($process->isSuccessful()) {
+ WP_CLI::success("Database created");
+ return;
+ }
+
+ $msg = $process->getConsoleOutput();
+ $dbExistsMysqlErrorCode = '1007';
+ $dbExists = Strings::contains($msg, $dbExistsMysqlErrorCode);
+
+ if (!$dbExists) {
+ WP_CLI::error("Failed creating database. Details:\n\n" . $msg);
+ }
+
+ global $table_prefix;
+ if ($this->someWpTablesExist(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST, $table_prefix)) {
+ WP_CLI::confirm('Database tables already exist, they will be droped and re-created. Proceed?', $assoc_args);
+ }
+
+ $this->dropTables();
+ }
+
+ /**
+ * Clones site to a new folder and database.
+ *
+ * ## OPTIONS
+ *
+ * --name=
+ * : Name of the clone. Used as a directory name, part of the DB prefix
+ * and an argument to the pull & push commands later.
+ *
+ * [--siteurl=]
+ * : URL of the clone. By default, the original URL is searched for
+ * and replaced with the clone name.
+ *
+ * [--dbname=]
+ * : Database name for the clone.
+ *
+ * [--dbuser=]
+ * : Database user for the clone.
+ *
+ * [--dbpass=]
+ * : Database user password for the clone.
+ *
+ * [--dbhost=]
+ * : Database host for the clone.
+ *
+ * [--dbprefix=]
+ * : Database table prefix for the clone.
+ *
+ * [--dbcharset=]
+ * : Database charset for the clone.
+ *
+ * [--dbcollate=]
+ * : Database collation for the clone.
+ *
+ * [--force]
+ * : Forces cloning even if the target directory or DB tables exists.
+ * Basically provides --yes to all warnings / confirmations.
+ *
+ * [--yes]
+ * : Another way to force the clone
+ *
+ * ## EXAMPLES
+ *
+ * The main site lives in a directory 'wpsite', uses the 'wp_' database table prefix and is
+ * accessible via 'http://localhost/wpsite'. The command
+ *
+ * wp vp clone --name=myclone
+ *
+ * does the following:
+ *
+ * - Creates new directory 'myclone' next to the current one
+ * - Clones the files there
+ * - Creates new database tables prefixed with 'wp_myclone_'
+ * - Populates database tables with data
+ * - Makes the site accessible as 'http://localhost/myclone'
+ *
+ *
+ * @subcommand clone
+ *
+ */
+ public function cloneSite($args = [], $assoc_args = [])
+ {
+ global $table_prefix;
+
+ if (isset($assoc_args['force'])) {
+ $assoc_args['yes'] = 1;
+ }
+
+ if (!VersionPress::isActive()) {
+ WP_CLI::error('This site is not tracked by VersionPress. Please run "wp vp activate" before cloning.');
+ }
+
+ $name = $assoc_args['name'];
+
+ if (!WorkflowUtils::isCloneNameValid($name)) {
+ // @codingStandardsIgnoreLine
+ WP_CLI::error("Clone name '$name' is not valid. It can only contain letters, numbers, hyphens and underscores.");
+ }
+
+ $currentWpPath = realpath(VP_PROJECT_ROOT);
+ $cloneDirName = $name;
+ $clonePath = dirname($currentWpPath) . '/' . $cloneDirName;
+ $cloneVpPluginPath = $clonePath . '/' . str_replace($currentWpPath, '', realpath(VERSIONPRESS_PLUGIN_DIR));
+
+ $cloneDbUser = isset($assoc_args['dbuser']) ? $assoc_args['dbuser'] : DB_USER;
+ $cloneDbPassword = isset($assoc_args['dbpass']) ? $assoc_args['dbpass'] : DB_PASSWORD;
+ $cloneDbName = isset($assoc_args['dbname']) ? $assoc_args['dbname'] : DB_NAME;
+ $cloneDbHost = isset($assoc_args['dbhost']) ? $assoc_args['dbhost'] : DB_HOST;
+ $cloneDbPrefix = isset($assoc_args['dbprefix']) ? $assoc_args['dbprefix'] : ($table_prefix . $name . '_');
+ $cloneDbCharset = isset($assoc_args['dbcharset']) ? $assoc_args['dbcharset'] : DB_CHARSET;
+ $cloneDbCollate = isset($assoc_args['dbcollate']) ? $assoc_args['dbcollate'] : DB_COLLATE;
+
+ // Checking the DB prefix, regex from wp-admin/setup-config.php
+ if (isset($assoc_args['dbprefix']) && preg_match('|[^a-z0-9_]|i', $cloneDbPrefix)) {
+ // @codingStandardsIgnoreLine
+ WP_CLI::error("Table prefix '$cloneDbPrefix' is not valid. It can only contain letters, numbers and underscores. Please choose different one.");
+ }
+
+ $prefixChanged = false;
+ if (Strings::contains($cloneDbPrefix, '-')) {
+ $cloneDbPrefix = str_replace('-', '_', $cloneDbPrefix);
+ $prefixChanged = true;
+ }
+
+ $currentUrl = get_home_url();
+ $suggestedUrl = $this->suggestCloneUrl($currentUrl, basename($currentWpPath), $cloneDirName);
+
+ if (!$suggestedUrl && !isset($assoc_args['siteurl'])) {
+ WP_CLI::error("The command cannot derive default clone URL. Please specify the --siteurl parameter.");
+ }
+
+ $cloneUrl = isset($assoc_args['siteurl']) ? $assoc_args['siteurl'] : $suggestedUrl;
+ $urlChanged = !isset($assoc_args['siteurl']) && !Strings::contains($cloneUrl, $cloneDirName);
+
+ if (is_dir($clonePath)) {
+ // @codingStandardsIgnoreLine
+ WP_CLI::confirm("Directory '" . basename($clonePath) . "' already exists, it will be deleted before cloning. Proceed?", $assoc_args);
+ }
+
+ if ($this->someWpTablesExist($cloneDbUser, $cloneDbPassword, $cloneDbName, $cloneDbHost, $cloneDbPrefix)) {
+ // @codingStandardsIgnoreLine
+ WP_CLI::confirm("Database tables for the clone already exist, they will be dropped and re-created. Proceed?", $assoc_args);
+ }
+
+ if (is_dir($clonePath)) {
+ try {
+ FileSystem::removeContent($clonePath);
+ } catch (IOException $e) {
+ WP_CLI::error("Could not delete directory '" . basename($clonePath) . "'. Please do it manually.");
+ }
+ }
+
+ vp_commit_all_frequently_written_entities();
+
+ // Clone the site
+ $cloneCommand = sprintf("git clone %s %s", ProcessUtils::escapeshellarg($currentWpPath), ProcessUtils::escapeshellarg($clonePath));
+
+ $process = VPCommandUtils::exec($cloneCommand, $currentWpPath);
+
+ if (!$process->isSuccessful()) {
+ WP_CLI::error($process->getConsoleOutput(), false);
+ WP_CLI::error("Cloning Git repo failed");
+ } else {
+ WP_CLI::success("Site files cloned");
+ }
+
+ // Adding the clone as a remote for the convenience of the `vp pull` command - its `--from`
+ // parameter can then be just the name of the clone, not a path to it
+ $addRemoteCommand = sprintf("git remote add %s %s", ProcessUtils::escapeshellarg($name), ProcessUtils::escapeshellarg($clonePath));
+ $process = VPCommandUtils::exec($addRemoteCommand, $currentWpPath);
+
+ if (!$process->isSuccessful()) {
+ // @codingStandardsIgnoreLine
+ $overwriteRemote = VPCommandUtils::cliQuestion("The Git repo of this site already defines remote '$name', overwrite it?", ["y", "n"], $assoc_args);
+
+ if ($overwriteRemote == "y") {
+ $addRemoteCommand = str_replace(" add ", " set-url ", $addRemoteCommand);
+ $process = VPCommandUtils::exec($addRemoteCommand, $currentWpPath);
+ if (!$process->isSuccessful()) {
+ WP_CLI::error("Could not update remote's URL");
+ } else {
+ WP_CLI::success("Updated remote configuration");
+ }
+ }
+ } else {
+ WP_CLI::success("Clone added as a remote");
+ }
+
+
+ // Enable pushing to origin
+ $configCommand = "git config receive.denyCurrentBranch ignore";
+ $process = VPCommandUtils::exec($configCommand);
+
+ if ($process->isSuccessful()) {
+ WP_CLI::success("Enabled pushing to the original repository");
+ } else {
+ WP_CLI::error("Cannot enable pushing to the original repository");
+ }
+
+ // Enable pushing to clone
+ $configCommand = "git config receive.denyCurrentBranch ignore";
+ $process = VPCommandUtils::exec($configCommand, $clonePath);
+
+ if ($process->isSuccessful()) {
+ WP_CLI::success("Enabled pushing to the clone");
+ } else {
+ WP_CLI::error("Cannot enable pushing to the clone");
+ }
+
+ // Copy & Update wp-config
+ $wpConfigFile = \WP_CLI\Utils\locate_wp_config();
+ $cloneConfigFile = str_replace($currentWpPath, $clonePath, $wpConfigFile);
+ copy($wpConfigFile, $cloneConfigFile);
+
+ $this->updateConfig(
+ $clonePath,
+ $name,
+ $cloneDbUser,
+ $cloneDbPassword,
+ $cloneDbName,
+ $cloneDbHost,
+ $cloneDbPrefix,
+ $cloneDbCharset,
+ $cloneDbCollate
+ );
+
+ // Copy VersionPress
+ FileSystem::copyDir(VERSIONPRESS_PLUGIN_DIR, $cloneVpPluginPath);
+ WP_CLI::success("Copied VersionPress");
+
+ // Finish the process by doing the standard restore-site
+ $relativePathToThisFile = PathUtils::getRelativePath($currentWpPath, __FILE__);
+ $process = VPCommandUtils::runWpCliCommand(
+ 'vp',
+ 'restore-site',
+ ['siteurl' => $cloneUrl, 'yes' => null, 'require' => $relativePathToThisFile],
+ $clonePath
+ );
+ WP_CLI::log(trim($process->getConsoleOutput()));
+
+ if ($process->isSuccessful()) {
+ WP_CLI::success("All done. Clone created here:");
+ WP_CLI::log("");
+ WP_CLI::log("Path: $clonePath");
+ WP_CLI::log("URL: $cloneUrl");
+
+ if ($urlChanged) {
+ WP_CLI::log("Note: Underscores changed to hyphens for URL.");
+ }
+
+ if ($prefixChanged) {
+ WP_CLI::log("Note: Hyphens changed to underscores for DB prefix.");
+ }
+ }
+ }
+
+ /**
+ * Suggests clone URL by replacing directory names. If no suggestion can be made, returns null.
+ *
+ * Examples (original dir "original", clone name "clone"):
+ *
+ * http://localhost/original -> http://localhost/clone
+ * http://original -> http://clone
+ * http://www.original.dev -> http://www.clone.dev
+ * http://example.com -> null
+ *
+ * @param string $originUrl
+ * @param string $originDirName
+ * @param string $cloneDirName
+ * @return string
+ */
+ private function suggestCloneUrl($originUrl, $originDirName, $cloneDirName)
+ {
+ if (!Strings::contains($originUrl, $originDirName)) {
+ return null;
+ }
+
+ return str_replace($originDirName, $cloneDirName, $originUrl);
+ }
+
+ /**
+ * Pulls changes from another clone
+ *
+ * ## OPTIONS
+ *
+ * [--from=]
+ * : Where to pull from. Can be a clone name (specified previously during the
+ * 'clone' command), a path or a URL. Defaults to 'origin' which is
+ * automatically set in every clone by the 'clone' command.
+ *
+ * [--continue]
+ * : Finishes the pull after solving merge conflicts.
+ *
+ * ## EXAMPLES
+ *
+ * Let's have a site 'wpsite' and a clone 'myclone' created from it. To pull the changes
+ * from the clone back into the main site, use:
+ *
+ * wp vp pull --from=myclone
+ *
+ * When in the clone, the pull can be run without any parameter:
+ *
+ * wp vp pull
+ *
+ * This will pull the changes from 'origin' which was set to the parent site during the
+ * 'clone' command.
+ *
+ */
+ public function pull($args = [], $assoc_args = [])
+ {
+ if (!VersionPress::isActive()) {
+ WP_CLI::error(
+ 'This site is not tracked by VersionPress. Please run "wp vp activate" before cloning / merging.'
+ );
+ }
+
+ if (isset($assoc_args['continue'])) {
+ $process = new Process('git diff --name-only --diff-filter=U', VP_PROJECT_ROOT);
+ $process->run();
+
+ if ($process->getConsoleOutput() !== '') {
+ WP_CLI::error(
+ 'There are still some conflicts. Please resolve them and run `wp vp pull --continue` again.'
+ );
+ }
+
+ $this->finishPull();
+ return;
+ }
+
+
+ $remote = isset($assoc_args['from']) ? $assoc_args['from'] : 'origin';
+
+ $process = VPCommandUtils::exec("git config --get remote." . ProcessUtils::escapeshellarg($remote) . ".url");
+ $remoteUrl = $process->getConsoleOutput();
+
+ if (is_dir($remoteUrl)) {
+ $this->runVPInternalCommand('commit-frequently-written-entities', [], $remoteUrl);
+ } else {
+ // We currently do not support commiting frequently written entities for repositories on a different server
+ }
+
+ $this->switchMaintenance('on');
+
+ $branchToPullFrom = 'master'; // hardcoded until we support custom branches
+ $pullCommand = 'git pull ' . ProcessUtils::escapeshellarg($remote) . ' ' . $branchToPullFrom;
+ $process = VPCommandUtils::exec($pullCommand);
+
+ if ($process->isSuccessful()) {
+ WP_CLI::success("Pulled changes from '$remote'");
+ } else {
+ if (stripos($process->getConsoleOutput(), 'automatic merge failed') !== false) {
+ WP_CLI::warning("");
+ WP_CLI::warning("CONFLICTS DETECTED. Your options:");
+ WP_CLI::warning("");
+ WP_CLI::warning(" 1) Keep the conflicts. You will be able to resolve them manually.");
+ WP_CLI::warning(" 2) Abort the process. The site will look like you never ran the pull.");
+ WP_CLI::warning("");
+
+ fwrite(STDOUT, "Choose 1 or 2: ");
+ $answer = trim(fgets(STDIN));
+
+ if ($answer == "1") {
+ WP_CLI::success("You've chosen to keep the conflicts on the disk. MAINTENANCE MODE IS STILL ON.");
+ WP_CLI::success("");
+ WP_CLI::success("Do this now:");
+ WP_CLI::success("");
+ WP_CLI::success(" 1. Resolve the conflicts manually as in a standard Git workflow");
+ WP_CLI::success(" 2. Stage and `git commit` the changes");
+ WP_CLI::success(" 3. Return here and run `wp vp pull --continue`");
+ WP_CLI::success("");
+ WP_CLI::success("That last step will turn the maintenance mode off.");
+ WP_CLI::success("You can also abort the merge manually by running `git merge --abort`");
+ exit();
+ } else {
+ $process = VPCommandUtils::exec('git merge --abort');
+ if ($process->isSuccessful()) {
+ $this->switchMaintenance('off');
+ WP_CLI::success("Pull aborted, your site is now clean and running");
+ exit();
+ } else {
+ WP_CLI::error("Aborting pull failed, do it manually by executing 'git merge --abort'", false);
+ WP_CLI::error("and also don't fortget to turn off the maintenance mode.");
+ }
+ }
+ } else { // not a merge conflict, some other error
+ $this->switchMaintenance('off');
+ WP_CLI::error("Changes from $remote couldn't be pulled. Details:\n\n" . $process->getConsoleOutput());
+ }
+ }
+
+ $this->finishPull();
+ }
+
+ private function finishPull()
+ {
+ global $versionPressContainer;
+
+ if (file_exists(VP_PROJECT_ROOT . '/composer.json')) {
+ $process = VPCommandUtils::exec('composer install', VP_PROJECT_ROOT);
+ if ($process->isSuccessful()) {
+ WP_CLI::success('Installed Composer dependencies');
+ } else {
+ WP_CLI::error('Composer dependencies could not be restored.');
+ }
+ }
+
+ /** @var ActionsDefinitionRepository $actionsDefinitionRepository */
+ $actionsDefinitionRepository = $versionPressContainer->resolve(VersionPressServices::ACTIONS_DEFINITION_REPOSITORY);
+ $actionsDefinitionRepository->restoreAllActionsFilesFromHistory();
+
+ // Run synchronization
+ /** @var SynchronizationProcess $syncProcess */
+ $syncProcess = $versionPressContainer->resolve(VersionPressServices::SYNCHRONIZATION_PROCESS);
+ $syncProcess->synchronizeAll();
+ WP_CLI::success("Synchronized database");
+
+ $this->switchMaintenance('off');
+ vp_flush_regenerable_options();
+ $this->flushRewriteRules();
+
+ WP_CLI::success("All done");
+ }
+
+ /**
+ * Applies changes from the disk to the database
+ *
+ * ## EXAMPLES
+ *
+ * This command is mainly used in a merge conflict situation, after a 'pull'. When
+ * the conflict is manually resolved and committed, run this command to make sure that
+ * the database in sync with the Git repository / filesystem:
+ *
+ * wp vp apply-changes
+ *
+ * Note that this command temporarily turns on the maintenance mode.
+ *
+ * @subcommand apply-changes
+ */
+ public function applyChanges($args = [], $assoc_args = [])
+ {
+
+ global $versionPressContainer;
+
+ $this->switchMaintenance('on');
+
+ /** @var ActionsDefinitionRepository $actionsDefinitionRepository */
+ $actionsDefinitionRepository = $versionPressContainer->resolve(VersionPressServices::ACTIONS_DEFINITION_REPOSITORY);
+ $actionsDefinitionRepository->restoreAllActionsFilesFromHistory();
+
+ /** @var SynchronizationProcess $syncProcess */
+ $syncProcess = $versionPressContainer->resolve(VersionPressServices::SYNCHRONIZATION_PROCESS);
+ $syncProcess->synchronizeAll();
+ WP_CLI::success("Database updated");
+ $this->switchMaintenance('off');
+ vp_flush_regenerable_options();
+ $this->flushRewriteRules();
+
+ WP_CLI::success("All done");
+ }
+
+ /**
+ * Pushes changes to another clone
+ *
+ * ## OPTIONS
+ *
+ * [--to=]
+ * : Name of the clone or a path to it. Defaults to 'origin' which, in a clone,
+ * points to its original site.
+ *
+ * ## EXAMPLES
+ *
+ * Push is a similar command to 'pull' but does not create a merge. To push from clone
+ * to the original site, run:
+ *
+ * wp vp push
+ *
+ * To push from the original site to the clone, use the '--to' parameter:
+ *
+ * wp vp push --to=clonename
+ *
+ *
+ */
+ public function push($args = [], $assoc_args = [])
+ {
+
+ if (!VersionPress::isActive()) {
+ WP_CLI::error(
+ 'This site is not tracked by VersionPress. Please run "wp vp activate" before cloning / merging.'
+ );
+ }
+
+ $remoteName = isset($assoc_args['to']) ? $assoc_args['to'] : 'origin';
+ $remotePath = $this->getRemoteUrl($remoteName);
+ if ($remotePath === null) {
+ $remotePath = $remoteName;
+ if (!is_dir($remotePath)) {
+ WP_CLI::error("'$remotePath' is not a valid path to a WP site");
+ }
+ }
+
+ $this->switchMaintenance('on', $remoteName);
+
+ vp_commit_all_frequently_written_entities();
+
+ $currentPushType = trim(VPCommandUtils::exec('git config --local push.default')->getOutput());
+ VPCommandUtils::exec('git config --local push.default simple');
+
+ // hardcoded branch name until we support custom branches
+ $pushCommand = "git push --set-upstream $remoteName master";
+
+ $process = VPCommandUtils::exec($pushCommand);
+ if ($process->isSuccessful()) {
+ WP_CLI::success("Changes successfully pushed");
+ } else {
+ $this->switchMaintenance('off', $remoteName);
+ WP_CLI::error("Changes couldn't be pushed. Details:\n\n" . $process->getConsoleOutput());
+ }
+
+ if ($currentPushType === '') { // implicit value
+ VPCommandUtils::exec("git config --local --unset push.default");
+ } else {
+ VPCommandUtils::exec("git config --local push.default $currentPushType");
+ }
+
+ $gitConfigPath = VP_PROJECT_ROOT . '/.git/config';
+ GitConfig::removeEmptySections($gitConfigPath);
+
+ $process = $this->runVPInternalCommand('finish-push', [], $remotePath);
+ if ($process->isSuccessful()) {
+ WP_CLI::success("Remote database synchronized");
+ } else {
+ WP_CLI::error("Push couldn't be finished. Details:\n\n" . $process->getConsoleOutput());
+ }
+ $this->switchMaintenance('off', $remoteName);
+ WP_CLI::success("All done");
+ }
+
+ /**
+ * Reverts commits
+ *
+ * ## OPTIONS
+ *
+ *
+ * : Hashes of commit that will be reverted (separated by comma).
+ *
+ * ## EXAMPLES
+ *
+ * wp vp undo a34bc28,d12ef22
+ *
+ *
+ * @when before_wp_load
+ */
+ public function undo($args = [], $assoc_args = [])
+ {
+ global $versionPressContainer;
+
+ if (!VersionPress::isActive()) {
+ WP_CLI::error('This site is not tracked by VersionPress. Please run "wp vp activate" first.');
+ }
+
+ /** @var Reverter $reverter */
+ $reverter = $versionPressContainer->resolve(VersionPressServices::REVERTER);
+ /** @var GitRepository $repository */
+ $repository = $versionPressContainer->resolve(VersionPressServices::GIT_REPOSITORY);
+
+ $initialCommitHash = $this->getInitialCommitHash($repository);
+
+ $commits = explode(',', $args[0]);
+ foreach ($commits as $hash) {
+ $log = $repository->log($hash);
+ if (!preg_match('/^[0-9a-f]+$/', $hash) || count($log) === 0) {
+ WP_CLI::error("Commit '$hash' does not exist.");
+ }
+ if ($log[0]->isMerge()) {
+ WP_CLI::error('Cannot undo merge commit.');
+ }
+ if (!$repository->wasCreatedAfter($hash, $initialCommitHash)) {
+ WP_CLI::error('Cannot undo changes before initial commit');
+ }
+ }
+
+ $this->switchMaintenance('on');
+
+ $status = $reverter->undo($commits);
+
+ if ($status === RevertStatus::VIOLATED_REFERENTIAL_INTEGRITY) {
+ WP_CLI::error(
+ "Violated referential integrity. Objects with missing references cannot be restored. " .
+ "For example we cannot restore comment where the related post was deleted.",
+ false
+ );
+ }
+
+ if ($status === RevertStatus::MERGE_CONFLICT) {
+ WP_CLI::error("Merge conflict. Overwritten changes can not be reverted.", false);
+ }
+
+ if ($status === RevertStatus::NOT_CLEAN_WORKING_DIRECTORY) {
+ WP_CLI::error("The working directory is not clean. Please commit your changes.", false);
+ }
+
+ if ($status === RevertStatus::REVERTING_MERGE_COMMIT) {
+ WP_CLI::error("Cannot undo a merge commit.", false);
+ }
+
+ if ($status === RevertStatus::NOTHING_TO_COMMIT) {
+ WP_CLI::error("Nothing to commit. Current state is the same as the one after the undo.", false);
+ }
+
+ if ($status === RevertStatus::OK) {
+ WP_CLI::success("Undo was successful.");
+ }
+
+ $this->switchMaintenance('off');
+ $this->flushRewriteRules();
+ }
+
+ /**
+ * Rollbacks site to the same state as it was in the specified commit.
+ *
+ * ## OPTIONS
+ *
+ *
+ * : Hash of commit.
+ *
+ * ## EXAMPLES
+ *
+ * wp vp rollback a34bc28
+ *
+ *
+ * @when before_wp_load
+ *
+ */
+ public function rollback($args = [], $assoc_args = [])
+ {
+ global $versionPressContainer;
+
+ if (!VersionPress::isActive()) {
+ WP_CLI::error('This site is not tracked by VersionPress. Please run "wp vp activate" first.');
+ }
+
+ /** @var Reverter $reverter */
+ $reverter = $versionPressContainer->resolve(VersionPressServices::REVERTER);
+ /** @var GitRepository $repository */
+ $repository = $versionPressContainer->resolve(VersionPressServices::GIT_REPOSITORY);
+
+ $initialCommitHash = $this->getInitialCommitHash($repository);
+
+ $hash = $args[0];
+ $log = $repository->log($hash);
+ if (!preg_match('/^[0-9a-f]+$/', $hash) || count($log) === 0) {
+ WP_CLI::error("Commit '$hash' does not exist.");
+ }
+ if (!$repository->wasCreatedAfter($hash, $initialCommitHash) && $log[0]->getHash() !== $initialCommitHash) {
+ WP_CLI::error('Cannot roll back before initial commit');
+ }
+ if ($log[0]->getHash() === $repository->getLastCommitHash()) {
+ WP_CLI::error('Nothing to commit. Current state is the same as the one you want rollback to.');
+ }
+
+
+ $this->switchMaintenance('on');
+
+ $status = $reverter->rollback([$hash]);
+
+ if ($status === RevertStatus::NOTHING_TO_COMMIT) {
+ WP_CLI::error("Nothing to commit. Current state is the same as the one you want rollback to.", false);
+ }
+
+ if ($status === RevertStatus::NOT_CLEAN_WORKING_DIRECTORY) {
+ WP_CLI::error("The working directory is not clean. Please commit your changes.", false);
+ }
+
+ if ($status === RevertStatus::OK) {
+ WP_CLI::success("Rollback was successful.");
+ }
+
+ $this->switchMaintenance('off');
+ $this->flushRewriteRules();
+ }
+
+ private function dropTables()
+ {
+ $tables = [
+ 'users',
+ 'usermeta',
+ 'posts',
+ 'comments',
+ 'links',
+ 'options',
+ 'postmeta',
+ 'terms',
+ 'term_taxonomy',
+ 'termmeta',
+ 'term_relationships',
+ 'commentmeta',
+ 'vp_id',
+ ];
+
+ $tables = array_map(function ($table) {
+ global $table_prefix;
+ return $table_prefix . $table;
+ }, $tables);
+
+ foreach ($tables as $table) {
+ VPCommandUtils::runWpCliCommand('db', 'query', ["DROP TABLE IF EXISTS `$table`"]);
+ }
+ }
+
+ /**
+ * Updates VersionPress
+ *
+ * ## OPTIONS
+ *
+ *
+ * : Path to ZIP file containing VersionPress.
+ *
+ * ## EXAMPLES
+ *
+ * wp vp update ../versionpress-4.0.zip
+ *
+ *
+ */
+ public function update($args = [], $assoc_args = [])
+ {
+ global $versionPressContainer;
+
+ $zip = $args[0];
+ if (!is_file($zip)) {
+ WP_CLI::error("File '$zip' not found.");
+ }
+
+ $this->switchMaintenance('on');
+
+ /** @var Committer $committer */
+ $committer = $versionPressContainer->resolve(VersionPressServices::COMMITTER);
+ $committer->disableCommit();
+
+ vp_deactivate();
+ WP_CLI::success('Deactivated VersionPress');
+
+ /** @var \Plugin_Upgrader $upgrader */
+ $upgrader = WP_CLI\Utils\get_upgrader(WP_CLI\DestructivePluginUpgrader::class);
+ // Use silent upgrader skin - we don't need any output from the upgrader
+ $upgrader->skin = new SilentUpgraderSkin();
+
+ $result = $upgrader->run([
+ 'package' => $zip,
+ 'destination' => WP_PLUGIN_DIR,
+ 'hook_extra' => [
+ 'type' => 'plugin',
+ 'action' => 'update',
+ 'plugin' => 'versionpress/versionpress.php',
+ ]
+ ]);
+
+ if ($result) {
+ WP_CLI::success('Updated VersionPress');
+
+ $process = $this->runVPInternalCommand('finish-update');
+ echo $process->getConsoleOutput();
+
+ $this->switchMaintenance('off');
+ } else {
+ WP_CLI::error(join("\n", [
+ 'Update failed. Unfortunatelly, you have to manually update VersionPress.',
+ ' 1. Delete wp-content/versionpress.',
+ ' 2. Extract the ZIP to wp-content/versionpress.',
+ ' 3. Run \'wp plugin activate versionpress\' and \'wp vp activate\'.',
+ ' 4. Delete the \'.maintenance\' file.',
+ ]));
+ }
+ }
+
+ /**
+ * Checks if some tables with the given prefix exist in the database
+ *
+ * @param string $dbUser
+ * @param string $dbPassword
+ * @param string $dbName
+ * @param string $dbHost
+ * @param string $dbPrefix
+ * @return bool
+ */
+ private function someWpTablesExist($dbUser, $dbPassword, $dbName, $dbHost, $dbPrefix)
+ {
+ $wpdb = new \wpdb($dbUser, $dbPassword, $dbName, $dbHost);
+ $wpdb->set_prefix($dbPrefix);
+ $tables = $wpdb->get_col("SHOW TABLES LIKE '{$dbPrefix}_%'");
+ $wpTables = array_intersect($tables, $wpdb->tables());
+ return count($wpTables) > 0;
+ }
+
+ private function updateConfig(
+ $clonePath,
+ $environment,
+ $dbUser,
+ $dbPassword,
+ $dbName,
+ $dbHost,
+ $dbPrefix,
+ $dbCharset,
+ $dbCollate
+ ) {
+ $environmentConstant = 'VP_ENVIRONMENT';
+
+ $replacements = [
+ "DB_NAME" => $dbName,
+ "DB_USER" => $dbUser,
+ "DB_PASSWORD" => $dbPassword,
+ "DB_HOST" => $dbHost,
+ "DB_CHARSET" => $dbCharset,
+ "DB_COLLATE" => $dbCollate,
+ $environmentConstant => $environment,
+ ];
+
+ $process = $this->runVPInternalCommand(
+ 'update-config',
+ ['table_prefix', $dbPrefix, 'variable' => null],
+ $clonePath
+ );
+
+ echo $process->getConsoleOutput();
+
+ foreach ($replacements as $constant => $value) {
+ $process = $this->runVPInternalCommand('update-config', [$constant, $value], $clonePath);
+ echo $process->getConsoleOutput();
+ }
+
+ WP_CLI::success("wp-config.php updated");
+ }
+
+ /**
+ * Returns URL for a remote name, or null if the remote isn't configured.
+ * For example, for "origin", it might return "https://github.com/project/repo.git".
+ *
+ * @param string $name Remote name, e.g., "origin"
+ * @return string|null Remote URL, or null if remote isn't configured
+ */
+ private function getRemoteUrl($name)
+ {
+ $listRemotesCommand = "git remote -v";
+ $remotesRaw = VPCommandUtils::exec($listRemotesCommand)->getConsoleOutput();
+
+ // https://regex101.com/r/iQ4kG4/2
+ $numberOfMatches = preg_match_all("/^([[:alnum:]]+)\\s+(.*) \\(fetch\\)$/m", $remotesRaw, $matches);
+ if ($numberOfMatches === 0) {
+ return null;
+ }
+
+ $remotes = [];
+ foreach ($matches[1] as $i => $cloneName) {
+ $url = $matches[2][$i];
+ $remotes[$cloneName] = $url;
+ }
+
+ if (isset($remotes[$name])) {
+ return $remotes[$name];
+ }
+
+ return null;
+ }
+
+ /**
+ * Switches the maintenance mode on or off for a site specified by a remote.
+ * The remote must be "local" - on the same filesystem. If no remote name is
+ * given, the current site's maintenance mode is switched.
+ *
+ * @param string $onOrOff "on" | "off"
+ * @param string|null $remoteName
+ */
+ private function switchMaintenance($onOrOff, $remoteName = null)
+ {
+ $remotePath = $remoteName ? $this->getRemoteUrl($remoteName) : null;
+ $process = $this->runVPInternalCommand('maintenance', [$onOrOff], $remotePath);
+
+ if ($process->isSuccessful()) {
+ WP_CLI::success("Maintenance mode turned $onOrOff" . ($remoteName ? " for '$remoteName'" : ""));
+ } else {
+ WP_CLI::error(
+ "Maintenance mode couldn't be switched" .
+ ($remoteName ? " for '$remoteName'" : "") .
+ ". Details:\n\n" . $process->getConsoleOutput()
+ );
+ }
+ }
+
+ private function runVPInternalCommand($subcommand, $args = [], $cwd = null)
+ {
+ $args = ['require' => __DIR__ . '/vp-internal.php'] + $args;
+ return VPCommandUtils::runWpCliCommand('vp-internal', $subcommand, $args, $cwd);
+ }
+
+ private function flushRewriteRules()
+ {
+ set_transient('vp_flush_rewrite_rules', 1);
+ /**
+ * If it fails, we just flush the rewrite rules on the next request.
+ * The disadvantage is that until the next (valid) request all rewritten
+ * URLs may be broken.
+ * Valid request is such a request, which does not require URL rewrite
+ * (e.g. homepage / administration) and finishes successfully.
+ */
+ wp_remote_get(get_home_url());
+ }
+
+ private function setConfigUrl($urlConstant, $pathConstant, $defaultPath, $baseUrl)
+ {
+ if (defined($pathConstant) && constant($pathConstant) !== $defaultPath) {
+ $wpConfigDir = dirname(\WP_CLI\Utils\locate_wp_config());
+ $relativePathToWpContent = str_replace($wpConfigDir, '', realpath(constant($pathConstant)));
+ $url = rtrim(rtrim($baseUrl, '/') . str_replace('//', '/', '/' . $relativePathToWpContent), '/');
+ $this->runVPInternalCommand('update-config', [$urlConstant, $url]);
+ }
+ }
+
+ /**
+ * @param $assoc_args
+ * @param $requirementsScope string of the requirements
+ */
+ private function checkVpRequirements($assoc_args, $requirementsScope)
+ {
+ require_once ABSPATH . WPINC . '/formatting.php';
+ require_once ABSPATH . WPINC . '/theme.php';
+ require_once ABSPATH . WPINC . '/link-template.php';
+
+ global $versionPressContainer;
+
+ $database = $versionPressContainer->resolve(VersionPressServices::WPDB);
+ $schema = $requirementsScope === RequirementsChecker::ENVIRONMENT ? null : $versionPressContainer->resolve(VersionPressServices::DB_SCHEMA);
+
+ $requirementsChecker = new RequirementsChecker($database, $schema, $requirementsScope);
+
+ $report = $requirementsChecker->getRequirements();
+
+ foreach ($report as $requirement) {
+ if ($requirement['fulfilled']) {
+ WP_CLI::success($requirement['name']);
+ } else {
+ if ($requirement['level'] === 'critical') {
+ WP_CLI::error($requirement['name'], false);
+ } else {
+ VPCommandUtils::warning($requirement['name']);
+ }
+ WP_CLI::log(' ' . $requirement['help']);
+ }
+ }
+
+ WP_CLI::line('');
+
+ if (!$requirementsChecker->isWithoutCriticalErrors()) {
+ WP_CLI::error('VersionPress cannot be fully activated.');
+ }
+
+ if (!$requirementsChecker->isEverythingFulfilled()) {
+ WP_CLI::confirm('There are some warnings. Continue?', $assoc_args);
+ }
+ }
+
+ /**
+ * Tries to require Wordpress config files. Throws WP-CLI error when files not found.
+ * @param string $wpConfigPath
+ * @param string $commonConfigName
+ */
+ private function requireWpConfig($wpConfigPath, $commonConfigName)
+ {
+ $commonConfigPath = dirname($wpConfigPath) . '/' . $commonConfigName;
+ if (file_exists($wpConfigPath)) {
+ require_once $wpConfigPath;
+ } else {
+ WP_CLI::error('wp-config.php file not found');
+ }
+ if (file_exists($commonConfigPath)) {
+ require_once $commonConfigPath;
+ } else {
+ WP_CLI::error($commonConfigName . ' file not found.');
+ }
+ }
+
+ /**
+ * @param GitRepository $repository
+ * @return string
+ */
+ private function getInitialCommitHash(GitRepository $repository)
+ {
+ $preActivationHash = trim(file_get_contents(VERSIONPRESS_ACTIVATION_FILE));
+ if (empty($preActivationHash)) {
+ return $repository->getInitialCommit()->getHash();
+ }
+ return $repository->getChildCommit($preActivationHash);
+ }
+}
+
+if (defined('WP_CLI') && WP_CLI) {
+ WP_CLI::add_command('vp', VPCommand::class);
+}
diff --git a/mu-plugins/versionpress/src/DI/DIContainer.php b/mu-plugins/versionpress/src/DI/DIContainer.php
new file mode 100644
index 0000000..f6aaf85
--- /dev/null
+++ b/mu-plugins/versionpress/src/DI/DIContainer.php
@@ -0,0 +1,227 @@
+providers[$name] = $serviceProvider;
+ }
+
+ /**
+ * @param $name string Service name
+ * @return mixed Service instance
+ */
+ public function resolve($name)
+ {
+ if (!isset($this->services[$name])) {
+ $provider = $this->providers[$name];
+ $this->services[$name] = $provider();
+ }
+ return $this->services[$name];
+ }
+
+ /**
+ * @return DIContainer
+ */
+ public static function getConfiguredInstance()
+ {
+ if (self::$instance != null) {
+ return self::$instance;
+ }
+
+ self::$instance = $dic = new DIContainer();
+
+ $dic->register(VersionPressServices::WPDB, function () {
+ global $wpdb;
+ return $wpdb;
+ });
+
+ $dic->register(VersionPressServices::DATABASE, function () use ($dic) {
+ return new Database($dic->resolve(VersionPressServices::WPDB));
+ });
+
+ $dic->register(VersionPressServices::STORAGE_FACTORY, function () use ($dic) {
+ global $wp_taxonomies;
+ return new StorageFactory(
+ VP_VPDB_DIR,
+ $dic->resolve(VersionPressServices::DB_SCHEMA),
+ $dic->resolve(VersionPressServices::DATABASE),
+ array_keys((array)$wp_taxonomies),
+ $dic->resolve(VersionPressServices::CHANGEINFO_FACTORY),
+ $dic->resolve(VersionPressServices::TABLE_SCHEMA_STORAGE)
+ );
+ });
+
+ $dic->register(VersionPressServices::MIRROR, function () use ($dic) {
+ return new Mirror(
+ $dic->resolve(VersionPressServices::STORAGE_FACTORY),
+ $dic->resolve(VersionPressServices::URL_REPLACER)
+ );
+ });
+
+ $dic->register(VersionPressServices::DB_SCHEMA, function () {
+ global $table_prefix, $wp_db_version;
+ return new DbSchemaInfo(
+ PluginDefinitionDiscovery::getPathsForActivePlugins('schema.yml'),
+ $table_prefix,
+ $wp_db_version
+ );
+ });
+
+ $dic->register(VersionPressServices::ACTIONS_DEFINITION_REPOSITORY, function () use ($dic) {
+ return new ActionsDefinitionRepository(VERSIONPRESS_TEMP_DIR . '/actions', $dic->resolve(VersionPressServices::GIT_REPOSITORY));
+ });
+
+ $dic->register(VersionPressServices::ACTIONSINFO_PROVIDER_ALL_PLUGINS, function () use ($dic) {
+ return new ActionsInfoProvider($dic->resolve(VersionPressServices::ACTIONS_DEFINITION_REPOSITORY)->getAllDefinitionFiles());
+ });
+
+ $dic->register(VersionPressServices::ACTIONSINFO_PROVIDER_ACTIVE_PLUGINS, function () {
+ return new ActionsInfoProvider(PluginDefinitionDiscovery::getPathsForActivePlugins('actions.yml'));
+ });
+
+ $dic->register(VersionPressServices::CHANGEINFO_FACTORY, function () use ($dic) {
+ return new ChangeInfoFactory(
+ $dic->resolve(VersionPressServices::DB_SCHEMA),
+ $dic->resolve(VersionPressServices::ACTIONSINFO_PROVIDER_ACTIVE_PLUGINS)
+ );
+ });
+
+ $dic->register(VersionPressServices::COMMIT_MESSAGE_PARSER, function () use ($dic) {
+ return new CommitMessageParser(
+ $dic->resolve(VersionPressServices::DB_SCHEMA),
+ $dic->resolve(VersionPressServices::ACTIONSINFO_PROVIDER_ALL_PLUGINS)
+ );
+ });
+
+ $dic->register(VersionPressServices::WPDB_MIRROR_BRIDGE, function () use ($dic) {
+ return new WpdbMirrorBridge(
+ $dic->resolve(VersionPressServices::DATABASE),
+ $dic->resolve(VersionPressServices::MIRROR),
+ $dic->resolve(VersionPressServices::DB_SCHEMA),
+ $dic->resolve(VersionPressServices::VPID_REPOSITORY),
+ $dic->resolve(VersionPressServices::SHORTCODES_REPLACER)
+ );
+ });
+
+ $dic->register(VersionPressServices::COMMITTER, function () use ($dic) {
+ return new Committer(
+ $dic->resolve(VersionPressServices::MIRROR),
+ $dic->resolve(VersionPressServices::GIT_REPOSITORY),
+ $dic->resolve(VersionPressServices::STORAGE_FACTORY)
+ );
+ });
+
+ $dic->register(VersionPressServices::INITIALIZER, function () use ($dic) {
+ return new Initializer(
+ $dic->resolve(VersionPressServices::DATABASE),
+ $dic->resolve(VersionPressServices::DB_SCHEMA),
+ $dic->resolve(VersionPressServices::STORAGE_FACTORY),
+ $dic->resolve(VersionPressServices::SYNCHRONIZER_FACTORY),
+ $dic->resolve(VersionPressServices::GIT_REPOSITORY),
+ $dic->resolve(VersionPressServices::URL_REPLACER),
+ $dic->resolve(VersionPressServices::VPID_REPOSITORY),
+ $dic->resolve(VersionPressServices::SHORTCODES_REPLACER),
+ $dic->resolve(VersionPressServices::CHANGEINFO_FACTORY),
+ $dic->resolve(VersionPressServices::ACTIONS_DEFINITION_REPOSITORY)
+ );
+ });
+
+ $dic->register(VersionPressServices::SYNCHRONIZER_FACTORY, function () use ($dic) {
+ return new SynchronizerFactory(
+ $dic->resolve(VersionPressServices::STORAGE_FACTORY),
+ $dic->resolve(VersionPressServices::DATABASE),
+ $dic->resolve(VersionPressServices::DB_SCHEMA),
+ $dic->resolve(VersionPressServices::VPID_REPOSITORY),
+ $dic->resolve(VersionPressServices::URL_REPLACER),
+ $dic->resolve(VersionPressServices::SHORTCODES_REPLACER),
+ $dic->resolve(VersionPressServices::TABLE_SCHEMA_STORAGE)
+ );
+ });
+
+ $dic->register(VersionPressServices::SYNCHRONIZATION_PROCESS, function () use ($dic) {
+ return new SynchronizationProcess($dic->resolve(VersionPressServices::SYNCHRONIZER_FACTORY));
+ });
+
+ $dic->register(VersionPressServices::REVERTER, function () use ($dic) {
+ return new Reverter(
+ $dic->resolve(VersionPressServices::SYNCHRONIZATION_PROCESS),
+ $dic->resolve(VersionPressServices::DATABASE),
+ $dic->resolve(VersionPressServices::COMMITTER),
+ $dic->resolve(VersionPressServices::GIT_REPOSITORY),
+ $dic->resolve(VersionPressServices::DB_SCHEMA),
+ $dic->resolve(VersionPressServices::STORAGE_FACTORY),
+ $dic->resolve(VersionPressServices::COMMIT_MESSAGE_PARSER)
+ );
+ });
+
+ $dic->register(VersionPressServices::GIT_REPOSITORY, function () {
+ return new GitRepository(VP_PROJECT_ROOT, VERSIONPRESS_TEMP_DIR, VERSIONPRESS_COMMIT_MESSAGE_PREFIX, VP_GIT_BINARY);
+ });
+
+ $dic->register(VersionPressServices::VPID_REPOSITORY, function () use ($dic) {
+ return new VpidRepository(
+ $dic->resolve(VersionPressServices::DATABASE),
+ $dic->resolve(VersionPressServices::DB_SCHEMA)
+ );
+ });
+
+ $dic->register(VersionPressServices::URL_REPLACER, function () {
+ return new AbsoluteUrlReplacer(get_home_url());
+ });
+
+ $dic->register(VersionPressServices::SHORTCODES_REPLACER, function () use ($dic) {
+ return new ShortcodesReplacer(
+ $dic->resolve(VersionPressServices::SHORTCODES_INFO),
+ $dic->resolve(VersionPressServices::VPID_REPOSITORY)
+ );
+ });
+
+ $dic->register(VersionPressServices::SHORTCODES_INFO, function () {
+ return new ShortcodesInfo(PluginDefinitionDiscovery::getPathsForActivePlugins('shortcodes.yml'));
+ });
+
+ $dic->register(VersionPressServices::SQL_QUERY_PARSER, function () use ($dic) {
+ return new SqlQueryParser(
+ $dic->resolve(VersionPressServices::DB_SCHEMA),
+ $dic->resolve(VersionPressServices::DATABASE)
+ );
+ });
+
+ $dic->register(VersionPressServices::TABLE_SCHEMA_STORAGE, function () use ($dic) {
+ return new TableSchemaStorage($dic->resolve(VersionPressServices::DATABASE), VP_VPDB_DIR . '/.schema');
+ });
+
+ return self::$instance;
+ }
+}
diff --git a/mu-plugins/versionpress/src/DI/VersionPressServices.php b/mu-plugins/versionpress/src/DI/VersionPressServices.php
new file mode 100644
index 0000000..7c35dcb
--- /dev/null
+++ b/mu-plugins/versionpress/src/DI/VersionPressServices.php
@@ -0,0 +1,34 @@
+__wp_query()` but that's ugly,
+ * fragile and easy to forget. This proxy improves that.
+ *
+ * (The PhpDoc API description below can be regenerated by `./wpdb-api-to-phpdoc.php`.)
+ *
+ * @property bool show_errors
+ * @property bool suppress_errors
+ * @property string last_error
+ * @property int num_queries
+ * @property int num_rows
+ * @property int rows_affected
+ * @property int insert_id
+ * @property array last_query
+ * @property array|null last_result
+ * @property array queries
+ * @property string prefix
+ * @property string base_prefix
+ * @property bool ready
+ * @property int blogid
+ * @property int siteid
+ * @property array tables
+ * @property array old_tables
+ * @property array global_tables
+ * @property array ms_global_tables
+ * @property string comments
+ * @property string commentmeta
+ * @property string links
+ * @property string options
+ * @property string postmeta
+ * @property string posts
+ * @property string terms
+ * @property string term_relationships
+ * @property string term_taxonomy
+ * @property string termmeta
+ * @property string usermeta
+ * @property string users
+ * @property string blogs
+ * @property string blog_versions
+ * @property string registration_log
+ * @property string signups
+ * @property string site
+ * @property string sitecategories
+ * @property string sitemeta
+ * @property array field_types
+ * @property string charset
+ * @property string collate
+ * @property string func_call
+ * @property bool is_mysql
+ * @method init_charset()
+ * @method set_charset($dbh, $charset = null, $collate = null)
+ * @method set_sql_mode($modes = [])
+ * @method string|\WP_Error set_prefix($prefix, $set_table_names = true)
+ * @method int set_blog_id($blog_id, $site_id = 0)
+ * @method string get_blog_prefix($blog_id = null)
+ * @method array tables($scope = 'all', $prefix = true, $blog_id = 0)
+ * @method select($db, $dbh = null)
+ * @method string _weak_escape($string)
+ * @method string _real_escape($string)
+ * @method string|array _escape($data)
+ * @method mixed escape($data)
+ * @method escape_by_ref($string)
+ * @method string|void prepare($query, $args)
+ * @method string esc_like($text)
+ * @method false|void print_error($str = '')
+ * @method bool show_errors($show = true)
+ * @method bool hide_errors()
+ * @method bool suppress_errors($suppress = true)
+ * @method flush()
+ * @method bool db_connect($allow_bail = true)
+ * @method bool|void check_connection($allow_bail = true)
+ * @method int|false insert($table, $data, $format = null)
+ * @method int|false replace($table, $data, $format = null)
+ * @method int|false _insert_replace_helper($table, $data, $format = null, $type = 'INSERT')
+ * @method int|false update($table, $data, $where, $format = null, $where_format = null)
+ * @method int|false delete($table, $where, $where_format = null)
+ * @method string|null get_var($query = null, $x = 0, $y = 0)
+ * @method array|object|null|void get_row($query = null, $output = OBJECT, $y = 0)
+ * @method array get_col($query = null, $x = 0)
+ * @method array|object|null get_results($query = null, $output = OBJECT)
+ * @method string|false|\WP_Error get_col_charset($table, $column)
+ * @method array|false|\WP_Error get_col_length($table, $column)
+ * @method string|\WP_Error strip_invalid_text_for_column($table, $column, $value)
+ * @method mixed get_col_info($info_type = 'name', $col_offset = -1)
+ * @method true timer_start()
+ * @method float timer_stop()
+ * @method false|void bail($message, $error_code = '500')
+ * @method bool close()
+ * @method \WP_Error|void check_database_version()
+ * @method bool supports_collation()
+ * @method string get_charset_collate()
+ * @method int|false has_cap($db_cap)
+ * @method string|array get_caller()
+ * @method null|string db_version()
+ */
+class Database
+{
+
+ /**
+ * @var \wpdb
+ */
+ private $wpdb;
+
+ public $vp_id;
+
+
+ public function __construct($wpdb)
+ {
+ $this->wpdb = $wpdb;
+ $this->vp_id = $wpdb->prefix . 'vp_id';
+ }
+
+ public function __get($name)
+ {
+ return $this->wpdb->$name;
+ }
+
+ public function __set($name, $value)
+ {
+ $this->wpdb->$name = $value;
+ }
+
+ public function __call($name, $arguments)
+ {
+ return call_user_func_array([$this->wpdb, $name], $arguments);
+ }
+
+
+ /**
+ * @see \wpdb::query()
+ * @param string $query Database query
+ * @return int|false Number of rows affected/selected or false on error
+ */
+ public function query($query)
+ {
+ $rawQueryMethodName = "__wp_query";
+ if (method_exists("wpdb", $rawQueryMethodName)) {
+ return $this->wpdb->$rawQueryMethodName($query);
+ } else {
+ return $this->wpdb->query($query);
+ }
+ }
+}
diff --git a/mu-plugins/versionpress/src/Database/DbSchemaInfo.php b/mu-plugins/versionpress/src/Database/DbSchemaInfo.php
new file mode 100644
index 0000000..4068979
--- /dev/null
+++ b/mu-plugins/versionpress/src/Database/DbSchemaInfo.php
@@ -0,0 +1,278 @@
+ EntityInfo object. Lazily constructed, see getEntityInfo().
+ */
+ private $entityInfoRegistry;
+
+ /** @var int */
+ private $dbVersion;
+
+ /**
+ * @param string[]|\Traversable $schemaFiles Paths to a schema.yml files to read from disk
+ * @param string $prefix
+ * @param int $dbVersion WordPress DB version (global variable $wp_db_version)
+ */
+ public function __construct($schemaFiles, $prefix, $dbVersion)
+ {
+ $this->dbVersion = $dbVersion;
+ $this->prefix = $prefix;
+
+ $this->refreshDbSchema($schemaFiles);
+ }
+
+ public function refreshDbSchema($schemaFiles)
+ {
+ $this->schema = [];
+ $this->entityInfoRegistry = [];
+
+ foreach ($schemaFiles as $schemaFile) {
+ $pluginSchema = Yaml::parse($schemaFile);
+ $pluginSchema = $this->useSchemaForCurrentVersion($pluginSchema);
+
+ $this->schema = array_merge_recursive($this->schema, $pluginSchema);
+ }
+ }
+
+ /**
+ * Returns EntityInfo for a given entity name (e.g., "post" or "comment")
+ *
+ * @param $entityName
+ * @return EntityInfo
+ */
+ public function getEntityInfo($entityName)
+ {
+ if (!$this->isEntity($entityName)) {
+ return null;
+ }
+
+ if (!isset($this->entityInfoRegistry[$entityName])) {
+ $this->entityInfoRegistry[$entityName] = new EntityInfo([$entityName => $this->schema[$entityName]]);
+ }
+
+ return $this->entityInfoRegistry[$entityName];
+ }
+
+
+ /**
+ * Gets all entities defined by the schema
+ *
+ * @return array
+ */
+ public function getAllEntityNames()
+ {
+ return array_keys($this->schema);
+ }
+
+ /**
+ * For something like "post", returns "posts"
+ *
+ * @param $entityName
+ * @return string
+ */
+ public function getTableName($entityName)
+ {
+ $tableName = $this->isEntity($entityName) ? $this->getEntityInfo($entityName)->tableName : $entityName;
+ return $tableName;
+ }
+
+ /**
+ * For something like "post", returns "wp_posts"
+ *
+ * @param $entityName
+ * @return string
+ */
+ public function getPrefixedTableName($entityName)
+ {
+ return $this->prefix . $this->getTableName($entityName);
+ }
+
+ /**
+ * Returns EntityInfo for a given table name (e.g., "posts" or "commentmeta")
+ *
+ * @param $tableName
+ * @return EntityInfo
+ */
+ public function getEntityInfoByTableName($tableName)
+ {
+ $entityNames = $this->getAllEntityNames();
+ foreach ($entityNames as $entityName) {
+ $entityInfo = $this->getEntityInfo($entityName);
+ if ($entityInfo->tableName === $tableName) {
+ return $entityInfo;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Returns EntityInfo for a given table name with prefix (e.g., "wp_posts" or "wp_commentmeta")
+ *
+ * @param $tableName
+ * @return EntityInfo
+ */
+ public function getEntityInfoByPrefixedTableName($tableName)
+ {
+ $tableName = $this->trimPrefix($tableName);
+ return $this->getEntityInfoByTableName($tableName);
+ }
+
+ /**
+ * Returns true if entity has a parent reference.
+ *
+ * @param $entityName
+ * @return bool
+ */
+ public function isChildEntity($entityName)
+ {
+ return $this->isEntity($entityName) && $this->getEntityInfo($entityName)->parentReference !== null;
+ }
+
+ /**
+ * Returns all rules for frequently written entities grouped by entity name.
+ *
+ * @return array
+ */
+ public function getRulesForFrequentlyWrittenEntities()
+ {
+ $frequentlyWrittenEntities = [];
+ foreach ($this->getAllEntityNames() as $entityName) {
+ $entityInfo = $this->getEntityInfo($entityName);
+ $frequentlyWrittenEntities[$entityName] = $entityInfo->getRulesAndIntervalsForFrequentlyWrittenEntities();
+ }
+
+ return $frequentlyWrittenEntities;
+ }
+
+
+ public function getIntervalsForFrequentlyWrittenEntities()
+ {
+ $rulesByEntity = $this->getRulesForFrequentlyWrittenEntities();
+ $intervals = [];
+
+ foreach ($rulesByEntity as $rules) {
+ foreach ($rules as $rule) {
+ $intervals[] = $rule['interval'];
+ }
+ }
+
+ return array_unique($intervals);
+ }
+
+ /**
+ * Returns true if given name is an entity (is defined in schema).
+ * Useful for prefixing VP tables.
+ *
+ * @param $entityName
+ * @return bool
+ */
+ public function isEntity($entityName)
+ {
+ return in_array($entityName, $this->getAllEntityNames());
+ }
+
+ /**
+ * Returns a map where key is a name of an entity and value is a list of names of referenced entities.
+ *
+ * @return array
+ */
+ public function getAllReferences()
+ {
+ $references = [];
+ foreach ($this->getAllEntityNames() as $entity) {
+ $references[$entity] = $this->getEntityInfo($entity)->getReferencedEntities();
+ }
+ return $references;
+ }
+
+ /**
+ * Returns valid schema for current version of WP.
+ * For example in WP < 4.4-beta1 removes the `termmeta` entity.
+ *
+ * @param $schema
+ * @return array
+ */
+ private function useSchemaForCurrentVersion($schema)
+ {
+ $currentDbVersion = $this->dbVersion;
+ return array_filter($schema, function ($entitySchema) use ($currentDbVersion) {
+ if (!isset($entitySchema['since'])) {
+ return true;
+ }
+
+ return $entitySchema['since'] <= $currentDbVersion;
+ });
+ }
+
+ public function getMnReferenceDetails($junctionEntity)
+ {
+ foreach ($this->getAllEntityNames() as $entityName) {
+ $entityInfo = $this->getEntityInfo($entityName);
+ foreach ($entityInfo->mnReferences as $reference => $targetEntity) {
+ $referenceDetails = ReferenceUtils::getMnReferenceDetails($this, $entityName, $reference);
+ if ($referenceDetails['junction-table'] === $junctionEntity) {
+ return $referenceDetails;
+ }
+ }
+ }
+ return null;
+ }
+
+ public function getAllMnReferences()
+ {
+ $mnReferences = [];
+
+ foreach ($this->getAllEntityNames() as $entityName) {
+ $entityInfo = $this->getEntityInfo($entityName);
+ if (!$entityInfo->mnReferences) {
+ continue;
+ }
+
+ foreach ($entityInfo->mnReferences as $reference => $targetEntity) {
+ if ($entityInfo->isVirtualReference($reference)) {
+ continue;
+ }
+ $mnReferences[] = ReferenceUtils::getMnReferenceDetails($this, $entityName, $reference);
+ }
+ }
+
+ return $mnReferences;
+ }
+
+ public function trimPrefix($tableName)
+ {
+ return substr($tableName, strlen($this->prefix));
+ }
+}
diff --git a/mu-plugins/versionpress/src/Database/EntityInfo.php b/mu-plugins/versionpress/src/Database/EntityInfo.php
new file mode 100644
index 0000000..e3996b4
--- /dev/null
+++ b/mu-plugins/versionpress/src/Database/EntityInfo.php
@@ -0,0 +1,311 @@
+ 'user',
+ * 'post_parent' => 'post'
+ * )
+ *
+ * If the entity doesn't have references, returns empty array.
+ *
+ * @var array
+ */
+ public $references = [];
+
+ /**
+ * Just like $references, only for M:N relationships (with junction table).
+ * The key is composed from table name and column in the junction table.
+ * This kind of relationship has to be described in both entities.
+ *
+ * Post:
+ * array(
+ * 'term_taxonomy.term_taxonomy_id' => 'term_taxonomy',
+ * )
+ *
+ * Term taxonomy:
+ * array(
+ * 'term_taxonomy.object_id' => 'post',
+ * )
+ *
+ * @var array
+ */
+ public $mnReferences = [];
+
+ /**
+ * The same as $references, only for dependent columns.
+ * The key consists of name of column, where reference source is stored with its value and column,
+ * where is name of referenced entities.
+ *
+ * array(
+ * 'meta_key=_thumbnail_id@meta_value' => 'post',
+ * 'meta_key=menu_object_item_id@meta_value' => 'post',
+ * )
+ *
+ * @var array
+ */
+ public $valueReferences = [];
+
+ /**
+ * True if entity has references. Basically returns count($references) > 0.
+ *
+ * @var bool
+ */
+ public $hasReferences = false;
+
+ public $storageClass = null;
+
+ /**
+ * If entity is child entity (meta, term_taxonomy etc.), this contains name of reference
+ * to its parent.
+ *
+ * @var string
+ */
+ public $parentReference;
+
+ private $virtualReferences = [];
+
+ private $frequentlyWritten = [];
+
+ private $ignoredEntities = [];
+
+ private $ignoredColumns = [];
+
+ public $cleanCache = [];
+
+ /**
+ * Does the parsing and sets all properties
+ *
+ * @param array $entitySchema Example:
+ * array('post' => array(
+ * 'table' => 'posts',
+ * 'id' => 'ID',
+ * 'references' => array (
+ * 'post_author' => 'user'
+ * )
+ * ))
+ */
+ public function __construct($entitySchema)
+ {
+ list($key) = array_keys($entitySchema);
+ $this->entityName = $key;
+
+ $schemaInfo = $entitySchema[$key];
+
+ if (isset($schemaInfo['table'])) {
+ $this->tableName = $schemaInfo['table'];
+ } else {
+ $this->tableName = $this->entityName;
+ }
+
+ // The schema defines either 'id' or 'vpid', see schema-readme.md. This has this meaning:
+ if (isset($schemaInfo['id'])) {
+ $this->idColumnName = $schemaInfo['id'];
+ $this->vpidColumnName = 'vp_id'; // convention
+ $this->usesGeneratedVpids = true;
+ $this->hasNaturalVpid = false;
+ } else {
+ $this->idColumnName = $schemaInfo['vpid'];
+ $this->vpidColumnName = $schemaInfo['vpid'];
+ $this->usesGeneratedVpids = false;
+ $this->hasNaturalVpid = true;
+ }
+
+ if (isset($schemaInfo['parent-reference'])) {
+ $this->parentReference = $schemaInfo['parent-reference'];
+ }
+
+ if (isset($schemaInfo['references'])) {
+ $this->references = $schemaInfo['references'];
+ $this->hasReferences = true;
+ }
+
+ if (isset($schemaInfo['mn-references'])) {
+ foreach ($schemaInfo['mn-references'] as $reference => $targetEntity) {
+ if (Strings::startsWith($reference, '~')) {
+ $reference = Strings::substring($reference, 1);
+ $this->virtualReferences[$reference] = true;
+ }
+ $this->mnReferences[$reference] = $targetEntity;
+ }
+ $this->hasReferences = true;
+ }
+
+ if (isset($schemaInfo['value-references'])) {
+ foreach ($schemaInfo['value-references'] as $key => $references) {
+ list($keyCol, $valueCol) = explode('@', $key);
+ foreach ($references as $reference => $targetEntity) {
+ $key = $keyCol . '=' . $reference . '@' . $valueCol;
+ $this->valueReferences[$key] = $targetEntity;
+ }
+ }
+ $this->hasReferences = true;
+ }
+
+ if (isset($schemaInfo['frequently-written'])) {
+ $this->frequentlyWritten = $schemaInfo['frequently-written'];
+ }
+
+ if (isset($schemaInfo['ignored-entities'])) {
+ $this->ignoredEntities = $schemaInfo['ignored-entities'];
+ }
+
+ if (isset($schemaInfo['ignored-columns'])) {
+ foreach ($schemaInfo['ignored-columns'] as $column) {
+ if (is_string($column)) {
+ $this->ignoredColumns[$column] = function () {
+ }; // if column does not have any compute function we create 'NOOP' function
+ } else {
+ $this->ignoredColumns[array_keys($column)[0]] = substr(array_values($column)[0], 1);
+ }
+ }
+ }
+
+ if (isset($schemaInfo['clean-cache'])) {
+ $this->cleanCache = $schemaInfo['clean-cache'];
+ }
+ }
+
+ public function getIgnoredColumns()
+ {
+ return $this->ignoredColumns;
+ }
+
+ public function isVirtualReference($reference)
+ {
+ return isset($this->virtualReferences[$reference]);
+ }
+
+ public function isFrequentlyWrittenEntity($entity)
+ {
+ $rulesAndIntervals = $this->getRulesAndIntervalsForFrequentlyWrittenEntities();
+ $rules = array_column($rulesAndIntervals, 'rule');
+ return QueryLanguageUtils::entityMatchesSomeRule($entity, $rules);
+ }
+
+ public function isIgnoredEntity($entity)
+ {
+ $rules = $this->getRulesForIgnoredEntities();
+ return QueryLanguageUtils::entityMatchesSomeRule($entity, $rules);
+ }
+
+ public function getRulesAndIntervalsForFrequentlyWrittenEntities()
+ {
+ $queries = array_map(function ($queryMaybeWithInterval) {
+ return is_string($queryMaybeWithInterval) ? $queryMaybeWithInterval : $queryMaybeWithInterval['query'];
+ }, $this->frequentlyWritten);
+
+ $rules = QueryLanguageUtils::createRulesFromQueries($queries);
+
+ $rulesAndIntervals = [];
+ foreach ($rules as $key => $rule) {
+ $interval = isset($this->frequentlyWritten[$key]['interval'])
+ ? $this->frequentlyWritten[$key]['interval']
+ : self::FREQUENTLY_WRITTEN_DEFAULT_INTERVAL;
+
+ $rulesAndIntervals[] = ['rule' => $rule, 'interval' => $interval];
+ }
+
+
+ return $rulesAndIntervals;
+ }
+
+ public function getRulesForIgnoredEntities()
+ {
+ return QueryLanguageUtils::createRulesFromQueries($this->ignoredEntities);
+ }
+
+ /**
+ * Returns list of referenced entities.
+ *
+ * @return array
+ */
+ public function getReferencedEntities()
+ {
+ $references = array_values($this->references);
+ $references += array_values($this->valueReferences);
+ $references += array_values($this->mnReferences);
+ $references = array_filter($references, function ($entity) {
+ return !Strings::startsWith($entity, '@');
+ });
+
+ return array_values(array_unique($references));
+ }
+
+ // Mocking in ChangeInfoEnvelopeTest needs this method here, otherwise, PHPUnit 5.7 produces this error:
+ // > Trying to configure method "__get" which cannot be configured because it does not exist, has not been specified, is final, or is static
+ public function __get($name)
+ {
+ }
+}
diff --git a/mu-plugins/versionpress/src/Database/ParsedQueryData.php b/mu-plugins/versionpress/src/Database/ParsedQueryData.php
new file mode 100644
index 0000000..cb25aa9
--- /dev/null
+++ b/mu-plugins/versionpress/src/Database/ParsedQueryData.php
@@ -0,0 +1,73 @@
+ post_modified, value => NOW() ],
+ * [ column => another_column, value => 123 ]
+ * ]
+ * @var array;
+ */
+ public $data;
+
+
+ /**
+ * SELECT query created from provided source query (INSERT, UPDATE, DELETE)
+ *
+ * @var string
+ */
+ public $sqlQuery;
+
+ /**
+ * Id column name resolved from `schema.yml` and $table
+ * @var string[]
+ */
+ public $idColumnsNames;
+
+ /**
+ * @var string Internal enumeration of queries which are currently supoorted by SqlQueryParser
+ */
+ public $queryType;
+
+ const UPDATE_QUERY = 'UPDATE';
+ const INSERT_QUERY = 'INSERT';
+ const DELETE_QUERY = 'DELETE';
+ const INSERT_IGNORE_QUERY = 'INSERT_IGNORE';
+ const INSERT_UPDATE_QUERY = 'INSERT_UPDATE';
+
+
+ public function __construct($queryType)
+ {
+ $this->queryType = $queryType;
+ }
+}
diff --git a/mu-plugins/versionpress/src/Database/ShortcodesInfo.php b/mu-plugins/versionpress/src/Database/ShortcodesInfo.php
new file mode 100644
index 0000000..b8c9188
--- /dev/null
+++ b/mu-plugins/versionpress/src/Database/ShortcodesInfo.php
@@ -0,0 +1,71 @@
+shortcodeSchema = array_merge_recursive($this->shortcodeSchema, Yaml::parse(file_get_contents($shortcodeFile)));
+ }
+ }
+
+ /**
+ * Returns all supported shortcode names - keys from the `shortcodes` array in the YAML file.
+ *
+ * @return string[]
+ */
+ public function getAllShortcodeNames()
+ {
+ return array_keys($this->shortcodeSchema['shortcodes']);
+ }
+
+ /**
+ * Returns description of a single shortcode as a map between shortcode attributes and entity names, e.g.:
+ *
+ * ```
+ * [
+ * 'id' => 'post',
+ * 'include' => 'post'
+ * ]
+ * ```
+ *
+ * @param string $shortcodeName
+ * @return array
+ */
+ public function getShortcodeInfo($shortcodeName)
+ {
+ return $this->shortcodeSchema['shortcodes'][$shortcodeName];
+ }
+
+ /**
+ * Returns a list of entities and their fields where shortcodes are supported.
+ * For example, vanilla WordPress only supports shortcodes in posts / their `post_content` column
+ * so the array would look like this:
+ *
+ * ```
+ * [
+ * 'post' => [
+ * 'post_content'
+ * ]
+ * ]
+ * ```
+ *
+ * @return array
+ */
+ public function getShortcodeLocations()
+ {
+ return $this->shortcodeSchema['shortcode-locations'];
+ }
+}
diff --git a/mu-plugins/versionpress/src/Database/ShortcodesReplacer.php b/mu-plugins/versionpress/src/Database/ShortcodesReplacer.php
new file mode 100644
index 0000000..5074ff1
--- /dev/null
+++ b/mu-plugins/versionpress/src/Database/ShortcodesReplacer.php
@@ -0,0 +1,171 @@
+shortcodesInfo = $shortcodeInfo;
+ $this->vpidRepository = $vpidRepository;
+ }
+
+ /**
+ * Translates IDs to VPIDs in shortcodes.
+ *
+ * @param string $string
+ * @return string
+ */
+ private function replaceShortcodes($string)
+ {
+ $pattern = get_shortcode_regex($this->shortcodesInfo->getAllShortcodeNames());
+ return preg_replace_callback(
+ "/$pattern/",
+ $this->createReplaceCallback([$this, 'getVpidByEntityNameAndId']),
+ $string
+ );
+ }
+
+ /**
+ * Translates VPIDs to IDs in shortcodes.
+ *
+ * @param string $string
+ * @return string
+ */
+ private function restoreShortcodes($string)
+ {
+ $pattern = get_shortcode_regex($this->shortcodesInfo->getAllShortcodeNames());
+ return preg_replace_callback("/$pattern/", $this->createReplaceCallback([$this, 'getIdByVpid']), $string);
+ }
+
+ /**
+ * Translates IDs to VPIDs in shortcodes for an entity
+ *
+ * @param string $entityName
+ * @param array $entity Entity data, see {@link WpdbMirrorBridge}
+ * @return array Entity data
+ */
+ public function replaceShortcodesInEntity($entityName, $entity)
+ {
+ if (!$this->entityCanContainShortcodes($entityName)) {
+ return $entity;
+ }
+
+ foreach ($entity as $field => $value) {
+ if ($this->fieldCanContainShortcodes($entityName, $field)) {
+ $entity[$field] = $this->replaceShortcodes($value);
+ }
+ }
+
+ return $entity;
+ }
+
+ /**
+ * Translates VPIDs to IDs in shortcodes for an entity
+ *
+ * @param string $entityName
+ * @param array $entity Entity data, see {@link WpdbMirrorBridge}
+ * @return array Entity data
+ */
+ public function restoreShortcodesInEntity($entityName, $entity)
+ {
+ if (!$this->entityCanContainShortcodes($entityName)) {
+ return $entity;
+ }
+
+ foreach ($entity as $field => $value) {
+ if ($this->fieldCanContainShortcodes($entityName, $field)) {
+ $entity[$field] = $this->restoreShortcodes($value);
+ }
+ }
+
+ return $entity;
+ }
+
+ /**
+ * Return true if entity can contain shortcodes
+ *
+ * @param string $entityName
+ * @return bool
+ */
+ public function entityCanContainShortcodes($entityName)
+ {
+ $shortcodeLocations = $this->shortcodesInfo->getShortcodeLocations();
+ return isset($shortcodeLocations[$entityName]);
+ }
+
+ /**
+ * Return true if a field on an entity can contain shortcodes
+ *
+ * @param string $entityName E.g., 'post'
+ * @param string $field E.g., 'post_content'
+ * @return bool
+ */
+ public function fieldCanContainShortcodes($entityName, $field)
+ {
+ if (!$this->entityCanContainShortcodes($entityName)) {
+ return false;
+ }
+
+ $shortcodeLocations = $this->shortcodesInfo->getShortcodeLocations();
+ $allowedFields = $shortcodeLocations[$entityName];
+
+ return array_search($field, $allowedFields) !== false;
+ }
+
+ private function createReplaceCallback($idProvider)
+ {
+ $shortcodesInfo = $this->shortcodesInfo;
+
+ return function ($m) use ($shortcodesInfo, $idProvider) {
+ // allow [[foo]] syntax for escaping a tag - code adopted from WP function `do_shortcode_tag`
+ if ($m[1] == '[' && $m[6] == ']') {
+ return substr($m[0], 1, -1);
+ }
+
+ $shortcodeTag = $m[2];
+ $shortcodeInfo = $shortcodesInfo->getShortcodeInfo($shortcodeTag);
+ $attributes = shortcode_parse_atts($m[3]) ?: [];
+
+ foreach ($attributes as $attribute => $value) {
+ if (isset($shortcodeInfo[$attribute])) {
+ $ids = explode(',', $value);
+ $entityName = $shortcodeInfo[$attribute];
+ $attributes[$attribute] = join(',', array_map(function ($id) use ($entityName, $idProvider) {
+ return $idProvider($entityName, $id);
+ }, $ids));
+ }
+ }
+
+ return WordPressMissingFunctions::renderShortcode($shortcodeTag, $attributes);
+ };
+ }
+
+ private function getVpidByEntityNameAndId($entityName, $id)
+ {
+ return $this->vpidRepository->getVpidForEntity($entityName, $id) ?: $id;
+ }
+
+ private function getIdByVpid($entityName, $vpid)
+ {
+ return $this->vpidRepository->getIdForVpid($vpid) ?: $vpid;
+ }
+}
diff --git a/mu-plugins/versionpress/src/Database/SqlQueryParser.php b/mu-plugins/versionpress/src/Database/SqlQueryParser.php
new file mode 100644
index 0000000..5b51c61
--- /dev/null
+++ b/mu-plugins/versionpress/src/Database/SqlQueryParser.php
@@ -0,0 +1,359 @@
+schema = $schema;
+ $this->database = $database;
+ }
+
+ /**
+ * Parses Sql query called. If not parseable, returns null
+ * @param string $query
+ * @return ParsedQueryData
+ */
+ public function parseQuery($query)
+ {
+ $parser = $this->getParser($query);
+ $sqlStatement = $parser->statements[0];
+ if ($sqlStatement instanceof UpdateStatement) {
+ return $this->parseUpdateQuery($parser, $query, $this->schema, $this->database);
+ } elseif ($sqlStatement instanceof InsertStatement) {
+ return $this->parseInsertQuery($parser, $query, $this->schema);
+ } elseif ($sqlStatement instanceof DeleteStatement) {
+ return $this->parseDeleteQuery($parser, $query, $this->schema, $this->database);
+ }
+ return null;
+ }
+
+ /**
+ * Parses UPDATE query
+ *
+ * @param Parser $parser
+ * @param DbSchemaInfo $schema
+ * @param string $query
+ * @param Database $database
+ * @return ParsedQueryData
+ */
+ private function parseUpdateQuery($parser, $query, $schema, $database)
+ {
+ /** @var UpdateStatement $sqlStatement */
+ $sqlStatement = $parser->statements[0];
+ $table = $sqlStatement->tables[0]->table;
+ $idColumns = $this->resolveIdColumns($schema, $table);
+ if ($idColumns == null) {
+ return null;
+ }
+ $parsedQueryData = new ParsedQueryData(ParsedQueryData::UPDATE_QUERY);
+ $parsedQueryData->table = $table;
+ $parsedQueryData->idColumnsNames = $idColumns;
+ $parsedQueryData->entityName = $this->resolveEntityName($schema, $table);
+ $selectSql = $this->getSelectQuery($parser, $idColumns);
+ $where = $this->getWhereFragments($parser, $query, $sqlStatement);
+ if (isset($where)) {
+ $selectSql .= " WHERE " . join(' ', $where);
+ }
+ $parsedQueryData->sqlQuery = $selectSql;
+ $parsedQueryData->ids = $database->get_results($selectSql, ARRAY_N);
+ $parsedQueryData->data = $this->getColumnDataToSet($sqlStatement);
+ return $parsedQueryData;
+ }
+
+ /**
+ * Parses INSERT query
+ *
+ * @param Parser $parser
+ * @param string $query
+ * @param DbSchemaInfo $schema
+ * @return ParsedQueryData
+ */
+ private function parseInsertQuery($parser, $query, $schema)
+ {
+ /** @var InsertStatement $sqlStatement */
+ $sqlStatement = $parser->statements[0];
+ $queryType = ParsedQueryData::INSERT_QUERY;
+ $table = $sqlStatement->into->dest->table;
+ $idColumns = $this->resolveIdColumns($schema, $table);
+ if ($idColumns == null) {
+ return null;
+ }
+ if (count($sqlStatement->options->options) > 0) {
+ foreach (array_keys($sqlStatement->options->options) as $key) {
+ $queryType .= "_" . $sqlStatement->options->options[$key];
+ }
+ if ($queryType == ParsedQueryData::INSERT_IGNORE_QUERY) {
+ return null;
+ }
+ }
+ if (strpos($query, 'ON DUPLICATE KEY UPDATE') !== false) {
+ $queryType .= "_UPDATE";
+ }
+ $parsedQueryData = new ParsedQueryData($queryType);
+ $parsedQueryData->data = $this->getColumnDataToSet($sqlStatement);
+ $parsedQueryData->table = $table;
+ $parsedQueryData->idColumnsNames = $idColumns;
+ $parsedQueryData->entityName = $this->resolveEntityName($schema, $table);
+ $selectSql = $this->getSelectQuery($parser, $idColumns);
+ $parsedQueryData->sqlQuery = $selectSql;
+ return $parsedQueryData;
+ }
+
+ /**
+ * Parses DELETE query
+ *
+ * @param Parser $parser
+ * @param string $query
+ * @param DbSchemaInfo $schema
+ * @param $database Database
+ * @return ParsedQueryData
+ */
+ private function parseDeleteQuery($parser, $query, $schema, $database)
+ {
+ /** @var DeleteStatement $sqlStatement */
+ $sqlStatement = $parser->statements[0];
+ $table = $sqlStatement->from[0]->table;
+ $idColumns = $this->resolveIdColumns($schema, $table);
+ if ($idColumns == null) {
+ return null;
+ }
+ $parsedQueryData = new ParsedQueryData(ParsedQueryData::DELETE_QUERY);
+ $parsedQueryData->idColumnsNames = $idColumns;
+ $parsedQueryData->entityName = $this->resolveEntityName($schema, $table);
+ $parsedQueryData->table = $table;
+ $selectSql = $this->getSelectQuery($parser, $idColumns);
+ $where = $this->getWhereFragments($parser, $query, $sqlStatement);
+ if (isset($where)) {
+ $selectSql .= " WHERE " . join(' ', $where);
+ }
+ $parsedQueryData->sqlQuery = $selectSql;
+ $parsedQueryData->ids = $database->get_results($selectSql, ARRAY_N);
+
+ return $parsedQueryData;
+ }
+
+ /**
+ * Returns representation of WHERE SQL clauses found in whole query
+ *
+ * @param Parser $parser
+ * @param string $sqlQuery
+ * @param DeleteStatement|UpdateStatement $primarySqlStatement
+ * @return array
+ */
+ private function getWhereFragments($parser, $sqlQuery, $primarySqlStatement)
+ {
+ if ($primarySqlStatement->where != null) {
+ $whereFragments = $primarySqlStatement->where;
+ return $whereFragments;
+ } elseif ($primarySqlStatement->where == null && strpos($sqlQuery, 'WHERE') !== false) {
+ if (isset($parser->statements[1])) {
+ /** @var UpdateStatement|DeleteStatement|ReplaceStatement $secondarySqlStatement */
+ $secondarySqlStatement = $parser->statements[1];
+ if ($secondarySqlStatement->where != null) {
+ $whereFragments = $secondarySqlStatement->where;
+ return $whereFragments;
+ }
+ }
+ } elseif ($parser->errors != null && $primarySqlStatement->where == null
+ && strpos($sqlQuery, 'WHERE') === false) {
+ $whereFragments = ['1=1'];
+ return $whereFragments;
+ }
+ }
+
+ /**
+ * Gets data which needs to be set by UPDATE statement
+ *
+ * Example
+ * [
+ * [ column => post_modified, value => NOW() ],
+ * [ column => another_column, value => 123 ]
+ * ]
+ * @param Statement $sqlStatement
+ * @return array
+ */
+ private function getColumnDataToSet($sqlStatement)
+ {
+
+ if ($sqlStatement instanceof UpdateStatement) {
+ $dataSet = [];
+ foreach ($sqlStatement->set as $set) {
+ $dataSet[str_replace('`', '', $set->column)] = stripslashes($set->value);
+ };
+ return $dataSet;
+ } elseif ($sqlStatement instanceof InsertStatement) {
+ $columns = $sqlStatement->into->columns;
+ $dataToSet = [];
+ foreach ($sqlStatement->values as $sets) {
+ $data = [];
+ foreach ($sets->values as $i => $value) {
+ if (is_string($value)) {
+ $data[$columns[$i]] = stripslashes($value);
+ } else {
+ $data[$columns[$i]] = $value;
+ }
+ }
+ array_push($dataToSet, $data);
+ }
+ return $dataToSet;
+ }
+ }
+
+ /**
+ * Creates Select SQL query from query in Parser
+ *
+ * @param Parser $parser
+ * @param string[] $idColumns
+ * @return string
+ */
+ private function getSelectQuery($parser, $idColumns)
+ {
+ $columnsSql = join(', ', $idColumns);
+
+ $selectQuery = "SELECT $columnsSql FROM ";
+ $sqlStatement = $parser->statements[0];
+ if ($sqlStatement instanceof InsertStatement) {
+ $selectQuery = "SELECT * FROM " . $sqlStatement->into->dest . " WHERE ";
+ $dataSet = $this->getColumnDataToSet($sqlStatement);
+ $whereConditions = [];
+ foreach ($dataSet[0] as $key => $value) {
+ array_push($whereConditions, $key . '=\'' . $value . '\'');
+ }
+ $selectQuery .= join(" AND ", $whereConditions);
+ return $selectQuery;
+ }
+ if (isset($sqlStatement->from)) {
+ $from = $sqlStatement->from[0];
+ } else {
+ $from = $sqlStatement->{'tables'}[0];
+ }
+
+ $selectQuery .= $from->expr;
+ if ($from->alias != null) {
+ $selectQuery .= ' AS ' . $from->alias;
+ }
+ if (isset($sqlStatement->join)) {
+ $join = $sqlStatement->join[0];
+ $selectQuery .= ' JOIN ' . $join->expr->expr;
+ if ($join->expr->alias != null) {
+ $selectQuery .= ' AS ' . $join->expr->alias;
+ }
+ if ($join->on != null) {
+ $selectQuery .= ' ON ' . $join->on[0]->expr;
+ }
+ }
+ return $selectQuery;
+ }
+
+ /**
+ * If query contains some suspicious patten, we need to transform it and than create Parser for further use.
+ *
+ * @param $query
+ * @return Parser
+ */
+ private function getParser($query)
+ {
+ $containsUsingPattern = "/(.*)(USING ?\\(([^\\)]+)\\))(.*)/"; //https://regex101.com/r/vF6dI5/1
+ $parser = new Parser($query);
+ if (preg_match_all($containsUsingPattern, $query, $matches)) {
+ return $this->getParserFromQueryWithUsingClause($query, $parser, $matches, $containsUsingPattern);
+ }
+ return $parser;
+ }
+
+ /**
+ * Returns ID column for a table
+ *
+ * @param DbSchemaInfo $schema
+ * @param string $table
+ * @return string[]|null
+ */
+ private function resolveIdColumns($schema, $table)
+ {
+ $entity = $schema->getEntityInfoByPrefixedTableName($table);
+
+ if ($entity) {
+ return [$entity->idColumnName];
+ }
+
+ // Temporary hack for M:N references until VP will support composite PKs
+ $referenceDetails = $schema->getMnReferenceDetails($schema->trimPrefix($table));
+
+ if ($referenceDetails) {
+ return [$referenceDetails['source-column'], $referenceDetails['target-column']];
+ }
+
+ return null;
+ }
+
+ /**
+ * Returns entity name for a table
+ *
+ * @param DbSchemaInfo $schema
+ * @param string $table
+ * @return mixed
+ */
+ private function resolveEntityName($schema, $table)
+ {
+
+ $entity = $schema->getEntityInfoByPrefixedTableName($table);
+ return $entity == null ? $schema->trimPrefix($table) : $entity->entityName;
+ }
+
+ /**
+ * @param $query
+ * @param $parser
+ * @param $matches
+ * @param $containsUsingPattern
+ * @return Parser
+ */
+ private function getParserFromQueryWithUsingClause($query, $parser, $matches, $containsUsingPattern)
+ {
+ /** @var DeleteStatement|InsertStatement $sqlStatement */
+ $sqlStatement = $parser->statements[0];
+ $transformedPart = 'ON ';
+ $usingColumn = str_replace('`', '', $matches[3][0]);
+ $from = $sqlStatement->from[0];
+ if ($from->alias != null) {
+ $transformedPart .= $from->alias . '.' . $usingColumn;
+ } else {
+ $transformedPart .= $from->table . '.' . $usingColumn;
+ }
+ $transformedPart .= '=';
+ $join = $sqlStatement->{'join'}[0];
+
+ if ($join->expr->alias != null) {
+ $transformedPart .= $join->expr->alias . '.' . $usingColumn;
+ } else {
+ $transformedPart .= $join->expr->table . '.' . $usingColumn;
+ }
+ $transformedQuery = preg_replace($containsUsingPattern, '$1' . $transformedPart . '$4', $query);
+ return new Parser($transformedQuery);
+ }
+}
diff --git a/mu-plugins/versionpress/src/Database/TableSchemaStorage.php b/mu-plugins/versionpress/src/Database/TableSchemaStorage.php
new file mode 100644
index 0000000..d7070b6
--- /dev/null
+++ b/mu-plugins/versionpress/src/Database/TableSchemaStorage.php
@@ -0,0 +1,70 @@
+.sql)
+ * to a directory specified in the constructor. Also, it automatically removes and restores the prefix.
+ */
+class TableSchemaStorage
+{
+ /** @var Database */
+ private $database;
+
+ private $directory;
+
+ public function __construct(Database $database, $directory)
+ {
+ $this->database = $database;
+ $this->directory = $directory;
+ }
+
+ public function saveSchema($table)
+ {
+ $schemaFile = $this->getSchemaFile($table);
+
+ $tableDDL = $this->database->get_var("show create table `{$table}`", 1);
+
+ if (!$tableDDL) {
+ return;
+ }
+
+ $tableDDL = str_replace("CREATE TABLE `{$this->database->prefix}", 'CREATE TABLE IF NOT EXISTS `' . Storage::PREFIX_PLACEHOLDER, $tableDDL);
+ $tableDDL = preg_replace('/( AUTO_INCREMENT=[0-9]+)/', '', $tableDDL);
+
+ FileSystem::mkdir($this->directory);
+ file_put_contents($schemaFile, $tableDDL);
+ }
+
+ public function getSchema($table)
+ {
+ $schemaFile = $this->getSchemaFile($table);
+
+ if (!file_exists($schemaFile)) {
+ throw new \Exception("Schema for table '$table' not found");
+ }
+
+ $tableDDL = file_get_contents($schemaFile);
+ return str_replace(Storage::PREFIX_PLACEHOLDER, $this->database->prefix, $tableDDL);
+ }
+
+ public function containsSchema($table)
+ {
+ return file_exists($this->getSchemaFile($table));
+ }
+
+ private function getSchemaFile($table)
+ {
+ $tableWithoutPrefix = strpos($table, $this->database->prefix) === 0 ? substr($table, strlen($this->database->prefix)) : $table;
+ $schemaFile = sprintf('%s/%s.sql', $this->directory, $tableWithoutPrefix);
+ return $schemaFile;
+ }
+
+ public function deleteAll()
+ {
+ FileSystem::removeContent($this->directory);
+ }
+}
diff --git a/mu-plugins/versionpress/src/Database/VpidRepository.php b/mu-plugins/versionpress/src/Database/VpidRepository.php
new file mode 100644
index 0000000..5109736
--- /dev/null
+++ b/mu-plugins/versionpress/src/Database/VpidRepository.php
@@ -0,0 +1,250 @@
+';
+
+ /** @var Database */
+ private $database;
+ /** @var DbSchemaInfo */
+ private $schemaInfo;
+
+ public function __construct($database, DbSchemaInfo $schemaInfo)
+ {
+ $this->database = $database;
+ $this->schemaInfo = $schemaInfo;
+ }
+
+ /**
+ * Returns VPID of entity of given type and id.
+ *
+ * @param $entityName
+ * @param $id
+ * @return null|string
+ */
+ public function getVpidForEntity($entityName, $id)
+ {
+ $tableName = $this->schemaInfo->getTableName($entityName);
+ return $this->database->get_var("SELECT HEX(vp_id) FROM {$this->database->vp_id} " .
+ "WHERE id = '$id' AND `table` = '$tableName'");
+ }
+
+ public function getIdForVpid($vpid)
+ {
+ return intval($this->database->get_var("SELECT id FROM {$this->database->vp_id} WHERE vp_id = UNHEX('$vpid')"));
+ }
+
+ public function replaceForeignKeysWithReferences($entityName, $entity)
+ {
+ $entityInfo = $this->schemaInfo->getEntityInfo($entityName);
+
+ foreach ($entityInfo->references as $referenceName => $targetEntity) {
+ if (isset($entity[$referenceName])) {
+ if ($this->isNullReference($entity[$referenceName])) {
+ $referenceVpids = 0;
+ } else {
+ $referenceVpids = $this->replaceIdsInString($targetEntity, $entity[$referenceName]);
+ }
+
+ $entity['vp_' . $referenceName] = $referenceVpids;
+ unset($entity[$referenceName]);
+ }
+ }
+
+ foreach ($entityInfo->valueReferences as $referenceName => $targetEntity) {
+ list($sourceColumn, $sourceValue, $valueColumn, $pathInStructure) =
+ array_values(ReferenceUtils::getValueReferenceDetails($referenceName));
+
+ if (isset($entity[$sourceColumn]) && ($entity[$sourceColumn] === $sourceValue ||
+ ReferenceUtils::valueMatchesWildcard($sourceValue, $entity[$sourceColumn]))
+ && isset($entity[$valueColumn])
+ ) {
+ if ($this->isNullReference($entity[$valueColumn])) {
+ continue;
+ }
+
+ if ($targetEntity[0] === '@') {
+ $entityNameProvider = substr($targetEntity, 1);
+ $targetEntity = call_user_func($entityNameProvider, $entity);
+ if (!$targetEntity) {
+ continue;
+ }
+ }
+
+ if ($pathInStructure) {
+ $paths = ReferenceUtils::getMatchingPathsInSerializedData($entity[$valueColumn], $pathInStructure);
+ } else {
+ $paths = [[]]; // root = the value itself
+ }
+
+ /** @var SerializedDataCursor[] $cursors */
+ $cursors = array_map(function ($path) use (&$entity, $valueColumn) {
+ return new SerializedDataCursor($entity[$valueColumn], $path);
+ }, $paths);
+
+ foreach ($cursors as $cursor) {
+ $ids = $cursor->getValue();
+ $referenceVpids = $this->replaceIdsInString($targetEntity, $ids);
+ $cursor->setValue($referenceVpids);
+ }
+ }
+ }
+
+ return $entity;
+ }
+
+ public function restoreForeignKeys($entityName, $entity)
+ {
+ $entityInfo = $this->schemaInfo->getEntityInfo($entityName);
+
+ foreach ($entityInfo->references as $referenceName => $targetEntity) {
+ $referenceField = "vp_{$referenceName}";
+ if (isset($entity[$referenceField])) {
+ if ($this->isNullReference($entity[$referenceField])) {
+ $referencedId = 0;
+ } else {
+ $referencedId = $this->restoreIdsInString($entity[$referenceField]);
+ }
+
+ if (!Strings::contains($referencedId, self::UNKNOWN_VPID_MARK)) {
+ $entity[$referenceName] = $referencedId;
+ unset($entity[$referenceField]);
+ }
+ }
+ }
+
+ foreach ($entityInfo->valueReferences as $referenceName => $targetEntity) {
+ list($sourceColumn, $sourceValue, $valueColumn, $pathInStructure) =
+ array_values(ReferenceUtils::getValueReferenceDetails($referenceName));
+
+ if (isset($entity[$sourceColumn]) && ($entity[$sourceColumn] === $sourceValue ||
+ ReferenceUtils::valueMatchesWildcard($sourceValue, $entity[$sourceColumn])) &&
+ isset($entity[$valueColumn])
+ ) {
+ if ($this->isNullReference($entity[$valueColumn])) {
+ continue;
+ }
+
+ if ($pathInStructure) {
+ $paths = ReferenceUtils::getMatchingPathsInSerializedData($entity[$valueColumn], $pathInStructure);
+ } else {
+ $paths = [[]]; // root = the value itself
+ }
+
+ /** @var SerializedDataCursor[] $cursors */
+ $cursors = array_map(function ($path) use (&$entity, $valueColumn) {
+ return new SerializedDataCursor($entity[$valueColumn], $path);
+ }, $paths);
+
+ foreach ($cursors as $cursor) {
+ $vpids = $cursor->getValue();
+ $referenceVpId = $this->restoreIdsInString($vpids);
+ $cursor->setValue($referenceVpId);
+ }
+ }
+ }
+
+ return $entity;
+ }
+
+ public function identifyEntity($entityName, $data, $id)
+ {
+ if ($this->schemaInfo->getEntityInfo($entityName)->usesGeneratedVpids) {
+ $data['vp_id'] = IdUtil::newId();
+ $this->saveId($entityName, $id, $data['vp_id']);
+
+
+ $data[$this->schemaInfo->getEntityInfo($entityName)->idColumnName] = $id;
+ }
+ $data = $this->fillId($entityName, $data, $id);
+
+ return $data;
+ }
+
+ public function deleteId($entityName, $id)
+ {
+ $tableName = $this->schemaInfo->getTableName($entityName);
+ $deleteQuery = "DELETE FROM {$this->database->vp_id} WHERE `table` = \"$tableName\" AND id = '$id'";
+ $this->database->query($deleteQuery);
+ }
+
+ private function saveId($entityName, $id, $vpId)
+ {
+ $tableName = $this->schemaInfo->getTableName($entityName);
+ $query = "INSERT INTO {$this->database->vp_id} (`vp_id`, `table`, `id`)
+ VALUES (UNHEX('$vpId'), \"$tableName\", $id)";
+ $this->database->query($query);
+ }
+
+ private function fillId($entityName, $data, $id)
+ {
+ $idColumnName = $this->schemaInfo->getEntityInfo($entityName)->idColumnName;
+ if (!isset($data[$idColumnName])) {
+ $data[$idColumnName] = $id;
+ }
+ return $data;
+ }
+
+ private function isNullReference($id)
+ {
+ // WordPress / plugins sometimes use empty string, zero or negative number to express null reference.
+ return (is_numeric($id) && intval($id) <= 0) || $id === '';
+ }
+
+ private function replaceIdsInString($targetEntity, $stringWithIds)
+ {
+ return preg_replace_callback('/(\d+)/', function ($match) use ($targetEntity) {
+ return $this->getVpidForEntity($targetEntity, $match[0]) ?: $match[0];
+ }, $stringWithIds);
+ }
+
+ private function restoreIdsInString($stringWithVpids)
+ {
+ $stringWithIds = preg_replace_callback(IdUtil::getRegexMatchingId(), function ($match) {
+ return $this->getIdForVpid($match[0]) ?: self::UNKNOWN_VPID_MARK;
+ }, $stringWithVpids);
+
+ return is_numeric($stringWithIds) ? intval($stringWithIds) : $stringWithIds;
+ }
+
+ /**
+ * Function used in schema.yml.
+ * Maps menu item with given postmeta (_menu_item_object_id) to target entity (post/category/custom url).
+ *
+ * @param $postmeta
+ * @return null|string
+ */
+ public static function getMenuReference($postmeta)
+ {
+ global $versionPressContainer;
+ /** @var Database $database */
+ $database = $versionPressContainer->resolve(VersionPressServices::DATABASE);
+
+ $menuItemType = $database->get_var("select meta_value from {$database->postmeta} pm join {$database->vp_id} vpid
+ on pm.post_id = vpid.id where pm.meta_key = '_menu_item_type'
+ and vpid.vp_id = UNHEX(\"{$postmeta['vp_post_id']}\")");
+
+ if ($menuItemType === 'taxonomy') {
+ return 'terms';
+ }
+
+ if ($menuItemType === 'post_type') {
+ return 'post';
+ }
+
+ // Special case - reference to homepage (WP sets it as 'custom', but actually it is 'post_type')
+ if ($menuItemType === 'custom' && is_numeric($postmeta['meta_value'])) {
+ return 'post';
+ }
+
+ return null; // custom url or unknown target
+ }
+}
diff --git a/mu-plugins/versionpress/src/Database/WpdbMirrorBridge.php b/mu-plugins/versionpress/src/Database/WpdbMirrorBridge.php
new file mode 100644
index 0000000..0f1717e
--- /dev/null
+++ b/mu-plugins/versionpress/src/Database/WpdbMirrorBridge.php
@@ -0,0 +1,563 @@
+database = $database;
+ $this->mirror = $mirror;
+ $this->dbSchemaInfo = $dbSchemaInfo;
+ $this->vpidRepository = $vpidRepository;
+ $this->shortcodesReplacer = $shortcodesReplacer;
+ }
+
+ public function insert($table, $data)
+ {
+ if ($this->disabled) {
+ return;
+ }
+
+ $entityInfo = $this->dbSchemaInfo->getEntityInfoByPrefixedTableName($table);
+
+ if ($entityInfo) {
+ $this->createEntity($table, $data);
+ return;
+ }
+
+ $referenceDetails = $this->dbSchemaInfo->getMnReferenceDetails($this->dbSchemaInfo->trimPrefix($table));
+
+ if ($referenceDetails) {
+ $this->createReference($referenceDetails, $data);
+ }
+ }
+
+ public function update($table, $data, $where)
+ {
+ if ($this->disabled) {
+ return;
+ }
+
+ $entityInfo = $this->dbSchemaInfo->getEntityInfoByPrefixedTableName($table);
+
+ if (!$entityInfo) {
+ return;
+ }
+
+ $entityName = $entityInfo->entityName;
+ $data = array_merge($where, $data);
+
+ array_walk($data, function (&$value, $key) {
+ if ($value === false) {
+ $value = '';
+ }
+ });
+
+ if (!$entityInfo->usesGeneratedVpids) { // options etc.
+ $data = $this->vpidRepository->replaceForeignKeysWithReferences($entityName, $data);
+ $this->mirror->save($entityName, $data);
+ return;
+ }
+
+ $ids = $this->detectAllAffectedIds($entityName, $data, $where);
+
+ foreach ($ids as $id) {
+ $this->updateEntity($data, $entityName, $id);
+ }
+ }
+
+ public function delete($table, $where, $parentIds)
+ {
+ if ($this->disabled) {
+ return;
+ }
+
+ $entityInfo = $this->dbSchemaInfo->getEntityInfoByPrefixedTableName($table);
+
+ if ($entityInfo) {
+ $this->deleteEntity($table, $where, $parentIds);
+ return;
+ }
+
+ $referenceDetails = $this->dbSchemaInfo->getMnReferenceDetails($this->dbSchemaInfo->trimPrefix($table));
+
+ if ($referenceDetails) {
+ $this->deleteReference($referenceDetails, $where);
+ }
+ }
+
+ /**
+ * Fill parentIds of child entities and returns them as associative array in `$id => $parentId` format.
+ * Returns FALSE when table contains entity which is not an childEntity.
+ *
+ * @param $table
+ * @param $where
+ * @return array
+ */
+ public function getParentIdsBeforeDelete($table, $where)
+ {
+ $entityInfo = $this->dbSchemaInfo->getEntityInfoByPrefixedTableName($table);
+ if (!$entityInfo) {
+ return [];
+ }
+ if (!$this->dbSchemaInfo->isChildEntity($entityInfo->entityName)) {
+ return [];
+ }
+
+ $ids = $this->detectAllAffectedIds($entityInfo->entityName, $where, $where);
+ $parentIds = [];
+ foreach ($ids as $id) {
+ $parentIds[$id] = $this->fillParentId($entityInfo->entityName, $entityInfo, $id);
+ }
+ return $parentIds;
+ }
+
+
+ /**
+ * @param ParsedQueryData $parsedQueryData
+ */
+ public function query($parsedQueryData)
+ {
+ if ($this->disabled) {
+ return;
+ }
+
+ switch ($parsedQueryData->queryType) {
+ case ParsedQueryData::UPDATE_QUERY:
+ $this->processUpdateQuery($parsedQueryData);
+ break;
+ case ParsedQueryData::DELETE_QUERY:
+ $this->processDeleteQuery($parsedQueryData);
+ break;
+ case ParsedQueryData::INSERT_QUERY:
+ $this->processInsertQuery($parsedQueryData);
+ break;
+ case ParsedQueryData::INSERT_UPDATE_QUERY:
+ $this->processInsertUpdateQuery($parsedQueryData);
+ break;
+ }
+ }
+
+ /**
+ * Returns all ids from DB suitable for given restriction.
+ * E.g. all comment_id values where comment_post_id = 1
+ * @param string $entityName
+ * @param array $where
+ * @return array
+ */
+ private function getIdsForRestriction($entityName, $where)
+ {
+ $idColumnName = $this->dbSchemaInfo->getEntityInfo($entityName)->idColumnName;
+ $table = $this->dbSchemaInfo->getPrefixedTableName($entityName);
+
+ $sql = "SELECT {$idColumnName} FROM {$table} WHERE ";
+ $sql .= join(
+ " AND ",
+ array_map(
+ function ($column) {
+ return "`$column` = %s";
+ },
+ array_keys($where)
+ )
+ );
+ $ids = $this->database->get_col($this->database->prepare($sql, $where));
+ return $ids;
+ }
+
+ private function updateEntity($data, $entityName, $id)
+ {
+ $vpId = $this->vpidRepository->getVpidForEntity($entityName, $id);
+
+ $table = $this->dbSchemaInfo->getPrefixedTableName($entityName);
+ $idColumnName = $this->dbSchemaInfo->getEntityInfo($entityName)->idColumnName;
+ $data = array_merge(
+ $this->database->get_row("SELECT * FROM `$table` WHERE `$idColumnName` = '$id'", ARRAY_A),
+ $data
+ );
+
+ $data['vp_id'] = $vpId;
+ $data = $this->vpidRepository->replaceForeignKeysWithReferences($entityName, $data);
+
+ if ($this->dbSchemaInfo->isChildEntity($entityName)) {
+ $entityInfo = $this->dbSchemaInfo->getEntityInfo($entityName);
+ $parentVpReference = "vp_" . $entityInfo->parentReference;
+ if (!isset($data[$parentVpReference])) {
+ $data[$parentVpReference] = $this->fillParentId($entityName, $entityInfo, $id);
+ }
+ }
+
+ $shouldBeSaved = $this->mirror->shouldBeSaved($entityName, $data);
+ if (!$shouldBeSaved) {
+ return;
+ }
+
+
+ // For example, the post exists in DB for a while but until now it wasn't tracked, so we have to save its postmeta and related term_taxonomies
+ $entityWasNotTrackedYet = !$vpId;
+
+ if ($entityWasNotTrackedYet) {
+ $data = $this->vpidRepository->identifyEntity($entityName, $data, $id);
+ }
+
+ $data = $this->shortcodesReplacer->replaceShortcodesInEntity($entityName, $data);
+ $this->mirror->save($entityName, $data);
+
+ if ($entityWasNotTrackedYet) {
+ $this->storeRelatedEntities($data, $entityName);
+ }
+ }
+
+ /**
+ * Returns all database IDs matching the restriction.
+ * In most cases it returns ID from $where array.
+ * For meta-entities it can find the ID by key and parent entity ID, if
+ * the ID is missing in the $where array.
+ * For all other cases see {@link WpdbMirrorBridge::getIdsForRestriction}.
+ *
+ * @param $entityName
+ * @param $data
+ * @param $where
+ * @return array List of ids
+ */
+ private function detectAllAffectedIds($entityName, $data, $where)
+ {
+ $idColumnName = $this->dbSchemaInfo->getEntityInfo($entityName)->idColumnName;
+
+ if (isset($where[$idColumnName])) {
+ return [$where[$idColumnName]];
+ }
+
+ return $this->getIdsForRestriction($entityName, $where);
+ }
+
+ private function fillParentId($metaEntityName, $entityInfo, $id)
+ {
+
+ $parentReference = $entityInfo->parentReference;
+ $parent = $entityInfo->references[$parentReference];
+ $vpIdTable = $this->database->vp_id;
+ $entityTable = $this->dbSchemaInfo->getPrefixedTableName($metaEntityName);
+ $parentTable = $this->dbSchemaInfo->getTableName($parent);
+ $idColumnName = $this->dbSchemaInfo->getEntityInfo($metaEntityName)->idColumnName;
+
+ return $this->database->get_var(
+ "SELECT HEX(vp_id) FROM $vpIdTable
+ WHERE `table` = '{$parentTable}'
+ AND ID = (SELECT {$parentReference} FROM $entityTable WHERE {$idColumnName} = '$id')"
+ );
+ }
+
+ /**
+ * Disables all actions. Useful for deactivating VersionPress.
+ */
+ public function disable()
+ {
+ $this->disabled = true;
+ }
+
+ /**
+ * Processes ParsedQueryData from UPDATE query and stores updated entity/entities data into Storage.
+ *
+ * @param ParsedQueryData $parsedQueryData
+ */
+ private function processUpdateQuery($parsedQueryData)
+ {
+
+ foreach ($parsedQueryData->ids as $ids) {
+ $id = $ids[0]; // Update supports only simple PKs (in one column)
+ $this->updateEntity([], $parsedQueryData->entityName, $id);
+ }
+ }
+
+ /**
+ * Process ParsedQueryData from DELETE query and deletes entity/entities data from Storage.
+ * Source parsed query does not contain any special Sql functions (e.g. NOW)
+ *
+ * @param ParsedQueryData $parsedQueryData
+ */
+ private function processDeleteQuery($parsedQueryData)
+ {
+ $entityInfo = $this->dbSchemaInfo->getEntityInfo($parsedQueryData->entityName);
+
+ if (!$entityInfo || !$entityInfo->usesGeneratedVpids) {
+ foreach ($parsedQueryData->ids as $ids) {
+ $where = [];
+ foreach ($parsedQueryData->idColumnsNames as $key => $idColumnName) {
+ $where[$idColumnName] = $ids[$key];
+ $this->vpidRepository->deleteId($parsedQueryData->entityName, $ids[$key]);
+ }
+
+ if (!$entityInfo) {
+ $referenceDetails = $this->dbSchemaInfo->getMnReferenceDetails($this->dbSchemaInfo->trimPrefix($parsedQueryData->table));
+ if (!$referenceDetails) {
+ return;
+ }
+
+ $this->deleteReference($referenceDetails, $where);
+ } else {
+ $this->mirror->delete($parsedQueryData->entityName, $where);
+ }
+ }
+ return;
+ }
+
+ foreach ($parsedQueryData->ids as $ids) {
+ $id = $ids[0]; // Composite primary key is not yet supported.
+ $where['vp_id'] = $this->vpidRepository->getVpidForEntity($parsedQueryData->entityName, $id);
+ if (!$where['vp_id']) {
+ continue; // already deleted - deleting postmeta is sometimes called twice
+ }
+
+ if ($this->dbSchemaInfo->isChildEntity($parsedQueryData->entityName)) {
+ $parentVpReference = "vp_" . $entityInfo->parentReference;
+ $where[$parentVpReference] = $this->fillParentId($parsedQueryData->entityName, $entityInfo, $id);
+ }
+
+ $this->vpidRepository->deleteId($parsedQueryData->entityName, $id);
+ $this->mirror->delete($parsedQueryData->entityName, $where);
+ }
+ }
+
+ /**
+ * Process ParsedQueryData from INSERT query and stores affected entity into Storage.
+ * Source parsed query does not contain any special Sql functions (e.g. NOW)
+ *
+ * @param ParsedQueryData $parsedQueryData
+ */
+ private function processInsertQuery($parsedQueryData)
+ {
+ $firstId = $this->database->insert_id;
+ $entityName = $parsedQueryData->entityName;
+ $entityInfo = $this->dbSchemaInfo->getEntityInfo($entityName);
+ $hasNaturalVpid = $entityInfo->hasNaturalVpid;
+ $idColumnName = $entityInfo->idColumnName;
+
+ $entitiesCount = count($parsedQueryData->data);
+
+ for ($i = 0; $i < $entitiesCount; $i++) {
+ if ($hasNaturalVpid) {
+ $id = $parsedQueryData->data[$i][$idColumnName];
+ } else {
+ $id = $firstId + $i;
+ }
+
+ $prefixedTableName = $this->dbSchemaInfo->getPrefixedTableName($entityName);
+ $sql = $this->database->prepare("SELECT * FROM `{$prefixedTableName}` WHERE `$idColumnName` = %s", $id);
+ $entity = $this->database->get_row($sql, ARRAY_A);
+ $entity = $this->vpidRepository->replaceForeignKeysWithReferences($entityName, $entity);
+
+ $shouldBeSaved = $this->mirror->shouldBeSaved($entityName, $entity);
+
+ if (!$shouldBeSaved) {
+ continue;
+ }
+
+ $entity = $this->vpidRepository->identifyEntity($entityName, $entity, $id);
+ $this->mirror->save($entityName, $entity);
+ }
+ }
+
+ /**
+ * Processes ParsedQueryData from INSERT ... ON DUPLICATE UPDATE query and stores changes into Storage
+ *
+ * @param ParsedQueryData $parsedQueryData
+ */
+ private function processInsertUpdateQuery($parsedQueryData)
+ {
+
+ if ($parsedQueryData->ids != 0) {
+ $id = $parsedQueryData->ids;
+ $data = $this->vpidRepository->replaceForeignKeysWithReferences(
+ $parsedQueryData->entityName,
+ $parsedQueryData->data[0]
+ );
+
+ $shouldBeSaved = $this->mirror->shouldBeSaved($parsedQueryData->entityName, $data);
+
+ if (!$shouldBeSaved) {
+ return;
+ }
+ $data = $this->vpidRepository->identifyEntity($parsedQueryData->entityName, $data, $id);
+ $this->mirror->save($parsedQueryData->entityName, $data);
+ } else {
+ $data = $this->database->get_results($parsedQueryData->sqlQuery, ARRAY_A)[0];
+ $this->updateEntity($data, $parsedQueryData->entityName, $data[$parsedQueryData->idColumnsNames[0]]);
+ }
+ }
+
+ /**
+ * @param $table
+ * @param $data
+ */
+ private function createEntity($table, $data)
+ {
+ $entityInfo = $this->dbSchemaInfo->getEntityInfoByPrefixedTableName($table);
+
+ $id = $this->database->insert_id;
+ $data = $this->database->get_row("SELECT * FROM `$table` WHERE `$entityInfo->idColumnName` = '$id'", ARRAY_A);
+
+ $entityName = $entityInfo->entityName;
+ $data = $this->vpidRepository->replaceForeignKeysWithReferences($entityName, $data);
+
+ array_walk($data, function (&$value, $key) {
+ if ($value === false) {
+ $value = '';
+ }
+ });
+
+ $shouldBeSaved = $this->mirror->shouldBeSaved($entityName, $data);
+
+ if (!$shouldBeSaved) {
+ return;
+ }
+
+ $data = $this->vpidRepository->identifyEntity($entityName, $data, $id);
+ $data = $this->shortcodesReplacer->replaceShortcodesInEntity($entityName, $data);
+ $this->mirror->save($entityName, $data);
+ }
+
+ private function createReference($referenceDetails, $data)
+ {
+ $sourceEntity = $referenceDetails['source-entity'];
+ $targetEntity = $referenceDetails['target-entity'];
+ $sourceColumn = $referenceDetails['source-column'];
+ $targetColumn = $referenceDetails['target-column'];
+
+ $reference = [
+ "vp_$sourceEntity" => $this->vpidRepository->getVpidForEntity($sourceEntity, $data[$sourceColumn]),
+ "vp_$targetEntity" => $this->vpidRepository->getVpidForEntity($targetEntity, $data[$targetColumn]),
+ ];
+
+ $this->mirror->save($referenceDetails['junction-table'], $reference);
+ }
+
+ private function deleteEntity($table, $where, $parentIds)
+ {
+ $entityInfo = $this->dbSchemaInfo->getEntityInfoByPrefixedTableName($table);
+ $entityName = $entityInfo->entityName;
+
+ if (!$entityInfo->usesGeneratedVpids) {
+ $this->mirror->delete($entityName, $where);
+ return;
+ }
+
+ $ids = $this->detectAllAffectedIds($entityName, $where, $where);
+
+ foreach ($ids as $id) {
+ $where['vp_id'] = $this->vpidRepository->getVpidForEntity($entityName, $id);
+ if (!$where['vp_id']) {
+ continue; // already deleted - deleting postmeta is sometimes called twice
+ }
+
+ if ($this->dbSchemaInfo->isChildEntity($entityName)
+ && !isset($where["vp_{$entityInfo->parentReference}"])
+ ) {
+ $where["vp_{$entityInfo->parentReference}"] = $parentIds[$id];
+ }
+
+ $this->vpidRepository->deleteId($entityName, $id);
+ $this->mirror->delete($entityName, $where);
+ }
+ }
+
+ private function deleteReference($referenceDetails, $where)
+ {
+ $sourceEntity = $referenceDetails['source-entity'];
+ $targetEntity = $referenceDetails['target-entity'];
+ $sourceColumn = $referenceDetails['source-column'];
+ $targetColumn = $referenceDetails['target-column'];
+
+ $reference = [
+ "vp_$sourceEntity" => $this->vpidRepository->getVpidForEntity($sourceEntity, $where[$sourceColumn]),
+ "vp_$targetEntity" => $this->vpidRepository->getVpidForEntity($targetEntity, $where[$targetColumn]),
+ ];
+
+ $this->mirror->delete($referenceDetails['junction-table'], $reference);
+ }
+
+ /**
+ * Saves all already existing meta and M:N references for an entity that wasn't tracked yet
+ *
+ * @param array $data
+ * @param string $entityName
+ */
+ private function storeRelatedEntities($data, $entityName)
+ {
+ $id = $data[$this->dbSchemaInfo->getEntityInfo($entityName)->idColumnName];
+
+ foreach ($this->dbSchemaInfo->getAllEntityNames() as $referencedEntityName) {
+ $entityInfo = $this->dbSchemaInfo->getEntityInfo($referencedEntityName);
+ if ($this->dbSchemaInfo->isChildEntity($referencedEntityName) && $entityInfo->references[$entityInfo->parentReference] === $entityName) {
+ $childEntities = $this->database->get_results(
+ "SELECT * FROM {$this->dbSchemaInfo->getPrefixedTableName($referencedEntityName)} WHERE `{$entityInfo->parentReference}` = '{$id}'",
+ ARRAY_A
+ );
+
+ foreach ($childEntities as $childEntity) {
+ $childEntity = $this->vpidRepository->replaceForeignKeysWithReferences($referencedEntityName, $childEntity);
+
+ if (!$this->mirror->shouldBeSaved($referencedEntityName, $childEntity)) {
+ continue;
+ }
+
+ $id = $childEntity[$entityInfo->idColumnName];
+ $vpid = $this->vpidRepository->getVpidForEntity($referencedEntityName, $id);
+
+ if ($vpid) {
+ $childEntity[$entityInfo->vpidColumnName] = $vpid;
+ } else {
+ $childEntity = $this->vpidRepository->identifyEntity($referencedEntityName, $childEntity, $childEntity[$entityInfo->idColumnName]);
+ }
+
+ $childEntity = $this->shortcodesReplacer->replaceShortcodesInEntity($referencedEntityName, $childEntity);
+ $this->mirror->save($referencedEntityName, $childEntity);
+ }
+ }
+ }
+
+ foreach ($this->dbSchemaInfo->getAllMnReferences() as $mnReferenceDetails) {
+ if ($mnReferenceDetails['source-entity'] === $entityName) {
+ $junctionTable = $mnReferenceDetails['junction-table'];
+ $prefixedJunctionTable = $this->dbSchemaInfo->getPrefixedTableName($junctionTable);
+ $sourceColumn = $mnReferenceDetails['source-column'];
+
+ $references = $this->database->get_results("SELECT * FROM `{$prefixedJunctionTable}` WHERE `{$sourceColumn}` = '{$id}'", ARRAY_A);
+
+ foreach ($references as $reference) {
+ $reference = $this->vpidRepository->replaceForeignKeysWithReferences($junctionTable, $reference);
+ $this->mirror->save($junctionTable, $reference);
+ }
+ }
+ }
+ }
+}
diff --git a/mu-plugins/versionpress/src/Database/wpdb-api-to-phpdoc.php b/mu-plugins/versionpress/src/Database/wpdb-api-to-phpdoc.php
new file mode 100644
index 0000000..bb08b03
--- /dev/null
+++ b/mu-plugins/versionpress/src/Database/wpdb-api-to-phpdoc.php
@@ -0,0 +1,54 @@
+
+$properties = $wpdbReflection->getProperties(ReflectionProperty::IS_PUBLIC);
+foreach ($properties as $property) {
+ preg_match_all('/@var (.*?)\n/s', $property->getDocComment(), $annotations);
+ $type = @$annotations[1][0];
+
+ echo "@property " . ($type ? $type . ' ' : '') . $property->getName() . "\n";
+}
+
+echo "\n";
+
+// Generate annotations for all public methods as
+// @method ()
+$methods = $wpdbReflection->getMethods(ReflectionMethod::IS_PUBLIC);
+foreach ($methods as $method) {
+ $parameters = $method->getParameters();
+ preg_match_all('/@return (.*?)[ \n]/s', $method->getDocComment(), $annotations);
+
+ @$returnType = $annotations[1][0];
+
+ echo "@method " . ($returnType ? $returnType . ' ' : '') . $method->getName() . "(";
+
+ $parametersWithDefaultValues = array_map(function (ReflectionParameter $parameter) {
+ if ($parameter->isDefaultValueAvailable()) {
+ if ($parameter->isDefaultValueConstant()) {
+ $default = $parameter->getDefaultValueConstantName();
+ } else {
+ $default = str_replace(
+ ['array (', "\n"],
+ ['array(', ''],
+ var_export($parameter->getDefaultValue(), true)
+ );
+ }
+ } else {
+ $default = null;
+ }
+
+ return '$' . $parameter->getName() . ($default !== null ? ' = ' . $default : '');
+ }, $method->getParameters());
+
+ echo join(', ', $parametersWithDefaultValues);
+
+ echo ")\n";
+}
diff --git a/mu-plugins/versionpress/src/Git/ChangeInfoPreprocessors/ChangeInfoPreprocessor.php b/mu-plugins/versionpress/src/Git/ChangeInfoPreprocessors/ChangeInfoPreprocessor.php
new file mode 100644
index 0000000..4e21bfe
--- /dev/null
+++ b/mu-plugins/versionpress/src/Git/ChangeInfoPreprocessors/ChangeInfoPreprocessor.php
@@ -0,0 +1,21 @@
+changeInfoFactory = $changeInfoFactory;
+ }
+
+ /**
+ * If both 'post/draft' and 'post/publish' actions exist for the same entity,
+ * replace them with one 'post/create' action.
+ *
+ * @param ChangeInfo[] $changeInfoList
+ * @return ChangeInfo[][]
+ */
+ public function process($changeInfoList)
+ {
+
+ // 1) Find and replace combination of post/draft and post/publish with single post/create action
+ $this->replaceChangeInfosCombination($changeInfoList, ["draft", "publish"], "create");
+
+ // 1) Find and replace combination of post/draft and post/update with single post/create action
+ $this->replaceChangeInfosCombination($changeInfoList, ["draft", "update"], "draft");
+
+ // 1) Find and replace combination of post/create and post/update with single post/create action
+ $this->replaceChangeInfosCombination($changeInfoList, ["create", "update"], "create");
+
+ return [$changeInfoList];
+ }
+
+ /**
+ * Find all changeInfos and group them according to provided indicies in $changeInfoList by VPID
+ * @param ChangeInfo[] $changeInfoList
+ * @param array $indicies
+ * @return array
+ */
+ private function getChangeInfosByIndicies($changeInfoList, $indicies)
+ {
+ $entities = [];
+ foreach ($changeInfoList as $key => $changeInfo) {
+ /** @var EntityChangeInfo $changeInfo */
+ if (ChangeInfoUtils::changeInfoRepresentsEntity($changeInfo, 'post') && in_array($changeInfo->getAction(), $indicies)) {
+ $entities[$changeInfo->getId()][$changeInfo->getAction()][] = $key;
+ }
+ }
+ return $entities;
+ }
+
+ /**
+ * Removes all changeInfos from source changeInfoList
+ * @param $changeInfoList
+ * @param $changeInfos
+ */
+ private function removeChangeInfos(&$changeInfoList, $changeInfos)
+ {
+ foreach ($changeInfos as $indicie => $indexes) {
+ foreach ($indexes as $index) {
+ unset($changeInfoList[$index]);
+ }
+ }
+ }
+
+ /**
+ * @param $changeInfoList
+ * @param array $indicies
+ * @param string $resultAction
+ */
+ private function replaceChangeInfosCombination(&$changeInfoList, $indicies, $resultAction)
+ {
+ $entities = $this->getChangeInfosByIndicies($changeInfoList, $indicies);
+ foreach ($entities as $entityId => $changeInfos) {
+ if (count($changeInfos) == 2) {
+ /** @var EntityChangeInfo $sourceChangeInfo */
+ $sourceChangeInfo = $changeInfoList[$changeInfos[$indicies[0]][0]];
+ $this->removeChangeInfos($changeInfoList, $changeInfos);
+
+ $fakeEntity = ['vp_id' => $sourceChangeInfo->getId()];
+
+ $changeInfoList[] = $this->changeInfoFactory->createEntityChangeInfo($fakeEntity, 'post', $resultAction, $sourceChangeInfo->getCustomTags(), $sourceChangeInfo->getChangedFiles());
+ }
+ }
+ }
+}
diff --git a/mu-plugins/versionpress/src/Git/ChangeInfoPreprocessors/PostTermSplittingPreprocessor.php b/mu-plugins/versionpress/src/Git/ChangeInfoPreprocessors/PostTermSplittingPreprocessor.php
new file mode 100644
index 0000000..8bb1431
--- /dev/null
+++ b/mu-plugins/versionpress/src/Git/ChangeInfoPreprocessors/PostTermSplittingPreprocessor.php
@@ -0,0 +1,49 @@
+containsPostChangeInfo($changeInfoList) && $this->containsTermChangeInfo($changeInfoList)) {
+
+ $filterFn = function ($changeInfo) {
+ return ChangeInfoUtils::changeInfoRepresentsEntity($changeInfo, 'term') ||
+ ChangeInfoUtils::changeInfoRepresentsEntity($changeInfo, 'term_taxonomy');
+ };
+
+ $termChangeInfoList = array_values(array_filter($changeInfoList, $filterFn));
+ $restChangeInfoList = array_values(array_filter($changeInfoList, function ($changeInfo) use ($filterFn) {
+ return !$filterFn($changeInfo);
+ }));
+
+ return [$termChangeInfoList, $restChangeInfoList];
+ }
+
+ return [$changeInfoList];
+ }
+
+ private function containsPostChangeInfo($changeInfoList)
+ {
+ return ArrayUtils::any($changeInfoList, function ($changeInfo) {
+ return ChangeInfoUtils::changeInfoRepresentsEntity($changeInfo, 'post');
+ });
+ }
+
+ private function containsTermChangeInfo($changeInfoList)
+ {
+ return ArrayUtils::any($changeInfoList, function ($changeInfo) {
+ return ChangeInfoUtils::changeInfoRepresentsEntity($changeInfo, 'term');
+ });
+ }
+}
diff --git a/mu-plugins/versionpress/src/Git/ChangeInfoPreprocessors/TermTaxonomyPreprocessor.php b/mu-plugins/versionpress/src/Git/ChangeInfoPreprocessors/TermTaxonomyPreprocessor.php
new file mode 100644
index 0000000..2ecd74e
--- /dev/null
+++ b/mu-plugins/versionpress/src/Git/ChangeInfoPreprocessors/TermTaxonomyPreprocessor.php
@@ -0,0 +1,69 @@
+changeInfoFactory = $changeInfoFactory;
+ }
+
+ /**
+ * Reads taxonomy from `term_taxonomy` action and assings it to `term`.
+ *
+ * @param ChangeInfo[] $changeInfoList
+ * @return ChangeInfo[][]
+ */
+ public function process($changeInfoList)
+ {
+ /** @var TrackedChangeInfo[] $termChangeInfos */
+ $termChangeInfos = array_filter($changeInfoList, function ($changeInfo) {
+ return $changeInfo instanceof TrackedChangeInfo && $changeInfo->getScope() === 'term';
+ });
+
+ if (!$termChangeInfos) {
+ return [$changeInfoList];
+ }
+
+ /** @var TrackedChangeInfo[] $termTaxonomyChangeInfos */
+ $termTaxonomyChangeInfos = array_filter($changeInfoList, function ($changeInfo) {
+ return $changeInfo instanceof TrackedChangeInfo && $changeInfo->getScope() === 'term_taxonomy';
+ });
+
+ $taxonomies = array_combine(
+ array_map(function (TrackedChangeInfo $changeInfo) {
+ return $changeInfo->getCustomTags()['VP-Term-Id'];
+ }, $termTaxonomyChangeInfos),
+ array_map(function (TrackedChangeInfo $changeInfo) {
+ return $changeInfo->getCustomTags()['VP-TermTaxonomy-Taxonomy'];
+ }, $termTaxonomyChangeInfos)
+ );
+
+ foreach ($termChangeInfos as $i => $termChangeInfo) {
+ $termId = $termChangeInfo->getId();
+ if (isset($taxonomies[$termId])) {
+ $tags = $termChangeInfo->getCustomTags();
+ $tags['VP-Term-Taxonomy'] = $taxonomies[$termId];
+
+ $changeInfoList[$i] = $this->changeInfoFactory->createTrackedChangeInfo(
+ $termChangeInfo->getScope(),
+ $termChangeInfo->getAction(),
+ $termChangeInfo->getId(),
+ $tags,
+ $termChangeInfo->getChangedFiles()
+ );
+ }
+ }
+
+ return [$changeInfoList];
+ }
+}
diff --git a/mu-plugins/versionpress/src/Git/ChangeInfoPreprocessors/UpdateActionChangeInfoPreprocessor.php b/mu-plugins/versionpress/src/Git/ChangeInfoPreprocessors/UpdateActionChangeInfoPreprocessor.php
new file mode 100644
index 0000000..b8e8aa3
--- /dev/null
+++ b/mu-plugins/versionpress/src/Git/ChangeInfoPreprocessors/UpdateActionChangeInfoPreprocessor.php
@@ -0,0 +1,59 @@
+getChangeInfosByIndicies($changeInfoList, ["update"]);
+
+ // 2) Replace all post/update with single post/update action
+ foreach ($entities as $entityId => $changeInfos) {
+ $updates = $changeInfos['update'];
+ if (count($updates) > 1) {
+ /** @var EntityChangeInfo $firstUpdateChangeInfo */
+ $firstUpdateChangeInfo = $changeInfoList[$changeInfos["update"][0]];
+ foreach ($updates as $update) {
+ unset($changeInfoList[$update]);
+ }
+
+ $changeInfoList[] = $firstUpdateChangeInfo;
+ }
+ }
+ return [$changeInfoList];
+ }
+
+ /**
+ * Find all changeInfos and group them according to provided indicies in $changeInfoList by VPID
+ * @param ChangeInfo[] $changeInfoList
+ * @param array $indicies
+ * @return array
+ */
+ private function getChangeInfosByIndicies($changeInfoList, $indicies)
+ {
+ $entities = [];
+ foreach ($changeInfoList as $key => $changeInfo) {
+ if ($changeInfo instanceof EntityChangeInfo && in_array($changeInfo->getAction(), $indicies)) {
+ $entities[$changeInfo->getId()][$changeInfo->getAction()][] = $key;
+ }
+ }
+ return $entities;
+ }
+}
diff --git a/mu-plugins/versionpress/src/Git/Commit.php b/mu-plugins/versionpress/src/Git/Commit.php
new file mode 100644
index 0000000..47f0ad1
--- /dev/null
+++ b/mu-plugins/versionpress/src/Git/Commit.php
@@ -0,0 +1,153 @@
+