Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
<?php
/**
* @file
* Contains Drupal\Core\Extension\ModuleHandlerInterface.
*/
namespace Drupal\Core\Extension;
/**
* Interface for classes that manage a set of enabled modules.
*
* Classes implementing this interface work with a fixed list of modules and are
* responsible for loading module files and maintaining information about module
* dependencies and hook implementations.
*/
interface ModuleHandlerInterface {
/**
* Includes a module's .module file.
*
* This prevents including a module more than once.
*
* @param string $name
* The name of the module to load.
*
* @return bool
* TRUE if the item is loaded or has already been loaded.
*/
public function load($name);
/**
* Loads all enabled modules.
*/
public function loadAll();
/**
* Returns whether all modules have been loaded.
*
* @return bool
* A Boolean indicating whether all modules have been loaded. This means all
* modules; the load status of bootstrap modules cannot be checked.
*/
public function isLoaded();
/**
* Reloads all enabled modules.
*/
public function reload();
/**
* Returns the list of currently active modules.
* @return \Drupal\Core\Extension\Extension[]
* An associative array whose keys are the names of the modules and whose
* values are Extension objects.
*/
public function getModuleList();
/**
* Returns a module extension object from the currently active modules list.
*
* @param string $name
* The name of the module to return.
*
* @return \Drupal\Core\Extension\Extension
* An extension object.
*
* @throws \InvalidArgumentException
* Thrown when the requested module does not exist.
*/
public function getModule($name);
* Sets an explicit list of currently active modules.
* @param \Drupal\Core\Extension\Extension[] $module_list
* An associative array whose keys are the names of the modules and whose
* values are Extension objects.
*/
public function setModuleList(array $module_list = array());
/**
* Adds a module to the list of currently active modules.
*
* @param string $name
* The module name; e.g., 'node'.
* @param string $path
* The module path; e.g., 'core/modules/node'.
*/
public function addModule($name, $path);
/**
* Adds an installation profile to the list of currently active modules.
*
* @param string $name
* The profile name; e.g., 'standard'.
* @param string $path
* The profile path; e.g., 'core/profiles/standard'.
*/
public function addProfile($name, $path);
/**
* Determines which modules require and are required by each module.
*
* @param array $modules
* An array of module objects keyed by module name. Each object contains
catch
committed
* information discovered during a Drupal\Core\Extension\ExtensionDiscovery
* scan.
*
* @return
* The same array with the new keys for each module:
* - requires: An array with the keys being the modules that this module
* requires.
* - required_by: An array with the keys being the modules that will not work
* without this module.
*
catch
committed
* @see \Drupal\Core\Extension\ExtensionDiscovery
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
*/
public function buildModuleDependencies(array $modules);
/**
* Determines whether a given module is enabled.
*
* @param string $module
* The name of the module (without the .module extension).
*
* @return bool
* TRUE if the module is both installed and enabled.
*/
public function moduleExists($module);
/**
* Loads an include file for each enabled module.
*
* @param string $type
* The include file's type (file extension).
* @param string $name
* (optional) The base file name (without the $type extension). If omitted,
* each module's name is used; i.e., "$module.$type" by default.
*/
public function loadAllIncludes($type, $name = NULL);
/**
* Loads a module include file.
*
* Examples:
* @code
* // Load node.admin.inc from the node module.
* $this->loadInclude('node', 'inc', 'node.admin');
* // Load content_types.inc from the node module.
* $this->loadInclude('node', 'inc', ''content_types');
* @endcode
*
* @param string $module
* The module to which the include file belongs.
* @param string $type
* The include file's type (file extension).
* @param string $name
* (optional) The base file name (without the $type extension). If omitted,
* $module is used; i.e., resulting in "$module.$type" by default.
*
* @return string|false
* The name of the included file, if successful; FALSE otherwise.
*/
public function loadInclude($module, $type, $name = NULL);
Angie Byron
committed
/**
* Retrieves a list of hooks that are declared through hook_hook_info().
*
* @return array
* An associative array whose keys are hook names and whose values are an
* associative array containing a group name. The structure of the array
* is the same as the return value of hook_hook_info().
*
* @see hook_hook_info()
*/
public function getHookInfo();
/**
* Determines which modules are implementing a hook.
*
* @param string $hook
* The name of the hook (e.g. "help" or "menu").
*
* @return array
* An array with the names of the modules which are implementing this hook.
*/
public function getImplementations($hook);
/**
* Write the hook implementation info to the cache.
*/
public function writeCache();
/**
* Resets the cached list of hook implementations.
*/
public function resetImplementations();
/**
* Returns whether a given module implements a given hook.
*
* @param string $module
* The name of the module (without the .module extension).
* @param string $hook
* The name of the hook (e.g. "help" or "menu").
*
* @return bool
* TRUE if the module is both installed and enabled, and the hook is
* implemented in that module.
*/
public function implementsHook($module, $hook);
/**
* Invokes a hook in a particular module.
*
* @param string $module
* The name of the module (without the .module extension).
* @param string $hook
* The name of the hook to invoke.
* @param ...
* Arguments to pass to the hook implementation.
*
* @return mixed
* The return value of the hook implementation.
*/
public function invoke($module, $hook, array $args = array());
/**
* Invokes a hook in all enabled modules that implement it.
*
* @param string $hook
* The name of the hook to invoke.
catch
committed
* @param array $args
* Arguments to pass to the hook.
*
* @return array
* An array of return values of the hook implementations. If modules return
* arrays from their implementations, those are merged into one array.
*/
public function invokeAll($hook, array $args = array());
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
/**
* Passes alterable variables to specific hook_TYPE_alter() implementations.
*
* This dispatch function hands off the passed-in variables to type-specific
* hook_TYPE_alter() implementations in modules. It ensures a consistent
* interface for all altering operations.
*
* A maximum of 2 alterable arguments is supported. In case more arguments need
* to be passed and alterable, modules provide additional variables assigned by
* reference in the last $context argument:
* @code
* $context = array(
* 'alterable' => &$alterable,
* 'unalterable' => $unalterable,
* 'foo' => 'bar',
* );
* $this->alter('mymodule_data', $alterable1, $alterable2, $context);
* @endcode
*
* Note that objects are always passed by reference in PHP5. If it is absolutely
* required that no implementation alters a passed object in $context, then an
* object needs to be cloned:
* @code
* $context = array(
* 'unalterable_object' => clone $object,
* );
* $this->alter('mymodule_data', $data, $context);
* @endcode
*
* @param string|array $type
* A string describing the type of the alterable $data. 'form', 'links',
* 'node_content', and so on are several examples. Alternatively can be an
* array, in which case hook_TYPE_alter() is invoked for each value in the
* array, ordered first by module, and then for each module, in the order of
* values in $type. For example, when Form API is using $this->alter() to
* execute both hook_form_alter() and hook_form_FORM_ID_alter()
* implementations, it passes array('form', 'form_' . $form_id) for $type.
* @param mixed $data
* The variable that will be passed to hook_TYPE_alter() implementations to be
* altered. The type of this variable depends on the value of the $type
* argument. For example, when altering a 'form', $data will be a structured
* array. When altering a 'profile', $data will be an object.
* @param mixed $context1
* (optional) An additional variable that is passed by reference.
* @param mixed $context2
* (optional) An additional variable that is passed by reference. If more
* context needs to be provided to implementations, then this should be an
* associative array as described above.
*/
public function alter($type, &$data, &$context1 = NULL, &$context2 = NULL);
/**
Dries Buytaert
committed
* Installs a given list of modules.
*
* Order of events:
* - Gather and add module dependencies to $module_list (if applicable).
Dries Buytaert
committed
* - For each module that is being installed:
* - Invoke hook_module_preinstall().
* - Install module schema and update system registries and caches.
Dries Buytaert
committed
* - Invoke hook_install() and add it to the list of installed modules.
* - Invoke hook_modules_installed().
*
Dries Buytaert
committed
* @param array $module_list
* An array of module names.
Dries Buytaert
committed
* @param bool $enable_dependencies
* (optional) If TRUE, dependencies will automatically be installed in the
* correct order. This incurs a significant performance cost, so use FALSE
Dries Buytaert
committed
* if you know $module_list is already complete.
*
Dries Buytaert
committed
* @return bool
* FALSE if one or more dependencies are missing, TRUE otherwise.
*
Dries Buytaert
committed
* @see hook_module_preinstall()
* @see hook_install()
* @see hook_modules_installed()
*/
Dries Buytaert
committed
public function install(array $module_list, $enable_dependencies = TRUE);
/**
* Uninstalls a given list of disabled modules.
*
* @param array $module_list
Dries Buytaert
committed
* The modules to uninstall.
* @param bool $uninstall_dependents
Dries Buytaert
committed
* (optional) If TRUE, dependent modules will automatically be uninstalled
* in the correct order. This incurs a significant performance cost, so use
* FALSE if you know $module_list is already complete.
*
* @return bool
Dries Buytaert
committed
* FALSE if one or more dependencies are missing, TRUE otherwise.
*
* @see hook_module_preuninstall()
* @see hook_uninstall()
* @see hook_modules_uninstalled()
*/
Dries Buytaert
committed
public function uninstall(array $module_list, $uninstall_dependents = TRUE);
Alex Pott
committed
/**
* Returns an array of directories for all enabled modules. Useful for
* tasks such as finding a file that exists in all module directories.
*
* @return array
*/
public function getModuleDirectories();
Angie Byron
committed
/**
* Gets the human readable name of a given module.
*
* @param string $module
* The machine name of the module which title should be shown.
*
* @return string
* Returns the human readable name of the module.
*/
public function getName($theme);