<?php
/**
* Main loading logic.
*/
namespace FortAwesome;
use \Exception, \Error;
defined( 'WPINC' ) || die;
if ( ! defined( 'FONTAWESOME_PLUGIN_FILE' ) ) {
/**
* Name of this plugin's entrypoint file.
*
* Relative to the WordPress plugins directory, as would
* be used for `$plugin` in the
* [`activate_{$plugin}`](https://developer.wordpress.org/reference/hooks/activate_plugin/) action hook.
*
* @since 4.0.0
*/
define( 'FONTAWESOME_PLUGIN_FILE', 'font-awesome/index.php' );
}
if ( ! defined( 'FONTAWESOME_MIN_PHP_VERSION' ) ) {
/**
* Minimum PHP VERSION required
*
* @since 4.0.0
*/
define( 'FONTAWESOME_MIN_PHP_VERSION', '5.6' );
}
if ( ! class_exists( 'FortAwesome\FontAwesome_Loader' ) ) :
/**
* Loader class, a Singleton. Coordinates potentially multiple installations of
* the Font Awesome plugin code, and ensures that the latest available semantic
* version is selected for execution at runtime. Exposes a few public API
* methods for initialization (activation), deactivation, and uninstallation
* of plugin code.
*
* Font Awesome plugin installations may be installed either directly
* as a plugin appearing in the plugins table, or as a composer dependency
* of any number of themes or other plugins.
*
* We only have in mind various installations of this code base,
* of course. Not other non-official Font Awesome plugins. We don't try
* to anticipate what _other_ potentially conflicting plugins might be installed.
*
* All Font Awesome plugin installations should attempt to load themselves via this loader,
* which will ensure that the code for plugin installation with the latest
* semantic version is what actually runs. It also ensures appropriate
* handling of initialization, deactivation and uninstallation, so that the
* actions of one plugin installation don't interfere with another's.
*
* Refer to `integrations/plugins/plugin-sigma`
* in this repo for an example of how to load the Font Awesome plugin code
* via this Loader when including it as a composer dependency.
*
* The client code should `require_once` the `index.php` found
* in the root of this code base:
*
* ```php
* require_once __DIR__ . '/vendor/fortawesome/wordpress-fontawesome/index.php';
* ```
*
* For example, suppose the following scenario: A later version of the plugin
* is installed from the WordPress plugins directory and appears in the
* plugins table. It is activated.
* Then suppose a page builder plugin is installed and activated. That page builder
* plugin includes this plugin code as a composer dependency. In that case,
* the plugin code with the later semantic version will be the one loaded
* and executed at runtime.
* The page builder plugin should work just as expected, even though it would
* be running against a newer version of the Font Awesome plugin code than it
* had shipped in its own vendor bundle.
*
* Now suppose that the site owner deactivates and deletes the plugin that
* appears in the plugins table, the one that had been installed from the
* WordPress plugins directory. Because this loader knows that the page builder
* plugin's installation is still present, that deactivation and uninstallation
* will not cause the Font Awesome plugin's options and transients to be removed from the
* database. And as soon as that plugin installation is removed,
* the Font Awesome plugin installation included in the page builder plugin's
* composer vendor bundle is automatically promoted and runs as expected with
* no change to the plugin's state in the database.
*
* This loader pattern follows that of [wponion](https://github.com/wponion/wponion/blob/master/wponion.php).
* Thanks to Varun Sridharan.
*
* @since 4.0.0
*/
final class FontAwesome_Loader {
/**
* Stores Loader Instance.
*
* @ignore
* @internal
*/
private static $instance = null;
/**
* Stores metadata about the various modules attempted to be
* loaded as the FontAwesome plugin.
*
* @ignore
* @internal
*/
private static $loaded = array();
/**
* Stores data about each plugin installation that has
* invoked font_awesome_load().
*
* @ignore
* @internal
*/
private static $data = array();
/**
* FontAwesome_Loader constructor.
*
* @ignore
* @internal
*/
private function __construct() {
add_action( 'wp_loaded', array( &$this, 'run_plugin' ), -1 );
add_action( 'activate_' . FONTAWESOME_PLUGIN_FILE, array( &$this, 'activate_plugin' ), -1 );
}
/**
* Choose the plugin installation with the latest semantic version to be
* the one that we'll load and use for other lifecycle operations like
* initialization, deactivation or uninstallation.
*
* @ignore
* @internal
* @throws Exception
*/
private function select_latest_version_plugin_installation() {
if ( count( self::$loaded ) > 0 || count( self::$data ) === 0 ) {
return;
}
usort(
self::$data,
function( $a, $b ) {
if ( version_compare( $a['version'], $b['version'], '=' ) ) {
return 0;
} elseif ( version_compare( $a['version'], $b['version'], 'gt' ) ) {
return -1;
} else {
return 1;
}
}
);
$selected_installation = self::$data[0];
if ( empty( $selected_installation ) ) {
throw new Exception(
sprintf(
esc_html__(
'Unable To Load Font Awesome Plugin.',
'font-awesome'
)
) .
// phpcs:ignore WordPress.PHP.DiscouragedPHPFunctions.obfuscation_base64_encode
' Data: ' . base64_encode( wp_json_encode( self::$data ) )
);
}
if ( ! version_compare( PHP_VERSION, FONTAWESOME_MIN_PHP_VERSION, '>=' ) ) {
throw(
new Exception(
sprintf(
/* translators: 1: minimum required php version 2: current php version */
esc_html__(
'Font Awesome requires a PHP Version of at least %1$s. Your current version of PHP is %2$s.',
'font-awesome'
),
FONTAWESOME_MIN_PHP_VERSION,
PHP_VERSION
)
)
);
}
self::$loaded = $selected_installation;
}
/**
* Runs the main plugin logic from the installation that has been selected.
*
* This is public because it's a callback, but should not be considered
* part of this plugin's API.
*
* For an example of how to use this loader when importing this plugin
* as a composer dependency, see `integrations/plugins/plugin-sigma.php`
* in this repo.
*
* @internal
* @ignore
*/
public function run_plugin() {
try {
$this->select_latest_version_plugin_installation();
require self::$loaded['path'] . 'font-awesome-init.php';
} catch ( Exception $e ) {
add_action(
'admin_notices',
function() use ( $e ) {
self::emit_admin_error_output( $e );
}
);
} catch ( Error $e ) {
add_action(
'admin_notices',
function() use ( $e ) {
self::emit_admin_error_output( $e );
}
);
}
}
/**
* Returns the path to the plugin installation that is actively loaded.
*
* @since 4.0.0
*/
public function loaded_path() {
return self::$loaded['path'];
}
/**
* Loads the activation hook for the plugin installation that has been
* selected for loading.
*
* This is public because it's a callback, but should not be considered
* part of this plugin's API.
*
* @internal
* @ignore
*/
public function activate_plugin() {
$activation_failed_message = __( 'Font Awesome could not be activated.', 'font-awesome' );
try {
$this->select_latest_version_plugin_installation();
require_once self::$loaded['path'] . 'includes/class-fontawesome-activator.php';
FontAwesome_Activator::activate();
} catch ( Exception $e ) {
self::emit_admin_error_output( $e, $activation_failed_message );
exit;
} catch ( Error $e ) {
self::emit_admin_error_output( $e, $activation_failed_message );
exit;
}
}
/**
* Internal use only, not part of this plugin's public API.
*
* @internal
* @ignore
*/
public static function emit_admin_error_output( $e, $context_message = '' ) {
if ( is_admin() && current_user_can( 'manage_options' ) ) {
echo '<div class="error">';
echo '<p>' . esc_html__( 'The Font Awesome plugin caught a fatal error', 'font-awesome' );
if ( is_string( $context_message ) && '' !== $context_message ) {
echo ': ' . esc_html( $context_message );
} else {
echo '.';
}
echo '</p><p>';
if ( ! is_a( $e, 'Exception' ) && ! is_a( $e, 'Error' ) ) {
esc_html_e( 'No error message available.', 'font-awesome' );
} else {
self::emit_error_output_to_console( $e );
if ( boolval( $e->getMessage() ) ) {
echo esc_html( $e->getMessage() );
}
}
echo '</p></div>';
}
}
/**
* Internal use only.
*
* @ignore
* @internal
* @param Error|Exception
*/
public static function emit_error_output_to_console( $e ) {
global $wp_version;
if ( ! is_a( $e, 'Exception' ) && ! is_a( $e, 'Error' ) ) {
return;
}
$wp_error = null;
if ( method_exists( $e, 'get_wp_error' ) ) {
$wp_error = $e->get_wp_error();
}
$additional_diagnostics = '';
$additional_diagnostics .= 'php version: ' . phpversion() . "\n";
$additional_diagnostics .= "WordPress version: $wp_version\n";
$additional_diagnostics .= 'multisite: ' . ( is_multisite() ? 'true' : 'false' ) . "\n";
$additional_diagnostics .= 'is_network_admin: ' . ( is_network_admin() ? 'true' : 'false' ) . "\n";
echo '<script>';
echo "console.group('" . esc_html__( 'Font Awesome Plugin Error Details', 'font-awesome' ) . "');";
echo "console.info('message: " . esc_html( self::escape_error_output( $e->getMessage() ) ) . "');";
// phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped
echo "console.info('stack trace:\\n" . self::escape_error_output( $e->getTraceAsString() ) . "');";
if ( $wp_error ) {
$codes = $wp_error->get_error_codes();
foreach ( $codes as $code ) {
echo "console.group('WP_Error');";
// phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped
echo "console.info('code: $code');";
$messages = $wp_error->get_error_messages( $code );
foreach ( $messages as $message ) {
// phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped
echo "console.info('message: " . self::escape_error_output( $message ) . "');";
}
$data = $wp_error->get_error_data( $code );
if ( $data ) {
// phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_print_r, WordPress.Security.EscapeOutput.OutputNotEscaped
echo "console.info('data:\\n" . self::escape_error_output( print_r( $data, true ) ) . "');";
}
echo 'console.groupEnd();';
}
}
if ( strlen( $additional_diagnostics ) > 0 ) {
echo "console.info('" . esc_html( self::escape_error_output( $additional_diagnostics ) ) . "');";
}
echo 'console.groupEnd();';
echo '</script>';
}
/**
* Internal use only, not part of this plugin's public API.
*
* @internal
* @ignore
* @return escaped string, or '' if the argument is not a string
*/
public static function escape_error_output( $content ) {
if ( ! is_string( $content ) ) {
return '';
}
$result = $content;
// JavaScript unicode escapes.
$result = preg_replace( '/\\\\x/', '\x5Cx', $result );
$result = preg_replace( '/\\\\u/', '\x5Cu', $result );
// Other stuff.
$result = preg_replace( '/\'/', "\\'", $result );
$result = preg_replace( '/\"/', '\\"', $result );
$result = preg_replace( '/\n/', '\\n', $result );
return $result;
}
/**
* Initializes the Font Awesome plugin's options.
*
* If multiple installations of the plugin are installed, such as by
* composer dependencies in multiple plugins, this will ensure that the
* plugin is not re-initialized.
*
* If the plugin's options are empty, this will initialize with defaults.
* Otherwise, it will leave them alone.
*
* Any theme or plugin that uses this plugin as a composer dependency
* should call this method from its own activation hook. For example:
*
* ```php
* register_activation_hook(
* __FILE__,
* 'FortAwesome\FontAwesome_Loader::initialize'
* );
* ```
*
* @since 4.0.0
*/
public static function initialize() {
$initialization_failed_msg = __( 'A theme or plugin tried to initialize Font Awesome, but failed.', 'font-awesome' );
try {
self::instance()->select_latest_version_plugin_installation();
require_once self::$loaded['path'] . 'includes/class-fontawesome-activator.php';
FontAwesome_Activator::initialize();
} catch ( Exception $e ) {
self::emit_admin_error_output( $e, $initialization_failed_msg );
exit;
} catch ( Error $e ) {
self::emit_admin_error_output( $e, $initialization_failed_msg );
exit;
}
}
/**
* Runs uninstall logic for the plugin, but only if its invocation
* represents the last plugin installation trying to clean up.
*
* Deletes options records in the database.
*
* If there would be other remaining installations previously added to this
* loader via {@link \FortAwesome\font_awesome_load()}, it does not delete the plugin options,
* since one of those others will end up becoming active and relying on the options data.
*
* Any theme or plugin that includes this Font Awesome plugin as a library
* dependency should call this from its own uninstall hook. For example:
*
* ```php
* register_uninstall_hook(
* __FILE__,
* 'FortAwesome\FontAwesome_Loader::maybe_uninstall'
* );
* ```
*
* @since 4.0.0
*/
public static function maybe_uninstall() {
if ( count( self::$data ) === 1 ) {
// If there's only installation in the list, then it's
// the one that has invoked this function and is is about to
// go away, so it's safe to clean up.
require_once trailingslashit( self::$data[0]['path'] ) . 'includes/class-fontawesome-deactivator.php';
FontAwesome_Deactivator::uninstall();
}
}
/**
* Deactivates, cleaning up temporary data, such as transients, if this
* represents the last installed copy of the Font Awesome plugin being deactivated.
*
* However, if this loader is aware of any remaining installations, it does
* not clean up temporary data, since one of those other Font Awesome plugin
* installations, if active, will be promoted and end up relying on the data.
*
* Any theme or plugin that includes this Font Awesome plugin as a library
* dependency should call this from its own uninstall hook. For example:
*
* ```php
* register_deactivation_hook(
* __FILE__,
* 'FortAwesome\FontAwesome_Loader::maybe_deactivate'
* );
* ```
*
* @since 4.0.0
*/
public static function maybe_deactivate() {
if ( count( self::$data ) === 1 ) {
require_once trailingslashit( self::$data[0]['path'] ) . 'includes/class-fontawesome-deactivator.php';
FontAwesome_Deactivator::deactivate();
}
}
/**
* Creates and/or returns the static instance for this Singleton.
*
* It is probably not necessary for a theme or plugin that depends upon
* the Font Awesome plugin to invoke this. It's probably more convenient
* to access the Loader's functionality through the its public static methods.
*
* @return \FortAwesome\FontAwesome_Loader
* @see FontAwesome_Loader::initialize()
* @see FontAwesome_Loader::maybe_deactivate()
* @see FontAwesome_Loader::maybe_uninstall()
* @since 4.0.0
*/
public static function instance() {
if ( null === self::$instance ) {
self::$instance = new self();
}
return self::$instance;
}
/**
* Stores plugin version and details for an installation that is being
* registered with this loader.
*
* This method is not part of this plugin's public API.
*
* @param string $data other information.
* @param string|bool $version framework version.
*
* @ignore
* @internal
* @return $this
*/
public function add( $data = '', $version = false ) {
if ( file_exists( trailingslashit( $data ) . 'index.php' ) ) {
if ( false === $version ) {
$args = get_file_data( trailingslashit( $data ) . 'index.php', array( 'version' => 'Version' ) );
$version = ( isset( $args['version'] ) && ! empty( $args['version'] ) ) ? $args['version'] : $version;
}
array_push(
self::$data,
array(
'version' => $version,
'path' => trailingslashit( $data ),
)
);
}
return $this;
}
}
endif; // ! class_exists
if ( ! function_exists( 'FortAwesome\font_awesome_load' ) ) {
/**
* Adds plugin installation path to be managed by this loader.
*
* @param string $plugin_installation_path
* @param bool $version
* @ignore
* @internal
* @since 4.0.0
*/
function font_awesome_load( $plugin_installation_path = __DIR__, $version = false ) {
FontAwesome_Loader::instance()
->add( $plugin_installation_path, $version );
}
}
if ( function_exists( 'FortAwesome\font_awesome_load' ) ) {
font_awesome_load( __DIR__ );
}