Subversion Repositories web.active

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download 

<?php namespace ProcessWire;

/**
 * ProcessWire Module Interface
 *
 * Provides the base interfaces required by modules.
 * 
 * ProcessWire 3.x, Copyright 2018 by Ryan Cramer
 * https://processwire.com
 * 
 * #pw-summary Module is the primary PHP interface for module types in ProcessWire. 
 * #pw-body = 
 * The Module interface doesn't actually require any specific methods,
 * (other than the `className()` method) but is required as an interface 
 * to state your intention to ProcessWire that your class is to be used 
 * as a Module. As a result, all methods are optional, but including the 
 * Module interface is not. You must also provide a means by which ProcessWire
 * can query information about your module. More on that below. 
 * 
 * ### Implementing the Module interface
 * 
 * Below is how you indicate a PHP class is a ProcessWire Module:
 * 
 * ~~~~~
 * <?php namespace ProcessWire;
 * class HelloWorld extends WireData implements Module { 
 *   // your class implementation
 * }
 * ~~~~~
 * 
 * Modules should either extend the `WireData` class, or if they are a 
 * predefined type already recognized by ProcessWire, they should extend 
 * the base class of that type (or another module based upon it). Base 
 * module types include:
 *
 * - `AdminTheme`
 * - `Fieldtype`
 * - `FileCompilerModule`
 * - `FileValidatorModule`
 * - `Inputfield`
 * - `ModuleJS`
 * - `PageAction`
 * - `Process`
 * - `Textformatter`
 * - `WireAction`
 * - `WireMail`
 * - `WireSessionHandler`
 * 
 * ### Requirements for Modules
 * 
 * 1. Must provide a means of getting information about the module.
 *    This can be with a static `getModuleInfo()` method, or with
 *    a `ModuleName.info.php` file or a `ModuleName.info.json` file. 
 * 
 * 2. Must provide a `className()` method that returns the module 
 *    class name. All Wire derived objects already do this, so 
 *    you don't have to provide it unless your Module does not
 *    descend from a ProcessWire class. We recommend that your
 *    modules extend the Wire or WireData class. 
 * 
 * 3. If you have a `__construct()` method, it must not require any
 *    particular arguments. 
 * 
 * 4. If your module is configurable, it must also fulfill the
 *    `ConfigurableModule` interface. 
 * 
 * ### Optional methods 
 * 
 * - `__construct()` - Called before module config is populated.
 * 
 * - `init()` - Called after module config is populated.
 * 
 * - `ready()` - Called after init(), after API ready. Note that ready() applies to 'autoload' modules only. 
 * 
 * - `install()` - Called when module is installed. 
 * 
 * - `uninstall()` - Called when module is uninstalled. 
 * 
 * - `upgrade($fromVersion, $toVersion)` - Called on version change.
 * 
 * - `isAutoload()` - Returns a boolean indicating whether the module should be loaded at boot. 
 *   Can also be specified as a property in module information.
 * 
 * - `isSingular()` - Returns a boolean indicating whether the module is limited to one instance or not. 
 *   Can also be specified as a property in module information.
 * 
 * - `getModuleInfo()` - A static method that returns an array of module information. 
 * 
 * These methods are outlined in more detail further down on this page. 
 * 
 * -----------------------------------------------------------------
 * 
 * ## Module Information
 * 
 * Modules must have some way to communicate information about 
 * themselves to ProcessWire. This is done by providing an 
 * associative array containing this module information. One
 * of the following implementations is required: 
 * 
 * 1. `getModuleInfo()` static method in your module class that returns an array.
 * 2. `YourModuleClass.info.php` file that populates an `$info` array.
 * 3. `YourModuleClass.info.json` file that contains an `info` object.
 *   
 * Each of these are demonstrated below:
 *  
 * **1) Static getModuleInfo() method:**
 * ~~~~~
 * public static function getModuleInfo() {
 *   return array(
 *     'title' => 'Your Module Title',
 *     'version' => 1,
 *     'author' => 'Your Name',
 *     'summary' => 'Description of what this module does and who made it.',
 *     'href' => 'http://www.domain.com/info/about/this/module/',
 *     'autoload' => false, // set to true if module should auto-load at boot
 *     'requires' => array(
 *        'HelloWorld>=1.0.1', 
 *        'PHP>=5.4.1', 
 *        'ProcessWire>=2.4.1'
 *     ),
 *     'installs' => array('Module1', 'Module2', 'Module3'),
 *     );
 * }
 * ~~~~~
 *
 * **2) YourModuleClass.info.php file:**  
 * Your file should populate an `$info` variable with an array exactly like 
 * described for #1 above, i.e.
 * 
 * ~~~~~
 * $info = array(
 *   'title' => 'Your Module Title',
 *   'version' => 1,
 *   // and so on, like the static version above
 * );
 * ~~~~~
 *
 * **3) YourModuleClass.info.json file:**  
 * Your JSON file should contain nothing but an object/map of the module info:
 * 
 * ~~~~~
 * {
 *   "title": "Your Module Title",
 *   "version": 1
 * }
 * ~~~~~
 * Note: The example JSON above just shows "title" and "version", but you would
 * likely add more than that as needed, like shown in the static version above. 
 * 
 * -----------------------------------------------------------------
 *
 * ## Module information properties
 * 
 * ### Required info properties
 *
 * - `title` (string): The module's title.
 * 
 * - `version` (int|string): An integer or string that indicates the version number.
 * 
 * - `summary` (string): Summary text of the module (1 sentence recommended).
 * 
 * ### Optional info properties
 * 
 * - `href` (string): URL to more information about the module.
 * 
 * - `requires` (array|string): Array or CSV string of module class names that are required by this 
 *    module in order to install.
 * 
 *    - **Requires Module version:** If a particular version of the module is required, then specify an operator
 *      and version number after the module name, like this: "HelloWorld>=1.0.1". 
 * 
 *    - **Requires PHP version:** If a particular version of PHP is required, then specify "PHP" as the module name
 *      followed by an operator and required version number, like this: "PHP>=5.6.0". 
 * 
 *    - **Requires ProcessWire version:** If a particular version of ProcessWire is required, then specify
 *      ProcessWire followed by an operator and required version number, like this: "ProcessWire>=2.4.1". 
 * 
 * - `installs` (array|string): Array or CSV string of module class names that this module will handle install 
 *    and uninstall for.
 *    This causes ProcessWire's dependency checker to ignore them and it is assumed your module will handle 
 *    them. If your module does not handle them, ProcessWire will automatically install/uninstall them 
 *    immediately after your module.
 * 
 * - `permanent` (boolean): This property is intended for only for core modules. When true, a module cannot be uninstalled.
 * 
 * - `permission` (string): Name of permission required of a user before ProcessWire will load the module (for non-superusers).
 *    Note that ProcessWire will not install this permission if it doesn't yet exist. To have it installed automatically,
 *    see the _permissions_ option below this.
 * 
 * - `permissions` (array): Array of permissions that ProcessWire will install (and uninstall) automatically.
 *    Permissions should be in the format: array('permission-name' => 'Permission description'). 
 * 
 * - `icon` (string): Optional icon name to represent this module.
 *    Currently uses [font-awesome](http://fortawesome.github.io/Font-Awesome/) icon names.
 *    Omit the "fa-" part, leaving just the icon name.
 * 
 * - `singular` (boolean): Is only one instance of this module allowed? (default=auto-detect).
 *    This is good for any module that you want to eliminate the possibility of multiple instances
 *    running at once. For instance, modules that become API variables are typically singular, whereas
 *    something like an Inputfield module would not be singular. When not specified, modules that extend an 
 *    existing base type typically inherit the singular setting from the module they extend. 
 * 
 * - `autoload` (boolean|string|callable|int): Should this module load automatically at boot? (default=false).
 *    This is good for modules that attach hooks or that need to otherwise load on every single
 *    request. Autoload is typically specified as a boolean true or false. Below are the different ways
 *    autoload can be specified: 
 * 
 *    - **Boolean:** Specify true or false to indicate the module should either always autoload (true) 
 *      or never autoload (false). 
 * 
 *    - **Selector string:** The module will be automatically loaded only if the current page matches the
 *      selector string. For example, a selector string of `template=admin` would mean the module will
 *      only autoload in the admin side of ProcessWire. 
 * 
 *    - **Callable function:** The module will automatically load only if the given callable function 
 *      returns true. 
 * 
 *    - **Integer:** If given integer 2 or higher, it will autoload the module before other autoload
 *      modules (in /site/modules/). Higher numbers autoload before lower numbers. 
 * 
 * - `searchable` (string): When present, indicates that module implements a search() method 
 *    consistent with the SearchableModule interface. The value of the 'searchable' property should 
 *    be the name that the search results are referred to, using ascii characters of a-z, 0-9, and
 *    underscore. See the SearchableModule interface in this file for more details. 
 * 
 * -----------------------------------------------------------------------------------------------
 * 
 * ## Module Methods
 * 
 * ### __construct()
 * 
 * This method is called by PHP immediately when the module is instantiated, and before any 
 * configuration data has been populated to the module. This method must not have any required
 * arguments. This method is a good place for populating default configuration values or any
 * other initialization you want to occur before ProcessWire sees it or populates anything to it.
 * Your construct method should not assume that the module will actually be executed, as 
 * ProcessWire may instantiate a module for informational reasons. 
 * 
 * ### init()
 * 
 * This method is called after `__construct()` and after any configuration data has been populated
 * to the module. It is called before the module is handed over to the requester. This is a good
 * place to perform any initialization that requires configuration data and can be a good place to 
 * attach hooks. 
 * 
 * ### ready()
 * 
 * This method is used only by _autoload_ modules. It is called when the entire ProcessWire API
 * is ready to use. This may be preferable to the `init()` method for autoload modules because 
 * they are loaded and init()'d at boot, when everything else is loading too. The ready() method
 * is called once the boot has completed and all API variables are ready to use, but before any
 * page has been rendered. This makes it an excellent place to attach hooks. 
 * 
 * ### isSingular()
 *
 * Indicates whether only one instance of a module is allowed to exist in memory. 
 * If this method is not present, it will be auto-determined based on module type. If it is provided
 * in the module information array (discussed above) that will override this method. 
 * 
 * This method exists primarily so that base module types may specify a singular state and have it 
 * automatically inherit to any modules extending the type. If you are not extending a base module
 * type then you can implement this method, or you can provide it in your module info array. 
 *
 * A module that returns TRUE is referred to as a "singular" module, because there will never be any more
 * than a single instance of the module running.
 *
 * Return TRUE if this module is a single reusable instance, returning the same instance on every 
 * call from Modules. Return FALSE if this module should return a new instance on every call from Modules.
 *
 * - Singular modules will have their instance active for the entire request after instantiated.
 * - Non-singular modules return a new instance on every `$modules->get("YourModule")` call.
 * - Modules that attach hooks are usually singular.
 * - Modules that may have multiple instances (like `Inputfield` modules) should _not_be singular.
 *
 * If you are having trouble deciding whether to make your module singular or not, be sure to read 
 * the documentation below for the `isAutoload()` method, because if your module is 'autoload' then 
 * it's probably also 'singular'.
 * 
 * ### isAutoload()
 * 
 * Should this module be automatically loaded at boot?
 * If this method is not present, it will be auto-determined based on module type. If it is provided
 * in the module information array (discussed above) that will override this method.
 *
 * This method exists primarily so that base module types may specify an autoload state and have it
 * automatically inherit to any modules extending the type. If you are not extending a base module
 * type then you can implement this method, or you can provide it in your module info array. 
 *  
 * A module that returns TRUE is referred to as an "autoload" module, because it automatically loads as
 * part of ProcessWire's boot process. Autoload modules load before PW attempts to handle the web request.
 *  
 * Return TRUE if this module is automatically loaded at runtime.
 * Return FALSE if this module must be requested via `$modules->get('ModuleName')` method before it is loaded.
 *  
 * Modules that are intended to attach hooks in the application typically should be autoload because
 * they listen in to classes rather than have classes call upon them. If they weren't autoloaded, then
 * they might never get to attach their hooks.
 *  
 * Modules that shouldn't be autoload are those that may or may not be needed at runtime, for example
 * `Fieldtype` and `Inputfield` modules.
 *  
 * _As a side note, I can't think of any reason why a non-singular module would ever be autoload. The fact that
 * an autoload module is automatically loaded as part of PW's boot process implies it's probably going to be the
 * only instance running. So if you've decided to make your module 'autoload', then is safe to assume you've
 * also decided your module will also be singular (if that helps anyone reading this)._
 * 
 * ### install()
 * 
 * This method is called when the module is first installed. If implemented, install() methods typically are
 * defined hookable as `public function ___install()`. 
 * 
 * The method should prepare the environment with anything else needed by the module, such as newly created 
 * fields, pages, templates, etc. or installation of other modules. 
 * 
 * If the install() method determines that the module called be installed for some reason, it should 
 * throw a `WireException.` 
 * 
 * ### uninstall()
 * 
 * This method is called when the module is uninstalled. If implemented, uninstall() methods typically are
 * defined hookable as `public function ___uninstall()`. 
 * 
 * This method should undo everything done by the install() method, or undo anything created by the module,
 * restoring the system back to the state that it was in before the module was installed. 
 * 
 * If the uninstall() method determines that it cannot proceed for some reason, it should throw 
 * a `WireException`. 
 * 
 * ### upgrade($fromVersion, $toVersion)
 * 
 * This method is called when a version change is detected. This method should make any adjustments needed
 * to support the module from one version to another. The previous known version ($fromVersion) and new
 * version ($toVersion) are provided as arguments.
 * 
 * If implemented, upgrade() methods typically are defined hookable as `public function ___upgrade(...)`. 
 * If the upgrade cannot proceed for some reason, this method should throw a `WireException`. 
 * 
 * 
 * 
 *
 * #pw-body
 * 
 * The following methods may or may not be implemented, all are optional:
 * 
 * #pw-method void install() Called when module is installed. 
 * #pw-method void uninstall() Called when module is uninstalled. 
 * #pw-method void upgrade($fromVersion, $toVersion) Called when a version change is detected for the module. 
 * #pw-method array getModuleInfo() Static method that returns array of module info (not required if module implements an info file instead). 
 * #pw-method void init() Called when the module is loaded, immediately after any configuration data has been populated to it. 
 * #pw-method void ready() For autoload modules only, called when the ProcessWire API is ready to use. 
 * #pw-method void setConfigData(array $data) Modules may optionally provide this method to receive config data from ProcessWire.
 * #pw-method bool isSingular() #pw-internal
 * #pw-method bool isAutoload() #pw-internal
 * 
 *
 */

interface Module {

    /**
     * Return an array of module information
     * 
     * @return array
     *
     * public static function getModuleInfo(); 
     * 
     */

    /**
     * Method to initialize the module. 
     *
     * While the method is required, if you don't need it, then just leave the implementation blank.
     *
     * This is called after ProcessWire's API is fully ready for use and hooks. It is called at the end of the 
     * bootstrap process. This is before PW has started retrieving or rendering a page. If you need to have the
     * API ready with the $page ready as well, then see the ready() method below this one. 
     *
     * public function init();
     * 
     */

    /**
     * Method called when API is fully ready and the $page is determined and set, but before a page is rendered.
     *
     * Optional and only called if it exists in the module. 
     *
     * public function ready();
     * 
     */

    /**
     * Return this object’s class name
     * 
     * If your Module descends from Wire, or any of it's derivatives (as would usually be the case),
     * then you don't need to implement this method as it's already present. 
     *
     * @param array|bool|null $options Optionally an option or boolean for 'namespace' option:
     * - `lowercase` (bool): Specify true to make it return hyphenated lowercase version of class name
     * - `namespace` (bool): Specify false to omit namespace from returned class name. Default=true.
     * - Note: when lowercase=true option is specified, the namespace=false option is required.
     * @return string
     * @see Wire::className()
     *
     */
    public function className($options = null);

    /**
     * Perform any installation procedures specific to this module, if needed. 
     *
     * The Modules class calls this install method right after performing the install. 
     * 
     * If this method throws an exception, PW will catch it, remove it from the installed module list, and
     * report that the module installation failed. You may specify details about why with the exception, i.e.
     * throw new WireException("Can't install because of ..."); 
     *
     * This method is OPTIONAL, which is why it's commented out below. 
     *
     * public function ___install();
     * 
     */

    /**
     * Perform any uninstall procedures specific to this module, if needed. 
     *
     * It calls this uninstall method right before completing the uninstall. 
     *
     * This method is OPTIONAL, which is why it's commented out below. 
     *
     * public function ___uninstall();
     * 
     */
    
    /**
     * Called when a version change is detected on the module
     * 
     * public function ___upgrade($fromVersion, $toVersion);
     * 
     */ 

    /**
     * Is this module intended to be only a single instance?
     *
     * @return bool
     * 
     * public function isSingular();
     * 
     */

    /**
     * Is this module automatically loaded at runtime?
     * 
     * @return bool
     *  
     * public function isAutoload(); 
     * 
     */ 
}

/**
 * Standard module interface with all methods. 
 * 
 * This interface is not intended to be used for anything other than for code hinting purposes. 
 *
 */
interface _Module {
    
    public function install();
    public function uninstall();
    public function upgrade($fromVersion, $toVersion);
    
    /** @return array */
    public static function getModuleInfo();
    
    public function init();
    
    public function ready();
    
    public function setConfigData(array $data);
    
    /** @return bool */
    public function isSingular();
    
    /** @return bool */
    public function isAutoload();

    /**
     * @param InputfieldWrapper|array|null $data
     * @return InputfieldWrapper
     * 
     */
    public function getModuleConfigInputfields($data = null);

    /**
     * @return array
     * 
     */
    public function getModuleConfigArray();
}

/**
 * Interface SearchableModule
 *
 * Interface for modules that implement a method and expected array return value
 * for completing basic text searches (primarily for admin search engine).
 * 
 * It is optional to add this interface to "implements" section of the module class definition.
 * However, you must specify a "searchable: name" property in your getModuleInfo() method in 
 * order for ProcessWire to recognize the module is searchable. See below for more info:
 *
 * ~~~~~~
 * public static function getModuleInfo() {
 *   return array(
 *     'searchable' => 'name', 
 * 
 *     // You'll need the above 'searchable' property returned by your getModuleInfo(). 
 *     // The value of 'name' should be the name by which search results should be referred to  
 *     // if the user wants to limit the search to this module. For instance, if your module 
 *     // was called “ProcessWidgets”, you’d probably choose the name “widgets” for this. 
 *     // If the module represents an API variable, the name should be the same as the API variable. 
 *     // ...
 *   );
 * }
 * ~~~~~
 * 
 */
interface SearchableModule {

    /**
     * Search for items containing $text and return an array representation of them
     * 
     * You may also implement this method as hookable, i.e. ___search(), but note that you’ll
     * want to skip the "implements SearchableModule" in your class definition. 
     *
     * Must return PHP array in the format below. For each item in the 'items' array, Only the 'title' 
     * and 'url' properties are required for each item (the rest are optional). 
     *
     * $result = array(
     *   'title' => 'Title of these items',
     *   'total' => 999, // total number of items found, or omit if pagination not supported or active
     *   'url' => '', // optional URL to view all items, or omit for a PW-generated one
     *   'properties' => array(), // optional list of supported search properties, only looked for if $options['info'] === true;
     *   'items' => array(
     *     [0] => array(
     *       'id' => 123, // Unique ID of item (optional)
     *       'name' => 'Name of item', // (optional)
     *       'title' => 'Title of item', // (*required)
     *       'subtitle' => 'Secondary/subtitle of item',  // (optional)
     *       'summary' => 'Summary or description of item', // (optional)
     *       'url' => 'URL to view or edit the item', // (*required)
     *       'icon' => 'Optional icon name to represent the item, i.e. "gear" or "fa-gear"', // (optional)
     *       'group' => 'Optionally group with other items having this group name, overrides $result[title]', // (optional)
     *       'status' => int, // refers to Page status, omit if not a Page item (optional)
     *       'modified' => int, // modified date of item as unix timestamp (optional)
     *     [1] => array(
     *       ...
     *     ),
     *   ),
     * );
     *
     * PLEASE NOTE:  
     * When ProcessWire calls this method, if the module is not already loaded (autoload), 
     * it instantiates the module but DOES NOT call the init() or ready() methods. That’s because the 
     * search method is generally self contained. If you need either of those methods to be called,
     * and your module is not autoload, you should call the method(s) from your search() method.
     * 
     * About the optional “properties” index:
     * If ProcessWire calls your search() method with $options['info'] == true; then it is likely wanting to see
     * what properties are available for search. For instance, properties for a Module search might be: 
     * [ 'name', 'title', 'summary' ]. Implementation of the properties index is optional, and for PW’s informational
     * purposes only. 
     * 
     * @param string $text Text to search for
     * @param array $options Options array provided to search() calls: 
     *  - `edit` (bool): True if any 'url' returned should be to edit rather than view items, where access allows. (default=true)
     *  - `multilang` (bool): If true, search all languages rather than just current (default=true).
     *  - `start` (int): Start index (0-based), if pagination active (default=0).
     *  - `limit` (int): Limit to this many items, or 0 for no limit. (default=0).
     *  - `type` (string): If search should only be of a specific type, i.e. "pages", "modules", etc. then it is 
     *     specified here. This corresponds with the getModuleInfo()['searchable'] name or item 'group' property. 
     *     Note that ProcessWire won’t call your search() method if the type cannot match this search. 
     *  - `operator` (string): Selector operator type requested, if more than one is supported (default is %=).
     *  - `property` (string): If search should limit to a particular property/field, it is named here. 
     *  - `verbose` (bool): True if output can optionally be more verbose, false if not. (default=false)
     *  - `debug` (bool): True if DEBUG option was specified in query. (default=false)
     *  - `help` (bool): True if we are just querying for help/info and are not using the search results. (default=false)
     * @return array
     *
     */
    public function search($text, array $options = array()); 
}