directories. if (file_exists("profiles/$profile/$directory")) { $searchdir[] = "profiles/$profile/$directory"; } // Always search sites/all/*. $searchdir[] = 'sites/all/' . $directory; // Also search sites//*. if (file_exists("$config/$directory")) { $searchdir[] = "$config/$directory"; } // Retrieve list of directories. // @todo Core: Allow to scan for directories. $directories = array(); $nomask = array('CVS'); foreach ($searchdir as $dir) { if (is_dir($dir) && $handle = opendir($dir)) { while (FALSE !== ($file = readdir($handle))) { if (!in_array($file, $nomask) && $file[0] != '.') { if (is_dir("$dir/$file")) { $directories[$file] = "$dir/$file"; } } } closedir($handle); } } return $directories; } /** * Looks for library info files. * * This function scans the following directories for info files: * - libraries * - profiles/$profilename/libraries * - sites/all/libraries * - sites/$sitename/libraries * - any directories specified via hook_libraries_info_file_paths() * * @return * An array of info files, keyed by library name. The values are the paths of * the files. */ function libraries_scan_info_files() { $profile = drupal_get_profile(); $config = conf_path(); // Build a list of directories. $directories = module_invoke_all('libraries_info_file_paths'); $directories[] = 'libraries'; $directories[] = "profiles/$profile/libraries"; $directories[] = 'sites/all/libraries'; $directories[] = "$config/libraries"; // Scan for info files. $files = array(); foreach ($directories as $dir) { if (file_exists($dir)) { $files = array_merge($files, file_scan_directory($dir, '@^[a-z0-9._-]+\.libraries\.info$@', array( 'key' => 'name', 'recurse' => FALSE, ))); } } foreach ($files as $filename => $file) { $files[basename($filename, '.libraries')] = $file; unset($files[$filename]); } return $files; } /** * Returns information about registered libraries. * * The returned information is unprocessed, i.e. as registered by modules. * * @param $name * (optional) The machine name of a library to return registered information * for, or FALSE if no library with the given name exists. If omitted, * information about all libraries is returned. * * @return * An associative array containing registered information for all libraries, * or the registered information for the library specified by $name. * * @see hook_libraries_info() * * @todo Re-introduce support for include file plugin system - either by copying * Wysiwyg's code, or directly switching to CTools. */ function libraries_info($name = NULL) { $libraries = &drupal_static(__FUNCTION__); if (!isset($libraries)) { $libraries = array(); // Gather information from hook_libraries_info(). foreach (module_implements('libraries_info') as $module) { foreach (module_invoke($module, 'libraries_info') as $machine_name => $properties) { $properties['module'] = $module; $libraries[$machine_name] = $properties; } } // Gather information from .info files. // .info files override module definitions. foreach (libraries_scan_info_files() as $machine_name => $file) { $properties = drupal_parse_info_file($file->uri); $properties['info file'] = $file->uri; $libraries[$machine_name] = $properties; } // Provide defaults. foreach ($libraries as $machine_name => &$properties) { $properties += array( 'machine name' => $machine_name, 'name' => $machine_name, 'vendor url' => '', 'download url' => '', 'path' => '', 'library path' => NULL, 'version callback' => 'libraries_get_version', 'version arguments' => array(), 'files' => array(), 'variants' => array(), 'versions' => array(), 'integration files' => array(), ); } // Allow modules to alter the registered libraries. drupal_alter('libraries_info', $libraries); } if (isset($name)) { return !empty($libraries[$name]) ? $libraries[$name] : FALSE; } return $libraries; } /** * Detect libraries and library versions. * * @todo We need to figure out whether, and if, how we want to retain the * processed information. I.e. either use a static cache here, or make * libraries_info() conditionally invoke libraries_detect($name). D7 only way: * Re-use drupal_static() of libraries_info() - but would still require to * update the (DB) cache (there likely will be one soon). Also, we probably do * not want to ALWAYS parse ALL possible libraries; rather, the * requesting/consuming module likely wants to know whether a list of * supported libraries (possibly those registered by itself, or in a certain * "category") is available... Food for thought. * * @param $libraries * An array of libraries to detect, as returned from libraries_info(). * * @see libraries_info() */ function libraries_detect($libraries) { foreach ($libraries as &$library) { libraries_detect_library($library); } return $libraries; } /** * Tries to detect a library and its installed version. * * @param $library * An associative array describing a single library, as returned from * libraries_info(). */ function libraries_detect_library(&$library) { $library['installed'] = FALSE; // Check whether the library exists. if (!isset($library['library path'])) { $library['library path'] = libraries_get_path($library['machine name']); } if (!file_exists($library['library path'])) { $library['error'] = 'not found'; $library['error message'] = t('The %library library could not be found.', array( '%library' => $library['name'], )); return; } // Detect library version, if not hardcoded. if (!isset($library['version'])) { // We support both a single parameter, which is an associative array, and an // indexed array of multiple parameters. if (isset($library['version arguments'][0])) { // Add the library as the first argument. $library['version'] = call_user_func_array($library['version callback'], array_merge(array($library), $library['version arguments'])); } else { $library['version'] = $library['version callback']($library, $library['version arguments']); } if (empty($library['version'])) { $library['error'] = 'not detected'; $library['error message'] = t('The version of the %library library could not be detected.', array( '%library' => $library['name'], )); return; } } // Determine to which supported version the installed version maps. if (!empty($library['versions'])) { ksort($library['versions']); $version = 0; foreach ($library['versions'] as $supported_version => $version_properties) { if (version_compare($library['version'], $supported_version, '>=')) { $version = $supported_version; } } if (!$version) { $library['error'] = 'not supported'; $library['error message'] = t('The installed version %version of the %library library is not supported.', array( '%version' => $library['version'], '%library' => $library['name'], )); return; } // Apply version specific definitions and overrides. $library = array_merge($library, $library['versions'][$version]); unset($library['versions']); } // Check each variant if it is installed. if (!empty($library['variants'])) { foreach ($library['variants'] as $variant_name => &$variant) { // If no variant callback has been set, assume the variant to be // installed. if (!isset($variant['variant callback'])) { $variant['installed'] = TRUE; } else { // We support both a single parameter, which is an associative array, // and an indexed array of multiple parameters. if (isset($variant['variant arguments'][0])) { // Add the library as the first argument, and the variant name as the second. $variant['installed'] = call_user_func_array($variant['variant callback'], array_merge(array($library, $variant_name), $variant['variant arguments'])); } else { $variant['installed'] = $variant['variant callback']($library, $variant_name, $variant['variant arguments']); } if (!$variant['installed']) { $variant['error'] = 'not found'; $variant['error message'] = t('The %variant variant of the %library library could not be found.', array( '%variant' => $variant_name, '%library' => $library['name'], )); } } } } // If we end up here, the library should be usable. $library['installed'] = TRUE; return $library; } /** * Loads a library. * * @param $name * The name of the library to load. * @param $variant * The name of the variant to load. Note that only one variant of a library * can be loaded within a single request. The variant that has been passed * first is used; different variant names in subsequent calls are ignored. * * @return * An associative array of the library information as returned from * libraries_info(). The top-level properties contain the effective definition * of the library (variant) that has been loaded. Additionally: * - installed: Whether the library is installed, as determined by * libraries_detect_library(). * - loaded: Either the amount of library files that have been loaded, or * FALSE if the library could not be loaded. * See hook_libraries_info() for more information. */ function libraries_load($name, $variant = NULL) { $loaded = &drupal_static(__FUNCTION__, array()); if (!isset($loaded[$name])) { $library = libraries_info($name); libraries_detect_library($library); // If a variant was specified, override the top-level properties with the // variant properties. if (isset($variant)) { // Ensure that the $variant key exists, and if it does not, set its // 'installed' property to FALSE by default. This will prevent the loading // of the library files below. $library['variants'] += array($variant => array('installed' => FALSE)); $library = array_merge($library, $library['variants'][$variant]); } // Regardless of whether a specific variant was requested or not, there can // only be one variant of a library within a single request. unset($library['variants']); // If the library (variant) is installed, load it. $library['loaded'] = FALSE; if ($library['installed']) { $library['loaded'] = libraries_load_files($library); } $loaded[$name] = $library; } return $loaded[$name]; } /** * Loads a library's files. * * @param $library * An array of library information as returned by libraries_info(). * * @return * The number of loaded files. */ function libraries_load_files($library) { // Load integration files. if (!empty($library['integration files'])) { foreach ($library['integration files'] as $module => $files) { libraries_load_files(array( 'files' => $files, 'path' => '', 'library path' => drupal_get_path('module', $module), )); } } // Construct the full path to the library for later use. $path = $library['library path']; $path = ($library['path'] !== '' ? $path . '/' . $library['path'] : $path); // Count the number of loaded files for the return value. $count = 0; // Load both the JavaScript and the CSS files. // The parameters for drupal_add_js() and drupal_add_css() require special // handling. // @see drupal_process_attached() foreach (array('js', 'css') as $type) { if (!empty($library['files'][$type])) { foreach ($library['files'][$type] as $data => $options) { // If the value is not an array, it's a filename and passed as first // (and only) argument. if (!is_array($options)) { // Prepend the library path to the file name. $data = "$path/$options"; $options = NULL; } // In some cases, the first parameter ($data) is an array. Arrays can't // be passed as keys in PHP, so we have to get $data from the value // array. if (is_numeric($data)) { $data = $options['data']; unset($options['data']); } // Apply the default group if the group isn't explicitly given. if (!isset($options['group'])) { $options['group'] = ($type == 'js') ? JS_DEFAULT : CSS_DEFAULT; } call_user_func('drupal_add_' . $type, $data, $options); $count++; } } } // Load PHP files. if (!empty($library['files']['php'])) { foreach ($library['files']['php'] as $file) { $file_path = DRUPAL_ROOT . '/' . $path . '/' . $file; if (file_exists($file_path)) { require_once $file_path; $count++; } } } return $count; } /** * Gets the version information from an arbitrary library. * * @param $library * An associative array containing all information about the library. * @param $options * An associative array containing with the following keys: * - file: The filename to parse for the version, relative to the library * path. For example: 'docs/changelog.txt'. * - pattern: A string containing a regular expression (PCRE) to match the * library version. For example: '@version\s+([0-9a-zA-Z\.-]+)@'. * - lines: (optional) The maximum number of lines to search the pattern in. * Defaults to 20. * - cols: (optional) The maximum number of characters per line to take into * account. Defaults to 200. In case of minified or compressed files, this * prevents reading the entire file into memory. * * @return * A string containing the version of the library. * * @see libraries_get_path() */ function libraries_get_version($library, $options) { // Provide defaults. $options += array( 'file' => '', 'pattern' => '', 'lines' => 20, 'cols' => 200, ); $file = DRUPAL_ROOT . '/' . $library['library path'] . '/' . $options['file']; if (empty($options['file']) || !file_exists($file)) { return; } $file = fopen($file, 'r'); while ($options['lines'] && $line = fgets($file, $options['cols'])) { if (preg_match($options['pattern'], $line, $version)) { fclose($file); return $version[1]; } $options['lines']--; } fclose($file); }