home/laciafrdyl/www/plugins/loco-translate/src/package/Plugin.php000064400000023642151561123310021200 0ustar00getHandle()); } /** * {@inheritdoc} */ public function getSlug(): string { // Fallback to first handle component return explode( '/', parent::getSlug(), 2 )[0]; } /** * @return Loco_package_Plugin[] */ public static function getAll(): array { $plugins = []; foreach( self::get_plugins() as $handle => $data ){ try { $plugins[] = Loco_package_Plugin::create($handle); } catch( Exception $e ){ // @codeCoverageIgnore } } return $plugins; } /** * Maintaining our own cache of full paths to available plugins, because get_mu_plugins doesn't get cached by WP * @return array[] */ public static function get_plugins(): array { $cached = wp_cache_get('plugins','loco'); if( ! is_array($cached) ){ $cached = []; // regular plugins + mu plugins: $search = [ 'WP_PLUGIN_DIR' => 'get_plugins', 'WPMU_PLUGIN_DIR' => 'get_mu_plugins', ]; foreach( $search as $const => $getter ){ if( $list = call_user_func($getter) ){ $base = loco_constant($const); foreach( $list as $handle => $data ){ if( isset($cached[$handle]) ){ Loco_error_AdminNotices::debug( sprintf('Plugin conflict on %s', $handle) ); continue; } // WordPress 4.6 introduced TextDomain header fallback @37562 see https://core.trac.wordpress.org/changeset/37562/ // if we don't force the original text domain header we can't know if a bundle is misconfigured. This leads to silent errors. // this has a performance overhead, and also results in "unconfigured" messages that users may not have had in previous releases. /*/ TODO perhaps implement a plugin setting that forces original headers $file = new Loco_fs_File($base.'/'.$handle); if( $file->exists() ){ $map = array( 'TextDomain' => 'Text Domain' ); $raw = get_file_data( $file->getPath(), $map, 'plugin' ); $data['TextDomain'] = $raw['TextDomain']; }*/ // set resolved base directory before caching our copy of plugin data $data['basedir'] = $base; $cached[$handle] = $data; } } } $cached = apply_filters('loco_plugins_data', $cached ); uasort( $cached, '_sort_uname_callback' ); // Intended as in-memory cache so adding short expiry for object caching plugins that may persist it. // All actions that invoke `wp_clean_plugins_cache` should purge this. See Loco_hooks_AdminHooks wp_cache_set('plugins', $cached, 'loco', 3600 ); } return $cached; } /** * Get raw plugin data from WordPress registry, plus additional "basedir" field for resolving handle to actual file. * @param string $handle Relative file path used as handle e.g. loco-translate/loco.php */ public static function get_plugin( string $handle ): ?array { // plugin must be registered with WordPress $search = self::get_plugins(); $data = $search[$handle] ?? null; // else plugin is not known to WordPress if( is_null($data) ){ $data = apply_filters( 'loco_missing_plugin', [], $handle ); } // plugin not valid if name absent from raw data if( empty($data['Name']) ){ return null; } // basedir is added by our get_plugins function, but filtered arrays could be broken if( ! array_key_exists('basedir',$data) ){ Loco_error_AdminNotices::debug( sprintf('"basedir" property required to resolve %s',$handle) ); return null; } return $data; } /** * {@inheritdoc} */ public function getHeaderInfo(): Loco_package_Header { $handle = $this->getHandle(); $data = self::get_plugin($handle); if( ! is_array($data) ){ // permitting direct file access if file exists (tests) $path = $this->getBootstrapPath(); if( $path && file_exists($path) ){ $data = get_plugin_data( $path, false, false ); } else { $data = []; } } return new Loco_package_Header( $data ); } /** * {@inheritdoc} */ public function getMetaTranslatable(): array { return [ 'Name' => 'Name of the plugin', 'Description' => 'Description of the plugin', 'PluginURI' => 'URI of the plugin', 'Author' => 'Author of the plugin', 'AuthorURI' => 'Author URI of the plugin', // 'Tags' => 'Tags of the plugin', ]; } /** * {@inheritdoc} */ public function setHandle( string $handle ): Loco_package_Bundle { // plugin handles are relative paths from plugin directory to bootstrap file // so plugin is single file if its handle has no directory prefix if( basename($handle) === $handle ){ $this->solo = true; } else { $this->solo = false; } return parent::setHandle($handle); } /** * {@inheritdoc} */ public function setDirectoryPath( string $path ): Loco_package_Bundle { parent::setDirectoryPath($path); // plugin bootstrap file can be inferred from base directory + handle // e.g. if base is "/path/to/foo" and handle is "foo/bar.php" we can derive "/path/to/foo/bar.php" if( ! $this->getBootstrapPath() ){ $handle = $this->getHandle(); if( '' !== $handle ) { $file = new Loco_fs_File( basename($handle) ); $file->normalize( $path ); $this->setBootstrapPath( $file->getPath() ); } } return $this; } /** * Create plugin bundle definition from WordPress plugin data. * * @param string $handle plugin handle relative to plugin directory * @return Loco_package_Plugin */ public static function create( string $handle ): Loco_package_Plugin { // plugin must be registered with at least a name and "basedir" $data = self::get_plugin($handle); if( ! $data ){ // translators: %s refers to the handle of a plugin, e.g. "loco-translate/loco.php" throw new Loco_error_Exception( sprintf( __('Plugin not found: %s','loco-translate'),$handle) ); } // lazy resolve of base directory from "basedir" property that we added $file = new Loco_fs_File( $handle ); $file->normalize( $data['basedir'] ); $base = $file->dirname(); // handle and name is enough data to construct empty bundle $bundle = new Loco_package_Plugin( $handle, $data['Name'] ); // check if listener heard the real text domain, but only use when none declared // This will no longer happen since WP 4.6 header fallback, but we could warn about it $listener = Loco_package_Listener::singleton(); if( $domain = $listener->getDomain($handle) ){ if( empty($data['TextDomain']) ){ $data['TextDomain'] = $domain; if( empty($data['DomainPath']) ){ $data['DomainPath'] = $listener->getDomainPath($domain); } } // ideally would only warn on certain pages, but unsure where to place this logic other than here // TODO possibly allow bundle to hold errors/warnings as part of its config. else if( $data['TextDomain'] !== $domain ){ Loco_error_AdminNotices::debug( sprintf("Plugin loaded text domain '%s' but WordPress knows it as '%s'",$domain, $data['TextDomain']) ); } } // do initial configuration of bundle from metadata $bundle->configure( $base, $data ); return $bundle; } /** * {@inheritDoc} */ public static function fromFile( Loco_fs_File $file ): ?Loco_package_Bundle { $find = $file->getPath(); foreach( self::get_plugins() as $handle => $data ){ $boot = new Loco_fs_File( $handle ); $boot->normalize( $data['basedir'] ); // single file plugins can only match if given file is the plugin file itself. if( basename($handle) === $handle ){ if( $boot->getPath() === $find ){ return self::create($handle); } } // else check file is under plugin root. else { $base = $boot->dirname(); $path = $base.substr( $find, strlen($base) ); if( $path === $find ){ return self::create($handle); } } } return null; } }