first commit

wp-content/plugins/loco-translate/src/hooks/AdminHooks.php

@@ -0,0 +1,204 @@
+<?php
+/**
+ * Common hooks for all admin contexts
+ */
+class Loco_hooks_AdminHooks extends Loco_hooks_Hookable {
+
+    /**
+     * @var Loco_mvc_AdminRouter
+     */
+    private $router;
+
+
+    /**
+     * "admin_notices" callback, 
+     * If this is hooked and not unhooked then auto-hooks using annotations have failed.
+     */
+    public static function print_hook_failure(){
+        echo '<div class="notice error"><p><strong>Error:</strong> Loco Translate failed to start up</p></div>';
+    }
+
+
+    /**
+     * Autoloader for polyfills and warnings when important classes are requested, but missing.
+     * This must be loaded after `loco_autoload` which is responsible for loading Loco_* classes.
+     */
+    public static function autoload_compat( $name ){
+        if( strlen($name) < 20 && 'Loco_' !== substr($name,0,5) ){
+            $path = loco_plugin_root().'/src/compat/'.$name.'.php';
+            if( file_exists($path) ){
+                require $path;
+            }
+        }
+    }
+
+
+    /**
+     * {@inheritdoc}
+     */
+    public function __construct(){
+        // renders failure notice if plugin failed to start up admin hooks.
+        add_action( 'admin_notices', [__CLASS__,'print_hook_failure'] );
+        // initialize hooks
+        parent::__construct();
+        // Ajax router will be called directly in tests
+        // @codeCoverageIgnoreStart
+        if( loco_doing_ajax() ){
+            $action = $_REQUEST['action'] ?? '';
+            // initialize Ajax router before hook fired so we can handle output buffering
+            if( isset($_REQUEST['route']) && str_starts_with($action,'loco_') ){
+                spl_autoload_register( [__CLASS__,'autoload_compat'] );
+                $this->router = new Loco_mvc_AjaxRouter;
+                Loco_package_Listener::create();
+            }
+        }
+        // @codeCoverageIgnoreEnd
+        // page router required on all pages as it hooks in the menu
+        else {
+            $this->router = new Loco_mvc_AdminRouter;
+            // we don't know we will render a page yet, but we know it'll be ours if it exists.
+            if( isset($_GET['page']) && 'loco' === substr($_GET['page'],0,4) ){
+                spl_autoload_register( [__CLASS__,'autoload_compat'] );
+                Loco_package_Listener::create();
+                // trigger post-upgrade process if required
+                Loco_data_Settings::get()->migrate();
+            }
+        }
+    }
+
+
+    /**
+     * @inheritdoc
+     */
+    public function unhook(){
+        spl_autoload_unregister( [__CLASS__,'autoload_compat'] );
+        parent::unhook();
+    }    
+
+
+	/**
+	 * "admin_init" callback.
+	 */
+    public function on_admin_init(){
+    	// This should fire just before WP_Privacy_Policy_Content::privacy_policy_guide is called
+        // View this content at /wp-admin/privacy-policy-guide.php#wp-privacy-policy-guide-loco-translate
+	    if( function_exists('wp_add_privacy_policy_content') ) {
+	    	$url = apply_filters('loco_external','https://localise.biz/wordpress/plugin/privacy');
+		    wp_add_privacy_policy_content(
+		    	__('Loco Translate','loco-translate'),
+			    esc_html( __("This plugin doesn't collect any data from public website visitors.",'loco-translate') ).'<br />'. 
+                wp_kses(
+                    // translators: %s will be replaced with a URL which may change without affecting the translation.
+                    sprintf( __('Administrators and auditors may wish to review Loco\'s <a href="%s">plugin privacy notice</a>.','loco-translate'), esc_url($url) ),
+                    ['a'=>['href'=>true]], ['https']
+                )
+		    );
+	    }
+    }
+
+
+    /**
+     * "admin_menu" callback.
+     */
+    public function on_admin_menu(){
+        // This earliest we need translations, and admin user locale should be set by now
+        if( $this->router ){
+            $domainPath = dirname( loco_plugin_self() ).'/languages';
+            load_plugin_textdomain( 'loco-translate', false, $domainPath );
+        }
+        // Unhook failure notice that would fire if this hook was not successful
+        remove_action( 'admin_notices', [__CLASS__,'print_hook_failure'] );
+    }
+
+
+    /**
+     * plugin_action_links action callback
+     * @param string[] $links
+     * @param string $plugin
+     * @return string[]
+     */
+    public function on_plugin_action_links( $links, $plugin = '' ){
+         try {
+             if( $plugin && current_user_can('loco_admin') && Loco_package_Plugin::get_plugin($plugin) ){
+                // coerce links to array
+                if( ! is_array($links) ){
+                    $links = $links && is_string($links) ? (array) $links : [];
+                }
+                // ok to add "translate" link into meta row
+                $href = Loco_mvc_AdminRouter::generate('plugin-view', [ 'bundle' => $plugin] );
+                $links[] = '<a href="'.esc_attr($href).'">'.esc_html__('Translate','loco-translate').'</a>';
+             }
+         }
+         catch( Exception $e ){
+             // $links[] = esc_html( 'Debug: '.$e->getMessage() );
+         }
+         return $links;
+    }
+
+
+    /**
+     * Purge in-memory caches that may be persisted by object caching plugins
+     */
+    private function purge_wp_cache(){
+        global $wp_object_cache;
+        if( function_exists('wp_cache_delete') && is_object($wp_object_cache) && method_exists($wp_object_cache,'delete') ){
+            wp_cache_delete('plugins','loco');
+        }
+    }
+
+
+    /**
+     * pre_update_option_{$option} filter callback for $option = "active_plugins"
+     */
+    public function filter_pre_update_option_active_plugins( ?array $value = null ){
+        $this->purge_wp_cache();
+        return $value;
+    }
+
+
+    /**
+     * pre_update_site_option_{$option} filter callback for $option = "active_sitewide_plugins"
+     */
+    public function filter_pre_update_site_option_active_sitewide_plugins( ?array $value = null ){
+        $this->purge_wp_cache();
+        return $value;
+    }
+
+
+    /**
+     * heartbeat_received filter callback 
+     */
+    public function filter_heartbeat_received( ?array $response = null, ?array $data = null ){
+        if( is_array($data) && array_key_exists('loco-translate',$data) ){
+            $nonces = $data['loco-translate']['nonces'] ?? [];
+            foreach( $nonces as $action => $value ){
+                // Refresh nonce if it's either expired, or in its second tick.
+                // Ajax controllers check user permissions before nonce is checked.
+                if( 1 !== wp_verify_nonce($value,$action) ){
+                    $nonces[$action] = wp_create_nonce($action);
+                }
+            }
+            $response['loco-translate']['nonces'] = $nonces;
+        }
+        return $response;
+    }
+
+
+
+    /**
+     * deactivate_plugin action callback
+     *
+    public function on_deactivate_plugin( $plugin, $network = false ){
+        if( loco_plugin_self() === $plugin ){
+            // TODO flush all our transient cache entries
+            // "DELETE FROM ___ WHERE `option_name` LIKE '_transient_loco_%' OR `option_name` LIKE '_transient_timeout_loco_%'";
+        }
+    }*/
+
+
+
+    /*public function filter_all( $hook ){
+        error_log( $hook, 0 );
+    }*/
+    
+}

wp-content/plugins/loco-translate/src/hooks/Hookable.php

@@ -0,0 +1,92 @@
+<?php
+/**
+ * Hookable objects automatically bind Wordpress filters and actions instance methods.
+ * - Filter methods take the form `public function filter_{hook}()`
+ * - Actions methods take the form `public function on_{hook}`
+ */
+abstract class Loco_hooks_Hookable {
+
+    /**
+     * Registry of tags to be deregistered when object removed from memory
+     * @var array
+     */
+    private $hooks;
+
+
+    /**
+     * Constructor register hooks immediately
+     */
+    public function __construct(){
+
+        $ref = new ReflectionClass( $this );
+        $this->hooks = [];
+        foreach( $ref->getMethods( ReflectionMethod::IS_PUBLIC ) as $method ){
+            $func = $method->name;
+            // support filter_{filter_hook} methods
+            if( 'filter_' === substr($func,0,7) ) {
+                $hook = substr( $func, 7 );
+            }
+            // support on_{action_hook} methods
+            else if( 'on_' === substr($func,0,3) ) {
+                $hook = substr( $func, 3 );
+            }
+            // support debug_{filter|action_hook} methods only in debug mode
+            else if( 'debug_' === substr($func,0,6) && loco_debugging() ) {
+                $hook = substr( $func, 6 );
+            }
+            else {
+                continue;
+            }
+            // this goes to 11 so we run after system defaults
+            $priority = 11;
+            // support @priority tag in comment block (uncomment if needed)
+            /*if( ( $docblock = $method->getDocComment() ) && ( $offset = strpos($docblock,'@priority ') ) ){
+                preg_match( '/^\d+/', substr($docblock,$offset+10), $r ) and
+                $priority = (int) $r[0];
+            }*/
+            $num_args = $method->getNumberOfParameters();
+            $this->addHook( $hook, $func, $num_args, $priority );
+        }
+    }
+
+
+
+    /**
+     * Manually append a hook, regardless of whether it's added already
+     */
+    protected function addHook( $hook, $func, $num_args = 0, $priority = 11  ){
+        // call add_action or add_filter with required arguments and hook is registered
+        add_filter( $hook, [ $this, $func ], $priority, $num_args );
+        $this->hooks[] = [ $hook, $func, $priority, $num_args ];
+    }
+
+
+    /**
+     * Ensure all hooks in memory are re-attached if they've been removed
+     */
+    protected function reHook(){
+        if( is_array($this->hooks) ){
+            foreach( $this->hooks as $r ){
+                list( $hook, $func, $priority, $num_args ) = $r;
+                if( ! has_filter($hook,[$this,$func]) ){
+                    add_filter( $hook, [$this,$func], $priority, $num_args );
+                }
+            }
+        }
+    }
+
+
+    /**
+     * Deregister active hooks.
+     * We can't use __destruct because instances persist in WordPress hook registry
+     */
+    public function unhook(){
+        if( is_array($this->hooks) ){
+            foreach( $this->hooks as $r ){
+                remove_filter( $r[0], [$this,$r[1]], $r[2] );
+            }
+        }
+        $this->hooks = null;
+    }
+
+}

wp-content/plugins/loco-translate/src/hooks/LoadHelper.php

@@ -0,0 +1,396 @@
+<?php
+/**
+ * Text Domain loading helper.
+ * Ensures custom translations can be loaded from `wp-content/languages/loco`.
+ * This functionality is optional. You can disable the plugin if you're not loading MO or JSON files from languages/loco
+ * 
+ * @noinspection PhpUnused
+ * @noinspection PhpUnusedParameterInspection
+ * @noinspection PhpMissingParamTypeInspection
+ * @noinspection PhpMissingReturnTypeInspection
+ */
+class Loco_hooks_LoadHelper extends Loco_hooks_Hookable {
+
+    /**
+     * Cache of custom locations passed from load_plugin_textdomain and load_theme_textdomain
+     * @var string[]
+     */
+    private $custom = [];
+
+    /**
+     * Deferred JSON files under our custom directory, indexed by script handle
+     * @var string[]
+     */
+    private $json = [];
+
+    /**
+     * Recursion lock, contains the current mofile being processed indexed by the domain
+     * @var string[]
+     */
+    private $lock = [];
+
+    /**
+     * The current MO file being loaded during the initial call to load_textdomain
+     */
+    private $mofile = '';
+
+    /**
+     * The current domain being loaded during the initial call to load_textdomain
+     */
+    private $domain = '';
+
+    /**
+     * Registry of text domains we've seen, whether loaded or not. This will catch early JIT problem.
+     */
+    private $seen = [];
+
+    /**
+     * {@inheritDoc}
+     */
+    public function __construct(){
+        parent::__construct();
+        // Text domains loaded prematurely won't be customizable, even if NOOP_Translations
+        global $l10n, $l10n_unloaded;
+        if( $l10n && is_array($l10n) ){
+            $unloaded = [];
+            foreach( array_keys($l10n) as $domain ){
+                if( $domain && is_string($domain) && 'default' !== $domain && apply_filters('loco_unload_early_textdomain',true,$domain) ){
+                    unload_textdomain($domain) and $unloaded[] = $domain;
+                    unset($l10n_unloaded[$domain]);
+                }
+            }
+            // debug all text domains unloaded, excluding NOOP_Translations for less noise.
+            if( $unloaded && loco_debugging() ){
+                $n = count($unloaded);
+                Loco_error_Debug::trace('Unloaded %u premature text domain%s (%s)', $n, 1===$n?'':'s', implode(',',$unloaded) );
+            }
+        }
+    }
+
+
+    /**
+     * Filter callback for `pre_get_language_files_from_path`
+     * Called from {@see WP_Textdomain_Registry::get_language_files_from_path}
+     *
+     * @param null|array $files we're not going to modify this.
+     * @param string $path either WP_LANG_DIR/plugins/', WP_LANG_DIR/themes/ or a user-defined location
+     */
+    public function filter_pre_get_language_files_from_path( $files, $path = '' ) {
+        if( is_string($path) && ! array_key_exists($path,$this->custom) ){
+            $len = strlen( loco_constant('WP_LANG_DIR') );
+            $rel = substr($path,$len);
+            if( '/' !== $rel && '/plugins/' !== $rel && '/themes/' !== $rel ){
+                $this->resolveType($path);
+            }
+        }
+        return $files;
+    }
+
+
+    /**
+     * Filter callback for `lang_dir_for_domain`
+     * Called from {@see WP_Textdomain_Registry::get} after path is obtained from {@see WP_Textdomain_Registry::get_path_from_lang_dir}
+     * @param false|string $path
+     * @param string $domain
+     * @param string $locale
+     * @return false|string
+     */
+    public function filter_lang_dir_for_domain( $path, $domain, $locale ){
+        // If path is false it means no system or author files were found. This will stop WordPress trying to load anything.
+        // Usually this occurs during true JIT loading, where an author path would not be set by e.g. load_plugin_textdomain.
+        if( false === $path ){
+            // Avoid WordPress bailing on domain load by letting it know about our custom path now
+            $base = rtrim( loco_constant('LOCO_LANG_DIR'), '/' );
+            foreach( ['/plugins/','/themes/'] as $type ){
+                if( self::try_readable($base.$type.$domain.'-'.$locale.'.mo') ){
+                    $path = $base.$type;
+                    // Caveat: if load_%_textdomain is called later on with a custom (author) path, it will be ignored.
+                    break;
+                }
+            }
+        }
+        return $path;
+    }
+
+
+    /**
+     * Triggers a new round of load_translation_file attempts.
+     */
+    public function on_load_textdomain( $domain, $mofile ){
+        if( isset($this->lock[$domain]) ){
+            // may be recursion for our custom file
+            if( $this->lock[$domain] === $mofile ){
+                return;
+            }
+            // else a new file, so release the lock
+            unset($this->lock[$domain]);
+        }
+        // flag whether the original MO file (or a valid sibling) exists for this load.
+        // we could check this during filter_load_translation_file but this saves doing it multiple times
+        $this->mofile = self::try_readable($mofile);
+        // Setting the domain just in case someone is applying filters manually in a strange order
+        $this->domain = $domain;
+        // If load_textdomain was called directly with a custom file we'll have missed it
+        if( 'default' !== $domain ){
+            $path = dirname($mofile).'/';
+            if( ! array_key_exists($path,$this->custom) ){
+                $this->resolveType($path);
+            }
+        }
+        $this->seen[$domain] = true;
+    }
+
+
+    /**
+     * Filter callback for `load_translation_file`
+     * Called from {@see load_textdomain} multiple times for each file format in preference order.
+     */
+    public function filter_load_translation_file( $file, $domain, $locale ){
+        // domain mismatch would be unexpected during normal execution, but anyone could apply filters.
+        if( $domain !== $this->domain ){
+            return $file;
+        }
+        // skip recursion for our own custom file:
+        if( isset($this->lock[$domain]) ){
+            return $file;
+        }
+        // loading a custom file directly is fine, although above lock will prevent in normal situations
+        $path = dirname($file).'/';
+        $custom = trailingslashit( loco_constant('LOCO_LANG_DIR') );
+        if( $path === $custom || str_starts_with($file,$custom) ){
+            return $file;
+        }
+        // map system file to custom location if possible. e.g. languages/foo => languages/loco/foo
+        // this will account for most installed translations which have been customized.
+        $system = trailingslashit( loco_constant('WP_LANG_DIR') );
+        if( str_starts_with($file,$system) ){
+            $mapped = substr_replace($file,$custom,0,strlen($system) );
+        }
+        // custom path may be author location, meaning it's under plugin or theme directories
+        else if( array_key_exists($path,$this->custom) ){
+            $ext = explode( '.', basename($file), 2 )[1];
+            $mapped = $custom.$this->custom[$path].'/'.$domain.'-'.$locale.'.'.$ext;
+        }
+        // otherwise we'll assume the custom path is not intended to be further customized.
+        else {
+            return $file;
+        }
+        // When the original file isn't found, calls to load_textdomain will return false and overwrite our custom file.
+        // Here we'll simply return our mapped version, whether it exists or not. WordPress will treat is as the original.
+        if( '' === $this->mofile ){
+            return $mapped;
+        }
+        // We know that the original file will eventually be found (even if via a second file attempt)
+        // This requires a recursive call to load_textdomain for our custom file, WordPress will handle if it exists.
+        $mapped = self::to_mopath($mapped);
+        $this->lock[$domain] = $mapped;
+        load_textdomain( $domain, $mapped, $locale );
+        /*/ Sanity check that original file does exist, and it's the one we're expecting:
+        if( '' === self::try_readable($file) || self::to_mopath($file) !== $this->mofile ){
+            throw new LogicException;
+        }*/
+        // Return original file, which we've established does exist, or if it doesn't another extension might
+        return $file;
+    }
+
+
+    /**
+     * Resolve a custom directory path to either a theme or a plugin
+     * @param string $path directory path with trailing slash
+     */
+    private function resolveType( string $path ):void {
+        // no point trying to resolve a relative path, this likely stems from bad call to load_textdomain
+        if( ! Loco_fs_File::is_abs($path) ){
+            return;
+        }
+        // custom location is likely to be inside a theme or plugin, but could be anywhere
+        if( Loco_fs_Locations::getPlugins()->check($path) ){
+            $this->custom[$path] = 'plugins';
+        }
+        else if( Loco_fs_Locations::getThemes()->check($path) ){
+            $this->custom[$path] = 'themes';
+        }
+        // folder could be plugin-specific, e.g. languages/woocommerce,
+        // but this won't be merged with custom because it IS custom.
+    }
+
+
+    /**
+     * Fix any file extension to use .mo
+     */
+    private static function to_mopath( string $path ):string {
+        if( str_ends_with($path,'.mo') ){
+            return $path;
+        }
+        // path should only be a .l10n.php file, but could be something custom
+        return dirname($path).'/'.explode('.', basename($path),2)[0].'.mo';
+    }
+
+
+    /**
+     * Check .mo or .php file is readable, and return the .mo file if so.
+     * Note that load_textdomain expects a .mo file, even if it ends up using .l10n.php
+     */
+    private static function try_readable( string $path ):string {
+        $mofile = self::to_mopath($path);
+        if( is_readable($mofile) || is_readable(substr($path,0,-2).'l10n.php') ){
+            return $mofile;
+        }
+        return '';
+    }
+    
+    
+    
+    // JSON //
+
+
+    /**
+     * `load_script_translation_file` filter callback
+     * Alternative method to merging in `pre_load_script_translations`
+     * @param string $path candidate JSON file (false on final attempt)
+     * @param string $handle
+     */
+    public function filter_load_script_translation_file( $path = '', $handle = '' ) {
+        // currently handle-based JSONs for author-provided translations will never map.
+        if( is_string($path) && preg_match('/^-[a-f0-9]{32}\\.json$/',substr($path,-38) ) ){
+            $system = loco_constant('WP_LANG_DIR').'/';
+            $custom = loco_constant('LOCO_LANG_DIR').'/';
+            if( str_starts_with($path,$system) ){
+                $mapped = substr_replace($path,$custom,0,strlen($system) );
+                // Defer merge until either JSON is resolved or final attempt passes an empty path.
+                if( is_readable($mapped) ){
+                    $this->json[$handle] = $mapped;
+                }
+            }
+        }
+        // If we return an unreadable file, load_script_translations will not fire.
+        // However, we need to allow WordPress to try all files. Last attempt will have empty path
+        else if( false === $path && array_key_exists($handle,$this->json) ){
+            $path = $this->json[$handle];
+            unset( $this->json[$handle] );
+        }
+        return $path;
+    }
+
+
+    /**
+     * `load_script_translations` filter callback.
+     * Merges custom translations on top of installed ones, as late as possible.
+     *
+     * @param string $json contents of JSON file that WordPress has read
+     * @param string $path path relating to given JSON (not used here)
+     * @param string $handle script handle for registered merge
+     * @return string final JSON translations
+     */
+    public function filter_load_script_translations( $json = '', $path = '', $handle = '' ) {
+        if( array_key_exists($handle,$this->json) ){
+            $path = $this->json[$handle];
+            unset( $this->json[$handle] );
+            if( is_string($json) && '' !== $json ){
+                $json = self::mergeJson( $json, file_get_contents($path) );
+            }
+            else {
+                $json = file_get_contents($path);
+            }
+        }
+        return $json;
+    }
+
+
+    /**
+     * Merge two JSON translation files such that custom strings override
+     * @param string $json Original/fallback JSON
+     * @param string $custom Custom JSON (must exclude empty keys)
+     * @return string Merged JSON
+     */
+    private static function mergeJson( string $json, string $custom ):string {
+        $fallbackJed = json_decode($json,true);
+        $overrideJed = json_decode($custom,true);
+        if( self::jedValid($fallbackJed) && self::jedValid($overrideJed) ){
+            // Original key is probably "messages" instead of domain, but this could change at any time.
+            // Although custom file should have domain key, there's no guarantee JSON wasn't overwritten or key changed.
+            $overrideMessages = current($overrideJed['locale_data']);
+            $fallbackMessages = current($fallbackJed['locale_data']);
+            // We could merge headers, but custom file should be correct
+            // $overrideMessages[''] += $fallbackMessages[''];
+            // Continuing to use "messages" here as per WordPress. Good backward compatibility is likely.
+            // Note that our custom JED is sparse (exported with empty keys absent). This is essential for + operator.
+            $overrideJed['locale_data'] =  [
+                'messages' => $overrideMessages + $fallbackMessages,
+            ];
+            // Note that envelope will be the custom one. No functional difference but demonstrates that merge worked.
+            $overrideJed['merged'] = true;
+            $json = json_encode($overrideJed);
+        }
+        // Handle situations where one or neither JSON strings are valid
+        else if( self::jedValid($overrideJed) ){
+            $json = $custom;
+        }
+        else if( ! self::jedValid($fallbackJed) ){
+            $json = '';
+        }
+        return $json;
+    }
+
+
+    /**
+     * Test if unserialized JSON is a valid JED structure
+     * @param mixed $jed
+     */
+    private static function jedValid( $jed ):bool {
+        return is_array($jed) && array_key_exists('locale_data',$jed) && is_array($jed['locale_data']) && $jed['locale_data'];
+    }
+    
+    
+    // Debug //
+
+
+
+    /**
+     * Alert to the early JIT loading issue for any text domain queried before we've seen it be loaded.
+     */
+    private function handle_unseen_textdomain( $domain ){
+        if( ! array_key_exists($domain,$this->seen) ){
+            $this->seen[$domain] = true;
+            do_action('loco_unseen_textdomain',$domain);
+        }
+    }
+
+
+    /**
+     * `gettext` filter callback. Enabled only in Debug mode.
+     */
+    public function debug_gettext( $translation = '', $text = '', $domain = '' ){
+        $this->handle_unseen_textdomain($domain?:'default');
+        return $translation;
+    }
+
+
+    /**
+     * `ngettext` filter callback. Enabled only in Debug mode.
+     */
+    public function debug_ngettext( $translation = '', $single = '', $plural = '', $number = 0, $domain = '' ){
+        $this->handle_unseen_textdomain($domain?:'default');
+        return $translation;
+    }
+
+
+    /**
+     * `gettext_with_context` filter callback. Enabled only in Debug mode.
+     */
+    public function debug_gettext_with_context( $translation = '', $text = '', $context = '', $domain = '' ){
+        $this->handle_unseen_textdomain($domain?:'default');
+        return $translation;
+    }
+
+
+    /**
+     * `ngettext_with_context` filter callback. Enabled only in Debug mode.
+     */
+    public function debug_ngettext_with_context( $translation = '', $single = '', $plural = '', $number = 0, $context = '', $domain = '' ){
+        $this->handle_unseen_textdomain($domain?:'default');
+        return $translation;
+    }
+    
+
+}

wp-content/plugins/loco-translate/src/hooks/TranslateBuffer.php

@@ -0,0 +1,88 @@
+<?php
+/**
+ * Buffers translations requested via __, _x, _n and _nx for exporting in a raw form.
+ */
+class Loco_hooks_TranslateBuffer extends Loco_hooks_Hookable {
+    
+    /**
+     * Temporary buffer of raw translation lookup keys
+     * @var array
+     */
+    private $buffer = [];
+    
+    /**
+     * `gettext` filter callback
+     */
+    public function filter_gettext( $msgstr, $msgid, $domain ){
+        $this->buffer[$domain][$msgid] = null;
+        return $msgstr;
+    }    
+
+
+    /**
+     * `gettext_with_context` filter callback
+     */
+    public function filter_gettext_with_context( $msgstr, $msgid, $msgctxt, $domain ){
+        $this->buffer[$domain][$msgctxt."\x04".$msgid] = null;
+        return $msgstr;
+    }
+
+
+    /**
+     * `ngettext` filter callback
+     */
+    public function filter_ngettext( $msgstr, $msgid, $msgid_plural, $number, $domain ){
+        $this->buffer[$domain][$msgid] = null;
+        return $msgstr;
+    }
+
+
+    /**
+     * `ngettext_with_context` filter callback
+     */
+    function filter_ngettext_with_context( $msgstr, $msgid, $msgid_plural, $number, $msgctxt, $domain ){
+        $this->buffer[$domain][$msgctxt."\x04".$msgid] = null;
+        return $msgstr;
+    }
+
+
+
+    /**
+     * Export all captured translations in a raw form and reset buffer
+     * @param string $domain the specific domain listened for
+     * @return array
+     */
+    public function flush( $domain ){
+        $export = [];
+        if( isset($this->buffer[$domain]) ){
+            // what we captures was just a unique namespace
+            $captured = $this->buffer[$domain];
+            unset($this->buffer[$domain]);
+            // process raw data for all that actually exist
+            // this survives on WordPress internals not changing :-/
+            $loaded = get_translations_for_domain($domain);
+            // since WordPress 6.5, this class doesn't pre-index the values
+            if( $loaded instanceof WP_Translations ){
+                /* @var Translation_Entry $entry */
+                foreach( $loaded->entries as $entry ){
+                    $key = $entry->key();
+                    if( array_key_exists($key,$captured) ){
+                        $export[$key] = $entry->translations;
+                    }
+                }
+            }
+            // legacy, entries are indexed already by the key:
+            else if( $loaded instanceof Translations ){
+                $entries = array_intersect_key( $loaded->entries, $captured );
+                /* @var $entry Translation_Entry */
+                foreach( $entries as $key => $entry ){
+                    $export[$key] = $entry->translations;
+                }
+            }
+        }
+
+        return $export;
+    }
+
+
+}