Changeset 3764005 for langforge/trunk/includes/class-migration.php

Timestamp:

10/25/2026 06:29:16 AM (27 hours ago)

Author:

avakodeforge

Message:

Release 1.3.0 (trunk + tag; see readme changelog)

File:

• langforge/trunk/includes/class-migration.php (modified) (12 diffs)

langforge/trunk/includes/class-migration.php

@@ -91 +91 @@
                     'count' => $count,
                     'note'  => sprintf(
-                        /* translators: 1: number of WPML translation records found, 2: number of languages. */
-                        __('Found %1$d translation records across %2$d languages.', 'langforge'),
-                        $count, $lang_count
+                        /* translators: 1: the record count with its noun ("%d translation record"), 2: the language count with its noun ("%d language"). */
+                        __('Found %1$s across %2$s.', 'langforge'),
+                        /* translators: %d: number of WPML translation records found. */
+                        sprintf(_n('%d translation record', '%d translation records', (int) $count, 'langforge'), (int) $count),
+                        /* translators: %d: number of languages. */
+                        sprintf(_n('%d language', '%d languages', (int) $lang_count, 'langforge'), (int) $lang_count)
                     ),
                 ];
@@ -121 +124 @@
                     'count' => $post_count,
                     'note'  => sprintf(
-                        /* translators: 1: number of Polylang posts assigned to languages, 2: total number of languages. */
-                        __('Found %1$d posts assigned to languages, %2$d languages total.', 'langforge'),
-                        $post_count, $lang_count
+                        /* translators: 1: the post count with its noun ("%d post"), 2: the language count with its noun ("%d language"). */
+                        __('Found %1$s assigned to languages, %2$s total.', 'langforge'),
+                        /* translators: %d: number of Polylang posts assigned to languages. */
+                        sprintf(_n('%d post', '%d posts', $post_count, 'langforge'), $post_count),
+                        /* translators: %d: number of languages. */
+                        sprintf(_n('%d language', '%d languages', $lang_count, 'langforge'), $lang_count)
                     ),
                 ];
@@ -137 +143 @@
                 'count' => $trp_stats['records'],
                 'note'  => sprintf(
-                    /* translators: 1: number of TranslatePress translated strings, 2: number of languages. */
-                    __('Found %1$d translated strings across %2$d languages.', 'langforge'),
-                    $trp_stats['records'], $trp_stats['languages']
+                    /* translators: 1: the string count with its noun ("%d translated string"), 2: the language count with its noun ("%d language"). */
+                    __('Found %1$s across %2$s.', 'langforge'),
+                    /* translators: %d: number of TranslatePress translated strings. */
+                    sprintf(_n('%d translated string', '%d translated strings', (int) $trp_stats['records'], 'langforge'), (int) $trp_stats['records']),
+                    /* translators: %d: number of languages. */
+                    sprintf(_n('%d language', '%d languages', (int) $trp_stats['languages'], 'langforge'), (int) $trp_stats['languages'])
                 ),
             ];
@@ -366 +375 @@
         // Clearing first makes re-migration idempotent.
         if (!empty($rows)) {
-            $element_ids_csv = implode(',', array_map('intval', array_column($rows, 'element_id')));
-            $wpdb->query("DELETE FROM {$lf_table} WHERE element_id IN ({$element_ids_csv})"); // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Table name from $wpdb->prefix; IN list is integer IDs cast via intval; custom plugin table.
+            $this->delete_post_translation_rows(array_column($rows, 'element_id'));
         }
 
@@ -426 +434 @@
         );
 
+        // 5b. Translations of terms (categories, tags, any taxonomy): the `tax_*` rows of
+        // icl_translations. Counted apart from the posts: `migrated` stays the number of posts.
+        $term_result = $this->migrate_wpml_terms();
+        $terms       = $term_result['linked'];
+        $errors     += $term_result['errors'];
+        if ($term_result['linked'] || $term_result['errors']) {
+            $log[] = $this->term_result_line($term_result);
+        }
+
         // 6. Migrate WPML string translations if tables exist
         $string_log = $this->migrate_wpml_strings();
@@ -437 +454 @@
         flush_rewrite_rules();
 
-        return compact('migrated', 'skipped', 'errors', 'log');
+        return compact('migrated', 'skipped', 'errors', 'terms', 'log');
     }
 
@@ -702 +719 @@
             'languages' => max(1, count($languages_with_records)),
         ];
+    }
+
+    /**
+ * Delete the translation rows of the POSTS with these numbers: a migration can be run again, and clears the
+ * rows of the posts it is about to write first.
+ *
+ * Posts' rows only (LANGFORGE_Post_Translation::post_row_sql): the table also holds the rows of terms, a term
+ * can have the number of a post, and a migration of posts must not delete what it does not write
+ * (BUG-LANG-SEO-03). One place for the three migrations (WPML, Polylang, TranslatePress).
+ *
+ * @param array $post_ids Post IDs; anything that is not a positive integer is dropped.
+ * @return int Rows deleted.
+ */
+    private function delete_post_translation_rows(array $post_ids): int {
+        global $wpdb;
+        $ids = array_values(array_unique(array_filter(array_map('intval', $post_ids), function ($id) { return $id > 0; })));
+        if (!$ids) {
+            return 0;
+        }
+        $lf_table = $wpdb->prefix . 'langforge_translations';
+        $ids_csv  = implode(',', $ids);
+        return (int) $wpdb->query("DELETE FROM {$lf_table} WHERE element_id IN ({$ids_csv}) AND " . LANGFORGE_Post_Translation::post_row_sql()); // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Table name from $wpdb->prefix; IN list is integer IDs cast via intval; custom plugin table.
     }
 
@@ -948 +987 @@
                 update_post_meta($target_id, '_langforge_migrated_from_translatepress_language', $target_code);
 
-                $wpdb->query($wpdb->prepare( // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- own table from $wpdb->prefix; one-time migration write
-                    "DELETE FROM {$lf_table} WHERE element_id IN (%d, %d)", // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Table name from $wpdb->prefix, values are %-prepared.
-                    $source_id,
-                    $target_id
-                ));
+                $this->delete_post_translation_rows([$source_id, $target_id]);
                 $group = (int) $wpdb->get_var("SELECT COALESCE(MAX(translation_group), 0) FROM {$lf_table}") + 1; // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- own table from $wpdb->prefix; one-time migration read
 
@@ -1016 +1051 @@
 
         return $count;
+    }
+
+
+    // Translations of terms (WPML `tax_*`, Polylang `term_language` / `term_translations`)
+
+
+    // BUG-LANG-MIGR-01: the migrations read posts only, so the translated categories were not linked
+    // after them. wp_langforge_translations keeps a term the way the taxonomy screen of the plugin
+    // writes it: element_type "tax_<taxonomy>", element_id the term_id, one translation_group for
+    // the pair (the groups of posts and terms count in the same series).
+
+    /**
+ * Taxonomies WPML registers for its own bookkeeping; its icl_translations rows of the type
+ * "tax_<name>" are not translations of the content of the site. They exist on the site (taxonomy_exists
+ * is true) as long as WPML is active, which it is when the migration runs.
+ */
+    private const WPML_SERVICE_TAXONOMIES = ['translation_priority'];
+
+    /** The line of the log for the terms. */
+    private function term_result_line(array $result): string {
+        return sprintf('Terms: linked %d translations in %d groups, errors %d', $result['linked'], $result['groups'], $result['errors']);
+    }
+
+    /**
+ * Clear the rows of the terms that are about to be written, so that a second run (migrate, tweak, migrate
+ * again) does not leave one term in two groups. By element and type, never by number alone: a post and a
+ * term can have the same number (see delete_post_translation_rows).
+ *
+ * @param array<string,int> $term_ids_by_taxonomy Taxonomy => term IDs.
+ * @return int Rows deleted.
+ */
+    private function delete_term_translation_rows(array $term_ids_by_taxonomy): int {
+        global $wpdb;
+        $lf_table = $wpdb->prefix . 'langforge_translations';
+        $deleted  = 0;
+        foreach ($term_ids_by_taxonomy as $taxonomy => $term_ids) {
+            $taxonomy = sanitize_key((string) $taxonomy);
+            $ids      = array_values(array_unique(array_filter(array_map('intval', $term_ids), function ($id) { return $id > 0; })));
+            if ($taxonomy === '' || !$ids) {
+                continue;
+            }
+            foreach (array_chunk($ids, 500) as $chunk) {
+                $ids_csv  = implode(',', $chunk);
+                $deleted += (int) $wpdb->query($wpdb->prepare("DELETE FROM {$lf_table} WHERE element_type = %s AND element_id IN ({$ids_csv})", LANGFORGE_Post_Translation::TERM_ELEMENT_PREFIX . $taxonomy)); // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Table name from $wpdb->prefix; IN list is integer IDs cast via intval; custom plugin table.
+            }
+        }
+        return $deleted;
+    }
+
+    /**
+ * Write groups of term translations.
+ *
+ * @param array<int,array<int,array{term_id:int,taxonomy:string,language:string,source:?string}>> $groups One list of members per group.
+ * @return array{linked:int,groups:int,errors:int} Rows written, groups with a row, rows that could not be written.
+ */
+    private function write_term_translation_groups(array $groups): array {
+        global $wpdb;
+        $lf_table = $wpdb->prefix . 'langforge_translations';
+        $linked   = $written = $errors = 0;
+
+        $by_taxonomy = [];
+        foreach ($groups as $members) {
+            foreach ($members as $member) {
+                $by_taxonomy[$member['taxonomy']][] = $member['term_id'];
+            }
+        }
+        if (!$by_taxonomy) {
+            return ['linked' => 0, 'groups' => 0, 'errors' => 0];
+        }
+        $this->delete_term_translation_rows($by_taxonomy);
+
+        $group_id = (int) $wpdb->get_var("SELECT COALESCE(MAX(translation_group), 0) FROM {$lf_table}"); // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- own table from $wpdb->prefix; one-time migration read
+        $seen     = [];
+        foreach ($groups as $members) {
+            $group_id++;
+            $has_row = false;
+            foreach ($members as $member) {
+                $element_type = LANGFORGE_Post_Translation::TERM_ELEMENT_PREFIX . $member['taxonomy'];
+                $key          = $element_type . ':' . $member['term_id'] . ':' . $member['language'];
+                if (isset($seen[$key])) {
+                    continue;
+                }
+                $seen[$key] = true;
+                $result = $wpdb->insert($lf_table, [ // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- own table from $wpdb->prefix; one-time migration write
+                    'element_id'           => $member['term_id'],
+                    'element_type'         => $element_type,
+                    'translation_group'    => $group_id,
+                    'language_code'        => $member['language'],
+                    'source_language_code' => $member['source'],
+                ]);
+                if ($result === false) {
+                    $errors++;
+                    continue;
+                }
+                $linked++;
+                $has_row = true;
+            }
+            if ($has_row) {
+                $written++;
+            }
+        }
+
+        return ['linked' => $linked, 'groups' => $written, 'errors' => $errors];
+    }
+
+    /**
+ * WPML keeps the translation of a term as a row of icl_translations of the type "tax_<taxonomy>":
+ * element_id is the term_taxonomy_id of the term (not its term_id), the members of a pair share a trid.
+ *
+ * @return array{linked:int,groups:int,errors:int}
+ */
+    private function migrate_wpml_terms(): array {
+        global $wpdb;
+        $icl_table = $wpdb->prefix . 'icl_translations';
+
+        // phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- WPML legacy/core table names from $wpdb->prefix; static query.
+        $rows = $wpdb->get_results( // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- WPML legacy table from $wpdb->prefix; one-time migration read
+            "SELECT t.element_type, t.trid, t.language_code, t.source_language_code, tt.term_id, tt.taxonomy
+             FROM {$icl_table} t
+             JOIN {$wpdb->term_taxonomy} tt ON tt.term_taxonomy_id = t.element_id
+             WHERE t.element_type LIKE 'tax_%'
+             ORDER BY t.trid ASC, tt.term_id ASC"
+        );
+        // phpcs:enable WordPress.DB.PreparedSQL.InterpolatedNotPrepared
+
+        $by_trid = [];
+        foreach ((array) $rows as $row) {
+            // The type of the row names the taxonomy of the term it points at; a number that is the
+            // term_taxonomy_id of a term of another taxonomy is not this row's term.
+            if ($row->element_type !== LANGFORGE_Post_Translation::TERM_ELEMENT_PREFIX . $row->taxonomy) {
+                continue;
+            }
+            // `tax_*` is every taxonomy WPML keeps a row for: its own service taxonomies too, and the ones of
+            // plugins that are gone. Only the taxonomies the site registers, and not WPML's own, are brought over.
+            if (in_array($row->taxonomy, self::WPML_SERVICE_TAXONOMIES, true) || !taxonomy_exists($row->taxonomy)) {
+                continue;
+            }
+            $language = sanitize_key($row->language_code);
+            if ($language === '') {
+                continue;
+            }
+            $by_trid[(int) $row->trid][] = [
+                'term_id'  => (int) $row->term_id,
+                'taxonomy' => sanitize_key($row->taxonomy),
+                'language' => $language,
+                'source'   => $row->source_language_code ? sanitize_key($row->source_language_code) : null,
+            ];
+        }
+
+        return $this->write_term_translation_groups(array_values($by_trid));
+    }
+
+    /**
+ * Taxonomy of terms, by term_id: the taxonomy that is not one of Polylang's own.
+ *
+ * @param int $term_ids
+ * @return array<int,string> term_id => taxonomy
+ */
+    private function taxonomies_of_terms(array $term_ids): array {
+        global $wpdb;
+        $found = [];
+        $ids   = array_values(array_unique(array_filter(array_map('intval', $term_ids), function ($id) { return $id > 0; })));
+        foreach (array_chunk($ids, 500) as $chunk) {
+            $ids_csv = implode(',', $chunk);
+            // phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- core table; IN list is integer IDs cast via intval above.
+            $rows    = $wpdb->get_results( // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- core table; IN list is integer IDs cast via intval; one-time migration read
+                "SELECT term_id, taxonomy FROM {$wpdb->term_taxonomy}
+                 WHERE term_id IN ({$ids_csv})
+                   AND taxonomy NOT IN ('language', 'term_language', 'post_translations', 'term_translations')
+                 ORDER BY term_taxonomy_id ASC"
+            );
+            // phpcs:enable WordPress.DB.PreparedSQL.InterpolatedNotPrepared
+            foreach ((array) $rows as $row) {
+                if (!isset($found[(int) $row->term_id])) {
+                    $found[(int) $row->term_id] = sanitize_key($row->taxonomy);
+                }
+            }
+        }
+        return $found;
+    }
+
+    /**
+ * The members of a map Polylang keeps in the description of a "post_translations" or "term_translations"
+ * term: language code => ID.
+ *
+ * The map is serialized and carries more than the languages: a "sync" list (the posts or terms whose
+ * data Polylang keeps in step), so a key that is not a language of Polylang is no member, and neither is
+ * a value that is not a positive whole ID (a list is no ID: (int) of a non-empty one is 1).
+ *
+ * @param mixed $map Unserialized description.
+ * @param array<string,mixed> $lang_info Languages of Polylang by code.
+ * @return array<string,int> code => ID
+ */
+    private function polylang_map_members($map, array $lang_info): array {
+        if (!is_array($map)) {
+            return [];
+        }
+        $members = [];
+        foreach ($map as $code => $id) {
+            $code = sanitize_key((string) $code);
+            if ($code === '' || !isset($lang_info[$code]) || !is_scalar($id) || !preg_match('/^[1-9][0-9]*$/', (string) $id)) {
+                continue;
+            }
+            $members[$code] = (int) $id;
+        }
+        return $members;
+    }
+
+    /**
+ * Polylang gives a term its language as a "term_language" term (slug pll_<code>) related to the term, and
+ * keeps a pair as a "term_translations" term whose description is the serialized map code => term_id
+ * (the same map as "post_translations", with a "sync" list of its own besides the languages).
+ *
+ * @param array<string,mixed> $lang_info Languages of the site by code (as read from Polylang).
+ * @param string $default_lang
+ * @return array{linked:int,groups:int,errors:int}
+ */
+    private function migrate_polylang_terms(array $lang_info, string $default_lang): array {
+        global $wpdb;
+
+        $pairs   = [];
+        $in_pair = [];
+        $pair_terms = $wpdb->get_results( // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- core table; one-time migration read
+            "SELECT tt.description FROM {$wpdb->term_taxonomy} tt WHERE tt.taxonomy = 'term_translations'"
+        );
+        foreach ((array) $pair_terms as $pair_term) {
+            $members = $this->polylang_map_members(forge_safe_unserialize($pair_term->description), $lang_info);
+            foreach ($members as $term_id) {
+                $in_pair[$term_id] = true;
+            }
+            if ($members) {
+                $pairs[] = $members;
+            }
+        }
+
+        // Terms that have a language and no pair: a row of their own, as single posts have.
+        $singles   = [];
+        $lang_rows = $wpdb->get_results( // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- core table; one-time migration read
+            "SELECT tr.object_id AS term_id, t.slug
+             FROM {$wpdb->term_relationships} tr
+             JOIN {$wpdb->term_taxonomy} tt ON tt.term_taxonomy_id = tr.term_taxonomy_id
+             JOIN {$wpdb->terms} t ON t.term_id = tt.term_id
+             WHERE tt.taxonomy = 'term_language'
+             ORDER BY tr.object_id ASC"
+        );
+        foreach ((array) $lang_rows as $row) {
+            $term_id = (int) $row->term_id;
+            $code    = sanitize_key((string) preg_replace('/^pll_/', '', (string) $row->slug));
+            if ($term_id <= 0 || $code === '' || isset($in_pair[$term_id]) || !isset($lang_info[$code])) {
+                continue;
+            }
+            $singles[$term_id] = $code;
+        }
+
+        $taxonomy_of = $this->taxonomies_of_terms(array_merge(array_keys($in_pair), array_keys($singles)));
+
+        $member = function (int $term_id, string $code) use ($taxonomy_of, $default_lang) {
+            return [
+                'term_id'  => $term_id,
+                'taxonomy' => $taxonomy_of[$term_id],
+                'language' => $code,
+                'source'   => $code === $default_lang ? null : ($default_lang !== '' ? $default_lang : null),
+            ];
+        };
+        $groups = [];
+        foreach ($pairs as $members) {
+            $group = [];
+            foreach ($members as $code => $term_id) {
+                if (isset($taxonomy_of[$term_id])) {
+                    $group[] = $member($term_id, (string) $code);
+                }
+            }
+            if ($group) {
+                $groups[] = $group;
+            }
+        }
+        foreach ($singles as $term_id => $code) {
+            if (isset($taxonomy_of[$term_id])) {
+                $groups[] = [$member((int) $term_id, $code)];
+            }
+        }
+
+        return $this->write_term_translation_groups($groups);
     }
 
@@ -1091 +1409 @@
         $group_post_ids = [];
         foreach ($group_terms as $group_term) {
-            $translations = forge_safe_unserialize($group_term->description);
-            if (!is_array($translations) || count($translations) < 1) continue;
+            // Only the languages of Polylang with a positive ID: the map carries a "sync" list besides them,
+            // and (int) of a non-empty list is 1 (BUG-LANG-MIGR-02).
+            $translations = $this->polylang_map_members(forge_safe_unserialize($group_term->description), $lang_info);
+            if (!$translations) continue;
 
             $translation_groups[] = $translations;
@@ -1111 +1431 @@
         $all_polylang_post_ids = array_unique(array_filter(array_map('intval', array_merge($group_post_ids, $language_post_ids))));
         if (!empty($all_polylang_post_ids)) {
-            $post_ids_csv = implode(',', $all_polylang_post_ids);
-            $wpdb->query("DELETE FROM {$lf_table} WHERE element_id IN ({$post_ids_csv})"); // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Table name from $wpdb->prefix; IN list is integer IDs cast via intval; custom plugin table.
+            $this->delete_post_translation_rows($all_polylang_post_ids);
         }
 
@@ -1220 +1539 @@
         );
 
+        // 8. Translations of terms: the `term_translations` pairs and the `term_language` of single terms.
+        $term_result = $this->migrate_polylang_terms($lang_info, (string) $default_lang);
+        $terms       = $term_result['linked'];
+        $errors     += $term_result['errors'];
+        if ($term_result['linked'] || $term_result['errors']) {
+            $log[] = $this->term_result_line($term_result);
+        }
+
         // same flush as WPML — new CPT rules need to land in wp_options.
         flush_rewrite_rules();
 
-        return compact('migrated', 'skipped', 'errors', 'log');
+        return compact('migrated', 'skipped', 'errors', 'terms', 'log');
     }