Subversion Repositories web.active

<?php namespace ProcessWire;

/**
 * ProcessWire Modules
 *
 * Loads and manages all runtime modules for ProcessWire
 *
 * Note that when iterating, find(), or calling any other method that returns module(s), excepting get(), a ModulePlaceholder may be
 * returned rather than a real Module. ModulePlaceholders are used in instances when the module may or may not be needed at runtime
 * in order to save resources. As a result, anything iterating through these Modules should check to make sure it's not a ModulePlaceholder
 * before using it. If it's a ModulePlaceholder, then the real Module can be instantiated/retrieved by $modules->get($className).
 * 
 * ProcessWire 3.x, Copyright 2021 by Ryan Cramer
 * https://processwire.com
 * 
 * #pw-summary Loads and manages all modules in ProcessWire. 
 * #pw-body = 
 * The `$modules` API variable is most commonly used for getting individual modules to use their API. 
 * ~~~~~
 * // Getting a module by name
 * $m = $modules->get('MarkupPagerNav');
 * 
 * // Getting a module by name (alternate)
 * $m = $modules->MarkupPagerNav;
 * ~~~~~
 * 
 * #pw-body
 * 
 * @todo Move all module information methods to a ModulesInfo class
 * @todo Move all module loading methods to a ModulesLoad class
 * 
 * @method void refresh($showMessages = false) Refresh the cache that stores module files by recreating it
 * @method null|Module install($class, $options = array())
 * @method bool|int delete($class)
 * @method bool uninstall($class)
 * @method bool saveModuleConfigData($className, array $configData) Alias of saveConfig() method #pw-internal
 * @method bool saveConfig($class, $data, $value = null)
 * @method InputfieldWrapper|null getModuleConfigInputfields($moduleName, InputfieldWrapper $form = null)  #pw-internal
 * @method void moduleVersionChanged(Module $module, $fromVersion, $toVersion) #pw-internal
 * @method bool|string isUninstallable($class, $returnReason = false) hookable in 3.0.181+ #pw-internal 
 *
 */

class Modules extends WireArray {
    
    /**
     * Whether or not module debug mode is active
     *
     */
    protected $debug = false;

    /**
     * Flag indicating the module may have only one instance at runtime. 
     *
     */
    const flagsSingular = 1; 

    /**
     * Flag indicating that the module should be instantiated at runtime, rather than when called upon. 
     *
     */
    const flagsAutoload = 2;

    /**
     * Flag indicating the module has more than one copy of it on the file system. 
     * 
     */
    const flagsDuplicate = 4;

    /**
     * When combined with flagsAutoload, indicates that the autoload is conditional 
     * 
     */
    const flagsConditional = 8;

    /**
     * When combined with flagsAutoload, indicates that the module's autoload state is temporarily disabled
     * 
     */
    const flagsDisabled = 16;

    /**
     * Indicates module that maintains a configurable interface but with no interactive Inputfields
     * 
     */
    const flagsNoUserConfig = 32;

    /**
     * Module where no file could be located
     * 
     */
    const flagsNoFile = 64;

    /**
     * Filename for module info cache file
     *
     */
    const moduleInfoCacheName = 'Modules.info';
    
    /**
     * Filename for verbose module info cache file
     *
     */
    const moduleInfoCacheVerboseName = 'ModulesVerbose.info';
    
    /**
     * Filename for uninstalled module info cache file
     *
     */
    const moduleInfoCacheUninstalledName = 'ModulesUninstalled.info';

    /**
     * Cache name for module version change cache
     * 
     */
    const moduleLastVersionsCacheName = 'ModulesVersions.info';

    /**
     * Array of modules that are not currently installed, indexed by className => filename
     *
     */
    protected $installable = array(); 

    /**
     * An array of module database IDs indexed by: class => id 
     *
     * Used internally for database operations
     *
     */
    protected $moduleIDs = array();

    /**
     * Full system paths where modules are stored
     * 
     * index 0 must be the core modules path (/i.e. /wire/modules/)
     *
     */
    protected $paths = array();

    /**
     * Cached module configuration data indexed by module ID
     * 
     * Values are integer 1 for modules that have config data but data is not yet loaded.
     * Values are an array for modules have have config data and has been loaded. 
     *
     */
    protected $configData = array();
    
    /**
     * Module created dates indexed by module ID
     *
     */
    protected $createdDates = array();

    /**
     * Have the modules been init'd() ?
     *
     */
    protected $initialized = false;

    /**
     * Becomes an array if debug mode is on
     *
     */
    protected $debugLog = array();

    /**
     * Array of moduleName => condition
     * 
     * Condition can be either an anonymous function or a selector string to be evaluated at ready().
     *
     */
    protected $conditionalAutoloadModules = array();

    /**
     * Cache of module information
     *
     */
    protected $moduleInfoCache = array();
    
    /**
     * Cache of module information (verbose text) including: summary, author, href, file, core
     *
     */
    protected $moduleInfoCacheVerbose = array();
    
    /**
     * Cache of uninstalled module information (verbose for uninstalled) including: summary, author, href, file, core
     * 
     * Note that this one is indexed by class name rather than by ID (since uninstalled modules have no ID)
     *
     */
    protected $moduleInfoCacheUninstalled = array();

    /**
     * Cache of module information from DB used across multiple calls temporarily by load() method
     *
     */
    protected $modulesTableCache = array();

    /**
     * Cache of namespace => path for unique module namespaces
     * 
     * @var array|null Becomes an array once populated
     * 
     */
    protected $moduleNamespaceCache = null;
    
    /**
     * Last known versions of modules, for version change tracking
     *
     * @var array of ModuleName (string) => last known version (integer|string)
     *
     */
    protected $modulesLastVersions = array();

    /**
     * Array of module ID => flags (int)
     * 
     * @var array
     * 
     */
    protected $moduleFlags = array();
    
    /**
     * Array of moduleName => substituteModuleName to be used when moduleName doesn't exist
     * 
     * Primarily for providing backwards compatiblity with modules assumed installed that 
     * may no longer be in core. 
     * 
     * see setSubstitutes() method
     *
     */
    protected $substitutes = array();

    /**
     * Instance of ModulesDuplicates
     * 
     * @var ModulesDuplicates
     * 
     */ 
    protected $duplicates;

    /**
     * Module file extensions indexed by module name where value 1=.module, and 2=.module.php
     * 
     * @var array
     * 
     */
    protected $moduleFileExts = array();

    /**
     * Dir for core modules relative to root path, i.e. '/wire/modules/'
     * 
     * @var string
     * 
     */
    protected $coreModulesDir = '';

    /**
     * Array of moduleName => order to indicate autoload order when necessary
     * 
     * @var array
     * 
     */
    protected $autoloadOrders = array();

    /**
     * Are we currently refreshing?
     * 
     * @var bool
     * 
     */
    protected $refreshing = false;

    /**
     * Properties that only appear in 'verbose' moduleInfo
     * 
     * @var array
     * 
     */
    protected $moduleInfoVerboseKeys = array(
        'summary', 
        'author', 
        'href', 
        'file', 
        'core', 
        'versionStr',
        'permissions',
        'searchable', 
        'page',
        // 'languages',
        );

    /**
     * Core module types that are isolated by directory
     * 
     * @var array
     *
     */
    protected $coreTypes = array(
        'AdminTheme',
        'Fieldtype',
        'Inputfield',
        'Jquery',
        'LanguageSupport',
        'Markup',
        'Process',
        'Session',
        'System',
        'Textformatter',
        );

    /**
     * Construct the Modules
     *
     * @param string $path Core modules path (you may add other paths with addPath method)
     *
     */
    public function __construct($path) {
        parent::__construct();
        $this->addPath($path); 
    }

    /**
     * Wired to API
     * 
     * #pw-internal
     * 
     */
    public function wired() {
        $this->coreModulesDir = '/' . $this->wire('config')->urls->data('modules');
        parent::wired();
    }

    /**
     * Get the ModulesDuplicates instance
     * 
     * #pw-internal
     * 
     * @return ModulesDuplicates
     * 
     */
    public function duplicates() {
        if(is_null($this->duplicates)) $this->duplicates = $this->wire(new ModulesDuplicates());
        return $this->duplicates; 
    }

    /**
     * Add another modules path, must be called before init()
     * 
     * #pw-internal
     *
     * @param string $path 
     *
     */
    public function addPath($path) {
        $this->paths[] = $path;
    }

    /**
     * Return all assigned module root paths
     * 
     * #pw-internal
     *
     * @return array of modules paths, with index 0 always being the core modules path.
     *
     */
    public function getPaths() {
        return $this->paths; 
    }

    /**
     * Initialize modules
     * 
     * Must be called after construct before this class is ready to use
     * 
     * #pw-internal
     * 
     * @see load()
     * 
     */
    public function init() {
        $this->setTrackChanges(false);
        $this->loadModuleInfoCache();
        $this->loadModulesTable();
        if(!empty($this->autoloadOrders)) $this->preloadModules();
        foreach($this->paths as $path) {
            $this->load($path);
        }
        $this->modulesTableCache = array(); // clear out data no longer needed
    }

    /**
     * Include site preload modules
     * 
     * Preload modules load before all other modules, including core modules. In order 
     * for a module to be a preload module, it must meet the following conditions:
     * 
     * - Module info `autoload` value is integer of 10000 or greater, i.e. `[ 'autoload' => 10000 ]`
     * - Module info `singular` value must be non-empty, i.e. `[ 'singular' => true ]`
     * - Module file is located in: /site/modules/ModuleName/ModuleName.module.php 
     * - Module cannot load any other modules at least until ready() method called. 
     * - Module cannot have any `requires` dependencies to any other modules. 
     * 
     * Please note the above is specifically stating that the module must be in its 
     * own “site/ModuleName/” directory and have the “.module.php” extension. Using 
     * just the “.module” extension is not supported for preload modules. 
     * 
     * @since 3.0.173
     * 
     */
    protected function preloadModules() {
        if(!isset($this->paths[1])) return;
        arsort($this->autoloadOrders);
        foreach($this->autoloadOrders as $moduleName => $order) {
            if($order < 10000) break;
            if(!isset($this->moduleIDs[$moduleName])) continue;
            $moduleID = $this->moduleIDs[$moduleName];
            if(!isset($this->moduleInfoCache[$moduleID])) continue;
            $info = $this->moduleInfoCache[$moduleID];
            if(empty($info['singular'])) continue;
            $file = $this->paths[1] . "$moduleName/$moduleName.module.php";
            if(!file_exists($file) || !$this->includeModuleFile($file, $moduleName)) continue;
            if(!isset($info['namespace'])) $info['namespace'] = '';
            $className = $info['namespace'] . $moduleName;
            $module = $this->newModule($className, $moduleName);
            if($module) parent::set($moduleName, $module);
        }
    }

    /**
     * Modules class accepts only Module instances, per the WireArray interface
     * 
     * #pw-internal
     * 
     * @param Wire $item
     * @return bool
     *
     */
    public function isValidItem($item) {
        return $item instanceof Module;
    }

    /**
     * The key/index used for each module in the array is it's class name, per the WireArray interface
     * 
     * #pw-internal
     * 
     * @param Wire $item
     * @return int|string
     *
     */
    public function getItemKey($item) {
        return $this->getModuleClass($item); 
    }

    /**
     * There is no blank/generic module type, so makeBlankItem returns null
     * 
     * #pw-internal
     *
     */
    public function makeBlankItem() {
        return null; 
    }

    /**
     * Make a new/blank WireArray
     * 
     * #pw-internal
     *
     */
    public function makeNew() {
        // ensures that find(), etc. operations don't initalize a new Modules() class
        return $this->wire(new WireArray());
    }

    /**
     * Make a new populated copy of a WireArray containing all the modules
     * 
     * #pw-internal
     *
     * @return WireArray
     *
     */
    public function makeCopy() {
        // ensures that find(), etc. operations don't initalize a new Modules() class
        $copy = $this->makeNew();
        foreach($this->data as $key => $value) $copy[$key] = $value; 
        $copy->resetTrackChanges($this->trackChanges()); 
        return $copy; 
    }

    /**
     * Initialize all the modules that are loaded at boot
     * 
     * #pw-internal
     * 
     * @param null|array|Modules $modules
     * @param array $completed
     * @param int $level
     * 
     */
    public function triggerInit($modules = null, $completed = array(), $level = 0) {
    
        $debugKey = null;
        $debugKey2 = null;
        if($this->debug) {
            $debugKey = $this->debugTimerStart("triggerInit$level");
            $this->message("triggerInit(level=$level)"); 
        }
        
        $queue = array();
        if(is_null($modules)) $modules = $this;

        foreach($modules as $class => $module) {
        
            if($module instanceof ModulePlaceholder) {
                // skip modules that aren't autoload and those that are conditional autoload
                if(!$module->autoload) continue;
                if(isset($this->conditionalAutoloadModules[$class])) continue;
            }
            
            if($this->debug) $debugKey2 = $this->debugTimerStart("triggerInit$level($class)"); 
            
            $info = $this->getModuleInfo($module); 
            $skip = false;

            // module requires other modules
            foreach($info['requires'] as $requiresClass) {
                if(in_array($requiresClass, $completed)) continue; 
                $dependencyInfo = $this->getModuleInfo($requiresClass);
                if(empty($dependencyInfo['autoload'])) {
                    // if dependency isn't an autoload one, there's no point in waiting for it
                    if($this->debug) $this->warning("Autoload module '$module' requires a non-autoload module '$requiresClass'");
                    continue;
                } else if(isset($this->conditionalAutoloadModules[$requiresClass])) {
                    // autoload module requires another autoload module that may or may not load
                    if($this->debug) $this->warning("Autoload module '$module' requires a conditionally autoloaded module '$requiresClass'");
                    continue; 
                }
                // dependency is autoload and required by this module, so queue this module to init later
                $queue[$class] = $module;
                $skip = true;
                break;
            }
            
            if(!$skip) {
                if($info['autoload'] !== false) {
                    if($info['autoload'] === true || $this->isAutoload($module)) {
                        $this->initModule($module);
                    }
                }
                $completed[] = $class;
            }
            
            if($this->debug) $this->debugTimerStop($debugKey2); 
        }

        // if there is a dependency queue, go recursive till the queue is completed
        if(count($queue) && $level < 3) {
            $this->triggerInit($queue, $completed, $level + 1);
        }

        $this->initialized = true;
        
        if($this->debug) if($debugKey) $this->debugTimerStop($debugKey);
        
        if(!$level && (empty($this->moduleInfoCache))) { // || empty($this->moduleInfoCacheVerbose))) {
            if($this->debug) $this->message("saveModuleInfoCache from triggerInit"); 
            $this->saveModuleInfoCache();
        }
    }

    /**
     * Given a class name, return the constructed module
     * 
     * @param string $className Module class name
     * @param string $moduleName Optional module name only (no namespace)
     * @return Module|null
     *
     */
    protected function newModule($className, $moduleName = '') {
        if(!$moduleName) {
            $moduleName = wireClassName($className, false);
            $className = wireClassName($className, true);
        }
        $debugKey = $this->debug ? $this->debugTimerStart("newModule($moduleName)") : null;
        if(!class_exists($className, false)) $this->includeModule($moduleName);
        if(!class_exists($className, false)) {
            // attempt 2.x module in dedicated namespace or root namespace
            $className = $this->getModuleNamespace($moduleName) . $moduleName;
        }

        if(ProcessWire::getNumInstances() > 1) {
            // in a multi-instance environment, ensures that anything happening during
            // the module __construct is using the right instance. necessary because the
            // construct method runs before the wire instance is set to the module
            $wire1 = ProcessWire::getCurrentInstance();
            $wire2 = $this->wire();
            if($wire1 !== $wire2) {
                ProcessWire::setCurrentInstance($wire2);
            } else {
                $wire1 = null;
            }
        } else {
            $wire1 = null;
            $wire2 = null;
        }
        
        try {
            $module = $this->wire(new $className());
        } catch(\Exception $e) {
            $this->error(sprintf($this->_('Failed to construct module: %s'), $className) . " - " . $e->getMessage());
            $module = null;
        }
        if($this->debug) $this->debugTimerStop($debugKey);
        if($wire1) ProcessWire::setCurrentInstance($wire1);
        return $module; 
    }

    /**
     * Return a new ModulePlaceholder for the given className
     * 
     * @param string $className Module class this placeholder will stand in for
     * @param string $ns Module namespace
     * @param string $file Full path and filename of $className
     * @param bool $singular Is the module a singular module?
     * @param bool $autoload Is the module an autoload module?
     * @return ModulePlaceholder
     *
     */
    protected function newModulePlaceholder($className, $ns, $file, $singular, $autoload) { 
        $module = $this->wire(new ModulePlaceholder());
        $module->setClass($className);
        $module->setNamespace($ns);
        $module->singular = $singular;
        $module->autoload = $autoload;
        $module->file = $file;
        return $module; 
    }

    /**
     * Initialize a single module
     * 
     * @param Module $module
     * @param array $options
     *  - `clearSettings` (bool): When true, module settings will be cleared when appropriate to save space. (default=true)
     *  - `configOnly` (bool): When true, module init() method NOT called, but config data still set (default=false) 3.0.169+
     *  - `configData` (array): Extra config data merge with module’s config data (default=[]) 3.0.169+
     *  - `throw` (bool): When true, exceptions will be allowed to pass through. (default=false)
     * @return bool True on success, false on fail
     * @throws \Exception Only if the `throw` option is true. 
     *
     */
    protected function initModule(Module $module, array $options = array()) {
        
        $result = true;
        $debugKey = null;
        $clearSettings = isset($options['clearSettings']) ? (bool) $options['clearSettings'] : true; 
        $throw = isset($options['throw']) ? (bool) $options['throw'] : false;
        
        if($this->debug) {
            static $n = 0;
            $this->message("initModule (" . (++$n) . "): " . wireClassName($module)); 
        }
        
        // if the module is configurable, then load its config data
        // and set values for each before initializing the module
        $extraConfigData = isset($options['configData']) ? $options['configData'] : null;
        $this->setModuleConfigData($module, null, $extraConfigData);
        
        $moduleName = wireClassName($module, false);
        $moduleID = isset($this->moduleIDs[$moduleName]) ? $this->moduleIDs[$moduleName] : 0;
        
        if($moduleID && isset($this->modulesLastVersions[$moduleID])) {
            $this->checkModuleVersion($module);
        }
        
        if(method_exists($module, 'init') && empty($options['configOnly'])) {
            
            if($this->debug) {
                $debugKey = $this->debugTimerStart("initModule($moduleName)"); 
            }
    
            try {
                $module->init();
            } catch(\Exception $e) {
                if($throw) throw($e);
                $this->error(sprintf($this->_('Failed to init module: %s'), $moduleName) . " - " . $e->getMessage());
                $result = false;
            }
            
            if($this->debug) {
                $this->debugTimerStop($debugKey);
            }
        }
        
        // if module is autoload (assumed here) and singular, then
        // we no longer need the module's config data, so remove it
        if($clearSettings && $this->isSingular($module)) {
            if(!$moduleID) $moduleID = $this->getModuleID($module);
            if(isset($this->configData[$moduleID])) $this->configData[$moduleID] = 1;
        }
        
        return $result;
    }

    /**
     * Call ready for a single module
     * 
     * @param Module $module
     * @return bool
     *
     */
    protected function readyModule(Module $module) {
        $result = true;
        if(method_exists($module, 'ready')) {
            $debugKey = $this->debug ? $this->debugTimerStart("readyModule(" . $module->className() . ")") : null; 
            try {
                $module->ready();
            } catch(\Exception $e) {
                $this->error(sprintf($this->_('Failed to ready module: %s'), $module->className()) . " - " . $e->getMessage());
                $result = false;
            }
            if($this->debug) {
                $this->debugTimerStop($debugKey);
                static $n = 0;
                $this->message("readyModule (" . (++$n) . "): " . wireClassName($module));
            }
        }
        return $result;
    }

    /**
     * Init conditional autoload modules, if conditions allow
     * 
     * @return array of skipped module names
     * 
     */
    protected function triggerConditionalAutoload() {
        
        // conditional autoload modules that are skipped (className => 1)
        $skipped = array();

        // init conditional autoload modules, now that $page is known
        foreach($this->conditionalAutoloadModules as $className => $func) {

            if($this->debug) {
                $moduleID = $this->getModuleID($className);
                $flags = $this->moduleFlags[$moduleID];
                $this->message("Conditional autoload: $className (flags=$flags, condition=" . (is_string($func) ? $func : 'func') . ")");
            }

            $load = true;

            if(is_string($func)) {
                // selector string
                if(!$this->wire('page')->is($func)) $load = false;
            } else {
                // anonymous function
                if(!is_callable($func)) $load = false;
                    else if(!$func()) $load = false;
            }

            if($load) {
                $module = $this->newModule($className);
                if($module) {
                    $this->set($className, $module);
                    if($this->initModule($module)) {
                        if($this->debug) $this->message("Conditional autoload: $className LOADED");
                    } else {
                        if($this->debug) $this->warning("Failed conditional autoload: $className");
                    }
                }

            } else {
                $skipped[$className] = $className;
                if($this->debug) $this->message("Conditional autoload: $className SKIPPED");
            }
        }
        
        // clear this out since we don't need it anymore
        $this->conditionalAutoloadModules = array();
        
        return $skipped;
    }

    /**
     * Trigger all modules 'ready' method, if they have it.
     *
     * This is to indicate to them that the API environment is fully ready and $page is in fuel.
     *
     * This is triggered by ProcessPageView::ready
     * 
     * #pw-internal
     *
     */
    public function triggerReady() {
        
        $debugKey = $this->debug ? $this->debugTimerStart("triggerReady") : null; 
        
        $skipped = $this->triggerConditionalAutoload();
        
        // trigger ready method on all applicable modules
        foreach($this as $module) {
            /** @var Module $module */
            if($module instanceof ModulePlaceholder) continue;
            
            // $info = $this->getModuleInfo($module); 
            // if($info['autoload'] === false) continue; 
            // if(!$this->isAutoload($module)) continue; 
            
            $class = $this->getModuleClass($module); 
            if(isset($skipped[$class])) continue; 
            
            $id = $this->moduleIDs[$class];
            if(!($this->moduleFlags[$id] & self::flagsAutoload)) continue;
            
            if(!method_exists($module, 'ready')) continue;
            
            $this->readyModule($module);
        }
        
        if($this->debug) $this->debugTimerStop($debugKey); 
    }

    /**
     * Retrieve the installed module info as stored in the database
     *
     */
    protected function loadModulesTable() {
        $this->autoloadOrders = array();
        $database = $this->wire()->database;
        // we use SELECT * so that this select won't be broken by future DB schema additions
        // Currently: id, class, flags, data, with created added at sysupdate 7
        $query = $database->prepare("SELECT * FROM modules ORDER BY class", "modules.loadModulesTable()"); // QA
        $query->execute();

        /** @noinspection PhpAssignmentInConditionInspection */
        while($row = $query->fetch(\PDO::FETCH_ASSOC)) {
            
            $moduleID = (int) $row['id'];
            $flags = (int) $row['flags'];
            $class = $row['class'];
            $this->moduleIDs[$class] = $moduleID;
            $this->moduleFlags[$moduleID] = $flags;
            $autoload = $flags & self::flagsAutoload;
            $loadSettings = $autoload || ($flags & self::flagsDuplicate) || ($class == 'SystemUpdater');
            
            if($loadSettings) {
                // preload config data for autoload modules since we'll need it again very soon
                $data = strlen($row['data']) ? wireDecodeJSON($row['data']) : array();
                $this->configData[$moduleID] = $data;
                // populate information about duplicates, if applicable
                if($flags & self::flagsDuplicate) $this->duplicates()->addFromConfigData($class, $data); 
                
            } else if(!empty($row['data'])) {
                // indicate that it has config data, but not yet loaded
                $this->configData[$moduleID] = 1; 
            }
            
            if(isset($row['created']) && $row['created'] != '0000-00-00 00:00:00') {
                $this->createdDates[$moduleID] = $row['created']; 
            }
            
            if($autoload && !empty($this->moduleInfoCache[$moduleID]['autoload'])) {
                $autoload = $this->moduleInfoCache[$moduleID]['autoload'];
                $disabled = $flags & self::flagsDisabled;
                if(is_int($autoload) && $autoload > 1 && !$disabled) {
                    // autoload specifies an order > 1, indicating it should load before others
                    $this->autoloadOrders[$class] = $autoload;
                }
            }
            
            unset($row['data'], $row['created']); // info we don't want stored in modulesTableCache
            $this->modulesTableCache[$class] = $row;
        }
        
        $query->closeCursor();
    }

    /**
     * Given a disk path to the modules, determine all installed modules and keep track of all uninstalled (installable) modules. 
     *
     * @param string $path 
     *
     */
    protected function load($path) {

        $config = $this->wire('config');
        $debugKey = $this->debug ? $this->debugTimerStart("load($path)") : null; 
        $installed =& $this->modulesTableCache;
        $modulesLoaded = array();
        $modulesDelayed = array();
        $modulesRequired = array();
        $rootPath = $config->paths->root;
        $basePath = substr($path, strlen($rootPath));

        foreach($this->findModuleFiles($path, true) as $pathname) {
    
            $pathname = trim($pathname);
            if(empty($pathname)) continue;
            $basename = basename($pathname);
            list($moduleName, $ext) = explode('.', $basename, 2); // i.e. "module.php" or "module"
            
            $this->moduleFileExts[$moduleName] = $ext === 'module' ? 1 : 2;
            // @todo next, remove the 'file' property from verbose module info since it is redundant
            
            $requires = array();
            $name = $moduleName;
            $moduleName = $this->loadModule($path, $pathname, $requires, $installed);
            if(!$config->paths->get($name)) $this->setConfigPaths($name, dirname($basePath . $pathname));
            if(!$moduleName) continue;
        
            if(count($requires)) {
                // module not loaded because it required other module(s) not yet loaded
                foreach($requires as $requiresModuleName) {
                    if(!isset($modulesRequired[$requiresModuleName])) $modulesRequired[$requiresModuleName] = array();
                    if(!isset($modulesDelayed[$moduleName])) $modulesDelayed[$moduleName] = array();
                    // queue module for later load
                    $modulesRequired[$requiresModuleName][$moduleName] = $pathname;
                    $modulesDelayed[$moduleName][] = $requiresModuleName;
                }
                continue;
            }

            // module was successfully loaded
            $modulesLoaded[$moduleName] = 1;
            $loadedNames = array($moduleName);

            // now determine if this module had any other modules waiting on it as a dependency
            /** @noinspection PhpAssignmentInConditionInspection */
            while($moduleName = array_shift($loadedNames)) {
                // iternate through delayed modules that require this one
                if(empty($modulesRequired[$moduleName])) continue; 
                
                foreach($modulesRequired[$moduleName] as $delayedName => $delayedPathName) {
                    $loadNow = true;
                    if(isset($modulesDelayed[$delayedName])) {
                        foreach($modulesDelayed[$delayedName] as $requiresModuleName) {
                            if(!isset($modulesLoaded[$requiresModuleName])) {
                                $loadNow = false;
                            }
                        }
                    }
                    if(!$loadNow) continue; 
                    // all conditions satisified to load delayed module
                    unset($modulesDelayed[$delayedName], $modulesRequired[$moduleName][$delayedName]);
                    $unused = array();
                    $loadedName = $this->loadModule($path, $delayedPathName, $unused, $installed);
                    if(!$loadedName) continue; 
                    $modulesLoaded[$loadedName] = 1; 
                    $loadedNames[] = $loadedName;
                }
            }
        }

        if(count($modulesDelayed)) {
            foreach($modulesDelayed as $moduleName => $requiredNames) {
                $this->error("Module '$moduleName' dependency not fulfilled for: " . implode(', ', $requiredNames), Notice::debug);
            }
        }
        
        if($this->debug) $this->debugTimerStop($debugKey); 
    }

    /**
     * Load a module into memory (companion to load bootstrap method)
     * 
     * @param string $basepath Base path of modules being processed (path provided to the load method)
     * @param string $pathname
     * @param array $requires This method will populate this array with required dependencies (class names) if present.
     * @param array $installed Array of installed modules info, indexed by module class name
     * @return string Returns module name (classname) 
     * 
     */
    protected function loadModule($basepath, $pathname, array &$requires, array &$installed) {
    
        $pathname = $basepath . $pathname;
        $dirname = dirname($pathname);
        $filename = basename($pathname);
        $basename = basename($filename, '.php');
        $basename = basename($basename, '.module');
        $requires = array();
        $duplicates = $this->duplicates();
        $moduleInfo = null;
        
        // check if module has duplicate files, where one to use has already been specified to use first
        $currentFile = $duplicates->getCurrent($basename); // returns the current file in use, if more than one
        if($currentFile) {
            // there is a duplicate file in use
            $file = rtrim($this->wire('config')->paths->root, '/') . $currentFile;
            if(file_exists($file) && $pathname != $file) {
                // file in use is different from the file we are looking at
                // check if this is a new/yet unknown duplicate
                if(!$duplicates->hasDuplicate($basename, $pathname)) {
                    // new duplicate
                    $duplicates->recordDuplicate($basename, $pathname, $file, $installed);
                }
                return '';
            }
        }

        // check if module has already been loaded, or maybe we've got duplicates
        if(wireClassExists($basename, false)) { 
            $module = parent::get($basename);
            $dir = rtrim((string) $this->wire()->config->paths->$basename, '/');
            if($module && $dir && $dirname != $dir) {
                $duplicates->recordDuplicate($basename, $pathname, "$dir/$filename", $installed);
                return '';
            }
            if($module) return $basename;
        }

        // if the filename doesn't end with .module or .module.php, then stop and move onto the next
        if(!strpos($filename, '.module') || (substr($filename, -7) !== '.module' && substr($filename, -11) !== '.module.php')) return false;
        
        //  if the filename doesn't start with the requested path, then continue
        if(strpos($pathname, $basepath) !== 0) return ''; 

        // if the file isn't there, it was probably uninstalled, so ignore it
        if(!file_exists($pathname)) return '';

        // if the module isn't installed, then stop and move on to next
        if(!array_key_exists($basename, $installed)) {
            $this->installable[$basename] = $pathname;
            return '';
        }

        $info = $installed[$basename];
        $this->setConfigPaths($basename, $dirname);
        $module = null;
        $autoload = false;

        if($info['flags'] & self::flagsAutoload) {
            
            // this is an Autoload module. 
            // include the module and instantiate it but don't init() it,
            // because it will be done by Modules::init()
            $moduleInfo = $this->getModuleInfo($basename);

            // determine if module has dependencies that are not yet met
            if(count($moduleInfo['requires'])) {
                foreach($moduleInfo['requires'] as $requiresClass) {
                    $nsRequiresClass = $this->getModuleClass($requiresClass, true);
                    if(!wireClassExists($nsRequiresClass, false)) {
                        $requiresInfo = $this->getModuleInfo($requiresClass); 
                        if(!empty($requiresInfo['error']) 
                            || $requiresInfo['autoload'] === true 
                            || !$this->isInstalled($requiresClass)) {   
                            // we only handle autoload===true since load() only instantiates other autoload===true modules
                            $requires[] = $requiresClass;
                        }
                    }
                }
                if(count($requires)) {
                    // module has unmet requirements
                    return $basename;
                }
            }

            // if not defined in getModuleInfo, then we'll accept the database flag as enough proof
            // since the module may have defined it via an isAutoload() function
            if(!isset($moduleInfo['autoload'])) $moduleInfo['autoload'] = true;
            /** @var bool|string|callable $autoload */
            $autoload = $moduleInfo['autoload'];
            if($autoload === 'function') {
                // function is stored by the moduleInfo cache to indicate we need to call a dynamic function specified with the module itself
                $i = $this->getModuleInfoExternal($basename); 
                if(empty($i)) {
                    $this->includeModuleFile($pathname, $basename);
                    $className = $moduleInfo['namespace'] . $basename;
                    if(method_exists($className, 'getModuleInfo')) {
                        $i = $className::getModuleInfo();
                    } else {
                        $i = array();
                    }
                }
                $autoload = isset($i['autoload']) ? $i['autoload'] : true;
                unset($i);
            }
            // check for conditional autoload
            if(!is_bool($autoload) && (is_string($autoload) || is_callable($autoload)) && !($info['flags'] & self::flagsDisabled)) {
                // anonymous function or selector string
                $this->conditionalAutoloadModules[$basename] = $autoload;
                $this->moduleIDs[$basename] = $info['id'];
                $autoload = true;
            } else if($autoload) {
                $this->includeModuleFile($pathname, $basename);
                if(!($info['flags'] & self::flagsDisabled)) {
                    $module = null;
                    if($this->refreshing) {
                        $module = parent::get($basename);
                    } else if(isset($this->autoloadOrders[$basename]) && $this->autoloadOrders[$basename] >= 10000) {
                        $module = parent::get($basename); // preloaded module
                    } 
                    if(!$module) $module = $this->newModule($basename);
                }
            }
        }

        if(is_null($module)) {
            // placeholder for a module, which is not yet included and instantiated
            if(!$moduleInfo) $moduleInfo = $this->getModuleInfo($basename);
            $module = $this->newModulePlaceholder($basename, $moduleInfo['namespace'], $pathname, $info['flags'] & self::flagsSingular, $autoload);
        }

        $this->moduleIDs[$basename] = $info['id'];
        $this->set($basename, $module);
        
        return $basename; 
    }

    /**
     * Find new module files in the given $path
     *
     * If $readCache is true, this will perform the find from the cache
     *
     * @param string $path Path to the modules
     * @param bool $readCache Optional. If set to true, then this method will attempt to read modules from the cache. 
     * @param int $level For internal recursive use.
     * @return array Array of module files
     *
     */
    protected function findModuleFiles($path, $readCache = false, $level = 0) {

        static $startPath;
        static $callNum = 0;
        static $prependFiles = array();

        $callNum++;
        $config = $this->wire('config');
        $cache = $this->wire('cache'); 
        $cacheName = '';

        if($level == 0) {
            $startPath = $path;
            $cacheName = "Modules." . str_replace($config->paths->root, '', $path);
            if($readCache && $cache) {
                $cacheContents = $cache->get($cacheName); 
                if($cacheContents !== null) {
                    if(empty($cacheContents) && $callNum === 1) {
                        // don't accept empty cache for first path (/wire/modules/)
                    } else {
                        $cacheContents = explode("\n", trim($cacheContents));
                        return $cacheContents;
                    }
                }
            }
        }

        $files = array();
        $autoloadOrders = null;
        
        if(count($this->autoloadOrders) && $path !== $config->paths->modules) {
            $autoloadOrders = &$this->autoloadOrders;
        }
        
        try {
            $dir = new \DirectoryIterator($path); 
        } catch(\Exception $e) {
            $this->trackException($e, false, true);
            $dir = null;
        }
        
        if($dir) foreach($dir as $file) {

            if($file->isDot()) continue; 

            $filename = $file->getFilename();
            $pathname = $file->getPathname();

            if(DIRECTORY_SEPARATOR != '/') {
                $pathname = str_replace(DIRECTORY_SEPARATOR, '/', $pathname); 
            }

            if(strpos($pathname, '/.') !== false) {
                $pos = strrpos(rtrim($pathname, '/'), '/');
                if($pathname[$pos+1] == '.') continue; // skip hidden files and dirs
            }

            // if it's a directory with a .module file in it named the same as the dir, then descend into it
            if($file->isDir() && ($level < 1 || (is_file("$pathname/$filename.module") || is_file("$pathname/$filename.module.php")))) {
                $files = array_merge($files, $this->findModuleFiles($pathname, false, $level + 1));
            }

            // if the filename doesn't end with .module or .module.php, then stop and move onto the next
            $extension = $file->getExtension();
            if($extension !== 'module' && $extension !== 'php') continue;
            list($moduleName, $extension) = explode('.', $filename, 2);
            if($extension !== 'module'  && $extension !== 'module.php') continue;
            
            $pathname = str_replace($startPath, '', $pathname); 
            
            if($autoloadOrders !== null && isset($autoloadOrders[$moduleName])) {
                $prependFiles[$pathname] = $autoloadOrders[$moduleName];
            } else {
                $files[] = $pathname;
            }
        }
        
        if($level == 0 && $dir !== null) {
            if(!empty($prependFiles)) {
                // one or more non-core modules must be loaded first in a specific order
                arsort($prependFiles);
                $files = array_merge(array_keys($prependFiles), $files);
                $prependFiles = array();
            }
            if($cache && $cacheName) {
                $cache->save($cacheName, implode("\n", $files), WireCache::expireReserved);
            }
        }

        return $files;
    }


    /**
     * Setup entries in config->urls and config->paths for the given module
     *
     * @param string $moduleName
     * @param string $path
     *
     */
    protected function setConfigPaths($moduleName, $path) {
        $config = $this->wire('config'); 
        $rootPath = $config->paths->root;
        if(strpos($path, $rootPath) === 0) {
            // if root path included, strip it out
            $path = substr($path, strlen($config->paths->root));
        }
        $path = rtrim($path, '/') . '/'; 
        $config->paths->set($moduleName, $path);
        $config->urls->set($moduleName, $path); 
    }

    /**
     * Get the requested Module 
     *
     * - If the module is not installed, but is installable, it will be installed, instantiated, and initialized.
     *   If you don't want that behavior, call `$modules->isInstalled('ModuleName')` as a conditional first. 
     * - You can also get/load a module by accessing it directly, like `$modules->ModuleName`.
     * - To get a module with additional options, use `$modules->getModule($name, $options)` instead. 
     * 
     * ~~~~~
     * // Get the MarkupAdminDataTable module
     * $table = $modules->get('MarkupAdminDataTable'); 
     * 
     * // You can also do this
     * $table = $modules->MarkupAdminDataTable;
     * ~~~~~
     *
     * @param string|int $key Module name (also accepts database ID)
     * @return Module|_Module|null Returns a Module or null if not found
     * @throws WirePermissionException If module requires a particular permission the user does not have
     * @see Modules::getModule(), Modules::isInstalled()
     *
     */
    public function get($key) {
        // If the module is a ModulePlaceholder, then it will be converted to the real module (included, instantiated, initialized).
        return $this->getModule($key);
    }

    /**
     * Attempt to find a substitute for moduleName and return module if found or null if not
     * 
     * @param $moduleName
     * @param array $options See getModule() options
     * @return Module|null
     * 
     */
    protected function getSubstituteModule($moduleName, array $options = array()) {
        
        $module = null;
        $options['noSubstitute'] = true; // prevent recursion
        
        while(isset($this->substitutes[$moduleName]) && !$module) {
            $substituteName = $this->substitutes[$moduleName];
            $module = $this->getModule($substituteName, $options);
            if(!$module) $moduleName = $substituteName;
        }
        
        return $module;
    }

    /**
     * Get the requested Module (with options)
     * 
     * This is the same as `$modules->get()` except that you can specify additional options to modify default behavior.
     * These are the options you can specify in the `$options` array argument:
     * 
     *  - `noPermissionCheck` (bool): Specify true to disable module permission checks (and resulting exception). (default=false)
     *  - `noInstall` (bool): Specify true to prevent a non-installed module from installing from this request. (default=false)
     *  - `noInit` (bool): Specify true to prevent the module from being initialized or configured. (default=false). See `configOnly` as alternative.
     *  - `noSubstitute` (bool): Specify true to prevent inclusion of a substitute module. (default=false)
     *  - `noCache` (bool): Specify true to prevent module instance from being cached for later getModule() calls. (default=false)
     *  - `noThrow` (bool): Specify true to prevent exceptions from being thrown on permission or fatal error. (default=false)
     *  - `returnError` (bool): Return an error message (string) on error, rather than null. (default=false)
     *  - `configOnly` (bool): Populate module config data but do not call its init() method. (default=false) 3.0.169+. Alternative to `noInit`.
     *  - `configData` (array): Associative array of additional config data to populate to module. (default=[]) 3.0.169+
     * 
     * If the module is not installed, but is installable, it will be installed, instantiated, and initialized.
     * If you don't want that behavior, call `$modules->isInstalled('ModuleName')` as a condition first, OR specify 
     * true for the `noInstall` option in the `$options` argument.
     * 
     * @param string|int $key Module name or database ID.
     * @param array $options Optional settings to change load behavior, see method description for details. 
     * @return Module|_Module|null|string Returns ready-to-use module or NULL|string if not found (string if `returnError` option used).
     * @throws WirePermissionException|\Exception If module requires a particular permission the user does not have
     * @see Modules::get()
     *
     */
    public function getModule($key, array $options = array()) {
    
        $module = null;
        $needsInit = false;
        $noInit = !empty($options['noInit']); // force cancel of Module::init() call?
        $initOptions = array(); // options for initModule() call
        $find = false; // try to find new location of module file?
        $error = '';
        
        if(empty($key)) {
            return empty($options['returnError']) ? null : "No module specified";
        }

        // check for optional module ID and convert to classname if found
        if(ctype_digit("$key")) {
            $moduleID = (int) $key;
            if(!$key = array_search($key, $this->moduleIDs)) {
                return empty($options['returnError']) ? null : "Unable to find module ID $moduleID";
            }
        } else {
            $moduleID = 0;
            $key = wireClassName($key, false);
        }
        
        $module = parent::get($key);
        
        if(!$module && !$moduleID) {
            // make non case-sensitive for module name ($key)
            $lowerKey = strtolower($key);
            foreach(array_keys($this->moduleIDs) as $className) {
                if(strtolower($className) !== $lowerKey) continue;
                $module = parent::get($className);
                break;
            }
        }
        
        if(!$module) { 
            if(empty($options['noSubstitute'])) {
                if($this->isInstallable($key) && empty($options['noInstall'])) {
                    // module is on file system and may be installed, no need to substitute
                } else {
                    $module = $this->getSubstituteModule($key, $options);
                    if($module) return $module; // returned module is ready to use
                }
            } else {
                $error = "Module '$key' not found and substitute not allowed (noSubstitute=true)";  
            }
        }
        
        if($module) {
            // check if it's a placeholder, and if it is then include/instantiate/init the real module 
            // OR check if it's non-singular, so that a new instance is created
            if($module instanceof ModulePlaceholder || !$this->isSingular($module)) {
                $placeholder = $module;
                $class = $this->getModuleClass($placeholder);
                try {
                    if($module instanceof ModulePlaceholder) $this->includeModule($module);
                    $module = $this->newModule($class);
                } catch(\Exception $e) {
                    if(empty($options['noThrow'])) throw $e;
                    return empty($options['returnError']) ? null : "Module '$key' - " . $e->getMessage();
                }
                // if singular, save the instance so it can be used in later calls
                if($module && $this->isSingular($module) && empty($options['noCache'])) $this->set($key, $module);
                $needsInit = true;
            }

        } else if(empty($options['noInstall'])) { 
            // module was not available to get, see if we can install it
            if(array_key_exists($key, $this->getInstallable())) {
                // check if the request is for an uninstalled module 
                // if so, install it and return it 
                try {
                    $module = $this->install($key);
                } catch(\Exception $e) {
                    if(empty($options['noThrow'])) throw $e;
                    if(!empty($options['returnError'])) return "Module '$key' install failed: " . $e->getMessage();
                }
                $needsInit = true;
                if(!$module) $error = "Module '$key' not installed and install failed";
            } else {
                $error = "Module '$key' is not present or listed as installable";
                $find = true;
            }
        } else {
            $error = "Module '$key' is not present and not installable (noInstall=true)";
            $find = true;
        }
        
        if(!$module && $find) {
            // This is reached if module has moved elsewhere in file system, like from:
            // site/modules/ModuleName.module to site/modules/ModuleName/ModuleName.module
            // Code below tries to find the file to keep it working, but modules need Refresh.
            try {
                if($this->includeModule($key)) {
                    $module = $this->newModule($key);
                }
            } catch(\Exception $e) {
                if(empty($options['noThrow'])) throw $e;
                $error .= ($error ? " - " : "Module '$key' - ") . $e->getMessage();
                return empty($options['returnError']) ? null : $error;
            }
        }
        
        if(!$module) {
            if(!$error) $error = "Unable to get module '$key'";
            return empty($options['returnError']) ? null : $error;
        }
        
        if(empty($options['noPermissionCheck'])) {
            // check that user has permission required to use module
            if(!$this->hasPermission($module, $this->wire('user'), $this->wire('page'))) {
                $error = $this->_('You do not have permission to execute this module') . ' - ' . wireClassName($module);
                if(empty($options['noThrow'])) throw new WirePermissionException($error);
                return empty($options['returnError']) ? null : $error;
            }
        }

        if($needsInit && $noInit) {
            // forced cancel of init() call
            $needsInit = false; 
        }
        
        if(!$needsInit && (!empty($options['configData']) || !empty($options['configOnly']))) {
            // if config data was supplied in options then we have to init()
            $needsInit = true;
            if(!empty($options['configData'])) $initOptions['configData'] = $options['configData'];
            // if forced noInit then tell initModule() to only config and not call Module::init()
            if($noInit || !empty($options['configOnly'])) $initOptions['configOnly'] = true;
        }

        // skip autoload modules because they have already been initialized in the load() method
        // unless they were just installed, in which case we need do init now
        if($needsInit) {
            // if the module is configurable, then load its config data
            // and set values for each before initializing the module
            $initOptions['clearSettings'] = false;
            $initOptions['throw'] = true;
            try {
                if(!$this->initModule($module, $initOptions)) {
                    return empty($options['returnError']) ? null : "Module '$module' failed init";
                }
            } catch(\Exception $e) {
                if(empty($options['noThrow'])) throw $e; 
                return empty($options['returnError']) ? null : "Module '$module' throw Exception on init - " . $e->getMessage();
            }
        }
    
        return $module; 
    }

    /**
     * Check if user has permission for given module
     * 
     * #pw-internal
     * 
     * @param string|object $moduleName Module instance or module name
     * @param User $user Optionally specify different user to consider than current.
     * @param Page $page Optionally specify different page to consider than current.
     * @param bool $strict If module specifies no permission settings, assume no permission.
     *   - Default (false) is to assume permission when module doesn't say anything about it. 
     *   - Process modules (for instance) generally assume no permission when it isn't specifically defined 
     *     (though this method doesn't get involved in that, leaving you to specify $strict instead). 
     * 
     * @return bool
     * 
     */
    public function hasPermission($moduleName, User $user = null, Page $page = null, $strict = false) {
        
        if(is_object($moduleName)) {
            $module = $moduleName;
            $className = $module->className(true);
            $moduleName = $module->className(false);
        } else {
            $module = null;
            // $className = wireClassName($moduleName, true);
            $className = $this->getModuleClass($moduleName, true); // ???
            $moduleName = wireClassName($moduleName, false);
        }

        $info = $this->getModuleInfo($module ? $module : $moduleName);
        if(empty($info['permission']) && empty($info['permissionMethod'])) return ($strict ? false : true);
        
        if(is_null($user)) $user = $this->wire('user');     
        if($user && $user->isSuperuser()) return true;
        
        if(!empty($info['permission'])) {
            if(!$user->hasPermission($info['permission'])) return false;
        }
        
        if(!empty($info['permissionMethod'])) {
            // module specifies a static method to call for permission
            if(is_null($page)) $page = $this->wire('page');
            $data = array(
                'wire' => $this->wire(),
                'page' => $page, 
                'user' => $user, 
                'info' => $info, 
            );
            $method = $info['permissionMethod'];
            $this->includeModule($moduleName);
            if(method_exists($className, $method)) return $className::$method($data);
            return false;
        }
        
        return true; 
    }

    /**
     * Get the requested module and reset cache + install it if necessary.
     *
     * This is exactly the same as get() except that this one will rebuild the modules cache if
     * it doesn't find the module at first. If the module is on the file system, this
     * one will return it in some instances that a regular get() can't. 
     * 
     * #pw-internal
     *
     * @param string|int $key Module className or database ID
     * @return Module|null
     *
     */
    public function getInstall($key) {
        $module = $this->get($key); 
        if(!$module) {
            $this->refresh();
            $module = $this->getModule($key); 
        }
        return $module; 
    }

    /**
     * Include the file for a given module, but don't instantiate it 
     * 
     * #pw-internal
     *
     * @param ModulePlaceholder|Module|string Expects a ModulePlaceholder or className
     * @param string $file Optionally specify the module filename if you already know it
     * @return bool true on success, false on fail or unknown
     *
     */
    public function includeModule($module, $file = '') {

        $className = '';
        $moduleName = '';
        
        if(is_string($module)) {
            $moduleName = ctype_alnum($module) ? $module : wireClassName($module);
            $className = wireClassName($module, true);
        } else if(is_object($module)) {
            if($module instanceof ModulePlaceholder) {
                $moduleName = $module->className();
                $className = $module->className(true);
            } else if($module instanceof Module) {
                return true; // already included
            }
        } else {
            $moduleName = $this->getModuleClass($module, false);
            $className = $this->getModuleClass($module, true);
        }
        
        if(!$className) return false;

        // already included
        if(class_exists($className, false)) return true;
    
        // attempt to retrieve module
        $module = parent::get($moduleName);
        
        if($module) {
            // module found, check to make sure it actually points to a module  
            if(!$module instanceof Module) $module = false;

        } else if($moduleName) {
            // This is reached for any of the following:
            // 1. an uninstalled module
            // 2. an installed module that has changed locations
            // 3. a module outside the \ProcessWire\ namespace
            // 4. a module that does not exist
            $fast = true;
            if(!$file) {
                // determine module file, if not already provided to the method
                $file = $this->getModuleFile($moduleName, array('fast' => true));
                if(!$file) {
                    $fast = false;
                    $file = $this->getModuleFile($moduleName, array('fast' => false));
                }
                // still can't figure out what file is? fail
                if(!$file) return false;
            }
            
            if(!$this->includeModuleFile($file, $moduleName)) {
                // module file failed to include(), try to identify and include file again
                if($fast) {
                    $filePrev = $file;
                    $file = $this->getModuleFile($moduleName, array('fast' => false));
                    if($file && $file !== $filePrev) {
                        $this->includeModuleFile($file, $moduleName);
                    }
                } else {
                    // we already tried this earlier, no point in doing it again
                }
            }
            
            // now check to see if included file resulted in presence of module class
            if(class_exists($className)) {
                // module in ProcessWire namespace
                $module = true;
            } else {
                // module in root namespace or some other namespace
                $namespace = $this->getModuleNamespace($moduleName, array('file' => $file));
                $className = trim($namespace, "\\") . "\\$moduleName";
                if(class_exists($className, false)) {
                    // successful include module
                    $module = true;
                }
            }
        }
        
        if($module === true) {
            // great
            return true; 
            
        } else if(!$module) {
            // darn
            return false;
            
        } else if($module instanceof ModulePlaceholder) {
            $this->includeModuleFile($module->file, $moduleName);
            return true; 
            
        } else if($module instanceof Module) {
            // it's already been included, since we have a real module
            return true; 
            
        } else {
            return false;
        }
    }

    /**
     * Include the given filename 
     * 
     * @param string $file
     * @param string $moduleName
     * @return bool
     * 
     */
    protected function includeModuleFile($file, $moduleName) {
        
        $wire1 = ProcessWire::getCurrentInstance();
        $wire2 = $this->wire();
        
        // check if there is more than one PW instance active
        if($wire1 !== $wire2) {
            // multi-instance is active, don't autoload module if class already exists
            // first do a fast check, which should catch any core modules 
            if(class_exists(__NAMESPACE__ . "\\$moduleName", false)) return true;
            // next do a slower check, figuring out namespace
            $ns = $this->getModuleNamespace($moduleName, array('file' => $file));
            $className = trim($ns, "\\") . "\\$moduleName";
            if(class_exists($className, false)) return true;
            // if this point is reached, module is not yet in memory in either instance
            // temporarily set the $wire instance to 2nd instance during include()
            ProcessWire::setCurrentInstance($wire2);
        }

        // get compiled version (if it needs compilation)
        $file = $this->compile($moduleName, $file);

        if($file) {
            /** @noinspection PhpIncludeInspection */
            $success = @include_once($file);
        } else {
            $success = false;
        }
    
        // set instance back, if multi-instance
        if($wire1 !== $wire2) ProcessWire::setCurrentInstance($wire1);
        
        return (bool) $success;
    }

    /**
     * Find modules based on a selector string 
     * 
     * #pw-internal Almost always recommend using findByPrefix() instead
     * 
     * @param string $selector Selector string
     * @return WireArray of found modules, instantiated and ready-to-use
     *  
     */
    public function find($selector) {
        // ensures any ModulePlaceholders are loaded in the returned result.
        $a = parent::find($selector); 
        if($a) {
            foreach($a as $key => $value) {
                $a[$key] = $this->get($value->className()); 
            }
        }
        return $a; 
    }

    /**
     * Find modules matching the given prefix (i.e. “Inputfield”)
     * 
     * By default this method returns module class names matching the given prefix. 
     * To instead retrieve instantiated (ready-to-use) modules, specify boolean true
     * for the second argument. Regardless of `$load` argument all returned arrays
     * are indexed by module name.
     * 
     * ~~~~~
     * // Retrieve array of all Textformatter module names
     * $items = $modules->findByPrefix('Textformatter'); 
     * 
     * // Retrieve array of all Textformatter modules (ready to use)
     * $items = $modules->findByPrefix('Textformatter', true); 
     * ~~~~~
     * 
     * @param string $prefix Specify prefix, i.e. "Process", "Fieldtype", "Inputfield", etc.
     * @param bool|int $load Specify one of the following (all indexed by module name):
     *  - Boolean true to return array of instantiated modules.
     *  - Boolean false to return array of module names (default).
     *  - Integer 1 to return array of module info for each matching module.
     *  - Integer 2 to return array of verbose module info for each matching module. 
     *  - Integer 3 to return array of Module or ModulePlaceholder objects (whatever current state is). Added 3.0.146.
     * @return array Returns array of module class names, module info arrays, or Module objects. In all cases, array indexes are class names.
     * 
     */
    public function findByPrefix($prefix, $load = false) {
        $results = array();
        foreach($this as $moduleName => $value) {
            if(stripos($moduleName, $prefix) !== 0) continue;
            if($load === false) {
                $results[$moduleName] = $moduleName;
            } else if($load === true) {
                $results[$moduleName] = $this->getModule($moduleName);
            } else if($load === 1) {
                $results[$moduleName] = $this->getModuleInfo($moduleName); 
            } else if($load === 2) {
                $results[$moduleName] = $this->getModuleInfoVerbose($moduleName);
            } else if($load === 3) {
                $results[$moduleName] = $value;
            } else {
                $results[$moduleName] = $moduleName;
            }
        }
        ksort($results);
        return $results;
    }

    /**
     * Find modules by matching a property or properties in their module info 
     * 
     * @param string|array $selector Specify one of the following: 
     *  - Selector string to match module info. 
     *  - Array of [ 'property' => 'value' ] to match in module info (this is not a selector array). 
     *  - Name of property that will match module if not empty in module info. 
     * @param bool|int $load Specify one of the following: 
     *  - Boolean true to return array of instantiated modules.
     *  - Boolean false to return array of module names (default).
     *  - Integer 1 to return array of module info for each matching module.
     *  - Integer 2 to return array of verbose module info for each matching module. 
     * @return array Array of modules, module names or module info arrays, indexed by module name.
     * 
     */
    public function findByInfo($selector, $load = false) {
        
        $selectors = null;
        $infos = null;
        $keys = null;
        $results = array();
        $verbose = $load === 2;
        $properties = array();
        $has = '';
        
        if(is_array($selector)) {
            // find matching all values in array
            $keys = $selector;
            $properties = array_keys($keys);
        } if(!ctype_alnum($selector) && Selectors::stringHasOperator($selector)) {
            // find by selectors
            $selectors = new Selectors($selector);
            if(!$verbose) foreach($selectors as $s) {
                $properties = array_merge($properties, $s->fields()); 
            }
        } else {
            // find non-empty property
            $has = $selector;
            $properties[] = $has;
        }
    
        // check if any verbose properties are part of the find
        if(!$verbose) foreach($properties as $property) {
            if(!in_array($property, $this->moduleInfoVerboseKeys)) continue;
            $verbose = true;
            break;
        }
        
        $moduleInfoOptions = array(
            'verbose' => $verbose,
            'minify' => false
        );
        
        foreach($this->getModuleInfo('*', $moduleInfoOptions) as $info) {
            $isMatch = false;
            
            if($has) {
                // simply check if property is non-empty
                if(!empty($info[$has])) $isMatch = true;
                
            } else if($selectors) {
                // match selector
                $total = 0;
                $n = 0;
                foreach($selectors as $selector) {
                    $total++;
                    $values = array();
                    foreach($selector->fields() as $property) {
                        if(isset($info[$property])) $values[] = $info[$property];
                    }
                    if($selector->matches($values)) $n++;
                }
                if($n && $n === $total) $isMatch = true;
                
            } else if($keys) {
                // match all values in $keys array
                $n = 0;
                foreach($keys as $key => $value) {
                    if($value === '*') {
                        // match any non-empty value
                        if(!empty($info[$key])) $n++;
                    } else {
                        // match exact value
                        if(isset($info[$key]) && $value == $info[$key]) $n++;
                    }
                }
                if($n && $n === count($keys)) $isMatch = true;
            }
            
            if($isMatch) {
                $moduleName = $info['name'];
                if(is_int($load)) {
                    $results[$moduleName] = $info;
                } else if($load === true) {
                    $results[$moduleName] = $this->getModule($moduleName);
                } else {
                    $results[$moduleName] = $moduleName;
                }
            }
        }
        
        return $results;
    }

    /**
     * Get an associative array [name => path] for all modules that aren’t currently installed.
     * 
     * #pw-internal
     *
     * @return array Array of elements with $moduleName => $pathName
     *
     */
    public function getInstallable() {
        return $this->installable; 
    }

    /**
     * Is the given module name installed?
     *
     * @param string $class Just a module class name, or optionally: `ModuleClassName>=1.2.3` (operator and version)
     * @return bool True if installed, false if not
     *
     */
    public function isInstalled($class) {

        if(is_object($class)) $class = $this->getModuleClass($class);

        $operator = null;
        $requiredVersion = null;
        $currentVersion = null;
        
        if(!ctype_alnum($class)) {
            // class has something other than just a classname, likely operator + version
            if(preg_match('/^([a-zA-Z0-9_]+)\s*([<>=!]+)\s*([\d.]+)$/', $class, $matches)) {
                $class = $matches[1];
                $operator = $matches[2];
                $requiredVersion = $matches[3];
            }
        }
        
        if($class === 'PHP' || $class === 'ProcessWire') {
            $installed = true; 
            if(!is_null($requiredVersion)) {
                $currentVersion = $class === 'PHP' ? PHP_VERSION : $this->wire('config')->version; 
            }
        } else {
            $installed = parent::get($class) !== null;
            if($installed && !is_null($requiredVersion)) {
                $info = $this->getModuleInfo($class); 
                $currentVersion = $info['version'];
            }
        }
    
        if($installed && !is_null($currentVersion)) {
            $installed = $this->versionCompare($currentVersion, $requiredVersion, $operator); 
        }
    
        return $installed;
    }


    /**
     * Is the given module name installable? (i.e. not already installed)
     * 
     * #pw-internal
     *
     * @param string $class Module class name
     * @param bool $now Is module installable RIGHT NOW? This makes it check that all dependencies are already fulfilled (default=false)
     * @return bool True if module is installable, false if not
     *
     */
    public function isInstallable($class, $now = false) {
        $installable = array_key_exists($class, $this->installable); 
        if(!$installable) return false;
        if(!wireInstanceOf($class, 'Module')) {
            $nsClass = $this->getModuleClass($class, true);
            if(!wireInstanceOf($nsClass, 'ProcessWire\\Module')) return false;
        }
        if($now) {
            $requires = $this->getRequiresForInstall($class); 
            if(count($requires)) return false;
        }
        return $installable;
    }
    
    /**
     * Install the given module name
     * 
     * #pw-group-manipulation
     *
     * @param string $class Module name (class name)
     * @param array|bool $options Optional associative array that can contain any of the following:
     *  - `dependencies` (boolean): When true, dependencies will also be installed where possible. Specify false to prevent installation of uninstalled modules. (default=true)
     *  - `resetCache` (boolean): When true, module caches will be reset after installation. (default=true)
     *  - `force` (boolean): Force installation, even if dependencies can't be met. 
     * @return null|Module Returns null if unable to install, or ready-to-use Module object if successfully installed. 
     * @throws WireException
     *
     */
    public function ___install($class, $options = array()) {
        
        $defaults = array(
            'dependencies' => true, 
            'resetCache' => true, 
            'force' => false, 
            );
        if(is_bool($options)) { 
            // dependencies argument allowed instead of $options, for backwards compatibility
            $dependencies = $options; 
            $options = array('dependencies' => $dependencies);
        } 
        $options = array_merge($defaults, $options); 
        $dependencyOptions = $options; 
        $dependencyOptions['resetCache'] = false; 

        if(!$this->isInstallable($class)) return null; 

        $requires = $this->getRequiresForInstall($class); 
        if(count($requires)) {
            $error = '';
            $installable = false; 
            if($options['dependencies']) {
                $installable = true; 
                foreach($requires as $requiresModule) {
                    if(!$this->isInstallable($requiresModule)) $installable = false;
                }
                if($installable) {
                    foreach($requires as $requiresModule) {
                        if(!$this->install($requiresModule, $dependencyOptions)) {
                            $error = $this->_('Unable to install required module') . " - $requiresModule. "; 
                            $installable = false;
                            break;
                        }
                    }
                }
            }
            if(!$installable) {
                $error = sprintf($this->_('Module %s requires: %s'), $class, implode(', ', $requires)) . ' ' . $error;
                if($options['force']) {
                    $this->warning($this->_('Warning!') . ' ' . $error);
                } else {
                    throw new WireException($error);
                }
            }
        }
        
        $languages = $this->wire('languages');
        if($languages) $languages->setDefault();

        $pathname = $this->installable[$class];
        $this->includeModuleFile($pathname, $class);
        $this->setConfigPaths($class, dirname($pathname)); 

        $module = $this->newModule($class);
        if(!$module) return null;
        $flags = 0;
        $database = $this->wire('database');
        $moduleID = 0;
        
        if($this->isSingular($module)) $flags = $flags | self::flagsSingular; 
        if($this->isAutoload($module)) $flags = $flags | self::flagsAutoload; 

        $sql = "INSERT INTO modules SET class=:class, flags=:flags, data=''";
        if($this->wire('config')->systemVersion >=7) $sql .= ", created=NOW()";
        $query = $database->prepare($sql, "modules.install($class)"); 
        $query->bindValue(":class", $class, \PDO::PARAM_STR); 
        $query->bindValue(":flags", $flags, \PDO::PARAM_INT); 
        
        try {
            if($query->execute()) $moduleID = (int) $database->lastInsertId();
        } catch(\Exception $e) {
            if($languages) $languages->unsetDefault();
            $this->trackException($e, false, true); 
            return null;
        }
        
        $this->moduleIDs[$class] = $moduleID;

        $this->add($module); 
        unset($this->installable[$class]);
        
        // note: the module's install is called here because it may need to know its module ID for installation of permissions, etc. 
        if(method_exists($module, '___install') || method_exists($module, 'install')) {
            try {
                /** @var _Module $module */
                $module->install();
                
            } catch(\PDOException $e) {
                $error = $this->_('Module reported error during install') . " ($class): " . $e->getMessage();
                $this->error($error);
                $this->trackException($e, false, $error);

            } catch(\Exception $e) {
                // remove the module from the modules table if the install failed
                $moduleID = (int) $moduleID;
                $error = $this->_('Unable to install module') .  " ($class): " . $e->getMessage();
                $ee = null;
                try {
                    $query = $database->prepare('DELETE FROM modules WHERE id=:id LIMIT 1'); // QA
                    $query->bindValue(":id", $moduleID, \PDO::PARAM_INT);
                    $query->execute();
                } catch(\Exception $ee) {
                    $this->trackException($e, false, $error)->trackException($ee, true);
                }
                if($languages) $languages->unsetDefault();
                if(is_null($ee)) $this->trackException($e, false, $error);
                return null;
            }
        }

        $info = $this->getModuleInfoVerbose($class, array('noCache' => true)); 
    
        // if this module has custom permissions defined in its getModuleInfo()['permissions'] array, install them 
        foreach($info['permissions'] as $name => $title) {
            $name = $this->wire('sanitizer')->pageName($name); 
            if(ctype_digit("$name") || empty($name)) continue; // permission name not valid
            $permission = $this->wire('permissions')->get($name); 
            if($permission->id) continue; // permision already there
            try {
                $permission = $this->wire('permissions')->add($name); 
                $permission->title = $title; 
                $this->wire('permissions')->save($permission);
                if($languages) $languages->unsetDefault(); 
                $this->message(sprintf($this->_('Added Permission: %s'), $permission->name)); 
            } catch(\Exception $e) {
                if($languages) $languages->unsetDefault(); 
                $error = sprintf($this->_('Error adding permission: %s'), $name);
                $this->trackException($e, false, $error); 
            }
        }

        // check if there are any modules in 'installs' that this module didn't handle installation of, and install them
        $label = $this->_('Module Auto Install');
        
        foreach($info['installs'] as $name) {
            if(!$this->isInstalled($name)) {
                try { 
                    $this->install($name, $dependencyOptions); 
                    $this->message("$label: $name"); 
                } catch(\Exception $e) {
                    $error = "$label: $name - " . $e->getMessage();
                    $this->trackException($e, false, $error); 
                }
            }
        }

        $this->log("Installed module '$module'"); 
        if($languages) $languages->unsetDefault();
        if($options['resetCache']) $this->clearModuleInfoCache();

        return $module; 
    }

    /**
     * Returns whether the module can be uninstalled
     * 
     * #pw-internal
     *
     * @param string|Module $class
     * @param bool $returnReason If true, the reason why it can't be uninstalled with be returned rather than boolean false.
     * @return bool|string 
     *
     */
    public function ___isUninstallable($class, $returnReason = false) {

        $reason = '';
        $reason1 = $this->_("Module is not already installed");
        $namespace = $this->getModuleNamespace($class);
        $class = $this->getModuleClass($class); 

        if(!$this->isInstalled($class)) {
            $reason = $reason1 . ' (a)';

        } else {
            $this->includeModule($class); 
            if(!wireClassExists($namespace . $class, false)) {
                $reason = $reason1 . " (b: $namespace$class)";
            }
        }

        if(!$reason) { 
            // if the moduleInfo contains a non-empty 'permanent' property, then it's not uninstallable
            $info = $this->getModuleInfo($class); 
            if(!empty($info['permanent'])) {
                $reason = $this->_("Module is permanent"); 
            } else {
                $dependents = $this->getRequiresForUninstall($class);   
                if(count($dependents)) $reason = $this->_("Module is required by other modules that must be removed first"); 
            }

            if(!$reason && in_array('Fieldtype', wireClassParents($namespace . $class))) {
                foreach($this->wire('fields') as $field) {
                    $fieldtype = wireClassName($field->type, false);
                    if($fieldtype == $class) { 
                        $reason = $this->_("This module is a Fieldtype currently in use by one or more fields");
                        break;
                    }
                }
            }
        }
        
        if($returnReason && $reason) return $reason;
    
        return $reason ? false : true;  
    }

    /**
     * Returns whether the module can be deleted (have it's files physically removed)
     * 
     * #pw-internal
     *
     * @param string|Module $class
     * @param bool $returnReason If true, the reason why it can't be removed will be returned rather than boolean false.
     * @return bool|string 
     *
     */
    public function isDeleteable($class, $returnReason = false) {

        $reason = '';
        $class = $this->getModuleClass($class); 

        $filename = isset($this->installable[$class]) ? $this->installable[$class] : null;
        $dirname = dirname($filename); 

        if(empty($filename) || $this->isInstalled($class)) {
            $reason = "Module must be uninstalled before it can be deleted.";

        } else if(is_link($filename) || is_link($dirname) || is_link(dirname($dirname))) {
            $reason = "Module is linked to another location";

        } else if(!is_file($filename)) {
            $reason = "Module file does not exist";

        } else if(strpos($filename, $this->paths[0]) === 0) {
            $reason = "Core modules may not be deleted.";

        } else if(!is_writable($filename)) {
            $reason = "We have no write access to the module file, it must be removed manually.";
        }

        if($returnReason && $reason) return $reason;
    
        return $reason ? false : true;  
    }

    /**
     * Delete the given module, physically removing its files
     * 
     * #pw-group-manipulation
     *
     * @param string $class Module name (class name)
     * @return bool|int
     * @throws WireException If module can't be deleted, exception will be thrown containing reason. 
     *
     */
    public function ___delete($class) {

        $class = $this->getModuleClass($class); 
        $success = true;
        $reason = $this->isDeleteable($class, true); 
        if($reason !== true) throw new WireException($reason); 
        $siteModulesPath = $this->wire('config')->paths->siteModules;

        $filename = $this->installable[$class];
        $basename = basename($filename); 
        
        /** @var WireFileTools $fileTools */
        $fileTools = $this->wire('files'); 

        // double check that $class is consistent with the actual $basename 
        if($basename === "$class.module" || $basename === "$class.module.php") {
            // good, this is consistent with the format we require
        } else {
            throw new WireException("Unrecognized module filename format"); 
        }

        // now determine if module is the owner of the directory it exists in
        // this is the case if the module class name is the same as the directory name

        $path = dirname($filename); // full path to directory, i.e. .../site/modules/ProcessHello
        $name = basename($path); // just name of directory that module is, i.e. ProcessHello
        $parentPath = dirname($path); // full path to parent directory, i.e. ../site/modules
        $backupPath = $parentPath . "/.$name"; // backup path, in case module is backed up

        // first check that we are still in the /site/modules/ (or another non core modules path)
        $inPath = false; // is module somewhere beneath /site/modules/ ?
        $inRoot = false; // is module in /site/modules/ root? i.e. /site/modules/ModuleName.module
        
        foreach($this->paths as $key => $modulesPath) {
            if($key === 0) continue; // skip core modules path
            if(strpos("$parentPath/", $modulesPath) === 0) $inPath = true; 
            if($modulesPath === $path) $inRoot = true; 
        }

        $basename = basename($basename, '.php');
        $basename = basename($basename, '.module'); 
        
        $files = array(
            "$basename.module",
            "$basename.module.php",
            "$basename.info.php",
            "$basename.info.json",
            "$basename.config.php", 
            "{$basename}Config.php",
            );
        
        if($inPath) { 
            // module is in /site/modules/[ModuleName]/
            
            $numOtherModules = 0; // num modules in dir other than this one
            $numLinks = 0; // number of symbolic links
            $dirs = array("$path/"); 
            
            do {
                $dir = array_shift($dirs); 
                $this->message("Scanning: $dir", Notice::debug); 
                
                foreach(new \DirectoryIterator($dir) as $file) {
                    if($file->isDot()) continue;
                    if($file->isLink()) {
                        $numLinks++;
                        continue; 
                    }
                    if($file->isDir()) {
                        $dirs[] = $fileTools->unixDirName($file->getPathname());
                        continue; 
                    }
                    if(in_array($file->getBasename(), $files)) continue; // skip known files
                    if(strpos($file->getBasename(), '.module') && preg_match('{(\.module|\.module\.php)$}', $file->getBasename())) {
                        // another module exists in this dir, so we don't want to delete that
                        $numOtherModules++;
                    }
                    if(preg_match('{^(' . $basename . '\.[-_.a-zA-Z0-9]+)$}', $file->getBasename(), $matches)) {
                        // keep track of potentially related files in case we have to delete them individually
                        $files[] = $matches[1]; 
                    }
                }
            } while(count($dirs)); 
            
            if(!$inRoot && !$numOtherModules && !$numLinks) {
                // the modulePath had no other modules or directories in it, so we can delete it entirely
                $success = $fileTools->rmdir($path, true); 
                if($success) {
                    $this->message("Removed directory: $path", Notice::debug);
                    if(is_dir($backupPath)) {
                        if($fileTools->rmdir($backupPath, true)) $this->message("Removed directory: $backupPath", Notice::debug); 
                    }
                    $files = array();
                } else {
                    $this->error("Failed to remove directory: $path", Notice::debug); 
                }
            }
        }

        // remove module files individually 
        foreach($files as $file) {
            $file = "$path/$file";
            if(!file_exists($file)) continue;
            if($fileTools->unlink($file, $siteModulesPath)) {
                $this->message("Removed file: $file", Notice::debug);
            } else {
                $this->error("Unable to remove file: $file", Notice::debug);
            }
        }
        
        $this->log("Deleted module '$class'");
        
        return $success; 
    }


    /**
     * Uninstall the given module name
     * 
     * #pw-group-manipulation
     *
     * @param string $class Module name (class name)
     * @return bool
     * @throws WireException
     *
     */
    public function ___uninstall($class) {

        $class = $this->getModuleClass($class); 
        $reason = $this->isUninstallable($class, true); 
        if($reason !== true) {
            // throw new WireException("$class - Can't Uninstall - $reason"); 
            return false;
        }
        
        // check if there are any modules still installed that this one says it is responsible for installing
        foreach($this->getUninstalls($class) as $name) {

            // catch uninstall exceptions at this point since original module has already been uninstalled
            $label = $this->_('Module Auto Uninstall');
            try {
                $this->uninstall($name);
                $this->message("$label: $name");

            } catch(\Exception $e) {
                $error = "$label: $name - " . $e->getMessage();
                $this->trackException($e, false, $error);
            }
        }

        $info = $this->getModuleInfoVerbose($class); 
        $module = $this->getModule($class, array(
            'noPermissionCheck' => true, 
            'noInstall' => true,
            // 'noInit' => true
        )); 
        if(!$module) return false;
        
        // remove all hooks attached to this module
        $hooks = $module instanceof Wire ? $module->getHooks() : array();
        foreach($hooks as $hook) {
            if($hook['method'] == 'uninstall') continue;
            $this->message("Removed hook $class => " . $hook['options']['fromClass'] . " $hook[method]", Notice::debug);
            $module->removeHook($hook['id']);
        }

        // remove all hooks attached to other ProcessWire objects
        $hooks = array_merge($this->getHooks('*'), $this->wire('hooks')->getAllLocalHooks());
        foreach($hooks as $hook) {
            /** @var Wire $toObject */
            $toObject = $hook['toObject'];
            $toClass = wireClassName($toObject, false);
            $toMethod = $hook['toMethod'];
            if($class === $toClass && $toMethod != 'uninstall') {
                $toObject->removeHook($hook['id']);
                $this->message("Removed hook $class => " . $hook['options']['fromClass'] . " $hook[method]", Notice::debug);
            }
        }
        
        if(method_exists($module, '___uninstall') || method_exists($module, 'uninstall')) {
            // note module's uninstall method may throw an exception to abort the uninstall
            /** @var _Module $module */
            $module->uninstall();
        }
        $database = $this->wire('database'); 
        $query = $database->prepare('DELETE FROM modules WHERE class=:class LIMIT 1'); // QA
        $query->bindValue(":class", $class, \PDO::PARAM_STR); 
        $query->execute();
    
        // add back to the installable list
        if(class_exists("ReflectionClass")) {
            $reflector = new \ReflectionClass($this->getModuleClass($module, true));
            $this->installable[$class] = $reflector->getFileName(); 
        }

        unset($this->moduleIDs[$class]);
        $this->remove($module);
    
        // delete permissions installed by this module
        if(isset($info['permissions']) && is_array($info['permissions'])) {
            foreach($info['permissions'] as $name => $title) {
                $name = $this->wire('sanitizer')->pageName($name); 
                if(ctype_digit("$name") || empty($name)) continue; 
                $permission = $this->wire('permissions')->get($name); 
                if(!$permission->id) continue; 
                try { 
                    $this->wire('permissions')->delete($permission); 
                    $this->message(sprintf($this->_('Deleted Permission: %s'), $name)); 
                } catch(\Exception $e) {
                    $error = sprintf($this->_('Error deleting permission: %s'), $name);
                    $this->trackException($e, false, $error);
                }
            }
        }

        $this->log("Uninstalled module '$class'"); 
        $this->refresh();

        return true; 
    }

    /**
     * Get flags for the given module
     * 
     * #pw-internal
     * 
     * @param int|string|Module $class Module to add flag to
     * @return int|false Returns integer flags on success, or boolean false on fail
     * 
     */
    public function getFlags($class) {
        $id = ctype_digit("$class") ? (int) $class : $this->getModuleID($class);
        if(isset($this->moduleFlags[$id])) return $this->moduleFlags[$id]; 
        if(!$id) return false;
        $query = $this->wire('database')->prepare('SELECT flags FROM modules WHERE id=:id');
        $query->bindValue(':id', $id, \PDO::PARAM_INT);
        $query->execute();
        if(!$query->rowCount()) return false;
        list($flags) = $query->fetch(\PDO::FETCH_NUM);
        $flags = (int) $flags; 
        $this->moduleFlags[$id] = $flags;
        return $flags; 
    }

    /**
     * Does module have flag?
     *
     * #pw-internal
     *
     * @param int|string|Module $class Module ID, class name or instance
     * @param int $flag
     * @return bool 
     * @since 3.0.170
     *
     */
    public function hasFlag($class, $flag) {
        $flags = $this->getFlags($class);
        return $flags === false ? false : ($flags & $flag);
    }

    /**
     * Set module flags
     * 
     * #pw-internal
     * 
     * @param $class
     * @param $flags
     * @return bool
     * 
     */
    public function setFlags($class, $flags) {
        $flags = (int) $flags; 
        $id = ctype_digit("$class") ? (int) $class : $this->getModuleID($class);
        if(!$id) return false;
        if($this->moduleFlags[$id] === $flags) return true; 
        $query = $this->wire('database')->prepare('UPDATE modules SET flags=:flags WHERE id=:id');
        $query->bindValue(':flags', $flags);
        $query->bindValue(':id', $id);
        if($this->debug) $this->message("setFlags(" . $this->getModuleClass($class) . ", " . $this->moduleFlags[$id] . " => $flags)");
        $this->moduleFlags[$id] = $flags;
        return $query->execute();
    }

    /**
     * Add or remove a flag from a module
     * 
     * #pw-internal
     * 
     * @param $class int|string|Module $class Module to add flag to
     * @param $flag int Flag to add (see flags* constants)
     * @param $add bool $add Specify true to add the flag or false to remove it
     * @return bool True on success, false on fail
     * 
     */
    public function setFlag($class, $flag, $add = true) {
        $id = ctype_digit("$class") ? (int) $class : $this->getModuleID($class);
        if(!$id) return false;
        $flag = (int) $flag; 
        if(!$flag) return false;
        $flags = $this->getFlags($id); 
        if($add) {
            if($flags & $flag) return true; // already has the flag
            $flags = $flags | $flag;
        } else {
            if(!($flags & $flag)) return true; // doesn't already have the flag
            $flags = $flags & ~$flag;
        }
        $this->setFlags($id, $flags); 
        return true;    
    }

    /**
     * Return an array of other module class names that are uninstalled when the given one is
     * 
     * #pw-internal
     * 
     * The opposite of this function is found in the getModuleInfo array property 'installs'. 
     * Note that 'installs' and uninstalls may be different, as only modules in the 'installs' list
     * that indicate 'requires' for the installer module will be uninstalled.
     * 
     * @param $class
     * @return array
     * 
     */
    public function getUninstalls($class) {
        
        $uninstalls = array();
        $class = $this->getModuleClass($class);
        if(!$class) return $uninstalls;
        $info = $this->getModuleInfoVerbose($class);
        
        // check if there are any modules still installed that this one says it is responsible for installing
        foreach($info['installs'] as $name) {

            // if module isn't installed, then great
            if(!$this->isInstalled($name)) continue;

            // if an 'installs' module doesn't indicate that it requires this one, then leave it installed
            $i = $this->getModuleInfo($name);
            if(!in_array($class, $i['requires'])) continue; 
            
            // add it to the uninstalls array
            $uninstalls[] = $name;
        }
        
        return $uninstalls;
    }

    /**
     * Returns the database ID of a given module class, or 0 if not found
     * 
     * #pw-internal
     *
     * @param string|Module $class Module or module name
     * @return int
     *
     */
    public function getModuleID($class) {
        
        $id = 0;

        if(is_object($class)) {
            if($class instanceof Module) {
                $class = $this->getModuleClass($class); 
            } else {
                // Class is not a module
                return $id; 
            }
        }

        if(isset($this->moduleIDs[$class])) {
            $id = (int) $this->moduleIDs[$class];
            
        } else foreach($this->moduleInfoCache as $key => $info) {   
            if($info['name'] == $class) {
                $id = (int) $key;
                break;
            }
        }
        
        return $id; 
    }

    /**
     * Returns the module's class name. 
     *
     * - Given a numeric database ID, returns the associated module class name or false if it doesn't exist
     * - Given a Module or ModulePlaceholder instance, returns the Module's class name. 
     *  
     * If the module has a className() method then it uses that rather than PHP's get_class().
     * This is important because of placeholder modules. For example, get_class would return 
     * 'ModulePlaceholder' rather than the correct className for a Module.
     * 
     * #pw-internal
     *
     * @param string|int|Module
     * @param bool $withNamespace Specify true to include the namespace in the class
     * @return string|bool The Module's class name or false if not found. 
     *  Note that 'false' is only possible if you give this method a non-Module, or an integer ID 
     *  that doesn't correspond to a module ID. 
     *
     */
    public function getModuleClass($module, $withNamespace = false) {
        
        $className = '';
        $namespace = '';

        if($module instanceof Module) {
            if(wireMethodExists($module, 'className')) {
                if($withNamespace) return $module->className(true);
                return $module->className();
            } else {
                return wireClassName($module, $withNamespace);
            }

        } else if(is_int($module) || ctype_digit("$module")) {
            $className = array_search((int) $module, $this->moduleIDs); 

        } else if(is_string($module)) {
            
            if(strpos($module, "\\") !== false) {
                $namespace = wireClassName($module, 1);
                $className = wireClassName($module, false);
            }

            // remove extensions if they were included in the module name
            if(strpos($module, '.') !== false) {
                $module = basename(basename($module, '.php'), '.module');
            }
            
            if(array_key_exists($module, $this->moduleIDs)) {
                $className = $module;
            } else if(array_key_exists($module, $this->installable)) {
                $className = $module;
            }
        }
        
        if($className) {
            if($withNamespace) {
                if($namespace) {
                    $className = "$namespace\\$className";
                } else {
                    $className = $this->getModuleNamespace($className) . $className;
                }
            }
            return $className;
        } 

        return false; 
    }

    /**
     * Retrieve module info from ModuleName.info.json or ModuleName.info.php
     * 
     * @param string $moduleName
     * @return array
     * 
     */
    protected function getModuleInfoExternal($moduleName) {
        // if($this->debug) $this->message("getModuleInfoExternal($moduleName)"); 
        
        // ...attempt to load info by info file (Module.info.php or Module.info.json)
        if(!empty($this->installable[$moduleName])) {
            $path = dirname($this->installable[$moduleName]) . '/';
        } else {
            $path = $this->wire('config')->paths->$moduleName;
        }
        
        if(empty($path)) return array();

        // module exists and has a dedicated path on the file system
        // we will try to get info from a PHP or JSON info file
        $filePHP = $path . "$moduleName.info.php";
        $fileJSON = $path . "$moduleName.info.json";

        $info = array();
        if(file_exists($filePHP)) {
            /** @noinspection PhpIncludeInspection */
            include($filePHP); // will populate $info automatically
            if(!is_array($info) || !count($info)) $this->error("Invalid PHP module info file for $moduleName"); 
            
        } else if(file_exists($fileJSON)) {
            $info = file_get_contents($fileJSON);
            $info = json_decode($info, true);
            if(!$info) {
                $info = array();
                $this->error("Invalid JSON module info file for $moduleName");
            }
        } 
        
        return $info; 
    }

    /**
     * Retrieve module info from internal getModuleInfo function in the class
     * 
     * @param Module|string $module
     * @param string $namespace
     * @return array
     * 
     */
    protected function getModuleInfoInternal($module, $namespace = '') {
        // if($this->debug) $this->message("getModuleInfoInternal($module)"); 
        
        $info = array();
        
        if($module instanceof ModulePlaceholder) {
            $this->includeModule($module); 
            $module = $module->className();
        }
        
        if($module instanceof Module) {
            if(method_exists($module, 'getModuleInfo')) {
                $info = $module::getModuleInfo(); 
            }
            
        } else if($module) {
            if(empty($namespace)) $namespace = $this->getModuleNamespace($module);
            $className = wireClassName($namespace . $module, true); 
            if(!class_exists($className)) $this->includeModule($module);
            if(is_callable("$className::getModuleInfo")) {
                $info = call_user_func(array($className, 'getModuleInfo'));
            }
        }
        
        return $info; 
    }
    
    /**
     * Pull module info directly from the module file's getModuleInfo without letting PHP parse it
     * 
     * Useful for getting module info from modules that extend another module not already on the file system.
     *
     * @param $className
     * @return array Only includes module info specified in the module file itself.
     *
    protected function getModuleInfoInternalSafe($className) {
        // future addition
        // load file, preg_split by /^\s*(public|private|protected)[^;{]+function\s*([^)]*)[^{]*{/
        // isolate the one that starts has getModuleInfo in matches[1]
        // parse data from matches[2]
        return array();
    }
     */

    /**
     * Retrieve module info for system properties: PHP or ProcessWire
     * 
     * @param $moduleName
     * @return array
     * 
     */
    protected function getModuleInfoSystem($moduleName) {

        $info = array();
        if($moduleName === 'PHP') {
            $info['id'] = 0; 
            $info['name'] = $moduleName;
            $info['title'] = $moduleName;
            $info['version'] = PHP_VERSION;
            return $info;

        } else if($moduleName === 'ProcessWire') {
            $info['id'] = 0; 
            $info['name'] = $moduleName;
            $info['title'] = $moduleName;
            $info['version'] = $this->wire('config')->version;
            $info['namespace'] = strlen(__NAMESPACE__) ? "\\" . __NAMESPACE__ . "\\" : "";
            $info['requiresVersions'] = array(
                'PHP' => array('>=', '5.3.8'),
                'PHP_modules' => array('=', 'PDO,mysqli'),
                'Apache_modules' => array('=', 'mod_rewrite'),
                'MySQL' => array('>=', '5.0.15'),
            );
            $info['requires'] = array_keys($info['requiresVersions']);
        } else {
            return array();
        }
        
        $info['versionStr'] = $info['version'];
        
        return $info;

    }

    /**
     * Returns an associative array of information for a Module
     * 
     * The array returned by this method includes the following: 
     * 
     *  - `id` (int): module database ID.
     *  - `name` (string): module class name.
     *  - `title` (string): module title.
     *  - `version` (int): module version.
     *  - `icon` (string): Optional icon name (excluding the "fa-") part.
     *  - `requires` (array): module names required by this module.
     *  - `requiresVersions` (array): required module versions–module name is key, value is array($operator, $version).
     *  - `installs` (array): module names that this module installs.
     *  - `permission` (string): permission name required to execute this module.
     *  - `autoload` (bool): true if module is autoload, false if not.
     *  - `singular` (bool): true if module is singular, false if not.
     *  - `created` (int): unix-timestamp of date/time module added to system (for uninstalled modules, it is the file date).
     *  - `installed` (bool): is the module currently installed? (boolean, or null when not determined)
     *  - `configurable` (bool|int): true or positive number when the module is configurable.
     *  - `namespace` (string): PHP namespace that module lives in.
     *
     * The following properties are also included when "verbose" mode is requested. When not in verbose mode, these 
     * properties are present but blank:
     *
     *  - `versionStr` (string): formatted module version string.
     *  - `file` (string): module filename from PW installation root, or false when it can't be found.
     *  - `core` (bool): true when module is a core module, false when not.
     *  - `author` (string): module author, when specified.
     *  - `summary` (string): summary of what this module does.
     *  - `href` (string): URL to module details (when specified).
     *  - `permissions` (array): permissions installed by this module, associative array ('permission-name' => 'Description').
     *  - `page` (array): definition of page to create for Process module (see Process class)
     *
     * The following properties appear only for "Process" modules, and only if specified by module. 
     * See the Process class for more details:
     *
     *  - `nav` (array): navigation definition
     *  - `useNavJSON` (bool): whether the Process module provides JSON navigation
     *  - `permissionMethod` (string|callable): method to call to determine permission
     *  - `page` (array): definition of page to create for Process module
     *
     * On error, an `error` index in returned array contains error message. You can also identify errors 
     * such as a non-existing module by the returned module info having an `id` index of `0`
     * 
     * ~~~~~
     * // example of getting module info
     * $moduleInfo = $modules->getModuleInfo('InputfieldCKEditor'); 
     * 
     * // example of getting verbose module info
     * $moduleInfo = $modules->getModuleInfoVerbose('MarkupAdminDataTable');
     * ~~~~~
     * 
     * @param string|Module|int $class Specify one of the following:
     *  - Module object instance 
     *  - Module class name (string)
     *  - Module ID (int)
     *  - To get info for ALL modules, specify `*` or `all`.
     *  - To get system information, specify `ProcessWire` or `PHP`.
     *  - To get a blank module info template, specify `info`.
     * @param array $options Optional options to modify behavior of what gets returned
     *  - `verbose` (bool): Makes the info also include verbose properties, which are otherwise blank. (default=false)
     *  - `minify` (bool): Remove non-applicable and properties that match defaults? (default=false, or true when getting `all`)
     *  - `noCache` (bool): prevents use of cache to retrieve the module info. (default=false)
     * @return array Associative array of module information. 
     *  - On error, an `error` index is also populated with an error message. 
     *  - When requesting a module that does not exist its `id` value will be `0` and its `name` will be blank.
     * @see Modules::getModuleInfoVerbose()
     * @todo move all getModuleInfo methods to their own ModuleInfo class and break this method down further.
     *  
     */
    public function getModuleInfo($class, array $options = array()) {
        
        $getAll = $class === '*' || $class === 'all';
        $getSystem = $class === 'ProcessWire' || $class === 'PHP' || $class === 'info';
        
        $defaults = array(
            'verbose' => false,
            'minify' => $getAll,
            'noCache' => false, 
            'noInclude' => false,
        );
        
        $options = array_merge($defaults, $options);
        $info = array();
        $module = $class;
        $moduleName = '';
        $moduleID = 0;
        $fromCache = false;  // was the data loaded from cache?
    
        if(!$getAll && !$getSystem) {
            $moduleName = $this->getModuleClass($module);
            $moduleID = (string) $this->getModuleID($module); // typecast to string for cache
        }
        
        static $infoTemplate = array(
            // module database ID
            'id' => 0, 
            // module class name 
            'name' => '',
            // module title
            'title' => '',
            // module version
            'version' => 0,
            // module version (always formatted string)
            'versionStr' => '0.0.0', 
            // who authored the module? (included in 'verbose' mode only)
            'author' => '',
            // summary of what this module does (included in 'verbose' mode only)
            'summary' => '',
            // URL to module details (included in 'verbose' mode only)
            'href' => '',
            // Optional name of icon representing this module (currently font-awesome icon names, excluding the "fa-" portion)
            'icon' => '', 
            // this method converts this to array of module names, regardless of how the module specifies it
            'requires' => array(),
            // module name is key, value is array($operator, $version). Note 'requiresVersions' index is created by this function.
            'requiresVersions' => array(),
            // array of module class names
            'installs' => array(),
            // permission required to execute this module
            'permission' => '',
            // permissions automatically installed/uninstalled with this module. array of ('permission-name' => 'Description')
            'permissions' => array(),
            // true if module is autoload, false if not. null=unknown
            'autoload' => null,
            // true if module is singular, false if not. null=unknown
            'singular' => null,
            // unix-timestamp date/time module added to system (for uninstalled modules, it is the file date)
            'created' => 0, 
            // is the module currently installed? (boolean, or null when not determined)
            'installed' => null,
            // this is set to true when the module is configurable, false when it's not, and null when it's not determined
            'configurable' => null,
            // verbose mode only: true when module implements SearchableModule interface, or null|false when not
            'searchable' => null, 
            // namespace that module lives in (string)
            'namespace' => null,
            // verbose mode only: this is set to the module filename (from PW installation root), false when it can't be found, null when it hasn't been determined
            'file' => null, 
            // verbose mode only: this is set to true when the module is a core module, false when it's not, and null when it's not determined
            'core' => null,
            // verbose mode only: any translations supplied with the module
            // 'languages' => null,
            
            // other properties that may be present, but are optional, for Process modules:
            // 'nav' => array(), // navigation definition: see Process.php
            // 'useNavJSON' => bool, // whether the Process module provides JSON navigation
            // 'page' => array(), // page to create for Process module: see Process.php
            // 'permissionMethod' => string or callable // method to call to determine permission: see Process.php
            );
        
        if($getAll) {
            if(empty($this->moduleInfoCache)) $this->loadModuleInfoCache();
            $modulesInfo = $this->moduleInfoCache;
            if($options['verbose']) {
                if(empty($this->moduleInfoCacheVerbose)) $this->loadModuleInfoCacheVerbose();
                foreach($this->moduleInfoCacheVerbose as $moduleID => $moduleInfoVerbose) {
                    $modulesInfo[$moduleID] = array_merge($modulesInfo[$moduleID], $moduleInfoVerbose);
                }
            }
            if(!$options['minify']) {
                foreach($modulesInfo as $moduleID => $info) {
                    $modulesInfo[$moduleID] = array_merge($infoTemplate, $info); 
                }
            }
            return $modulesInfo;

        } else if($getSystem) {
            // module is a system 
            if($class === 'info') return $infoTemplate;
            $info = $this->getModuleInfoSystem($module);
            return $options['minify'] ? $info : array_merge($infoTemplate, $info);

        } else if($module instanceof Module) {
            // module is an instance
            // $moduleName = method_exists($module, 'className') ? $module->className() : get_class($module); 
            // return from cache if available
            
            if(empty($options['noCache']) && !empty($this->moduleInfoCache[$moduleID])) {
                $info = $this->moduleInfoCache[$moduleID]; 
                $fromCache = true; 
            } else {
                $info = $this->getModuleInfoExternal($moduleName); 
                if(!count($info)) $info = $this->getModuleInfoInternal($module); 
            }
            
        } else {
            
            // module is a class name or ID
            if(ctype_digit("$module")) $module = $moduleName;
            
            // return from cache if available (as it almost always should be)
            if(empty($options['noCache']) && !empty($this->moduleInfoCache[$moduleID])) {
                $info = $this->moduleInfoCache[$moduleID];
                $fromCache = true; 
                
            } else if(empty($options['noCache']) && $moduleID == 0) {
                // uninstalled module
                if(!count($this->moduleInfoCacheUninstalled)) $this->loadModuleInfoCacheVerbose(true);
                if(isset($this->moduleInfoCacheUninstalled[$moduleName])) {
                    $info = $this->moduleInfoCacheUninstalled[$moduleName];
                    $fromCache = true; 
                }
            }
            
            if(!$fromCache) { 
                $namespace = $this->getModuleNamespace($moduleName); 
                if(class_exists($namespace . $moduleName, false)) {
                    // module is already in memory, check external first, then internal
                    $info = $this->getModuleInfoExternal($moduleName);
                    if(!count($info)) $info = $this->getModuleInfoInternal($moduleName, $namespace);
                    
                } else {
                    // module is not in memory, check external first, then internal
                    $info = $this->getModuleInfoExternal($moduleName);
                    if(!count($info)) {
                        if(isset($this->installable[$moduleName])) $this->includeModuleFile($this->installable[$moduleName], $moduleName);
                        // info not available externally, attempt to locate it interally
                        $info = $this->getModuleInfoInternal($moduleName, $namespace);
                    }
                }
            }
        }
        
        if(!$fromCache && !count($info)) {
            $info = $infoTemplate; 
            $info['title'] = $module;
            $info['summary'] = 'Inactive';
            $info['error'] = 'Unable to locate module';
            return $info;
        }
        
        if(!$options['minify']) $info = array_merge($infoTemplate, $info); 
        $info['id'] = (int) $moduleID;

        if($fromCache) {
            // since cache is loaded at init(), this is the most common scenario

            if($options['verbose']) { 
                if(empty($this->moduleInfoCacheVerbose)) $this->loadModuleInfoCacheVerbose();
                if(!empty($this->moduleInfoCacheVerbose[$moduleID])) {
                    $info = array_merge($info, $this->moduleInfoCacheVerbose[$moduleID]); 
                }
            }
        
            // populate defaults for properties omitted from cache 
            if(is_null($info['autoload'])) $info['autoload'] = false;
            if(is_null($info['singular'])) $info['singular'] = false;
            if(is_null($info['configurable'])) $info['configurable'] = false;
            if(is_null($info['core'])) $info['core'] = false;
            if(is_null($info['installed'])) $info['installed'] = true;
            if(is_null($info['namespace'])) $info['namespace'] = strlen(__NAMESPACE__) ? "\\" . __NAMESPACE__ . "\\" : "";
            if(!empty($info['requiresVersions'])) $info['requires'] = array_keys($info['requiresVersions']);
            if($moduleName == 'SystemUpdater') $info['configurable'] = 1; // fallback, just in case
            
            // we skip everything else when module comes from cache since we can safely assume the checks below 
            // are already accounted for in the cached module info
        
        } else {
            // not from cache, only likely to occur when refreshing modules info caches

            // if $info[requires] isn't already an array, make it one
            if(!is_array($info['requires'])) {
                $info['requires'] = str_replace(' ', '', $info['requires']); // remove whitespace
                if(strpos($info['requires'], ',') !== false) {
                    $info['requires'] = explode(',', $info['requires']);
                } else {
                    $info['requires'] = array($info['requires']);
                }
            }
    
            // populate requiresVersions
            foreach($info['requires'] as $key => $class) {
                if(!ctype_alnum($class)) {
                    // has a version string
                    list($class, $operator, $version) = $this->extractModuleOperatorVersion($class); 
                    $info['requires'][$key] = $class; // convert to just class
                } else {
                    // no version string
                    $operator = '>=';
                    $version = 0; 
                }
                $info['requiresVersions'][$class] = array($operator, $version); 
            }

            // what does it install?
            // if $info[installs] isn't already an array, make it one
            if(!is_array($info['installs'])) {
                $info['installs'] = str_replace(' ', '', $info['installs']); // remove whitespace
                if(strpos($info['installs'], ',') !== false) {
                    $info['installs'] = explode(',', $info['installs']);
                } else {
                    $info['installs'] = array($info['installs']);
                }
            }

            // misc
            if($options['verbose']) $info['versionStr'] = $this->formatVersion($info['version']); // versionStr
            $info['name'] = $moduleName; // module name

            // module configurable?
            $configurable = $this->isConfigurable($moduleName, false);
            if($configurable === true || is_int($configurable) && $configurable > 1) {
                // configurable via ConfigurableModule interface
                // true=static, 2=non-static, 3=non-static $data, 4=non-static wrap,
                // 19=non-static getModuleConfigArray, 20=static getModuleConfigArray
                $info['configurable'] = $configurable; 
            } else if($configurable) {
                // configurable via external file: ModuleName.config.php or ModuleNameConfig.php file
                $info['configurable'] = basename($configurable); 
            } else {
                // not configurable
                $info['configurable'] = false;
            }
            
            // created date
            if(isset($this->createdDates[$moduleID])) $info['created'] = strtotime($this->createdDates[$moduleID]);
            $info['installed'] = isset($this->installable[$moduleName]) ? false : true;
            if(!$info['installed'] && !$info['created'] && isset($this->installable[$moduleName])) {
                // uninstalled modules get their created date from the file or dir that they are in (whichever is newer)
                $pathname = $this->installable[$moduleName];
                $filemtime = (int) filemtime($pathname);
                $dirname = dirname($pathname);
                $dirmtime = substr($dirname, -7) == 'modules' || strpos($dirname, $this->paths[0]) !== false ? 0 : (int) filemtime($dirname);
                $info['created'] = $dirmtime > $filemtime ? $dirmtime : $filemtime;
            }
            
            // namespace
            if($info['core']) {
                // default namespace, assumed since all core modules are in default namespace
                $info['namespace'] = strlen(__NAMESPACE__) ? "\\" . __NAMESPACE__ . "\\" : ""; 
            } else {
                $info['namespace'] = $this->getModuleNamespace($moduleName, array(
                    'file' => $info['file'],
                    'noCache' => $options['noCache']
                ));
            }
            
            if(!$options['verbose']) foreach($this->moduleInfoVerboseKeys as $key) unset($info[$key]); 
        } 
        
        if(is_null($info['namespace'])) {
            $info['namespace'] = strlen(__NAMESPACE__) ? "\\" . __NAMESPACE__ . "\\" : "";
        }
        
        if(empty($info['created']) && isset($this->createdDates[$moduleID])) {
            $info['created'] = strtotime($this->createdDates[$moduleID]);
        }
        
        if($options['verbose']) {
            // the file property is not stored in the verbose cache, but provided as a verbose key
            $info['file'] = $this->getModuleFile($moduleName);
            if($info['file']) $info['core'] = strpos($info['file'], $this->coreModulesDir) !== false; // is it core?
        } else {
            // module info may still contain verbose keys with undefined values 
        }
        
        if($options['minify']) {
            // when minify, any values that match defaults from infoTemplate are removed
            if(!$options['verbose']) foreach($this->moduleInfoVerboseKeys as $key) unset($info[$key]); 
            foreach($info as $key => $value) {
                if(!array_key_exists($key, $infoTemplate)) continue;
                if($value !== $infoTemplate[$key]) continue;
                unset($info[$key]); 
            }
        }
        
        // if($this->debug) $this->message("getModuleInfo($moduleName) " . ($fromCache ? "CACHE" : "NO-CACHE")); 
        
        return $info;
    }

    /**
     * Returns a verbose array of information for a Module
     * 
     * This is the same as what’s returned by `Modules::getModuleInfo()` except that it has the following additional properties:
     * 
     *  - `versionStr` (string): formatted module version string.
     *  - `file` (string): module filename from PW installation root, or false when it can't be found.
     *  - `core` (bool): true when module is a core module, false when not.
     *  - `author` (string): module author, when specified.
     *  - `summary` (string): summary of what this module does.
     *  - `href` (string): URL to module details (when specified).
     *  - `permissions` (array): permissions installed by this module, associative array ('permission  - name' => 'Description').
     *  - `page` (array): definition of page to create for Process module (see Process class)
     *
     * @param string|Module|int $class May be class name, module instance, or module ID
     * @param array $options Optional options to modify behavior of what gets returned:
     *  - `noCache` (bool): prevents use of cache to retrieve the module info
     *  - `noInclude` (bool): prevents include() of the module file, applicable only if it hasn't already been included
     * @return array Associative array of module information
     * @see Modules::getModuleInfo()
     *
     */
    public function getModuleInfoVerbose($class, array $options = array()) {
        $options['verbose'] = true; 
        $info = $this->getModuleInfo($class, $options); 
        return $info;
    }

    /**
     * Get just a single property of module info
     * 
     * @param Module|string $class Module instance or module name
     * @param string $property Name of property to get
     * @param array $options Additional options (see getModuleInfo method for options)
     * @return mixed|null Returns value of property or null if not found
     * @since 3.0.107
     * 
     */
    public function getModuleInfoProperty($class, $property, array $options = array()) {
        if(in_array($property, $this->moduleInfoVerboseKeys)) {
            $info = $this->getModuleInfoVerbose($class, $options);
            $info['verbose'] = true;
        } else {
            $info = $this->getModuleInfo($class, $options);
        }
        if(!isset($info[$property]) && empty($info['verbose'])) {
            // try again, just in case we can find it in verbose data
            $info = $this->getModuleInfoVerbose($class, $options);
        }
        return isset($info[$property]) ? $info[$property] : null;
    }

    /**
     * Get an array of all unique, non-default, non-root module namespaces mapped to directory names
     * 
     * #pw-internal
     * 
     * @return array
     * 
     */
    public function getNamespaces() {
        if(!is_null($this->moduleNamespaceCache)) return $this->moduleNamespaceCache;
        $defaultNamespace = strlen(__NAMESPACE__) ? "\\" . __NAMESPACE__ . "\\" : "";
        $namespaces = array();
        foreach($this->moduleInfoCache as $moduleID => $info) {
            if(!isset($info['namespace']) || $info['namespace'] === $defaultNamespace || $info['namespace'] === "\\") continue;
            $moduleName = $info['name'];
            $namespaces[$info['namespace']] = $this->wire('config')->paths->$moduleName;
        }
        $this->moduleNamespaceCache = $namespaces; 
        return $namespaces; 
    }

    /**
     * Get the namespace for the given module
     * 
     * #pw-internal
     * 
     * @param string|Module $moduleName
     * @param array $options
     *  - `file` (string): Known module path/file, as an optimization.
     *  - `noCache` (bool): Specify true to force reload namespace info directly from module file. (default=false)
     *  - `noLoad` (bool): Specify true to prevent loading of file for namespace discovery. (default=false) Added 3.0.170
     * @return null|string Returns namespace, or NULL if unable to determine. Namespace is ready to use in a string (i.e. has trailing slashes)
     * 
     */
    public function getModuleNamespace($moduleName, $options = array()) {
        
        $defaults = array(
            'file' => null,
            'noLoad' => false, 
            'noCache' => false,
        );
        
        $namespace = null;
        $options = array_merge($defaults, $options);
    
        if(is_object($moduleName) || strpos($moduleName, "\\") !== false) {
            $className = is_object($moduleName) ? get_class($moduleName) : $moduleName; 
            $parts = explode("\\", $className);
            array_pop($parts);
            $namespace = count($parts) ? implode("\\", $parts) : "";
            $namespace = $namespace == "" ? "\\" : "\\$namespace\\";
            return $namespace;
        }
        
        if(empty($options['noCache'])) {
            $moduleID = $this->getModuleID($moduleName);
            $info = isset($this->moduleInfoCache[$moduleID]) ? $this->moduleInfoCache[$moduleID] : null;
            if($info && isset($info['namespace'])) {
                return $info['namespace'];
            }
        }
        
        if(empty($options['file'])) {
            $options['file'] = $this->getModuleFile($moduleName);
        }
        
        if(strpos($options['file'], $this->coreModulesDir) !== false) {
            // all core modules use \ProcessWire\ namespace
            $namespace = strlen(__NAMESPACE__) ? __NAMESPACE__ . "\\" : "";
            return $namespace;
        }
        
        if(!$options['file'] || !file_exists($options['file'])) {
            return null;
        }

        if(empty($options['noLoad'])) {
            $namespace = $this->getFileNamespace($options['file']);
        }
            
        return $namespace;
    }

    /**
     * Get the namespace used in the given .php or .module file
     * 
     * #pw-internal
     * 
     * @param string $file
     * @return string Includes leading and trailing backslashes where applicable
     * 
     */
    public function getFileNamespace($file) {
        $namespace = $this->wire()->files->getNamespace($file); 
        if($namespace !== "\\") $namespace = "\\" . trim($namespace, "\\") . "\\";
        return $namespace; 
    }

    /**
     * Get the class defined in the file (or optionally the 'extends' or 'implements')
     * 
     * #pw-internal
     * 
     * @param string $file
     * @return array Returns array with these indexes:
     *  'class' => string (class without namespace)
     *  'className' => string (class with namespace)
     *  'extends' => string
     *  'namespace' => string
     *  'implements' => array
     * 
     */
    public function getFileClassInfo($file) {
        
        $value = array(
            'class' => '',
            'className' => '',
            'extends' => '',
            'namespace' => '',
            'implements' => array()
        );
        
        if(!is_file($file)) return $value;
        $data = file_get_contents($file);
        if(!strpos($data, 'class')) return $value;
        if(!preg_match('/^\s*class\s+(.+)$/m', $data, $matches)) return $value;
    
        if(strpos($matches[1], "\t") !== false) $matches[1] = str_replace("\t", " ", $matches[1]);
        $parts = explode(' ', trim($matches[1]));
        
        foreach($parts as $key => $part) {
            if(empty($part)) unset($parts[$key]);
        }
        
        $className = array_shift($parts);   
        if(strpos($className, '\\') !== false) {
            $className = trim($className, '\\');
            $a = explode('\\', $className);
            $value['className'] = "\\$className\\";
            $value['class'] = array_pop($a);
            $value['namespace'] = '\\' . implode('\\', $a) . '\\';
        } else {
            $value['className'] = '\\' . $className;
            $value['class'] = $className;
            $value['namespace'] = '\\';
        }
    
        while(count($parts)) {
            $next = array_shift($parts);
            if($next == 'extends') {
                $value['extends'] = array_shift($parts);
            } else if($next == 'implements') {
                $implements = array_shift($parts);
                if(strlen($implements)) {
                    $implements = str_replace(' ', '', $implements);
                    $value['implements'] = explode(',', $implements);
                }
            }
        }
        
        return $value; 
    }

    /**
     * Alias of getConfig() for backwards compatibility
     * 
     * #pw-internal
     * 
     * @param string|Module $className
     * @return array
     * 
     */
    public function getModuleConfigData($className) {
        return $this->getConfig($className);
    }

    /**
     * Return the URL where the module can be edited, configured or uninstalled
     * 
     * If module is not installed, it just returns the URL to ProcessModule.
     * 
     * #pw-group-configuration
     * 
     * @param string|Module $className
     * @param bool $collapseInfo
     * @return string
     * 
     */
    public function getModuleEditUrl($className, $collapseInfo = true) {
        if(!is_string($className)) $className = $this->getModuleClass($className);
        $url = $this->wire('config')->urls->admin . 'module/';
        if(empty($className) || !$this->isInstalled($className)) return $url;
        $url .= "edit/?name=$className";
        if($collapseInfo) $url .= "&collapse_info=1";
        return $url;
    }
    
    /**
     * Given a module name, return an associative array of configuration data for it
     * 
     * - Applicable only for modules that support configuration.
     * - Configuration data is stored encoded in the database "modules" table "data" field.
     * 
     * ~~~~~~
     * // Getting, modifying and saving module config data
     * $data = $modules->getConfig('HelloWorld');
     * $data['greeting'] = 'Hello World! How are you today?';
     * $modules->saveConfig('HelloWorld', $data);
     * 
     * // Getting just one property 'apiKey' from module config data
     * @apiKey = $modules->getConfig('HelloWorld', 'apiKey'); 
     * ~~~~~~
     *
     * #pw-group-configuration
     * #pw-changelog 3.0.16 Changed from more verbose name `getModuleConfigData()`, which can still be used. 
     * 
     * @param string|Module $class
     * @param string $property Optionally just get value for a specific property (omit to get all config)
     * @return array|string|int|float Module configuration data, returns array unless a specific $property was requested
     * @see Modules::saveConfig() 
     * @since 3.0.16 Use method getModuleConfigData() with same arguments for prior versions (can also be used on any version).
     *
     */
    public function getConfig($class, $property = '') {

        $emptyReturn = $property ? null : array();
        $className = $class;
        if(is_object($className)) $className = wireClassName($className->className(), false);
        if(!isset($this->moduleIDs[$className])) return $emptyReturn;
        $id = $this->moduleIDs[$className];
        if(!$id) return $emptyReturn;
        if(!isset($this->configData[$id])) return $emptyReturn; // module has no config data
        
        if(is_array($this->configData[$id])) {
            $data = $this->configData[$id];
        } else {
            $configable = $this->isConfigable($className);
            if(!$configable) return $emptyReturn;
            $database = $this->wire()->database;
            $query = $database->prepare("SELECT data FROM modules WHERE id=:id", "modules.getConfig($className)"); // QA
            $query->bindValue(":id", (int) $id, \PDO::PARAM_INT);
            $query->execute();
            $data = $query->fetchColumn();
            $query->closeCursor();
            if(strlen($data)) $data = wireDecodeJSON($data);
            if(empty($data)) $data = array();
            $this->configData[$id] = $data;
        }
        
        if($property) return isset($data[$property]) ? $data[$property] : null;

        return $data;   
    }
    
    /**
     * Get the path + filename (or optionally URL) for this module
     * 
     * @param string|Module $class Module class name or object instance
     * @param array|bool $options Options to modify default behavior:
     *  - `getURL` (bool): Specify true if you want to get the URL rather than file path (default=false). 
     *  - `fast` (bool): Specify true to omit file_exists() checks (default=false). 
     *  - `guess` (bool): Manufacture/guess a module location if one cannot be found (default=false) 3.0.170+
     *  - Note: If you specify a boolean for the $options argument, it is assumed to be the $getURL property.
     * @return bool|string Returns string of module file, or false on failure. 
     * 
     */
    public function getModuleFile($class, $options = array()) {

        $config = $this->wire()->config;
        $className = $class;
        if(is_bool($options)) $options = array('getURL' => $options);
        if(!isset($options['getURL'])) $options['getURL'] = false;
        if(!isset($options['fast'])) $options['fast'] = false;
        
        $file = false;
    
        // first see it's an object, and if we can get the file from the object
        if(is_object($className)) {
            $module = $className; 
            if($module instanceof ModulePlaceholder) $file = $module->file; 
            $moduleName = $module->className();
            $className = $module->className(true);
        } else {
            $moduleName = wireClassName($className, false);
        }
        
        $hasDuplicate = $this->duplicates()->hasDuplicate($moduleName);
        
        if(!$hasDuplicate) {
            // see if we can determine it from already stored paths
            $path = $config->paths->$moduleName;
            if($path) {
                $file = $path . $moduleName . ($this->moduleFileExts[$moduleName] === 2 ? '.module.php' : '.module');
                if(!$options['fast'] && !file_exists($file)) $file = false;
            }
        }

        // next see if we've already got the module filename cached locally
        if(!$file && isset($this->installable[$moduleName]) && !$hasDuplicate) {
            $file = $this->installable[$moduleName];
            if(!$options['fast'] && !file_exists($file)) $file = false;
        } 
        
        if(!$file) {
            $dupFile = $this->duplicates()->getCurrent($moduleName);
            if($dupFile) {
                $rootPath = $config->paths->root;
                $file = rtrim($rootPath, '/') . $dupFile;
                if(!file_exists($file)) {
                    // module in use may have been deleted, find the next available one that exists
                    $file = '';
                    $dups = $this->duplicates()->getDuplicates($moduleName); 
                    foreach($dups['files'] as $pathname) {
                        $pathname = rtrim($rootPath, '/') . $pathname;
                        if(file_exists($pathname)) $file = $pathname;
                        if($file) break;
                    }
                }
            }
        }
        
        if(!$file) {
            // see if it's a predefined core type that can be determined from the type
            // this should only come into play if module has moved or had a load error
            foreach($this->coreTypes as $typeName) {
                if(strpos($moduleName, $typeName) !== 0) continue;
                $checkFiles = array(
                    "$typeName/$moduleName/$moduleName.module",
                    "$typeName/$moduleName/$moduleName.module.php",
                    "$typeName/$moduleName.module",
                    "$typeName/$moduleName.module.php",
                );
                $path1 = $config->paths->modules;
                foreach($checkFiles as $checkFile) {
                    $file1 = $path1 . $checkFile;
                    if(file_exists($file1)) $file = $file1;
                    if($file) break;
                }
                if($file) break;
            }
            if(!$file) {
                // check site modules
                $checkFiles = array(
                    "$moduleName/$moduleName.module",
                    "$moduleName/$moduleName.module.php",
                    "$moduleName.module",
                    "$moduleName.module.php",
                );
                $path1 = $config->paths->siteModules;
                foreach($checkFiles as $checkFile) {
                    $file1 = $path1 . $checkFile;
                    if(file_exists($file1)) $file = $file1;
                    if($file) break;
                }
            }
        }

        if(!$file) {
            // if all the above failed, try to get it from Reflection
            try {
                // note we don't call getModuleClass() here because it may result in a circular reference
                if(strpos($className, "\\") === false) {
                    $moduleID = $this->getModuleID($moduleName);
                    if(!empty($this->moduleInfoCache[$moduleID]['namespace'])) {
                        $className = rtrim($this->moduleInfoCache[$moduleID]['namespace'], "\\") . "\\$moduleName";
                    } else {
                        $className = strlen(__NAMESPACE__) ? "\\" . __NAMESPACE__ . "\\$moduleName" : $moduleName;
                    }
                }
                $reflector = new \ReflectionClass($className);
                $file = $reflector->getFileName();
                
            } catch(\Exception $e) {
                $file = false;
            }
        }
        
        if(!$file && !empty($options['guess'])) {
            // make a guess about where module would be if we had been able to find it
            $file = $config->paths->siteModules . "$moduleName/$moduleName.module";
        }

        if($file) {
            if(DIRECTORY_SEPARATOR != '/') $file = str_replace(DIRECTORY_SEPARATOR, '/', $file);
            if($options['getURL']) $file = str_replace($config->paths->root, '/', $file);
        }

        return $file;
    }

    /**
     * Is the given module interactively configurable?
     * 
     * This method can be used to simply determine if a module is configurable (yes or no), or more specifically
     * how it is configurable. 
     * 
     * ~~~~~
     * // Determine IF a module is configurable
     * if($modules->isConfigurable('HelloWorld')) {
     *   // Module is configurable
     * } else {
     *   // Module is NOT configurable
     * }
     * ~~~~~
     * ~~~~~
     * // Determine HOW a module is configurable
     * $configurable = $module->isConfigurable('HelloWorld');
     * if($configurable === true) {
     *   // configurable in a way compatible with all past versions of ProcessWire
     * } else if(is_string($configurable)) {
     *   // configurable via an external configuration file
     *   // file is identifed in $configurable variable
     * } else if(is_int($configurable)) {
     *   // configurable via a method in the class
     *   // the $configurable variable contains a number with specifics
     * } else {
     *   // module is NOT configurable
     * }
     * ~~~~~
     * 
     * ### Return value details
     * 
     * #### If module is configurable via external configuration file:
     * 
     * - Returns string of full path/filename to `ModuleName.config.php` file 
     * 
     * #### If module is configurable because it implements a configurable module interface:
     * 
     * - Returns boolean `true` if module is configurable via the static `getModuleConfigInputfields()` method.
     *   This particular method is compatible with all past versions of ProcessWire. 
     * - Returns integer `2` if module is configurable via the non-static `getModuleConfigInputfields()` and requires no arguments.
     * - Returns integer `3` if module is configurable via the non-static `getModuleConfigInputfields()` and requires `$data` array.
     * - Returns integer `4` if module is configurable via the non-static `getModuleConfigInputfields()` and requires `InputfieldWrapper` argument.
     * - Returns integer `19` if module is configurable via non-static `getModuleConfigArray()` method.
     * - Returns integer `20` if module is configurable via static `getModuleConfigArray()` method.
     * 
     * #### If module is not configurable:
     * 
     * - Returns boolean `false` if not configurable
     * 
     * *This method is named isConfigurableModule() in ProcessWire versions prior to to 3.0.16.*
     * 
     * #pw-group-configuration
     * 
     * @param Module|string $class Module name
     * @param bool $useCache Use caching? This accepts a few options: 
     *  - Specify boolean `true` to allow use of cache when available (default behavior). 
     *  - Specify boolean `false` to disable retrieval of this property from getModuleInfo (forces a new check).
     *  - Specify string `interface` to check only if module implements ConfigurableModule interface. 
     *  - Specify string `file` to check only if module has a separate configuration class/file.
     * @return bool|string|int See details about return values in method description. 
     * @since 3.0.16
     * 
     * @todo all ConfigurableModule methods need to be split out into their own class (ConfigurableModules?)
     * @todo this method has two distinct parts (file and interface) that need to be split in two methods.
     * 
     */
    public function isConfigurable($class, $useCache = true) {

        $className = $class;
        $moduleInstance = null;
        $namespace = $this->getModuleNamespace($className);
        if(is_object($className)) {
            $moduleInstance = $className;
            $className = $this->getModuleClass($moduleInstance);
        }
        $nsClassName = $namespace . $className;
        
        if($useCache === true || $useCache === 1 || $useCache === "1") {
            $info = $this->getModuleInfo($className);
            // if regular module info doesn't have configurable info, attempt it from verbose module info
            // should only be necessary for transition period between the 'configurable' property being 
            // moved from verbose to non-verbose module info (i.e. this line can be deleted after PW 2.7)
            if($info['configurable'] === null) $info = $this->getModuleInfoVerbose($className);
            if(!$info['configurable']) {
                if($moduleInstance && $moduleInstance instanceof ConfigurableModule) {
                    // re-try because moduleInfo may be temporarily incorrect for this request because of change in moduleInfo format
                    // this is due to reports of ProcessChangelogHooks not getting config data temporarily between 2.6.11 => 2.6.12
                    $this->error(
                        "Configurable module check failed for $className. " . 
                        "If this error persists, please do a Modules > Refresh.", 
                        Notice::debug
                    );
                    $useCache = false; 
                } else {
                    return false;
                }
            } else {
                if($info['configurable'] === true) return $info['configurable'];
                if($info['configurable'] === 1 || $info['configurable'] === "1") return true;
                if(is_int($info['configurable']) || ctype_digit("$info[configurable]")) return (int) $info['configurable'];
                if(strpos($info['configurable'], $className) === 0) {
                    if(empty($info['file'])) $info['file'] = $this->getModuleFile($className);
                    if($info['file']) {
                        return dirname($info['file']) . "/$info[configurable]";
                    }
                }
            }
        }

        if($useCache !== "interface") {
            // check for separate module configuration file
            $dir = dirname($this->getModuleFile($className));
            if($dir) {
                $files = array(
                    "$dir/{$className}Config.php", 
                    "$dir/$className.config.php"
                ); 
                $found = false;
                foreach($files as $file) {
                    if(!is_file($file)) continue;
                    $config = null; // include file may override
                    $this->includeModuleFile($file, $className);
                    $classConfig = $nsClassName . 'Config';
                    if(class_exists($classConfig, false)) {
                        $parents = wireClassParents($classConfig, false);
                        if(is_array($parents) && in_array('ModuleConfig', $parents)) {
                            $found = $file;
                            break;
                        }
                    } else {
                        // bypass include_once, because we need to read $config every time
                        if(is_null($config)) {
                            $classInfo = $this->getFileClassInfo($file);
                            if($classInfo['class']) {
                                // not safe to include because this is not just a file with a $config array
                            } else {
                                $ns = $this->getFileNamespace($file);
                                $file = $this->compile($className, $file, $ns);
                                if($file) {
                                    /** @noinspection PhpIncludeInspection */
                                    include($file);
                                }
                            }
                        }
                        if(!is_null($config)) {
                            // included file specified a $config array
                            $found = $file;
                            break;
                        }
                    }
                }
                if($found) return $found;
            }
        }

        // if file-only check was requested and we reach this point, exit with false now
        if($useCache === "file") return false;
    
        // ConfigurableModule interface checks
        
        $result = false;
        
        foreach(array('getModuleConfigArray', 'getModuleConfigInputfields') as $method) {
            
            $configurable = false;
        
            // if we have a module instance, use that for our check
            if($moduleInstance && $moduleInstance instanceof ConfigurableModule) {
                if(method_exists($moduleInstance, $method)) {
                    $configurable = $method;
                } else if(method_exists($moduleInstance, "___$method")) {
                    $configurable = "___$method";
                }
            }

            // if we didn't have a module instance, load the file to find what we need to know
            if(!$configurable) {
                if(!wireClassExists($nsClassName, false)) {
                    $this->includeModule($className);
                }
                $interfaces = wireClassImplements($nsClassName, false);
                if(is_array($interfaces) && in_array('ConfigurableModule', $interfaces)) {
                    if(wireMethodExists($nsClassName, $method)) {
                        $configurable = $method;
                    } else if(wireMethodExists($nsClassName, "___$method")) {
                        $configurable = "___$method";
                    }
                }
            }
            
            // if still not determined to be configurable, move on to next method
            if(!$configurable) continue;
            
            // now determine if static or non-static
            $ref = new \ReflectionMethod(wireClassName($nsClassName, true), $configurable);
            
            if($ref->isStatic()) {
                // config method is implemented as a static method
                if($method == 'getModuleConfigInputfields') {
                    // static getModuleConfigInputfields
                    $result = true;
                } else {
                    // static getModuleConfigArray
                    $result = 20; 
                }
                
            } else if($method == 'getModuleConfigInputfields') {
                // non-static getModuleConfigInputfields
                // we allow for different arguments, so determine what it needs
                $parameters = $ref->getParameters();
                if(count($parameters)) {
                    $param0 = reset($parameters);
                    if(strpos($param0, 'array') !== false || strpos($param0, '$data') !== false) {
                        // method requires a $data array (for compatibility with non-static version)
                        $result = 3;
                    } else if(strpos($param0, 'InputfieldWrapper') !== false || strpos($param0, 'inputfields') !== false) {
                        // method requires an empty InputfieldWrapper (as a convenience)
                        $result = 4;
                    }
                }
                // method requires no arguments
                if(!$result) $result = 2;
                
            } else {
                // non-static getModuleConfigArray
                $result = 19;
            }
        
            // if we make it here, we know we already have a result so can stop now
            break;
        }
        
        return $result;
    }
    

    /**
     * Indicates whether module accepts config settings, whether interactively or API only
     * 
     * - Returns false if module does not accept config settings. 
     * - Returns integer `30` if module accepts config settings but is not interactively configurable.
     * - Returns true, int or string if module is interactively configurable, see `Modules::isConfigurable()` return values.
     * 
     * @param string|Module $class
     * @param bool $useCache
     * @return bool|int|string
     * @since 3.0.179
     *
     */
    public function isConfigable($class, $useCache = true) {
        if(is_object($class)) {
            if($class instanceof ConfigModule) {
                $result = 30;
            } else {
                $result = $this->isConfigurable($class, $useCache);
            }
        } else {
            $result = $this->isConfigurable($class, $useCache);
            if(!$result && wireInstanceOf($class, 'ConfigModule')) $result = 30;
        }
        return $result;
    }

    /**
     * Alias of isConfigurable() for backwards compatibility
     * 
     * #pw-internal
     * 
     * @param $className
     * @param bool $useCache
     * @return mixed
     * 
     */
    public function isConfigurableModule($className, $useCache = true) {
        return $this->isConfigurable($className, $useCache); 
    }

    /**
     * Populate configuration data to a ConfigurableModule
     *
     * If the Module has a 'setConfigData' method, it will send the array of data to that. 
     * Otherwise it will populate the properties individually. 
     *
     * @param Module $module
     * @param array|null $data Configuration data [key=value], or omit/null if you want it to retrieve the config data for you.
     * @param array|null $extraData Additional runtime configuration data to merge (default=null) 3.0.169+
     * @return bool True if configured, false if not configurable
     * 
     */
    protected function setModuleConfigData(Module $module, $data = null, $extraData = null) {

        $configurable = $this->isConfigable($module); 
        if(!$configurable) return false;
        if(!is_array($data)) $data = $this->getConfig($module);
        if($extraData !== null && is_array($extraData)) $data = array_merge($data, $extraData);

        $nsClassName = $module->className(true);
        $moduleName = $module->className(false);
        
        if(is_string($configurable) && is_file($configurable) && strpos(basename($configurable), $moduleName) === 0) {
            // get defaults from ModuleConfig class if available
            $className = $nsClassName . 'Config';
            $config = null; // may be overridden by included file
            // $compile = strrpos($className, '\\') < 1 && $this->wire('config')->moduleCompile;
            $configFile = '';
            
            if(!class_exists($className, false)) {
                $configFile = $this->compile($className, $configurable); 
                // $configFile = $compile ? $this->wire('files')->compile($configurable) : $configurable;
                if($configFile) {
                    /** @noinspection PhpIncludeInspection */
                    include_once($configFile);
                }
            }
            
            if(wireClassExists($className)) {
                $parents = wireClassParents($className, false);
                if(is_array($parents) && in_array('ModuleConfig', $parents)) { 
                    $moduleConfig = $this->wire(new $className());
                    if($moduleConfig instanceof ModuleConfig) {
                        $defaults = $moduleConfig->getDefaults();
                        $data = array_merge($defaults, $data);
                    }
                }
            } else {
                // the file may have already been include_once before, so $config would not be set
                // so we try a regular include() next. 
                if(is_null($config)) {
                    if(!$configFile) {
                        $configFile = $this->compile($className, $configurable);
                        // $configFile = $compile ? $this->wire('files')->compile($configurable) : $configurable;
                    }
                    if($configFile) {
                        /** @noinspection PhpIncludeInspection */
                        include($configFile);
                    }
                }
                if(is_array($config)) {
                    // alternatively, file may just specify a $config array
                    $moduleConfig = $this->wire(new ModuleConfig());
                    $moduleConfig->add($config);
                    $defaults = $moduleConfig->getDefaults();
                    $data = array_merge($defaults, $data);
                }
            }
        }

        if(method_exists($module, 'setConfigData') || method_exists($module, '___setConfigData')) {
            /** @var _Module $module */
            $module->setConfigData($data); 
            return true;
        }

        foreach($data as $key => $value) {
            $module->$key = $value; 
        }
        
        return true; 
    }

    /**
     * Alias of saveConfig() for backwards compatibility
     * 
     * #pw-internal
     * 
     * @param $className
     * @param array $configData
     * @return mixed
     * 
     */
    public function ___saveModuleConfigData($className, array $configData) {
        return $this->saveConfig($className, $configData);
    }

    /**
     * Save provided configuration data for the given module
     * 
     * - Applicable only for modules that support configuration.
     * - Configuration data is stored encoded in the database "modules" table "data" field.
     * 
     * ~~~~~~
     * // Getting, modifying and saving module config data
     * $data = $modules->getConfig('HelloWorld');
     * $data['greeting'] = 'Hello World! How are you today?';
     * $modules->saveConfig('HelloWorld', $data);
     * ~~~~~~
     * 
     * #pw-group-configuration
     * #pw-group-manipulation
     * #pw-changelog 3.0.16 Changed name from the more verbose saveModuleConfigData(), which will still work.
     *
     * @param string|Module $class Module or module name
     * @param array|string $data Associative array of configuration data, or name of property you want to save.
     * @param mixed|null $value If you specified a property in previous arg, the value for the property.
     * @return bool True on success, false on failure
     * @throws WireException
     * @see Modules::getConfig()
     * @since 3.0.16 Use method saveModuleConfigData() with same arguments for prior versions (can also be used on any version).
     *
     */
    public function ___saveConfig($class, $data, $value = null) {
        $className = $class;
        if(is_object($className)) $className = $className->className();
        $moduleName = wireClassName($className, false);
        if(!$id = $this->moduleIDs[$moduleName]) throw new WireException("Unable to find ID for Module '$moduleName'");
        
        if(is_string($data)) {
            // a property and value have been provided
            $property = $data;  
            $data = $this->getConfig($class);
            if(is_null($value)) {
                // remove the property
                unset($data[$property]);
            } else {
                // populate the value for the property
                $data[$property] = $value;
            }
        } else {
            // data must be an associative array of configuration data
            if(!is_array($data)) return false;
        }

        // ensure original duplicates info is retained and validate that it is still current
        $data = $this->duplicates()->getDuplicatesConfigData($moduleName, $data); 
        
        $this->configData[$id] = $data; 
        $json = count($data) ? wireEncodeJSON($data, true) : '';
        $database = $this->wire('database');    
        $query = $database->prepare("UPDATE modules SET data=:data WHERE id=:id", "modules.saveConfig($moduleName)"); // QA
        $query->bindValue(":data", $json, \PDO::PARAM_STR);
        $query->bindValue(":id", (int) $id, \PDO::PARAM_INT); 
        $result = $query->execute();
        // $this->log("Saved module '$moduleName' config data");
        
        return $result;
    }

    /**
     * Get the Inputfields that configure the given module or return null if not configurable
     * 
     * #pw-internal
     * 
     * @param string|Module|int $moduleName
     * @param InputfieldWrapper|null $form Optionally specify the form you want Inputfields appended to.
     * @return InputfieldWrapper|null
     * 
     */
    public function ___getModuleConfigInputfields($moduleName, InputfieldWrapper $form = null) {
        
        $moduleName = $this->getModuleClass($moduleName);
        $configurable = $this->isConfigurable($moduleName);
        if(!$configurable) return null;
        
        if(is_null($form)) $form = $this->wire(new InputfieldWrapper());
        $data = $this->getConfig($moduleName);
        $fields = null;
        
        // check for configurable module interface
        $configurableInterface = $this->isConfigurable($moduleName, "interface");
        if($configurableInterface) {
            if(is_int($configurableInterface) && $configurableInterface > 1 && $configurableInterface < 20) {
                // non-static 
                /** @var ConfigurableModule|Module|_Module $module */
                if($configurableInterface === 2) {
                    // requires no arguments
                    $module = $this->getModule($moduleName);
                    $fields = $module->getModuleConfigInputfields();
                } else if($configurableInterface === 3) {
                    // requires $data array
                    $module = $this->getModule($moduleName, array('noInit' => true, 'noCache' => true));
                    $this->setModuleConfigData($module);
                    $fields = $module->getModuleConfigInputfields($data);
                } else if($configurableInterface === 4) {
                    // requires InputfieldWrapper
                    // we allow for option of no return statement in the method
                    $module = $this->getModule($moduleName);
                    $fields = $this->wire(new InputfieldWrapper());
                    $fields->setParent($form);
                    $_fields = $module->getModuleConfigInputfields($fields);
                    if($_fields instanceof InputfieldWrapper) $fields = $_fields;
                    unset($_fields);
                } else if($configurableInterface === 19) {
                    // non-static getModuleConfigArray method
                    $module = $this->getModule($moduleName);
                    $fields = $this->wire(new InputfieldWrapper());
                    $fields->importArray($module->getModuleConfigArray());
                    $fields->populateValues($module);
                }
            } else if($configurableInterface === 20) {
                // static getModuleConfigArray method
                $fields = $this->wire(new InputfieldWrapper());
                $fields->importArray(call_user_func(array(wireClassName($moduleName, true), 'getModuleConfigArray')));
                $fields->populateValues($data);
            } else if($configurableInterface) {
                // static getModuleConfigInputfields method
                $nsClassName = $this->getModuleNamespace($moduleName) . $moduleName;
                $fields = call_user_func(array($nsClassName, 'getModuleConfigInputfields'), $data);
            }
            if($fields instanceof InputfieldWrapper) {
                foreach($fields as $field) {
                    $form->append($field);
                }
            } else if($fields instanceof Inputfield) {
                $form->append($fields);
            } else {
                $this->error("$moduleName.getModuleConfigInputfields() did not return InputfieldWrapper");
            }
        }
        
        // check for file-based config
        $file = $this->isConfigurable($moduleName, "file");
        if(!$file || !is_string($file) || !is_file($file)) {
            // config is not file-based
        } else {
            // file-based config
            $config = null;
            $ns = $this->getModuleNamespace($moduleName);
            $configClass = $ns . $moduleName . "Config";
            if(!class_exists($configClass)) {
                $configFile = $this->compile($moduleName, $file, $ns);
                if($configFile) {
                    /** @noinspection PhpIncludeInspection */
                    include_once($configFile);
                }
            }
            $configModule = null;

            if(wireClassExists($configClass)) {
                // file contains a ModuleNameConfig class
                $configModule = $this->wire(new $configClass());

            } else {
                if(is_null($config)) {
                    $configFile = $this->compile($moduleName, $file, $ns);
                    // if(!$configFile) $configFile = $compile ? $this->wire('files')->compile($file) : $file;
                    if($configFile) {
                        /** @noinspection PhpIncludeInspection */
                        include($configFile); // in case of previous include_once 
                    }
                }
                if(is_array($config)) {
                    // file contains a $config array
                    $configModule = $this->wire(new ModuleConfig());
                    $configModule->add($config);
                }
            }

            if($configModule && $configModule instanceof ModuleConfig) {
                $defaults = $configModule->getDefaults();
                $data = array_merge($defaults, $data);
                $configModule->setArray($data);
                $fields = $configModule->getInputfields();
                if($fields instanceof InputfieldWrapper) {
                    foreach($fields as $field) {
                        $form->append($field);
                    }
                    foreach($data as $key => $value) {
                        $f = $form->getChildByName($key);
                        if(!$f) continue;
                        if($f instanceof InputfieldCheckbox && $value) {
                            $f->attr('checked', 'checked');
                        } else {
                            $f->attr('value', $value);
                        }
                    }
                } else {
                    $this->error("$configModule.getInputfields() did not return InputfieldWrapper");
                }
            }
        } // file-based config
        
        if($form) {
            // determine how many visible Inputfields there are in the module configuration
            // for assignment or removal of flagsNoUserConfig flag when applicable
            $numVisible = 0;
            foreach($form->getAll() as $inputfield) {
                if($inputfield instanceof InputfieldHidden || $inputfield instanceof InputfieldWrapper) continue;
                $numVisible++;
            }
            $flags = $this->getFlags($moduleName);
            if($numVisible) {
                if($flags & self::flagsNoUserConfig) {
                    $info = $this->getModuleInfoVerbose($moduleName);
                    if(empty($info['addFlag']) || !($info['addFlag'] & self::flagsNoUserConfig)) {
                        $this->setFlag($moduleName, self::flagsNoUserConfig, false); // remove flag
                    }
                }
            } else {
                if(!($flags & self::flagsNoUserConfig)) {
                    if(empty($info['removeFlag']) || !($info['removeFlag'] & self::flagsNoUserConfig)) {
                        $this->setFlag($moduleName, self::flagsNoUserConfig, true); // add flag
                    }
                }
            }
        }
        
        return $form;
    }
    

    /**
     * Is the given module Singular (single instance)?
     *
     * isSingular and isAutoload Module methods have been deprecated. So this method, and isAutoload() 
     * exist in part to enable singular and autoload properties to be set in getModuleInfo, rather than 
     * with methods. 
     *
     * Note that isSingular() and isAutoload() are not deprecated for ModulePlaceholder, so the Modules
     * class isn't going to stop looking for them. 
     * 
     * #pw-internal
     *
     * @param Module|string $module Module instance or class name
     * @return bool 
     *
     */
    public function isSingular($module) {
        $info = $this->getModuleInfo($module); 
        if(isset($info['singular']) && $info['singular'] !== null) return $info['singular'];
        if(is_object($module)) {
            if(method_exists($module, 'isSingular')) return $module->isSingular();
        } else {
            // singular status can't be determined if module not installed and not specified in moduleInfo
            if(isset($this->installable[$module])) return null;
            $this->includeModule($module); 
            $module = wireClassName($module, true);
            if(method_exists($module, 'isSingular')) {
                /** @var Module|_Module $moduleInstance */
                $moduleInstance = $this->wire(new $module());
                return $moduleInstance->isSingular();
            }
        }
        return false;
    }

    /**
     * Is the given module Autoload (automatically loaded at runtime)?
     * 
     * #pw-internal
     *
     * @param Module|string $module Module instance or class name
     * @return bool|string|null Returns string "conditional" if conditional autoload, true if autoload, or false if not. Or null if unavailable. 
     *
     */
    public function isAutoload($module) {
        
        $info = $this->getModuleInfo($module); 
        $autoload = null;
        
        if(isset($info['autoload']) && $info['autoload'] !== null) {
            // if autoload is a string (selector) or callable, then we flag it as autoload
            if(is_string($info['autoload']) || wireIsCallable($info['autoload'])) return "conditional"; 
            $autoload = $info['autoload'];
            
        } else if(!is_object($module)) {
            if(isset($this->installable[$module])) {
                // module is not installed
                // we are not going to be able to determine if this is autoload or not
                $flags = $this->getFlags($module); 
                if($flags !== null) {
                    $autoload = $flags & self::flagsAutoload;
                } else {
                    // unable to determine
                    return null;
                }
            } else {
                // include for method exists call
                $this->includeModule($module);
                $module = wireClassName($module, true);
                $module = $this->wire(new $module());
            }
        }
    
        if($autoload === null && is_object($module) && method_exists($module, 'isAutoload')) {
            /** @var module $module */
            $autoload = $module->isAutoload();
        }
    
        return $autoload; 
    }
    
    /**
     * Returns whether the modules have been initialized yet
     * 
     * #pw-internal
     *
     * @return bool
     *
     */
    public function isInitialized() {
        return $this->initialized; 
    }

    /**
     * Does the given module name resolve to a module in the system (installed or uninstalled)
     * 
     * If given module name also includes a namespace, then that namespace will be validated as well. 
     * 
     * #pw-internal
     * 
     * @param string|Module $moduleName With or without namespace
     * @return bool
     * 
     */
    public function isModule($moduleName) {
        
        if(!is_string($moduleName)) {
            if(is_object($moduleName)) {
                if($moduleName instanceof Module) return true;
                return false;
            }
            $moduleName = $this->getModuleClass($moduleName);
        }
        /** @var string $moduleName */
        
        if(strpos($moduleName, "\\") !== false) {
            $namespace = wireClassName($moduleName, 1);
            $moduleName = wireClassName($moduleName, false);
        } else {
            $namespace = false;
        }
        
        if(isset($this->moduleIDs[$moduleName])) {
            $isModule = true;
        } else if(isset($this->installable[$moduleName])) {
            $isModule = true;
        } else {
            $isModule = false;
        }
        
        if($isModule && $namespace) {
            $actualNamespace = $this->getModuleNamespace($moduleName);
            if(trim("$namespace", '\\') != trim("$actualNamespace", '\\')) {
                $isModule = false;
            }
        }
        
        return $isModule;
    }

    /**
     * Is the given namespace a unique recognized module namespace? If yes, returns the path to it. If not, returns boolean false.
     * 
     * #pw-internal
     * 
     * @param string $namespace
     * @return bool|string
     * 
     */
    public function getNamespacePath($namespace) {
        if(is_null($this->moduleNamespaceCache)) $this->getNamespaces();
        $namespace = "\\" . trim($namespace, "\\") . "\\";
        return isset($this->moduleNamespaceCache[$namespace]) ? $this->moduleNamespaceCache[$namespace] : false;    
    }
    
    /**
     * Refresh the modules cache
     * 
     * This forces the modules file and information cache to be re-created. 
     * 
     * #pw-group-manipulation
     * 
     * @param bool $showMessages Show notification messages about what was found? (default=false) 3.0.172+
     *
     */
    public function ___refresh($showMessages = false) {
        if($this->wire()->config->systemVersion < 6) return;
        $this->refreshing = true;
        $this->clearModuleInfoCache($showMessages);
        $this->loadModulesTable();
        foreach($this->paths as $path) $this->findModuleFiles($path, false); 
        foreach($this->paths as $path) $this->load($path);
        if($this->duplicates()->numNewDuplicates() > 0) $this->duplicates()->updateDuplicates(); // PR#1020
        $this->refreshing = false;
    }

    /**
     * Alias of refresh() method for backwards compatibility
     * 
     * #pw-internal
     * 
     */
    public function resetCache() {
        $this->refresh();
    }

    /**
     * Return an array of module class names that require the given one
     * 
     * #pw-internal
     * 
     * @param string $class
     * @param bool $uninstalled Set to true to include modules dependent upon this one, even if they aren't installed.
     * @param bool $installs Set to true to exclude modules that indicate their install/uninstall is controlled by $class.
     * @return array()
     *
     */
    public function getRequiredBy($class, $uninstalled = false, $installs = false) {

        $class = $this->getModuleClass($class); 
        $info = $this->getModuleInfo($class); 
        $dependents = array();

        foreach($this as $module) {
            $c = $this->getModuleClass($module);    
            if(!$uninstalled && !$this->isInstalled($c)) continue; 
            $i = $this->getModuleInfo($c); 
            if(!count($i['requires'])) continue; 
            if($installs && in_array($c, $info['installs'])) continue; 
            if(in_array($class, $i['requires'])) $dependents[] = $c; 
        }

        return $dependents; 
    }

    /**
     * Return an array of module class names required by the given one
     * 
     * Default behavior is to return all listed requirements, whether they are currently met by
     * the environment or not. Specify TRUE for the 2nd argument to return only requirements
     * that are not currently met. 
     * 
     * #pw-internal
     * 
     * @param string $class
     * @param bool $onlyMissing Set to true to return only required modules/versions that aren't 
     *  yet installed or don't have the right version. It excludes those that the class says it 
     *  will install (via 'installs' property of getModuleInfo)
     * @param null|bool $versions Set to true to always include versions in the returned requirements list. 
     *  Set to null to always exclude versions in requirements list (so only module class names will be there).
     *  Set to false (which is the default) to include versions only when version is the dependency issue.
     *  Note versions are already included when the installed version is not adequate.
     * @return array of strings each with ModuleName Operator Version, i.e. "ModuleName>=1.0.0"
     *
     */
    public function getRequires($class, $onlyMissing = false, $versions = false) {
        
        $class = $this->getModuleClass($class); 
        $info = $this->getModuleInfo($class); 
        $requires = $info['requires']; 
        $currentVersion = 0;

        // quick exit if arguments permit it 
        if(!$onlyMissing) {
            if($versions) foreach($requires as $key => $value) {
                list($operator, $version) = $info['requiresVersions'][$value]; 
                if(empty($version)) continue; 
                if(ctype_digit("$version")) $version = $this->formatVersion($version); 
                if(!empty($version)) $requires[$key] .= "$operator$version";
            }
            return $requires; 
        }

        foreach($requires as $key => $requiresClass) {

            if(in_array($requiresClass, $info['installs'])) {
                // if this module installs the required class, then we can stop now
                // and we assume it's installing the version it wants
                unset($requires[$key]); 
            }

            list($operator, $requiresVersion) = $info['requiresVersions'][$requiresClass];
            $installed = true; 

            if($requiresClass == 'PHP') {
                $currentVersion = PHP_VERSION; 

            } else if($requiresClass == 'ProcessWire') { 
                $currentVersion = $this->wire('config')->version; 

            } else if($this->isInstalled($requiresClass)) {
                if(!$requiresVersion) {
                    // if no version is specified then requirement is already met
                    unset($requires[$key]); 
                    continue; 
                }
                $i = $this->getModuleInfo($requiresClass, array('noCache' => true)); 
                $currentVersion = $i['version'];
            } else {
                // module is not installed
                $installed = false; 
            }

            if($installed && $this->versionCompare($currentVersion, $requiresVersion, $operator)) {
                // required version is installed
                unset($requires[$key]); 

            } else if(empty($requiresVersion)) {
                // just the class name is fine
                continue; 
                
            } else if(is_null($versions)) {
                // request is for no versions to be included (just class names)
                $requires[$key] = $requiresClass; 

            } else {
                // update the requires string to clarify what version it requires
                if(ctype_digit("$requiresVersion")) $requiresVersion = $this->formatVersion($requiresVersion); 
                $requires[$key] = "$requiresClass$operator$requiresVersion";
            }
        }

        return $requires; 
    }


    /**
     * Compare one module version to another, returning TRUE if they match the $operator or FALSE otherwise
     * 
     * #pw-internal
     *
     * @param int|string $currentVersion May be a number like 123 or a formatted version like 1.2.3
     * @param int|string $requiredVersion May be a number like 123 or a formatted version like 1.2.3
     * @param string $operator
     * @return bool
     *
     */
    public function versionCompare($currentVersion, $requiredVersion, $operator) {
        
        if(ctype_digit("$currentVersion") && ctype_digit("$requiredVersion")) {
            // integer comparison is ok
            $currentVersion = (int) $currentVersion;
            $requiredVersion = (int) $requiredVersion;
            $result = false;
            
            switch($operator) {
                case '=': $result = ($currentVersion == $requiredVersion); break;
                case '>': $result = ($currentVersion > $requiredVersion); break;
                case '<': $result = ($currentVersion < $requiredVersion); break;
                case '>=': $result = ($currentVersion >= $requiredVersion); break;
                case '<=': $result = ($currentVersion <= $requiredVersion); break;
                case '!=': $result = ($currentVersion != $requiredVersion); break;
            }
            return $result;
        }

        // if either version has no periods or only one, like "1.2" then format it to stanard: "1.2.0"
        if(substr_count($currentVersion, '.') < 2) $currentVersion = $this->formatVersion($currentVersion);
        if(substr_count($requiredVersion, '.') < 2) $requiredVersion = $this->formatVersion($requiredVersion); 
        
        return version_compare($currentVersion, $requiredVersion, $operator); 
    }

    /**
     * Return array of ($module, $operator, $requiredVersion)
     *
     * $version will be 0 and $operator blank if there are no requirements.
     * 
     * @param string $require Module class name with operator and version string
     * @return array of array($moduleClass, $operator, $version)
     *
     */
    protected function extractModuleOperatorVersion($require) {

        if(ctype_alnum($require)) {
            // no version is specified
            return array($require, '', 0); 
        }

        $operators = array('<=', '>=', '<', '>', '!=', '='); 
        $operator = '';
        foreach($operators as $o) {
            if(strpos($require, $o)) {
                $operator = $o;
                break;
            }
        }

        // if no operator found, then no version is being specified
        if(!$operator) return array($require, '', 0); 

        // extract class and version
        list($class, $version) = explode($operator, $require); 

        // make version an integer if possible
        if(ctype_digit("$version")) $version = (int) $version; 
    
        return array($class, $operator, $version); 
    }

    /**
     * Return an array of module class names required by the given one to be installed before this one.
     *
     * Excludes modules that are required but already installed. 
     * Excludes uninstalled modules that $class indicates it handles via it's 'installs' getModuleInfo property.
     * 
     * #pw-internal
     * 
     * @param string $class
     * @return array()
     *
     */
    public function getRequiresForInstall($class) {
        return $this->getRequires($class, true); 
    }

    /**
     * Return an array of module class names required by the given one to be uninstalled before this one.
     *
     * Excludes modules that the given one says it handles via it's 'installs' getModuleInfo property.
     * Module class names in returned array include operator and version in the string. 
     * 
     * #pw-internal
     * 
     * @param string $class
     * @return array()
     *
     */
    public function getRequiresForUninstall($class) {
        return $this->getRequiredBy($class, false, true); 
    }
    
    /**
     * Return array of dependency errors for given module name
     * 
     * #pw-internal
     *
     * @param $moduleName
     * @return array If no errors, array will be blank. If errors, array will be of strings (error messages)
     *
     */
    public function getDependencyErrors($moduleName) {

        $moduleName = $this->getModuleClass($moduleName);
        $info = $this->getModuleInfo($moduleName);
        $errors = array();

        if(empty($info['requires'])) return $errors;

        foreach($info['requires'] as $requiresName) {
            $error = '';

            if(!$this->isInstalled($requiresName)) {
                $error = $requiresName;

            } else if(!empty($info['requiresVersions'][$requiresName])) {
                list($operator, $version) = $info['requiresVersions'][$requiresName];
                $info2 = $this->getModuleInfo($requiresName); 
                $requiresVersion = $info2['version'];
                if(!empty($version) && !$this->versionCompare($requiresVersion, $version, $operator)) {
                    $error = "$requiresName $operator $version";
                }
            }

            if($error) $errors[] = sprintf($this->_('Failed module dependency: %s requires %s'), $moduleName, $error);
        }

        return $errors;
    }

    /**
     * Find modules that are missing their module file on the file system
     * 
     * Return value is array: 
     * ~~~~~
     * [ 
     *   'ModuleName' => [ 
     *     'id' => 123, 
     *     'name' => 'ModuleName', 
     *     'file' => '/path/to/expected/file.module'
     *   ],
     *   'ModuleName' => [
     *     ...
     *   ]
     * ];
     * ~~~~~
     * 
     * #pw-internal
     * 
     * @return array
     * @since 3.0.170
     * 
     */
    public function findMissingModules() {

        $missing = array();
        $unflags = array();
        
        $sql = "SELECT id, class FROM modules WHERE flags & :flagsNoFile ORDER BY class";
        $query = $this->wire()->database->prepare($sql);
        $query->bindValue(':flagsNoFile', self::flagsNoFile, \PDO::PARAM_INT);
        $query->execute();
        
        while($row = $query->fetch(\PDO::FETCH_ASSOC)) {
            
            $class = $row['class'];
            
            $file = $this->getModuleFile($class, array('fast' => true));
            
            if($file && file_exists($file)) {
                $unflags[] = $class;
                continue;
            }
            
            $fileAlt = $this->getModuleFile($class, array('fast' => false));
            
            if($fileAlt) {
                $file = $fileAlt;
                if(file_exists($file)) continue;
            }   
            
            if(!$file) {
                $file = $this->getModuleFile($class, array('fast' => true, 'guess' => true));
            }
            
            $missing[$class] = array(
                'id' => $row['id'],
                'name' => $class,
                'file' => $file,
            );
        }
    
        foreach($unflags as $name) {
            $this->setFlag($name, self::flagsNoFile, false);
        }
        
        return $missing;
    }

    /**
     * Remove entry for module from modules table 
     * 
     * #pw-internal
     * 
     * @param string|int $class Module class or ID
     * @return bool
     * @since 3.0.170
     * 
     */
    public function removeModuleEntry($class) {
        $database = $this->wire()->database;
        if(ctype_digit("$class")) {
            $query = $database->prepare('DELETE FROM modules WHERE id=:id LIMIT 1'); 
            $query->bindValue(':id', (int) $class, \PDO::PARAM_INT);
        } else {
            $query = $database->prepare('DELETE FROM modules WHERE class=:class LIMIT 1');
            $query->bindValue(':class', $class, \PDO::PARAM_STR);
        }
        $result = $query->execute() ? $query->rowCount() > 0 : false;
        $query->closeCursor();
        return $result; 
    }

    /**
     * Given a module version number, format it in a consistent way as 3 parts: 1.2.3 
     * 
     * #pw-internal
     * 
     * @param $version int|string
     * @return string
     * 
     */
    public function formatVersion($version) {
        
        $version = trim($version);

        if(!ctype_digit(str_replace('.', '', $version))) {
            // if version has some characters other than digits or periods, remove them
            $version = preg_replace('/[^\d.]/', '', $version); 
        }
        
        if(ctype_digit("$version")) {
            // version contains only digits
            // make sure version is at least 3 characters in length, left padded with 0s
            $len = strlen($version); 

            if($len < 3) {
                $version = str_pad($version, 3, "0", STR_PAD_LEFT);

            } else if($len > 3) {
                // they really need to use a string for this type of version, 
                // as we can't really guess, but we'll try, converting 1234 to 1.2.34
            }

            // $version = preg_replace('/(\d)(?=\d)/', '$1.', $version); 
            $version = 
                substr($version, 0, 1) . '.' . 
                substr($version, 1, 1) . '.' . 
                substr($version, 2); 
            
        } else if(strpos($version, '.') !== false) {
            // version is a formatted string
            if(strpos($version, '.') == strrpos($version, '.')) {
                // only 1 period, like: 2.0, convert that to 2.0.0
                if(preg_match('/^\d\.\d$/', $version)) $version .= ".0";
            }
            
        } else {
            // invalid version?
        }
        
        if(!strlen($version)) $version = '0.0.0';
        
        return $version;
    }
    
    /**
     * Load the module information cache
     * 
     * @return bool
     * 
     */
    protected function loadModuleInfoCache() {
        $data = $this->wire('cache')->get(self::moduleInfoCacheName);   
        if($data) { 
            // if module class name keys in use (i.e. ProcessModule) it's an older version of 
            // module info cache, so we skip over it to force its re-creation
            if(is_array($data) && !isset($data['ProcessModule'])) $this->moduleInfoCache = $data; 
            $data = $this->wire('cache')->get(self::moduleLastVersionsCacheName);
            if(is_array($data)) $this->modulesLastVersions = $data;
            return true;
        }
        return false;
    }
    
    /**
     * Load the module information cache (verbose info: summary, author, href, file, core)
     *
     * @param bool $uninstalled If true, it will load the uninstalled verbose cache.
     * @return bool
     *
     */
    protected function loadModuleInfoCacheVerbose($uninstalled = false) {
        $name = $uninstalled ? self::moduleInfoCacheUninstalledName : self::moduleInfoCacheVerboseName;
        $data = $this->wire('cache')->get($name);
        if($data) {
            if(is_array($data)) {
                if($uninstalled) $this->moduleInfoCacheUninstalled = $data; 
                    else $this->moduleInfoCacheVerbose = $data;
            }
            return true;
        }
        return false;
    }

    /**
     * Clear the module information cache
     * 
     * @param bool|null $showMessages Specify true to show message notifications
     * 
     */
    protected function clearModuleInfoCache($showMessages = false) {
        
        $cache = $this->wire()->cache;
        $versionChanges = array();
        $newModules = array();
        $moveModules = array();
        $missModules = array();

        // record current module versions currently in moduleInfo
        $moduleVersions = array();
        foreach($this->moduleInfoCache as $id => $moduleInfo) {
            if(isset($this->modulesLastVersions[$id])) {
                $moduleVersions[$id] = $this->modulesLastVersions[$id];
            } else {
                $moduleVersions[$id] = $moduleInfo['version'];
            }
        }
    
        // delete the caches
        $cache->delete(self::moduleInfoCacheName);
        $cache->delete(self::moduleInfoCacheVerboseName);
        $cache->delete(self::moduleInfoCacheUninstalledName);
        
        $this->moduleInfoCache = array();
        $this->moduleInfoCacheVerbose = array();
        $this->moduleInfoCacheUninstalled = array();
    
        // save new moduleInfo cache
        $this->saveModuleInfoCache();

        // compare new moduleInfo versions with the previous ones, looking for changes
        foreach($this->moduleInfoCache as $id => $moduleInfo) {
            $moduleName = $moduleInfo['name'];
            if(!isset($moduleVersions[$id])) {
                if(isset($this->moduleIDs[$moduleName])) {
                    $moveModules[] = $moduleName;
                } else {
                    $newModules[] = $moduleName;
                }
                continue;
            }
            if($moduleVersions[$id] != $moduleInfo['version']) {
                $fromVersion = $this->formatVersion($moduleVersions[$id]);
                $toVersion = $this->formatVersion($moduleInfo['version']);
                $versionChanges[] = "$fromVersion => $toVersion: $moduleName";
                $this->modulesLastVersions[$id] = $moduleVersions[$id];
                if(strpos($moduleName, 'Fieldtype') === 0) {
                    // apply update now, to Fieldtype modules only (since they are loaded differently)
                    $this->getModule($moduleName);
                }
            }
        }
        
        foreach($this->moduleIDs as $moduleName => $moduleID) {
            if(isset($this->moduleInfoCache[$moduleID])) {
                // module is present in moduleInfo
                if($this->hasFlag($moduleID, self::flagsNoFile)) {
                    $file = $this->getModuleFile($moduleName, array('fast' => false)); 
                    if($file) {
                        // remove flagsNoFile if file is found
                        $this->setFlag($moduleID, self::flagsNoFile, false);
                    }
                }
            } else {
                // module is missing moduleInfo
                $file = $this->getModuleFile($moduleName, array('fast' => false)); 
                if(!$file) {
                    $file = $this->getModuleFile($moduleName, array('fast' => true, 'guess' => true)); 
                    // add flagsNoFile if file cannot be located
                    $missModules[] = "$moduleName => $file";
                    $this->setFlag($moduleID, self::flagsNoFile, true);
                }
            }   
        }
        
        $this->updateModuleVersionsCache();
        
        // report detected changes
        $sanitizer = $this->wire()->sanitizer;
        $reports = array(
            array(
                'label' => $this->_('Found %d new module(s):'),
                'items' => $newModules, 
            ),
            /*
            array(
                'label' => $this->_('Found %d moved module(s):'),
                'items' => $moveModules, 
            ),
            */
            array(
                'label' => $this->_('Found %d module(s) missing file:'),
                'items' => $missModules,
            ),
            array(
                'label' => $this->_('Found %d module version changes (applied when each module is loaded):'), 
                'items' => $versionChanges,
            ),
        );
        
        foreach($reports as $report) {
            if(!count($report['items'])) continue;
            if($showMessages) $this->message(
                $sanitizer->entities1(sprintf($report['label'], count($report['items']))) . 
                '<pre>' . $sanitizer->entities(implode("\n", $report['items'])) . '</pre>',
                Notice::allowMarkup | Notice::noGroup
            );
            $this->log(
                sprintf($report['label'], count($report['items'])) . ' ' . 
                implode(', ', $report['items'])
            );
        }
    }

    /**
     * Update the cache of queued module version changes
     * 
     */
    protected function updateModuleVersionsCache() {
        foreach($this->modulesLastVersions as $id => $version) {
            // clear out stale data, if present
            if(!in_array($id, $this->moduleIDs)) unset($this->modulesLastVersions[$id]);
        }
        if(count($this->modulesLastVersions)) {
            $this->wire()->cache->save(self::moduleLastVersionsCacheName, $this->modulesLastVersions, WireCache::expireReserved);
        } else {
            $this->wire()->cache->delete(self::moduleLastVersionsCacheName);
        }
    }

    /**
     * Check the module version to make sure it is consistent with our moduleInfo
     * 
     * When not consistent, this triggers the moduleVersionChanged hook, which in turn
     * triggers the $module->___upgrade($fromVersion, $toVersion) method. 
     * 
     * @param Module $module
     * 
     */
    protected function checkModuleVersion(Module $module) {
        $id = $this->getModuleID($module);
        $moduleInfo = $this->getModuleInfo($module);
        $lastVersion = isset($this->modulesLastVersions[$id]) ? $this->modulesLastVersions[$id] : null;
        if(!is_null($lastVersion)) { 
            if($lastVersion != $moduleInfo['version']) {
                $this->moduleVersionChanged($module, $lastVersion, $moduleInfo['version']); 
                unset($this->modulesLastVersions[$id]);
            }
            $this->updateModuleVersionsCache();
        }
    }

    /**
     * Hook called when a module's version changes
     * 
     * This calls the module's ___upgrade($fromVersion, $toVersion) method. 
     * 
     * @param Module|_Module $module
     * @param int|string $fromVersion
     * @param int|string $toVersion
     * 
     */
    protected function ___moduleVersionChanged(Module $module, $fromVersion, $toVersion) {
        $moduleName = wireClassName($module, false);
        $moduleID = $this->getModuleID($module);
        $fromVersionStr = $this->formatVersion($fromVersion);
        $toVersionStr = $this->formatVersion($toVersion);
        $this->message($this->_('Upgrading module') . " ($moduleName: $fromVersionStr => $toVersionStr)");
        try {
            if(method_exists($module, '___upgrade')) {
                $module->upgrade($fromVersion, $toVersion);
            }
            unset($this->modulesLastVersions[$moduleID]);
        } catch(\Exception $e) {
            $this->error("Error upgrading module ($moduleName): " . $e->getMessage());
        }
    }

    /**
     * Update module flags if any happen to differ from what's in the given moduleInfo
     * 
     * @param $moduleID
     * @param array $info
     * 
     */
    protected function updateModuleFlags($moduleID, array $info) {
        
        $flags = (int) $this->getFlags($moduleID); 
        
        if($info['autoload']) {
            // module is autoload
            if(!($flags & self::flagsAutoload)) {
                // add autoload flag
                $this->setFlag($moduleID, self::flagsAutoload, true);
            }
            if(is_string($info['autoload'])) {
                // requires conditional flag
                // value is either: "function", or the conditional string (like key=value)
                if(!($flags & self::flagsConditional)) $this->setFlag($moduleID, self::flagsConditional, true);
            } else {
                // should not have conditional flag
                if($flags & self::flagsConditional) $this->setFlag($moduleID, self::flagsConditional, false);
            }
            
        } else if($info['autoload'] !== null) {
            // module is not autoload
            if($flags & self::flagsAutoload) {
                // remove autoload flag
                $this->setFlag($moduleID, self::flagsAutoload, false);
            }
            if($flags & self::flagsConditional) {
                // remove conditional flag
                $this->setFlag($moduleID, self::flagsConditional, false);
            }
        }
        
        if($info['singular']) {
            if(!($flags & self::flagsSingular)) $this->setFlag($moduleID, self::flagsSingular, true); 
        } else {
            if($flags & self::flagsSingular) $this->setFlag($moduleID, self::flagsSingular, false); 
        }

        // handle addFlag and removeFlag moduleInfo properties
        foreach(array(0 => 'removeFlag', 1 => 'addFlag') as $add => $flagsType) {
            if(empty($info[$flagsType])) continue;
            if($flags & $info[$flagsType]) {
                // already has the flags
                if(!$add) {
                    // remove the flag(s)
                    $this->setFlag($moduleID, $info[$flagsType], false);
                }
            } else {
                // does not have the flags
                if($add) {
                    // add the flag(s)
                    $this->setFlag($moduleID, $info[$flagsType], true);
                }
            }
        }
    }

    /**
     * Save the module information cache
     * 
     */
    protected function saveModuleInfoCache() {
        
        if($this->debug) {
            static $n = 0;
            $this->message("saveModuleInfoCache (" . (++$n) . ")"); 
        }
        
        $this->moduleInfoCache = array();
        $this->moduleInfoCacheVerbose = array();
        $this->moduleInfoCacheUninstalled = array();
        
        $user = $this->wire('user'); 
        $languages = $this->wire('languages'); 
        $language = null;
        
        if($languages) {
            // switch to default language to prevent caching of translated title/summary data
            $language = $user->language; 
            try { 
                if($language && $language->id && !$language->isDefault()) $user->language = $languages->getDefault(); // save
            } catch(\Exception $e) {
                $this->trackException($e, false, true); 
            }
        }
    
        foreach(array(true, false) as $installed) { 
            
            $items = $installed ? $this : array_keys($this->installable);   
            
            foreach($items as $module) {
                
                $class = is_object($module) ? $module->className() : $module;
                $class = wireClassName($class, false);
                $info = $this->getModuleInfo($class, array('noCache' => true, 'verbose' => true));
                $moduleID = (int) $info['id']; // note ID is always 0 for uninstalled modules
                
                if(!empty($info['error'])) {
                    if($this->debug) $this->warning("$class reported error: $info[error]"); 
                    continue;
                }
                
                if(!$moduleID && $installed) {
                    if($this->debug) $this->warning("No module ID for $class"); 
                    continue;
                }
                
                if(!$this->debug) unset($info['id']); // no need to double store this property since it is already the array key
                
                if(is_null($info['autoload'])) {
                    // module info does not indicate an autoload state
                    $info['autoload'] = $this->isAutoload($module); 
                    
                } else if(!is_bool($info['autoload']) && !is_string($info['autoload']) && wireIsCallable($info['autoload'])) {
                    // runtime function, identify it only with 'function' so that it can be recognized later as one that
                    // needs to be dynamically loaded
                    $info['autoload'] = 'function';
                }
            
                if(is_null($info['singular'])) {
                    $info['singular'] = $this->isSingular($module); 
                }
            
                if(is_null($info['configurable'])) {
                    $info['configurable'] = $this->isConfigurable($module, false);
                }
                
                if($moduleID) $this->updateModuleFlags($moduleID, $info);
            
                if($installed) { 
                    
                    $verboseKeys = $this->moduleInfoVerboseKeys; 
                    $verboseInfo = array();
                    
                    foreach($verboseKeys as $key) {
                        if(!empty($info[$key])) $verboseInfo[$key] = $info[$key]; 
                        unset($info[$key]); // remove from regular moduleInfo 
                    }
                    
                    $this->moduleInfoCache[$moduleID] = $info; 
                    $this->moduleInfoCacheVerbose[$moduleID] = $verboseInfo;
                    
                } else {
                    $this->moduleInfoCacheUninstalled[$class] = $info; 
                }
            }
        }
    
        $caches = array(
            self::moduleInfoCacheName => 'moduleInfoCache', 
            self::moduleInfoCacheVerboseName => 'moduleInfoCacheVerbose',
            self::moduleInfoCacheUninstalledName => 'moduleInfoCacheUninstalled',
        );
        
        foreach($caches as $cacheName => $varName) {
            $data = $this->$varName;
            foreach($data as $moduleID => $moduleInfo) {
                foreach($moduleInfo as $key => $value) {
                    // remove unpopulated properties
                    if($key == 'installed') {
                        // no need to store an installed==true property
                        if($value) unset($data[$moduleID][$key]);
                        
                    } else if($key == 'requires' && !empty($value) && !empty($data[$moduleID]['requiresVersions'])) {
                        // requiresVersions has enough info to re-construct requires, so no need to store it
                        unset($data[$moduleID][$key]);
                        
                    } else if(($key == 'created' && empty($value))
                        || ($value === 0 && ($key == 'singular' || $key == 'autoload' || $key == 'configurable'))
                        || ($value === null || $value === "" || $value === false) 
                        || (is_array($value) && !count($value))) {
                        // no need to store these false, null, 0, or blank array properties
                        unset($data[$moduleID][$key]);
                        
                    } else if(($key == 'namespace' && $value == "\\" . __NAMESPACE__ . "\\") || (!strlen(__NAMESPACE__) && empty($value))) {
                        // no need to cache default namespace in module info
                        unset($data[$moduleID][$key]);
                        
                    } else if($key == 'file') {
                        // file property is cached elsewhere so doesn't need to be included in this cache
                        unset($data[$moduleID][$key]);
                    }
                }
            }
            $this->wire('cache')->save($cacheName, $data, WireCache::expireReserved); 
        }
    
        $this->log('Saved module info caches'); 
        
        if($languages && $language) $user->language = $language; // restore
    }

    /**
     * Start a debug timer, only works when module debug mode is on ($this->debug)
     * 
     * @param $note
     * @return int|null Returns a key for the debug timer
     * 
     */
    protected function debugTimerStart($note) {
        if(!$this->debug) return null;
        $key = count($this->debugLog);
        while(isset($this->debugLog[$key])) $key++;
        $this->debugLog[$key] = array(
            0 => Debug::timer("Modules$key"),
            1 => $note
        );
        return $key;
    }

    /**
     * Stop a debug timer, only works when module debug mode is on ($this->debug)
     *
     * @param int $key The key returned by debugTimerStart
     *
     */
    protected function debugTimerStop($key) {
        if(!$this->debug) return;
        $log = $this->debugLog[$key];
        $timerKey = $log[0];
        $log[0] = Debug::timer($timerKey);
        $this->debugLog[$key] = $log;
        Debug::removeTimer($timerKey);
    }

    /**
     * Return a log of module construct, init and ready times, active only when debug mode is on ($this->debug)
     * 
     * #pw-internal
     *
     * @return array
     *
     */
    public function getDebugLog() {
        return $this->debugLog;
    }

    /**
     * Substitute one module for another, to be used only when $moduleName doesn't exist. 
     * 
     * #pw-internal
     *
     * @param string $moduleName Module class name that may need a substitute
     * @param string $substituteName Module class name you want to substitute when $moduleName isn't found.
     *  Specify null to remove substitute.
     *
     */
    public function setSubstitute($moduleName, $substituteName = null) {
        if(is_null($substituteName)) {
            unset($this->substitutes[$moduleName]);
        } else {
            $this->substitutes[$moduleName] = $substituteName; 
        }
    }

    /**
     * Substitute modules for other modules, to be used only when $moduleName doesn't exist.
     * 
     * This appends existing entries rather than replacing them. 
     * 
     * #pw-internal
     *
     * @param array $substitutes Array of module name => substitute module name
     *
     */
    public function setSubstitutes(array $substitutes) {
        $this->substitutes = array_merge($this->substitutes, $substitutes); 
    }

    /**
     * Load module related CSS and JS files (where applicable)
     * 
     * - Applies only to modules that carry class-named CSS and/or JS files, such as Process, Inputfield and ModuleJS modules. 
     * - Assets are populated to `$config->styles` and `$config->scripts`.
     * 
     * #pw-internal
     * 
     * @param Module|int|string $module Module object or class name
     * @return int Returns number of files that were added
     * 
     */
    public function loadModuleFileAssets($module) {

        $class = $this->getModuleClass($module);
        static $classes = array();
        if(isset($classes[$class])) return 0; // already loaded
        $info = null;
        $config = $this->wire('config');
        $path = $config->paths->$class;
        $url = $config->urls->$class;
        $debug = $config->debug;
        $version = 0; 
        $cnt = 0;

        foreach(array('styles' => 'css', 'scripts' => 'js') as $type => $ext) {
            $fileURL = '';
            $modified = 0;
            $file = "$path$class.$ext";
            $minFile = "$path$class.min.$ext";
            if(!$debug && is_file($minFile)) {
                $fileURL = "$url$class.min.$ext";
                $modified = filemtime($minFile);
            } else if(is_file($file)) {
                $fileURL = "$url$class.$ext";
                $modified = filemtime($file);
            }
            if($fileURL) {
                if(!$version) {
                    $info = $this->getModuleInfo($module, array('verbose' => false));
                    $version = (int) isset($info['version']) ? $info['version'] : 0;
                }
                $config->$type->add("$fileURL?v=$version-$modified");
                $cnt++;
            }
        }
        
        $classes[$class] = true; 
        
        return $cnt;
    }

    /**
     * Get module language translation files
     * 
     * @param Module|string $module
     * @return array Array of translation files including full path, indexed by basename without extension
     * @since 3.0.181
     * 
     */
    public function getModuleLanguageFiles($module) {
    
        $module = $this->getModuleClass($module);
        if(empty($module)) return array();
        
        $path = $this->wire()->config->paths($module);
        if(empty($path)) return array();
        
        $pathHidden = $path . '.languages/';
        $pathVisible = $path . 'languages/';
        
        if(is_dir($pathVisible)) {
            $path = $pathVisible;
        } else if(is_dir($pathHidden)) {
            $path = $pathHidden;
        } else {
            return array();
        }
    
        $items = array();
        $options = array(
            'extensions' => array('csv'),
            'recursive' => false,
            'excludeHidden' => true, 
        );
        
        foreach($this->wire()->files->find($path, $options) as $file) {
            $basename = basename($file, '.csv');
            $items[$basename] = $file;
        }
        
        return $items;
    }

    /**
     * Enables use of $modules('ModuleName')
     *
     * @param string $key
     * @return mixed
     *
     */
    public function __invoke($key) {
        return $this->get($key);
    }

    /**
     * Save to the modules log
     * 
     * #pw-internal
     * 
     * @param string $str Message to log
     * @param string $moduleName
     * @return WireLog
     * 
     */ 
    public function log($str, $moduleName = '') {
        if(!in_array('modules', $this->wire('config')->logs)) return $this->___log();
        if(!is_string($moduleName)) $moduleName = (string) $moduleName; 
        if($moduleName && strpos($str, $moduleName) === false) $str .= " (Module: $moduleName)";
        return $this->___log($str, array('name' => 'modules')); 
    }

    /**
     * Record and log error message
     * 
     * #pw-internal
     * 
     * @param array|Wire|string $text
     * @param int $flags
     * @return Modules|WireArray
     * 
     */
    public function error($text, $flags = 0) {
        $this->log($text); 
        return parent::error($text, $flags); 
    }

    /**
     * Compile and return the given file for module, if allowed to do so
     * 
     * #pw-internal
     * 
     * @param Module|string $moduleName
     * @param string $file Optionally specify the module filename as an optimization
     * @param string|null $namespace Optionally specify namespace as an optimization
     * @return string|bool
     * 
     */
    public function compile($moduleName, $file = '', $namespace = null) {
        
        static $allowCompile = null;
        if($allowCompile === null) $allowCompile = $this->wire('config')->moduleCompile;
        
        // if not given a file, track it down
        if(empty($file)) $file = $this->getModuleFile($moduleName);

        // don't compile when module compilation is disabled
        if(!$allowCompile) return $file;
    
        // don't compile core modules
        if(strpos($file, $this->coreModulesDir) !== false) return $file;
    
        // if namespace not provided, get it
        if(is_null($namespace)) {
            if(is_object($moduleName)) {
                $className = $moduleName->className(true);
                $namespace = wireClassName($className, 1);
            } else if(is_string($moduleName) && strpos($moduleName, "\\") !== false) {
                $namespace = wireClassName($moduleName, 1);
            } else {
                $namespace = $this->getModuleNamespace($moduleName, array('file' => $file));
            }
        }
    
        // determine if compiler should be used
        if(__NAMESPACE__) {
            $compile = $namespace === '\\' || empty($namespace);
        } else {
            $compile = trim($namespace, '\\') === 'ProcessWire';
        }
    
        // compile if necessary
        if($compile) {
            /** @var FileCompiler $compiler */
            $compiler = $this->wire(new FileCompiler(dirname($file)));
            $compiledFile = $compiler->compile(basename($file));
            if($compiledFile) $file = $compiledFile;
        }
    
        return $file;
    }
    
}