Prosellers Shell V2.0

Editing: module-manager.php

Cancel

<?php

class blcModuleManager {

/* @var blcConfigurationManager */
	var $plugin_conf;
	var $module_dir = '';

var $_module_cache;
	var $_category_cache;
	var $_category_cache_active;
	var $_virtual_modules = array();

var $loaded;
	var $instances;
	var $default_active_modules;

/**
	 * Class "constructor".
	 *
	 * @param array $default_active_modules An array of module ids specifying which modules are active by default.
	 * @return void
	 */
	function init( $default_active_modules = null ) {
		$this->module_dir = realpath( dirname( __FILE__ ) . '/../modules' );

$this->plugin_conf            = blc_get_configuration();
		$this->default_active_modules = $default_active_modules;

$this->loaded    = array();
		$this->instances = array();

add_filter( 'extra_plugin_headers', array( &$this, 'inject_module_headers' ) );
	}

/**
	 * Get an instance of the module manager.
	 *
	 * @param array|null $default_active_modules
	 * @return blcModuleManager
	 */
	//phpcs:ignore WordPress.NamingConventions.ValidFunctionName.MethodNameInvalid
	static function getInstance( $default_active_modules = null ) {
		static $instance = null;
		if ( is_null( $instance ) ) {
			$instance = new blcModuleManager();
			$instance->init( $default_active_modules );
		}
		return $instance;
	}

/**
	 * Retrieve a list of all installed BLC modules.
	 *
	 * This is essentially a slightly modified copy of get_plugins().
	 *
	 * @return array An associative array of module headers indexed by module ID.
	 */
	function get_modules() {
		if ( ! isset( $this->_module_cache ) ) {
			//Refresh the module cache.

$relative_path = '/' . plugin_basename( $this->module_dir );
			if ( ! function_exists( 'get_plugins' ) ) {
				//BUG: Potentional security flaw/bug. plugin.php is not meant to be loaded outside admin panel.
				require_once( ABSPATH . 'wp-admin/includes/plugin.php' );
			}
			$modules = get_plugins( $relative_path );

$this->_module_cache = array();

foreach ( $modules as $module_filename => $module_header ) {
				//Figure out the module ID. If not specified, it is equal to module's filename (sans the .php)
				if ( ! empty( $module_header['ModuleID'] ) ) {
					$module_id = strtolower( trim( $module_header['ModuleID'] ) );
				} else {
					$module_id = strtolower( basename( $module_filename, '.php' ) );
				}

$module_header                     = $this->normalize_module_header( $module_header, $module_id, $module_filename );
				$this->_module_cache[ $module_id ] = $module_header;
			}

$this->_category_cache = null;
		}

return array_merge( $this->_module_cache, $this->_virtual_modules );
	}

/**
	 * Retrieve modules that match a specific category, or all modules sorted by categories.
	 *
	 * If a category ID is specified, this method returns the modules that have the "ModuleCategory:"
	 * file header set to that value, or an empty array if no modules match that category. The
	 * return array is indexed by module id :
	 * [module_id1 => module1_data, module_id1 => module2_data, ...]
	 *
	 * If category is omitted, this method returns a list of all categories plus the modules
	 * they contain. Only categories that have at least one module will be included. The return
	 * value is an array of arrays, indexed by category ID :
	 * [category1 => [module1_id => module1_data, module2_id => module2_data, ...], ...]
	 *
	 *
	 * @param string $category Category id, e.g. "parser" or "container". Optional.
	 * @param bool $markup Apply markup to module headers. Not implemented.
	 * @param bool $translate Translate module headers. Defaults to false.
	 * @return array An array of categories or module data.
	 */
	function get_modules_by_category( $category = '', $markup = false, $translate = false ) {
		if ( ! isset( $this->_category_cache ) ) {
			$this->_category_cache = $this->sort_into_categories( $this->get_modules() );
		}

if ( empty( $category ) ) {
			if ( $markup || $translate ) {

//Translate/apply markup to module headers
				$processed = array();
				foreach ( $this->_category_cache as $category_id => $modules ) {
					$processed[ $category_id ] = array();
					foreach ( $modules as $module_id => $module_data ) {
						if ( $translate ) {
							$module_data['Name'] = _x( $module_data['Name'], 'module name', 'broken-link-checker' ); //phpcs:ignore WordPress.WP.I18n.NonSingularStringLiteralText
						}
						$processed[ $category_id ][ $module_id ] = $module_data;
					}
				}

return $processed;
			} else {
				return $this->_category_cache;
			}
		} else {
			if ( isset( $this->_category_cache[ $category ] ) ) {
				if ( $markup || $translate ) {
					//Translate/apply markup to module headers
					$processed = array();
					foreach ( $this->_category_cache[ $category ] as $module_id => $module_data ) {
						if ( $translate ) {
							$module_data['Name'] = _x( $module_data['Name'], 'module name', 'broken-link-checker' ); //phpcs:ignore WordPress.WP.I18n.NonSingularStringLiteralText
						}
						$processed[ $module_id ] = $module_data;
					}
					return $processed;
				} else {
					return $this->_category_cache[ $category ];
				}
			} else {
				return array();
			}
		}
	}

/**
	 * Retrieve active modules that match a specific category, or all active modules sorted by categories.
	 *
	 * @see blcModuleManager::get_modules_by_category()
	 *
	 * @param string $category Category id. Optional.
	 * @return array An associative array of categories or module data.
	 */
	function get_active_by_category( $category = '' ) {
		if ( ! isset( $this->_category_cache_active ) ) {
			$this->_category_cache_active = $this->sort_into_categories( $this->get_active_modules() );
		}

if ( empty( $category ) ) {
			return $this->_category_cache_active;
		} else {
			if ( isset( $this->_category_cache_active[ $category ] ) ) {
				return $this->_category_cache_active[ $category ];
			} else {
				return array();
			}
		}
	}

/**
	 * Get the module ids of all active modules that belong to a specific category,
	 * quoted and ready for use in SQL.
	 *
	 * @param string $category Category ID. If not specified, a list of all active modules will be returned.
	 * @return string A comma separated list of single-quoted module ids, e.g. 'module-foo','module-bar','modbaz'
	 */
	function get_escaped_ids( $category = '' ) {
		global $wpdb;

if ( empty( $category ) ) {
			$modules = $this->get_active_modules();
		} else {
			$modules = $this->get_active_by_category( $category );
		}

$modules = array_map( 'esc_sql', array_keys( $modules ) );
		$modules = "'" . implode( "', '", $modules ) . "'";

return $modules;
	}

/**
	 * Sort a list of modules into categories. Inside each category, modules are sorted by priority (descending).
	 *
	 * @access private
	 *
	 * @param array $modules
	 * @return array
	 */
	function sort_into_categories( $modules ) {
		$categories = array();

foreach ( $modules as $module_id => $module_data ) {
			$cat = $module_data['ModuleCategory'];
			if ( isset( $categories[ $cat ] ) ) {
				$categories[ $cat ][ $module_id ] = $module_data;
			} else {
				$categories[ $cat ] = array( $module_id => $module_data );
			}
		}

foreach ( $categories as $cat => $cat_modules ) {
			uasort( $categories[ $cat ], array( &$this, 'compare_priorities' ) );
		}

return $categories;
	}

/**
	 * Callback for sorting modules by priority.
	 *
	 * @access private
	 *
	 * @param array $a First module header.
	 * @param array $b Second module header.
	 * @return int
	 */
	function compare_priorities( $a, $b ) {
		return $b['ModulePriority'] - $a['ModulePriority'];
	}

/**
	 * Retrieve a reference to an active module.
	 *
	 * Each module is instantiated only once, so if the module was already loaded you'll get back
	 * a reference to the existing module object. If the module isn't loaded or instantiated yet,
	 * the function will do it automatically (but only for active modules).
	 *
	 * @param string $module_id Module ID.
	 * @param bool $autoload Optional. Whether to load the module file if it's not loaded yet. Defaults to TRUE.
	 * @param string $category Optional. Return the module only if it's in a specific category. Categories are ignored by default.
	 * @return blcModule A reference to a module object, or NULL on error.
	 */
	function get_module( $module_id, $autoload = true, $category = '' ) {
		$no_result = null;
		if ( ! is_string( $module_id ) ) {
			//$backtrace = debug_backtrace();
			//FB::error($backtrace, "get_module called with a non-string argument");
			return $no_result;
		}

if ( empty( $this->loaded[ $module_id ] ) ) {
			if ( $autoload && $this->is_active( $module_id ) ) {
				if ( ! $this->load_module( $module_id ) ) {
					return $no_result;
				}
			} else {
				return $no_result;
			}
		}

if ( ! empty( $category ) ) {
			$data = $this->get_module_data( $module_id );
			if ( $data['ModuleCategory'] != $category ) {
				return $no_result;
			}
		}

$module = $this->init_module( $module_id );
		return $module;
	}

/**
	 * Retrieve the header data of a specific module.
	 * Uses cached module info if available.
	 *
	 * @param string $module_id
	 * @param bool $use_active_cache Check the active module cache before the general one. Defaults to true.
	 * @return array Associative array of module data, or FALSE if the specified module was not found.
	 */
	function get_module_data( $module_id, $use_active_cache = true ) {
		//Check virtual modules
		if ( isset( $this->_virtual_modules[ $module_id ] ) ) {
			return $this->_virtual_modules[ $module_id ];
		}

//Check active modules
		if ( $use_active_cache && isset( $this->plugin_conf->options['all_modules'][ $module_id ] ) ) {
			return $this->plugin_conf->options['all_modules'][ $module_id ];
		}

//Otherwise, use the general module cache
		if ( ! isset( $this->_module_cache ) ) {
			$this->get_modules(); //Populates the cache
		}

if ( isset( $this->_module_cache[ $module_id ] ) ) {
			return $this->_module_cache[ $module_id ];
		} else {
			return false;
		}
	}

/**
	 * Retrieve a list of active modules.
	 *
	 * The list of active modules is stored in the 'active_modules' key of the
	 * plugin configuration object. If this key is not set, this function will
	 * create it and populate it using the list of default active modules passed
	 * to the module manager's constructor.
	 *
	 * @return array Associative array of module data indexed by module ID.
	 */
	function get_active_modules() {
		if ( ! empty( $this->plugin_conf->options['all_modules'] ) ) {
			return $this->plugin_conf->options['all_modules'];
		}

$active             = array();
		$modules            = $this->get_modules();
		$active_modules_ids = $this->get_active_modules_ids();

foreach ( $active_modules_ids as $module_id ) {
			if ( array_key_exists( $module_id, $modules ) ) {
				$active[ $module_id ] = $modules[ $module_id ];
			}
		}

$this->plugin_conf->options['all_modules'] = $active;
		$this->plugin_conf->save_options();

return $this->plugin_conf->options['all_modules'];
	}

/**
	 * Retrieve the IDs of all active modules.
	 *
	 * @return array An array of module IDs.
	 */
	public function get_active_modules_ids() {
		if ( ! empty( $this->plugin_conf->options['active_modules'] ) ) {
			return $this->plugin_conf->options['active_modules'];
		}

$active = $this->get_default_active_module_ids();

$this->plugin_conf->options['active_modules'] = $active;
		$this->plugin_conf->save_options();

return $this->plugin_conf->options['active_modules'];
	}

/**
	 * Build the list of module IDs that should be active on a fresh/reset site, filtered
	 * against installed modules.
	 *
	 * Only 'post', 'page' and 'comment' are pre-checked among "container"-category modules
	 * (the "Look for links in" checkboxes) — every other container (custom taxonomies, ...)
	 * needs an explicit opt-in. 'custom_field' and 'acf_field' are the exception: they're
	 * auto-included once something is actually configured for them to check, mirroring the
	 * one-time exclusion that used to live in legacy/includes/activation.php. Modules marked
	 * ModuleAlwaysActive are never excluded here regardless of category, since is_active()
	 * (not just the checkbox UI) depends on them staying in this list.
	 *
	 * @return array An array of module IDs.
	 */
	protected function get_default_active_module_ids() {
		if ( ! is_array( $this->default_active_modules ) ) {
			return array();
		}

$modules = $this->get_modules();

$default_containers = array(
			'post',
			'page',
			'comment',
			'youtube-iframe',
			'dummy',
		);
		if ( ! empty( $this->plugin_conf->options['custom_fields'] ) ) {
			$default_containers[] = 'custom_field';
		}
		if ( ! empty( $this->plugin_conf->options['acf_fields'] ) ) {
			$default_containers[] = 'acf_field';
		}

$active = array();
		foreach ( $this->default_active_modules as $module_id ) {
			if ( ! array_key_exists( $module_id, $modules ) ) {
				continue;
			}

$module_data      = $modules[ $module_id ];
			$is_always_active = ! empty( $module_data['ModuleAlwaysActive'] );
			$is_container     = isset( $module_data['ModuleCategory'] ) && 'container' === $module_data['ModuleCategory'];

if ( $is_container && ! $is_always_active && ! in_array( $module_id, $default_containers, true ) ) {
				continue;
			}

$active[] = $module_id;
		}

return $active;
	}

/**
	 * Determine if module is active.
	 *
	 * @param string $module_id
	 * @return bool
	 */
	function is_active( $module_id ) {
		return in_array( $module_id, $this->get_active_modules_ids(), true );
	}

/**
	 * Activate a module.
	 * Does nothing if the module is already active.
	 *
	 * @param string $module_id
	 * @return bool True if module was activated successfully, false otherwise.
	 */
	function activate( $module_id ) {
		if ( $this->is_active( $module_id ) ) {
			return true;
		}

//Retrieve the module header
		$module_data = $this->get_module_data( $module_id, false );
		if ( ! $module_data ) {
			return false;
		}

//Attempt to load the module
		if ( $this->load_module( $module_id, $module_data ) ) {
			$active_modules = $this->plugin_conf->options['active_modules'];
			//Okay, if it loads, we can assume it works.
			$active_modules[] = $module_id;

$this->plugin_conf->options['active_modules'] = $active_modules;
			$this->plugin_conf->save_options();
			//Invalidate the per-category active module cache
			$this->_category_cache_active = null;

//Notify the module that it's been activated
			$module = $this->get_module( $module_id );
			if ( $module ) {
				$module->activated();
			}
			$this->refresh_active_module_cache();

return true;
		} else {
			return false;
		}
	}

/**
	 * Deactivate a module.
	 * Does nothing if the module is already inactive.
	 *
	 * @param string $module_id
	 * @return bool
	 */
	function deactivate( $module_id ) {
		if ( ! $this->is_active( $module_id ) ) {
			return true;
		}

//Some modules are supposed to be always active and thus can't be deactivated
		$module_data = $this->get_module_data( $module_id, false );
		if ( isset( $module_data['ModuleAlwaysActive'] ) && $module_data['ModuleAlwaysActive'] ) {
			return false;
		}

//Notify the module that it's being deactivated
		$module = $this->get_module( $module_id );
		if ( $module ) {
			$module->deactivated();
		}

$active_modules = $this->plugin_conf->options['active_modules'];
		$module_idx     = array_search( $module_id, $active_modules, true );
		unset( $active_modules[ $module_idx ] );
		$this->plugin_conf->options['active_modules'] = $active_modules;

//Keep track of when each module was last deactivated. Used for parser resynchronization.
		if ( isset( $this->plugin_conf->options['module_deactivated_when'] ) ) {
			$module_deactivated_when               = $this->plugin_conf->options['module_deactivated_when'];
			$module_deactivated_when[ $module_id ] = current_time( 'timestamp' );

$this->plugin_conf->options['module_deactivated_when'] = $module_deactivated_when;
		} else {
			$this->plugin_conf->options['module_deactivated_when'] = array(
				$module_id => current_time( 'timestamp' ),
			);
		}
		$this->plugin_conf->save_options();
		$this->refresh_active_module_cache();

$this->_category_cache_active = null; //Invalidate the by-category cache since we just changed something
		return true;
	}

/**
	 * Determine when a module was last deactivated.
	 *
	 * @param string $module_id Module ID.
	 * @return int Timestamp of last deactivation, or 0 if the module has never been deactivated.
	 */
	function get_last_deactivation_time( $module_id ) {
		if ( isset( $this->plugin_conf->options['module_deactivated_when'][ $module_id ] ) ) {
			return $this->plugin_conf->options['module_deactivated_when'][ $module_id ];
		} else {
			return 0;
		}
	}

/**
	 * Set the current list of active modules. If any of the modules are not currently active,
	 * they will be activated. Any currently active modules that are not on the new list will
	 * be deactivated.
	 *
	 * @param array $ids An array of module IDs.
	 * @return void
	 */
	function set_active_modules( $ids ) {
		$current_active = $this->get_active_modules_ids();

$activate   = array_diff( $ids, $current_active );
		$deactivate = array_diff( $current_active, $ids );

//Deactivate any modules not present in the new list
		foreach ( $deactivate as $module_id ) {
			$this->deactivate( $module_id );
		}

//Activate modules present in the new list but not in the old list
		foreach ( $activate as $module_id ) {
			$this->activate( $module_id );
		}

//Ensure all active modules have the latest headers
		$this->refresh_active_module_cache();

//Invalidate the per-category active module cache
		$this->_category_cache_active = null;
	}

/**
	 * Send the activation message to all currently active plugins when the plugin is activated.
	 *
	 * @return void
	 */
	function plugin_activated() {
		global $blclog;

//Ensure all active modules have the latest headers
		$blclog->log( '... Updating module cache' );
		$start = microtime( true );
		$this->refresh_active_module_cache();
		$blclog->info( sprintf( '... Cache refresh took %.3f seconds', microtime( true ) - $start ) );

//Notify them that we've been activated
		$blclog->log( '... Loading modules' );
		$start = microtime( true );
		$this->load_modules();
		$blclog->info( sprintf( '... %d modules loaded in %.3f seconds', count( $this->loaded ), microtime( true ) - $start ) );

$active = $this->get_active_modules_ids();
		foreach ( $active as $module_id ) {
			$blclog->log( sprintf( '... Notifying module "%s"', $module_id ) );
			$module = $this->get_module( $module_id );
			if ( $module ) {
				$module->plugin_activated();
			} else {
				$blclog->warn( sprintf( '... Module "%s" failed to load!', $module_id ) );
			}
		}
	}

/**
	 * Refresh the cached data of all active modules.
	 *
	 * @return array An updated list of active modules.
	 */
	function refresh_active_module_cache() {
		$modules        = $this->get_modules();
		$active_modules = $this->plugin_conf->options['active_modules'];

$all_modules = array();
		foreach ( $active_modules as $module_id ) {
			if ( array_key_exists( $module_id, $modules ) ) {
				$all_modules[ $module_id ] = $modules[ $module_id ];
			}
		}
		$this->plugin_conf->options['all_modules'] = $all_modules;

$this->plugin_conf->save_options();
		$this->_category_cache_active = null; //Invalidate the by-category active module cache
		return $this->plugin_conf->options['all_modules'];
	}

/**
	 * Load active modules.
	 *
	 * @param string $context Optional. If specified, only the modules that match this context (or the "all" context) will be loaded.
	 * @return void
	 */
	function load_modules( $context = '' ) {
		$active = $this->get_active_modules();
		//Avoid trying to load a virtual module before the module that registered it has been loaded.
		$active = $this->put_virtual_last( $active );

foreach ( $active as $module_id => $module_data ) {
			//Load the module
			$should_load = ( 'all' == $module_data['ModuleContext'] ) || ( ! empty( $context ) && $module_data['ModuleContext'] == $context );
			if ( $should_load ) {
				$this->load_module( $module_id, $module_data );
			}
		}
	}

/**
	 * Load and possibly instantiate a specific module.
	 *
	 * @access private
	 *
	 * @param string $module_id
	 * @param array $module_data
	 * @return bool True if the module was successfully loaded, false otherwise.
	 */
	function load_module( $module_id, $module_data = null ) {

//Only load each module once.
		if ( ! empty( $this->loaded[ $module_id ] ) ) {
			return true;
		}

if ( ! isset( $module_data ) ) {
			$module_data = $this->get_module_data( $module_id );
			if ( empty( $module_data ) ) {
				return false;
			}
		}

//Load a normal module
		if ( empty( $module_data['virtual'] ) ) {

//Skip invalid and missing modules
			if ( empty( $module_data['file'] ) ) {
				return false;
			}

//Get the full path to the module file
			$filename = $this->module_dir . '/' . $module_data['file'];
			if ( ! file_exists( $filename ) ) {
				return false;
			}

//Load it
			include $filename;
			$this->loaded[ $module_id ] = true;

} else {

//Virtual modules don't need to be explicitly loaded, but they must
			//be registered.
			if ( ! array_key_exists( $module_id, $this->_virtual_modules ) ) {
				return false;
			}
			$this->loaded[ $module_id ] = true;

}

//Instantiate the main module class unless lazy init is on (default is off)
		if ( ! array_key_exists( $module_id, $this->instances ) ) { //Only try to instantiate once
			if ( ! $module_data['ModuleLazyInit'] ) {
				$this->init_module( $module_id, $module_data );
			}
		}

return true;
	}

/**
	 * Instantiate a certain module.
	 *
	 * @param string $module_id
	 * @param array $module_data Optional. The header data of the module that needs to be instantiated. If not specified, it will be retrieved automatically.
	 * @return object The newly instantiated module object (extends blcModule), or NULL on error.
	 */
	function init_module( $module_id, $module_data = null ) {
		//Each module is only instantiated once.
		if ( isset( $this->instances[ $module_id ] ) ) {
			return $this->instances[ $module_id ];
		}

if ( ! isset( $module_data ) ) {
			$module_data = $this->get_module_data( $module_id );
			if ( empty( $module_data ) ) {
				return null;
			}
		}

if ( ! empty( $module_data['ModuleClassName'] ) && class_exists( $module_data['ModuleClassName'] ) ) {
			$className                     = $module_data['ModuleClassName'];
			$this->instances[ $module_id ] = new $className(
				$module_id,
				$module_data,
				$this->plugin_conf,
				$this
			);
			return $this->instances[ $module_id ];
		};

return null;
	}

function is_instantiated( $module_id ) {
		return ! empty( $this->instances[ $module_id ] );
	}

/**
	 * Register a virtual module.
	 *
	 * Virtual modules are the same as normal modules, except that they can be added
	 * on the fly, e.g. by other modules.
	 *
	 * @param string $module_id Module Id.
	 * @param string $module_data Associative array of module data. All module header fields are allowed, except ModuleID.
	 * @return void
	 */
	function register_virtual_module( $module_id, $module_data ) {
		$module_data                          = $this->normalize_module_header( $module_data, $module_id );
		$module_data['virtual']               = true;
		$this->_virtual_modules[ $module_id ] = $module_data;
	}

/**
	 * Sort an array of modules so that all virtual modules are placed at its end.
	 *
	 * @param array $modules Input array, [module_id => module_data, ...].
	 * @return array Sorted array.
	 */
	function put_virtual_last( $modules ) {
		uasort( $modules, array( &$this, 'compare_virtual_flags' ) );
		return $modules;
	}

/**
	 * Callback function for sorting modules by the state of their 'virtual' flag.
	 *
	 * @param array $a Associative array of module A data
	 * @param array $b Associative array of module B data
	 * @return int
	 */
	function compare_virtual_flags( $a, $b ) {
		if ( empty( $a['virtual'] ) ) {
			return empty( $b['virtual'] ) ? 0 : -1;
		} else {
			return empty( $b['virtual'] ) ? 1 : 0;
		}
	}

/**
	 * Validate active modules.
	 *
	 * Validates all active modules, deactivates invalid ones and returns
	 * an array of deactivated modules.
	 *
	 * @return array
	 */
	function validate_active_modules() {
		$active = $this->get_active_modules();
		if ( empty( $active ) ) {
			return array();
		}

$invalid = array();
		foreach ( $active as $module_id => $module_data ) {
			$rez = $this->validate_module( $module_data );
			if ( is_wp_error( $rez ) ) {
				$invalid[ $module_id ] = $rez;
				$this->deactivate( $module_id );
			}
		}

return $invalid;
	}

/**
	 * Validate module data.
	 *
	 * Checks that the module file exists or that the module
	 * is a currently registered virtual module.
	 *
	 * @param array $module_data Associative array of module data.
	 * @return bool|WP_Error True on success, an error object if the module fails validation
	 */
	function validate_module( $module_data ) {
		if ( empty( $module_data['ModuleID'] ) ) {
			return new WP_Error( 'invalid_cached_header', 'The cached module header is invalid' );
		}

if ( empty( $module_data['virtual'] ) ) {
			//Normal modules must have a valid filename
			if ( empty( $module_data['file'] ) ) {
				return new WP_Error( 'module_not_found', 'Invalid module file' );
			}

$filename = $this->module_dir . '/' . $module_data['file'];
			if ( ! file_exists( $filename ) ) {
				return new WP_Error( 'module_not_found', 'Module file not found' );
			}

//The module file header must be in the proper format. While $module_data comes
			//from cache and can be assumed to be correct, get_modules() will attempt to load
			//the current headers and only return modules with semi-valid headers.
			$installed = $this->get_modules();
			if ( ! array_key_exists( $module_data['ModuleID'], $installed ) ) {
				return new WP_Error( 'invalid_module_header', 'Invalid module header' );
			}
		} else {
			//Virtual modules need to be currently registered
			if ( ! array_key_exists( $module_data['ModuleID'], $this->_virtual_modules ) ) {
				return new WP_Error( 'module_not_registered', 'The virtual module is not registered' );
			}
		}

return true;
	}

/**
	 * Add BLC-module specific headers to the list of allowed plugin headers. This
	 * lets us use get_plugins() to retrieve the list of BLC modules.
	 *
	 * @param array $headers Currently known plugin headers.
	 * @return array New plugin headers.
	 */
	function inject_module_headers( $headers ) {
		$module_headers = array(
			'ModuleID',
			'ModuleCategory',
			'ModuleContext',
			'ModuleLazyInit',
			'ModuleClassName',
			'ModulePriority',
			'ModuleCheckerUrlPattern',
			'ModuleHidden',            //Don't show the module in the Settings page
			'ModuleAlwaysActive',      //Module can't be deactivated.
			'ModuleRequiresPro',       //Can only be activated in the Pro version
		);

return array_merge( $headers, $module_headers );
	}

/**
	 * Normalize a module header, using defaults where necessary.
	 *
	 * @param array $module_header Module header, as read from the module's .php file.
	 * @param string $module_id Module ID.
	 * @param string $module_filename Module filename. Optional.
	 * @return array Normalized module header.
	 */
	function normalize_module_header( $module_header, $module_id, $module_filename = '' ) {
		//Default values for optional module header fields
		$defaults = array(
			'ModuleContext'      => 'all',
			'ModuleCategory'     => 'other',
			'ModuleLazyInit'     => 'false',
			'ModulePriority'     => '0',
			'ModuleHidden'       => 'false',
			'ModuleAlwaysActive' => 'false',
			'ModuleRequiresPro'  => 'false',
			'TextDomain'         => 'broken-link-checker', //For translating module headers
		);

$module_header['ModuleID'] = $module_id;   //Just for consistency
		$module_header['file']     = $module_filename; //Used later to load the module

//Apply defaults
		foreach ( $defaults as $field => $default_value ) {
			if ( empty( $module_header[ $field ] ) ) {
				$module_header[ $field ] = $default_value;
			}
		}

//Convert bool/int fields from strings to native datatypes
		$module_header['ModuleLazyInit']     = $this->str_to_bool( $module_header['ModuleLazyInit'] );
		$module_header['ModuleHidden']       = $this->str_to_bool( $module_header['ModuleHidden'] );
		$module_header['ModuleAlwaysActive'] = $this->str_to_bool( $module_header['ModuleAlwaysActive'] );
		$module_header['ModuleRequiresPro']  = $this->str_to_bool( $module_header['ModuleRequiresPro'] );
		$module_header['ModulePriority']     = intval( $module_header['ModulePriority'] );

return $module_header;
	}

/**
	 * Converts the strings "true" and "false" to boolean TRUE and FALSE, respectively.
	 * Any other string will yield FALSE.
	 *
	 * @param string $value "true" or "false", case-insensitive.
	 * @return bool
	 */
	function str_to_bool( $value ) {
		$value = trim( strtolower( $value ) );
		return 'true' == $value;
	}

/**
	 * Generates a PHP script that calls the __() i18n function with
	 * the name and description of each available module. The generated
	 * script is used to make module headers show up in the .POT file.
	 *
	 * @access private
	 *
	 * @return string
	 */
	function _build_header_translation_code() {
		$this->_module_cache = null; //Clear the cache
		$modules             = $this->get_modules();

$strings = array();
		foreach ( $modules as $module_id => $module_header ) {
			if ( $module_header['ModuleHidden'] || ( 'write-module-placeholders' == $module_id ) ) {
				continue;
			}
			if ( ! empty( $module_header['Name'] ) ) {
				$strings[] = sprintf(
					'_x("%s", "module name", "broken-link-checker");',
					str_replace( '"', '\"', $module_header['Name'] )
				);
			}
		}

return "<?php\n" . implode( "\n", $strings ) . "\n";
	}
}

Editing: module-manager.php

Upload Files

Create New

Change Permissions

Change Date

Rename Item

Confirm Delete