class FeaturesManager in Features 8.4
Same name and namespace in other branches
- 8.3 src/FeaturesManager.php \Drupal\features\FeaturesManager
The FeaturesManager provides helper functions for building packages.
Hierarchy
- class \Drupal\features\FeaturesManager implements FeaturesManagerInterface uses StringTranslationTrait
Expanded class hierarchy of FeaturesManager
1 file declares its use of FeaturesManager
- FeaturesManagerTest.php in tests/
src/ Unit/ FeaturesManagerTest.php
1 string reference to 'FeaturesManager'
1 service uses FeaturesManager
File
- src/
FeaturesManager.php, line 25
Namespace
Drupal\featuresView source
class FeaturesManager implements FeaturesManagerInterface {
use StringTranslationTrait;
/**
* The entity type manager.
*
* @var \Drupal\Core\Entity\EntityTypeManagerInterface
*/
protected $entityTypeManager;
/**
* The target storage.
*
* @var \Drupal\Core\Config\StorageInterface
*/
protected $configStorage;
/**
* The extension storages.
*
* @var \Drupal\features\FeaturesExtensionStoragesByDirectoryInterface
*/
protected $extensionStorages;
/**
* The configuration manager.
*
* @var \Drupal\Core\Config\ConfigManagerInterface
*/
protected $configManager;
/**
* The configuration factory.
*
* @var \Drupal\Core\Config\ConfigFactoryInterface
*/
protected $configFactory;
/**
* The module handler.
*
* @var \Drupal\Core\Extension\ModuleHandlerInterface
*/
protected $moduleHandler;
/**
* The config reverter.
*
* @var \Drupal\config_update\ConfigRevertInterface
*/
protected $configReverter;
/**
* The module extension list service.
*
* @var \Drupal\Core\Extension\ModuleExtensionList
*/
protected $moduleExtensionList;
/**
* The Features settings.
*
* @var array
*/
protected $settings;
/**
* The app root.
*
* @var string
*/
protected $root;
/**
* The configuration present on the site.
*
* @var \Drupal\features\ConfigurationItem[]
*/
private $configCollection;
/**
* The packages to be generated.
*
* @var \Drupal\features\Package[]
*/
protected $packages;
/**
* Whether the packages have been assigned a bundle prefix.
*
* @var bool
*/
protected $packagesPrefixed;
/**
* The package assigner.
*
* @var \Drupal\features\FeaturesAssigner
*/
protected $assigner;
/**
* Cache module.features.yml data keyed by module name.
*
* @var array
*/
protected $featureInfoCache;
/**
* Constructs a FeaturesManager object.
*
* @param string $root
* The app root.
* @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
* The entity type manager.
* @param \Drupal\Core\Config\ConfigFactoryInterface $config_factory
* The configuration factory.
* @param \Drupal\Core\Config\StorageInterface $config_storage
* The target storage.
* @param \Drupal\Core\Config\ConfigManagerInterface $config_manager
* The configuration manager.
* @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
* The module handler.
* @param \Drupal\config_update\ConfigRevertInterface $config_reverter
* The config revert interface.
* @param \Drupal\Core\Extension\ModuleExtensionList $module_extension_list
* The module extension list service.
*/
public function __construct($root, EntityTypeManagerInterface $entity_type_manager, ConfigFactoryInterface $config_factory, StorageInterface $config_storage, ConfigManagerInterface $config_manager, ModuleHandlerInterface $module_handler, ConfigRevertInterface $config_reverter, ModuleExtensionList $module_extension_list) {
$this->root = $root;
$this->entityTypeManager = $entity_type_manager;
$this->configStorage = $config_storage;
$this->configManager = $config_manager;
$this->moduleHandler = $module_handler;
$this->configFactory = $config_factory;
$this->configReverter = $config_reverter;
$this->moduleExtensionList = $module_extension_list;
$this->settings = $config_factory
->getEditable('features.settings');
$this->extensionStorages = new FeaturesExtensionStoragesByDirectory($this->configStorage);
$this->extensionStorages
->addStorage(InstallStorage::CONFIG_INSTALL_DIRECTORY);
$this->extensionStorages
->addStorage(InstallStorage::CONFIG_OPTIONAL_DIRECTORY);
$this->packages = [];
$this->packagesPrefixed = FALSE;
$this->configCollection = [];
}
/**
* {@inheritdoc}
*/
public function setRoot($root) {
$this->root = $root;
// Clear cache.
$this->featureInfoCache = [];
}
/**
* {@inheritdoc}
*/
public function getActiveStorage() {
return $this->configStorage;
}
/**
* {@inheritdoc}
*/
public function getExtensionStorages() {
return $this->extensionStorages;
}
/**
* {@inheritdoc}
*/
public function getFullName($type, $name) {
if ($type == FeaturesManagerInterface::SYSTEM_SIMPLE_CONFIG || !$type) {
return $name;
}
$definition = $this->entityTypeManager
->getDefinition($type);
$prefix = $definition
->getConfigPrefix() . '.';
return $prefix . $name;
}
/**
* {@inheritdoc}
*/
public function getConfigType($fullname) {
$result = [
'type' => '',
'name_short' => '',
];
$prefix = FeaturesManagerInterface::SYSTEM_SIMPLE_CONFIG . '.';
if (strpos($fullname, $prefix) !== FALSE) {
$result['type'] = FeaturesManagerInterface::SYSTEM_SIMPLE_CONFIG;
$result['name_short'] = substr($fullname, strlen($prefix));
}
else {
foreach ($this->entityTypeManager
->getDefinitions() as $entity_type => $definition) {
if ($definition
->entityClassImplements('Drupal\\Core\\Config\\Entity\\ConfigEntityInterface')) {
$prefix = $definition
->getConfigPrefix() . '.';
if (strpos($fullname, $prefix) === 0) {
$result['type'] = $entity_type;
$result['name_short'] = substr($fullname, strlen($prefix));
}
}
}
}
return $result;
}
/**
* {@inheritdoc}
*/
public function reset() {
$this->packages = [];
// Don't use getConfigCollection because reset() may be called in
// cases where we don't need to load config.
foreach ($this->configCollection as $config) {
$config
->setPackage(NULL);
}
}
/**
* {@inheritdoc}
*/
public function getConfigCollection($reset = FALSE) {
$this
->initConfigCollection($reset);
return $this->configCollection;
}
/**
* {@inheritdoc}
*/
public function setConfigCollection(array $config_collection) {
$this->configCollection = $config_collection;
}
/**
* {@inheritdoc}
*/
public function getPackages() {
return $this->packages;
}
/**
* {@inheritdoc}
*/
public function setPackages(array $packages) {
$this->packages = $packages;
}
/**
* {@inheritdoc}
*/
public function getPackage($machine_name) {
if (isset($this->packages[$machine_name])) {
return $this->packages[$machine_name];
}
return NULL;
}
/**
* {@inheritdoc}
*/
public function findPackage($machine_name) {
$result = $this
->getPackage($machine_name);
if (!isset($result)) {
// Didn't find direct match, but now go through and look for matching
// full name (bundle_machinename)
foreach ($this->packages as $name => $package) {
if ($package
->getFullName() == $machine_name) {
return $this->packages[$name];
}
}
}
return $result;
}
/**
* {@inheritdoc}
*/
public function setPackage(Package $package) {
if ($package
->getMachineName()) {
$this->packages[$package
->getMachineName()] = $package;
}
}
/**
* {@inheritdoc}
*/
public function loadPackage($module_name, $any = FALSE) {
$package = $this
->getPackage($module_name);
// Load directly from module if packages are not loaded or
// if we want to include ANY module regardless of its a feature.
if ((empty($this->packages) || $any) && !isset($package)) {
$module_list = $this->moduleHandler
->getModuleList();
if (!empty($module_list[$module_name])) {
$extension = $module_list[$module_name];
$package = $this
->initPackageFromExtension($extension);
$config = $this
->listExtensionConfig($extension);
$package
->setConfigOrig($config);
$package
->setStatus(FeaturesManagerInterface::STATUS_INSTALLED);
}
}
return $package;
}
/**
* {@inheritdoc}
*/
public function filterPackages(array $packages, $namespace = '', $only_exported = FALSE) {
$result = [];
/** @var \Drupal\features\Package $package */
foreach ($packages as $key => $package) {
// A package matches the namespace if:
// - it's prefixed with the namespace, or
// - it's assigned to a bundle named for the namespace, or
// - the namespace is the default bundle and it has an empty bundle, and
// - we're not removing only exported packages, or
// - we are removing only exported packages and it's not exported.
if ((strpos($package
->getMachineName(), $namespace . '_') === 0 || $package
->getBundle() && $package
->getBundle() === $namespace || $namespace === FeaturesBundleInterface::DEFAULT_BUNDLE && empty($package
->getBundle())) && (!$only_exported || $package
->getStatus() === FeaturesManagerInterface::STATUS_NO_EXPORT)) {
$result[$key] = $package;
}
}
return $result;
}
/**
* {@inheritdoc}
*/
public function getAssigner() {
if (empty($this->assigner)) {
$this
->setAssigner(\Drupal::service('features_assigner'));
}
return $this->assigner;
}
/**
* {@inheritdoc}
*/
public function setAssigner(FeaturesAssignerInterface $assigner) {
$this->assigner = $assigner;
$this
->reset();
}
/**
* {@inheritdoc}
*/
public function getGenerator() {
return $this->generator;
}
/**
* {@inheritdoc}
*/
public function setGenerator(FeaturesGeneratorInterface $generator) {
$this->generator = $generator;
}
/**
* {@inheritdoc}
*/
public function getExportSettings() {
return $this->settings
->get('export');
}
/**
* {@inheritdoc}
*/
public function getSettings() {
return $this->settings;
}
/**
* {@inheritdoc}
*/
public function getExtensionInfo(Extension $extension) {
return Yaml::decode(file_get_contents($this->root . '/' . $extension
->getPathname()));
}
/**
* {@inheritdoc}
*/
public function isFeatureModule(Extension $module, FeaturesBundleInterface $bundle = NULL) {
if ($features_info = $this
->getFeaturesInfo($module)) {
// If no bundle was requested, it's enough that this is a feature.
if (is_null($bundle)) {
return TRUE;
}
elseif ($bundle
->isDefault()) {
return !isset($features_info['bundle']);
}
else {
return isset($features_info['bundle']) && $features_info['bundle'] == $bundle
->getMachineName();
}
}
return FALSE;
}
/**
* {@inheritdoc}
*/
public function listPackageDirectories(array $machine_names = [], FeaturesBundleInterface $bundle = NULL) {
if (empty($machine_names)) {
$machine_names = array_keys($this
->getPackages());
}
// If the bundle is a profile, then add the profile's machine name.
if (isset($bundle) && $bundle
->isProfile() && !in_array($bundle
->getProfileName(), $machine_names)) {
$machine_names[] = $bundle
->getProfileName();
}
// If we are checking the default bundle, return all features.
if (isset($bundle) && $bundle
->isDefault()) {
$bundle = NULL;
}
$modules = $this
->getFeaturesModules($bundle);
// Filter to include only the requested packages.
$modules = array_filter($modules, function ($module) use ($bundle, $machine_names) {
return in_array($module
->getName(), $machine_names);
});
$directories = [];
foreach ($modules as $module) {
$directories[$module
->getName()] = $module
->getPath();
}
return $directories;
}
/**
* {@inheritdoc}
*/
public function getAllModules() {
static $modules;
if (!isset($modules)) {
// ModuleHandler::getModuleDirectories() returns data only for installed
// modules. system_rebuild_module_data() includes only the site's install
// profile directory, while we may need to include a custom profile.
// @see _system_rebuild_module_data().
$listing = new ExtensionDiscovery($this->root);
$profile_directories = $listing
->setProfileDirectoriesFromSettings()
->getProfileDirectories();
$installed_profile = $this
->drupalGetProfile();
if (isset($bundle) && $bundle
->isProfile()) {
$profile_directory = 'profiles/' . $bundle
->getProfileName();
if ($bundle
->getProfileName() != $installed_profile && is_dir($profile_directory)) {
$profile_directories[] = $profile_directory;
}
}
$listing
->setProfileDirectories($profile_directories);
// Find modules.
$modules = $listing
->scan('module');
// Find installation profiles.
$profiles = $listing
->scan('profile');
foreach ($profiles as $key => $profile) {
$modules[$key] = $profile;
}
}
return $modules;
}
/**
* {@inheritdoc}
*/
public function getFeaturesModules(FeaturesBundleInterface $bundle = NULL, $installed = FALSE) {
$modules = $this
->getAllModules();
// Filter by bundle.
$features_manager = $this;
$modules = array_filter($modules, function ($module) use ($features_manager, $bundle) {
return $features_manager
->isFeatureModule($module, $bundle);
});
// Filtered by installed status.
if ($installed) {
$features_manager = $this;
$modules = array_filter($modules, function ($extension) use ($features_manager) {
return $features_manager
->extensionEnabled($extension);
});
}
return $modules;
}
/**
* {@inheritdoc}
*/
public function extensionEnabled(Extension $extension) {
return $this->moduleHandler
->moduleExists($extension
->getName());
}
/**
* {@inheritdoc}
*/
public function initPackage($machine_name, $name = NULL, $description = '', $type = 'module', FeaturesBundleInterface $bundle = NULL, Extension $extension = NULL) {
if (isset($this->packages[$machine_name])) {
return $this->packages[$machine_name];
}
elseif (isset($bundle) && isset($this->packages[$bundle
->getFullName($machine_name)])) {
return $this->packages[$bundle
->getFullName($machine_name)];
}
return $this->packages[$machine_name] = $this
->getPackageObject($machine_name, $name, $description, $type, $bundle, $extension);
}
/**
* {@inheritdoc}
*/
public function initPackageFromExtension(Extension $extension) {
$info = $this
->getExtensionInfo($extension);
$features_info = $this
->getFeaturesInfo($extension);
$bundle = $this
->getAssigner()
->findBundle($info, $features_info);
// Use the full extension name as the short_name. Important to allow
// multiple modules with different namespaces such as oa_media, test_media.
$short_name = $extension
->getName();
return $this
->initPackage($short_name, $info['name'], !empty($info['description']) ? $info['description'] : '', $info['type'], $bundle, $extension);
}
/**
* Helper function to update dependencies array for a specific config item.
*
* @param \Drupal\features\ConfigurationItem $config
* a config item.
* @param array $module_list
*
* @return array $dependencies
*/
protected function getConfigDependency(ConfigurationItem $config, array $module_list = []) {
$dependencies = [];
$type = $config
->getType();
// For configuration in the InstallStorage::CONFIG_INSTALL_DIRECTORY
// directory, set any dependencies of the configuration item as package
// dependencies.
// As its name implies, the core-provided
// InstallStorage::CONFIG_OPTIONAL_DIRECTORY should not create
// dependencies.
if ($config
->getSubdirectory() === InstallStorage::CONFIG_INSTALL_DIRECTORY) {
if ($type === FeaturesManagerInterface::SYSTEM_SIMPLE_CONFIG) {
$dependencies[] = strtok($config
->getName(), '.');
}
else {
$dependencies[] = $this->entityTypeManager
->getDefinition($type)
->getProvider();
}
if (isset($config
->getData()['dependencies']['module'])) {
$dependencies = array_merge($dependencies, $config
->getData()['dependencies']['module']);
}
// Only return dependencies for installed modules and not, for example,
// 'core'.
$dependencies = array_intersect($dependencies, array_keys($module_list));
}
return $dependencies;
}
/**
* {@inheritdoc}
*/
public function assignConfigPackage($package_name, array $item_names, $force = FALSE) {
$config_collection = $this
->getConfigCollection();
$module_list = $this->moduleHandler
->getModuleList();
$current_bundle = $this->assigner
->getBundle();
$packages =& $this->packages;
if (isset($packages[$package_name])) {
$package =& $packages[$package_name];
}
elseif (isset($current_bundle) && isset($this->packages[$current_bundle
->getFullName($package_name)])) {
$package =& $this->packages[$current_bundle
->getFullName($package_name)];
}
else {
throw new \Exception($this
->t('Failed to package @package_name. Package not found.', [
'@package_name' => $package_name,
]));
}
foreach ($item_names as $item_name) {
if (isset($config_collection[$item_name])) {
// Add to the package if:
// - force is set or
// - the item hasn't already been assigned elsewhere, and
// - the package hasn't been excluded.
// - and the item isn't already in the package.
$item =& $config_collection[$item_name];
$already_assigned = !empty($item
->getPackage());
// If this is the profile package, we can reassign extension-provided
// configuration.
$package_bundle = $this
->getAssigner()
->getBundle($package
->getBundle());
$is_profile_package = isset($package_bundle) ? $package_bundle
->isProfilePackage($package_name) : FALSE;
// An item is assignable if:
// - it is not provider excluded or this is the profile package, and
// - it is not flagged as excluded.
$assignable = (!$item
->isProviderExcluded() || $is_profile_package) && !$item
->isExcluded();
// An item is assignable if it was provided by the current package.
$assignable = $assignable || $item
->getProvider() == $package
->getMachineName();
$excluded_from_package = in_array($package_name, $item
->getPackageExcluded());
$already_in_package = in_array($item_name, $package
->getConfig());
if (($force || !$already_assigned && $assignable && !$excluded_from_package) && !$already_in_package) {
// Add the item to the package's config array.
$package
->appendConfig($item_name);
// Mark the item as already assigned.
$item
->setPackage($package_name);
$module_dependencies = $this
->getConfigDependency($item, $module_list);
$package
->setDependencies($this
->mergeUniqueItems($package
->getDependencies(), $module_dependencies));
}
// Return memory.
unset($item);
}
}
$this
->setConfigCollection($config_collection);
}
/**
* {@inheritdoc}
*/
public function assignConfigByPattern(array $patterns) {
// Regular expressions for items that are likely to generate false
// positives when assigned by pattern.
$false_positives = [
// Blocks with the page title should not be assigned to a 'page' package.
'/block\\.block\\..*_page_title/',
];
$config_collection = $this
->getConfigCollection();
// Sort by key so that specific package will claim items before general
// package. E.g., event_registration and registration_event will claim
// before event.
uksort($patterns, function ($a, $b) {
// Count underscores to determine specificity of the package.
return (int) (substr_count($a, '_') <= substr_count($b, '_'));
});
foreach ($patterns as $pattern => $machine_name) {
if (isset($this->packages[$machine_name])) {
foreach ($config_collection as $item_name => $item) {
// Test for and skip false positives.
foreach ($false_positives as $false_positive) {
if (preg_match($false_positive, $item_name)) {
continue 2;
}
}
if (!$item
->getPackage() && preg_match('/(\\.|-|_|^)' . $pattern . '(\\.|-|_|$)/', $item
->getShortName())) {
try {
$this
->assignConfigPackage($machine_name, [
$item_name,
]);
} catch (\Exception $exception) {
\Drupal::logger('features')
->error($exception
->getMessage());
}
}
}
}
}
}
/**
* {@inheritdoc}
*/
public function assignConfigDependents(array $item_names = NULL, $package = NULL) {
$config_collection = $this
->getConfigCollection();
if (empty($item_names)) {
$item_names = array_keys($config_collection);
}
foreach ($item_names as $item_name) {
// Make sure the extension provided item exists in the active
// configuration storage.
if (isset($config_collection[$item_name]) && $config_collection[$item_name]
->getPackage()) {
foreach ($config_collection[$item_name]
->getDependents() as $dependent_item_name) {
if (isset($config_collection[$dependent_item_name]) && (!empty($package) || empty($config_collection[$dependent_item_name]
->getPackage()))) {
try {
$package_name = !empty($package) ? $package : $config_collection[$item_name]
->getPackage();
$this
->assignConfigPackage($package_name, [
$dependent_item_name,
]);
} catch (\Exception $exception) {
\Drupal::logger('features')
->error($exception
->getMessage());
}
}
}
}
}
}
/**
* {@inheritdoc}
*/
public function setPackageBundleNames(FeaturesBundleInterface $bundle, array &$package_names = []) {
$this->packagesPrefixed = TRUE;
if (!$bundle
->isDefault()) {
$new_package_names = [];
// Assign the selected bundle to the exports.
$packages = $this
->getPackages();
if (empty($package_names)) {
$package_names = array_keys($packages);
}
foreach ($package_names as $package_name) {
// Rename package to use bundle prefix.
$package = $packages[$package_name];
// The install profile doesn't need renaming.
if ($package
->getType() != 'profile') {
unset($packages[$package_name]);
$package
->setMachineName($bundle
->getFullName($package
->getMachineName()));
$packages[$package
->getMachineName()] = $package;
}
// Set the bundle machine name.
$packages[$package
->getMachineName()]
->setBundle($bundle
->getMachineName());
$new_package_names[] = $package
->getMachineName();
}
$this
->setPackages($packages);
$package_names = $new_package_names;
}
}
/**
* {@inheritdoc}
*/
public function assignPackageDependencies(Package $package = NULL) {
if (is_null($package)) {
$packages = $this
->getPackages();
}
else {
$packages = [
$package,
];
}
$module_list = $this->moduleHandler
->getModuleList();
$config_collection = $this
->getConfigCollection();
foreach ($packages as $package) {
$module_dependencies = [];
foreach ($package
->getConfig() as $item_name) {
if (isset($config_collection[$item_name])) {
$dependencies = $this
->getConfigDependency($config_collection[$item_name], $module_list);
$module_dependencies = array_merge($module_dependencies, $dependencies);
}
}
$package
->setDependencies($this
->mergeUniqueItems($package
->getDependencies(), $module_dependencies));
}
}
/**
* {@inheritdoc}
*/
public function assignInterPackageDependencies(FeaturesBundleInterface $bundle, array &$packages) {
if (!$this->packagesPrefixed) {
throw new \Exception($this
->t('The packages have not yet been prefixed with a bundle name.'));
}
$config_collection = $this
->getConfigCollection();
$module_list = $this->moduleHandler
->getModuleList();
/** @var \Drupal\features\Package[] $packages */
foreach ($packages as $package) {
foreach ($package
->getConfig() as $item_name) {
if (!empty($config_collection[$item_name]
->getData()['dependencies']['config'])) {
foreach ($config_collection[$item_name]
->getData()['dependencies']['config'] as $dependency_name) {
if (isset($config_collection[$dependency_name]) && $config_collection[$dependency_name]
->getSubdirectory() === InstallStorage::CONFIG_INSTALL_DIRECTORY) {
// If the required item is assigned to one of the packages, add
// a dependency on that package.
$dependency_set = FALSE;
if ($dependency_package = $config_collection[$dependency_name]
->getPackage()) {
$package_name = $bundle
->getFullName($dependency_package);
if ($package_name && array_key_exists($package_name, $packages) && isset($module_list[$package_name])) {
$package
->appendDependency($package_name);
$dependency_set = TRUE;
}
}
// Otherwise, if the dependency is provided by an existing
// feature, add a dependency on that feature.
if (!$dependency_set && ($extension_name = $config_collection[$dependency_name]
->getProvider())) {
// No extension should depend on the install profile.
$package_name = $bundle
->getFullName($package
->getMachineName());
if ($extension_name != $package_name && $extension_name != $this
->drupalGetProfile() && isset($module_list[$extension_name])) {
$package
->appendDependency($extension_name);
}
}
}
}
}
}
}
// Unset the $package pass by reference.
unset($package);
}
/**
* Gets the name of the currently active installation profile.
*
* @return string|null
* The name of the installation profile or NULL if no installation profile is
* currently active. This is the case for example during the first steps of
* the installer or during unit tests.
*/
protected function drupalGetProfile() {
return \Drupal::installProfile();
}
/**
* Merges a set of new item into an array.
*
* Only unique values are retained.
*
* @param array $items
* An array of items.
* @param array $new_items
* An array of new items to be merged in.
*
* @return array
* The merged and unique items.
*/
protected function mergeUniqueItems(array $items, array $new_items) {
$items = array_unique(array_merge($items, $new_items));
return $items;
}
/**
* Initializes and returns a package or profile array.
*
* @param string $machine_name
* Machine name of the package.
* @param string $name
* (optional) Human readable name of the package.
* @param string $description
* (optional) Description of the package.
* @param string $type
* (optional) Type of project.
* @param \Drupal\features\FeaturesBundleInterface $bundle
* (optional) Bundle to use to add profile directories to the scan.
* @param \Drupal\Core\Extension\Extension $extension
* (optional) An Extension object.
*
* @return \Drupal\features\Package
* An array of package properties; see
* FeaturesManagerInterface::getPackages().
*/
protected function getPackageObject($machine_name, $name = NULL, $description = '', $type = 'module', FeaturesBundleInterface $bundle = NULL, Extension $extension = NULL) {
if (!isset($bundle)) {
$bundle = $this
->getAssigner()
->getBundle();
}
$package = new Package($machine_name, [
'name' => isset($name) ? $name : ucwords(str_replace([
'_',
'-',
], ' ', $machine_name)),
'description' => $description,
'type' => $type,
'status' => FeaturesManagerInterface::STATUS_DEFAULT,
'state' => FeaturesManagerInterface::STATE_DEFAULT,
'bundle' => $bundle
->isDefault() ? '' : $bundle
->getMachineName(),
]);
// If no extension was passed in, look for a match.
if (!isset($extension)) {
$module_list = $this
->getFeaturesModules($bundle);
$module_name = $package
->getMachineName();
if (isset($module_list[$module_name])) {
$extension = $module_list[$module_name];
}
}
// If there is an extension, set extension-specific properties.
if (isset($extension)) {
$info = $this
->getExtensionInfo($extension);
$features_info = $this
->getFeaturesInfo($extension);
$package
->setExtension($extension);
$package
->setInfo($info);
$package
->setFeaturesInfo($features_info);
$package
->setConfigOrig($this
->listExtensionConfig($extension));
$package
->setStatus($this
->extensionEnabled($extension) ? FeaturesManagerInterface::STATUS_INSTALLED : FeaturesManagerInterface::STATUS_UNINSTALLED);
$package
->setVersion(isset($info['version']) ? $info['version'] : '');
}
return $package;
}
/**
* Convert a Dependency object back to a string value.
*
* @param \Drupal\Core\Extension\Dependency $dependency
* The dependency to convert.
* @return string
* The normalized "project:name (constraint)" string.
*/
protected function getDependencyString(Dependency $dependency) {
$dependency_name = $dependency
->getName();
$project = $dependency
->getProject();
if (empty($project)) {
$path = $this->moduleExtensionList
->getPath($dependency_name);
// Handle project for core modules.
$project = strpos($path, 'core/modules') === 0 ? 'drupal' : $dependency_name;
// Override with project key for contrib or custom modules.
$info = $this->moduleExtensionList
->getExtensionInfo($dependency_name);
$project = isset($info['project']) ? $info['project'] : $project;
}
$new_dependency = $project . ':' . $dependency_name;
if ($constraint_string = $dependency
->getConstraintString()) {
$new_dependency = $new_dependency . ' (' . $constraint_string . ')';
}
return $new_dependency;
}
/**
* Generates and adds .info.yml files to a package.
*
* @param \Drupal\features\Package $package
* The package.
*/
protected function addInfoFile(Package $package) {
$info = [
'name' => $package
->getName(),
'description' => $package
->getDescription(),
'type' => $package
->getType(),
'core_version_requirement' => $package
->getCoreVersionRequirement(),
'dependencies' => $package
->getDependencies(),
'themes' => $package
->getThemes(),
'version' => $package
->getVersion(),
];
$features_info = [];
// Assign to a "package" named for the profile.
if ($package
->getBundle()) {
$bundle = $this
->getAssigner()
->getBundle($package
->getBundle());
}
// Save the current bundle in the info file so the package
// can be reloaded later by the AssignmentPackages plugin.
if (isset($bundle) && !$bundle
->isDefault()) {
$info['package'] = $bundle
->getName();
$features_info['bundle'] = $bundle
->getMachineName();
}
else {
unset($features_info['bundle']);
}
if ($package
->getConfig()) {
foreach ([
'excluded',
'required',
] as $constraint) {
if (!empty($package
->{'get' . $constraint}())) {
$features_info[$constraint] = $package
->{'get' . $constraint}();
}
else {
unset($features_info[$constraint]);
}
}
if (empty($features_info)) {
$features_info = TRUE;
}
}
// The name and description need to be cast as strings from the
// TranslatableMarkup objects returned by t() to avoid raising an
// InvalidDataTypeException on Yaml serialization.
foreach ([
'name',
'description',
] as $key) {
$info[$key] = (string) $info[$key];
}
// Add profile-specific info data.
if ($info['type'] == 'profile') {
// Set the distribution name.
$info['distribution'] = [
'name' => $info['name'],
];
}
$package
->appendFile([
'filename' => $package
->getMachineName() . '.info.yml',
'subdirectory' => NULL,
// Filter to remove any empty keys, e.g., an empty themes array.
'string' => Yaml::encode(array_filter($info)),
], 'info');
$package
->appendFile([
'filename' => $package
->getMachineName() . '.features.yml',
'subdirectory' => NULL,
'string' => Yaml::encode($features_info),
], 'features');
}
/**
* Generates and adds files to a given package or profile.
*/
protected function addPackageFiles(Package $package) {
$config_collection = $this
->getConfigCollection();
// Always add .info.yml and .features.yml files.
$this
->addInfoFile($package);
// Only add files if there is at least one piece of configuration present.
if ($package
->getConfig()) {
// Add configuration files.
foreach ($package
->getConfig() as $name) {
$config = $config_collection[$name];
$package
->appendFile([
'filename' => $config
->getName() . '.yml',
'subdirectory' => $config
->getSubdirectory(),
'string' => Yaml::encode($config
->getData()),
], $name);
}
}
}
/**
* {@inheritdoc}
*/
public function mergeInfoArray(array $info1, array $info2, array $keys = []) {
// If keys were specified, use only those.
if (!empty($keys)) {
$info2 = array_intersect_key($info2, array_fill_keys($keys, NULL));
}
$info = NestedArray::mergeDeep($info1, $info2);
// Merge dependencies. Preserve constraints.
// Handle cases of mixed "project:module" and "module" dependencies.
$dependencies = [];
// First collect dependency list from info1.
if (!empty($info1['dependencies'])) {
foreach ($info1['dependencies'] as $dependency_string) {
$dependency = Dependency::createFromString($dependency_string);
$dependencies[$dependency
->getName()] = $this
->getDependencyString($dependency);
}
}
// Now merge dependencies from info2.
if (!empty($info2['dependencies'])) {
foreach ($info2['dependencies'] as $dependency_string) {
$dependency = Dependency::createFromString($dependency_string);
$dependency_name = $dependency
->getName();
if (isset($dependencies[$dependency_name])) {
// Dependency already in list, so only overwrite if there is a constraint.
if ($dependency
->getConstraintString()) {
$dependencies[$dependency_name] = $this
->getDependencyString($dependency);
}
}
else {
// Wasn't in info1, so merge it into list.
$dependencies[$dependency_name] = $this
->getDependencyString($dependency);
}
}
}
if (!empty($dependencies)) {
$info['dependencies'] = array_values($dependencies);
sort($info['dependencies']);
}
// Process themes keys.
$keys = [
'themes',
];
foreach ($keys as $key) {
if (isset($info[$key]) && is_array($info[$key])) {
// NestedArray::mergeDeep() may produce duplicate values.
$info[$key] = array_unique($info[$key]);
sort($info[$key]);
}
}
return $info;
}
/**
* {@inheritdoc}
*/
public function listConfigTypes($bundles_only = FALSE) {
$definitions = [];
foreach ($this->entityTypeManager
->getDefinitions() as $entity_type => $definition) {
if ($definition
->entityClassImplements('Drupal\\Core\\Config\\Entity\\ConfigEntityInterface')) {
if (!$bundles_only || $definition
->getBundleOf()) {
$definitions[$entity_type] = $definition;
}
}
}
$entity_types = array_map(function (EntityTypeInterface $definition) {
return $definition
->getLabel();
}, $definitions);
// Sort the entity types by label, then add the simple config to the top.
uasort($entity_types, 'strnatcasecmp');
return $bundles_only ? $entity_types : [
FeaturesManagerInterface::SYSTEM_SIMPLE_CONFIG => $this
->t('Simple configuration'),
] + $entity_types;
}
/**
* {@inheritdoc}
*/
public function listExtensionConfig(Extension $extension) {
return $this->extensionStorages
->listExtensionConfig($extension);
}
/**
* {@inheritdoc}
*/
public function listExistingConfig($installed = FALSE, FeaturesBundleInterface $bundle = NULL) {
$config = [];
$existing = $this
->getFeaturesModules($bundle, $installed);
foreach ($existing as $extension) {
// Keys are configuration item names and values are providing extension
// name.
$new_config = array_fill_keys($this
->listExtensionConfig($extension), $extension
->getName());
$config = array_merge($config, $new_config);
}
return $config;
}
/**
* {@inheritdoc}
*/
public function listConfigByType($config_type) {
// For a given entity type, load all entities.
if ($config_type && $config_type !== FeaturesManagerInterface::SYSTEM_SIMPLE_CONFIG) {
$entity_storage = $this->entityTypeManager
->getStorage($config_type);
$names = [];
foreach ($entity_storage
->loadMultiple() as $entity) {
$entity_id = $entity
->id();
$label = $entity
->label() ?: $entity_id;
$names[$entity_id] = $label;
}
}
else {
$definitions = [];
foreach ($this->entityTypeManager
->getDefinitions() as $entity_type => $definition) {
if ($definition
->entityClassImplements('Drupal\\Core\\Config\\Entity\\ConfigEntityInterface')) {
$definitions[$entity_type] = $definition;
}
}
// Gather the config entity prefixes.
$config_prefixes = array_map(function (EntityTypeInterface $definition) {
return $definition
->getConfigPrefix() . '.';
}, $definitions);
// Find all config, and then filter our anything matching a config prefix.
$names = $this->configStorage
->listAll();
$names = array_combine($names, $names);
foreach ($names as $item_name) {
foreach ($config_prefixes as $config_prefix) {
if (strpos($item_name, $config_prefix) === 0) {
unset($names[$item_name]);
}
}
}
}
return $names;
}
/**
* Creates a high performant version of the ConfigDependencyManager.
*
* @return \Drupal\features\FeaturesConfigDependencyManager
* A high performant version of the ConfigDependencyManager.
*
* @see \Drupal\Core\Config\Entity\ConfigDependencyManager
*/
protected function getFeaturesConfigDependencyManager() {
$dependency_manager = new FeaturesConfigDependencyManager();
// Read all configuration using the factory. This ensures that multiple
// deletes during the same request benefit from the static cache. Using the
// factory also ensures configuration entity dependency discovery has no
// dependencies on the config entity classes. Assume data with UUID is a
// config entity. Only configuration entities can be depended on so we can
// ignore everything else.
$data = array_map(function (ImmutableConfig $config) {
$data = $config
->get();
if (isset($data['uuid'])) {
return $data;
}
return FALSE;
}, $this->configFactory
->loadMultiple($this->configStorage
->listAll()));
$dependency_manager
->setData(array_filter($data));
return $dependency_manager;
}
/**
* Loads configuration from storage into a property.
*/
protected function initConfigCollection($reset = FALSE) {
if ($reset || empty($this->configCollection)) {
$config_collection = [];
$config_types = $this
->listConfigTypes();
$dependency_manager = $this
->getFeaturesConfigDependencyManager();
// List configuration provided by installed features.
$existing_config = $this
->listExistingConfig(NULL);
$existing_config_by_directory = $this->extensionStorages
->listAllByDirectory();
foreach (array_keys($config_types) as $config_type) {
$config = $this
->listConfigByType($config_type);
foreach ($config as $item_name => $label) {
$name = $this
->getFullName($config_type, $item_name);
$data = $this->configStorage
->read($name);
$config_collection[$name] = new ConfigurationItem($name, $data, [
'shortName' => $item_name,
'label' => $label,
'type' => $config_type,
'dependents' => array_keys($dependency_manager
->getDependentEntities('config', $name)),
// Default to the install directory.
'subdirectory' => isset($existing_config_by_directory[$name]) ? $existing_config_by_directory[$name] : InstallStorage::CONFIG_INSTALL_DIRECTORY,
'package' => '',
'providerExcluded' => NULL,
'provider' => isset($existing_config[$name]) ? $existing_config[$name] : NULL,
'packageExcluded' => [],
]);
}
}
$this
->setConfigCollection($config_collection);
}
}
/**
* {@inheritdoc}
*/
public function prepareFiles(array $packages) {
foreach ($packages as $package) {
$this
->addPackageFiles($package);
}
}
/**
* {@inheritdoc}
*/
public function getExportInfo(Package $package, FeaturesBundleInterface $bundle = NULL) {
$full_name = isset($bundle) ? $bundle
->getFullName($package
->getMachineName()) : $package
->getMachineName();
$path = '';
// Adjust export directory to be in profile.
if (isset($bundle) && $bundle
->isProfile()) {
$path .= 'profiles/' . $bundle
->getProfileName();
}
// If this is not the profile package, nest the directory.
if (!isset($bundle) || !$bundle
->isProfilePackage($package
->getMachineName())) {
$path .= empty($path) ? 'modules' : '/modules';
$export_settings = $this
->getExportSettings();
if (!empty($export_settings['folder'])) {
$path .= '/' . $export_settings['folder'];
}
}
// Use the same path of a package to override it.
if ($extension = $package
->getExtension()) {
$extension_path = $extension
->getPath();
$path = dirname($extension_path);
}
return [
$full_name,
$path,
];
}
/**
* {@inheritdoc}
*/
public function detectOverrides(Package $feature, $include_new = FALSE) {
/** @var \Drupal\config_update\ConfigDiffInterface $config_diff */
$config_diff = \Drupal::service('config_update.config_diff');
$different = [];
foreach ($feature
->getConfig() as $name) {
$active = $this->configStorage
->read($name);
$extension = $this->extensionStorages
->read($name);
$extension = !empty($extension) ? $extension : [];
if (($include_new || !empty($extension)) && !$config_diff
->same($extension, $active)) {
$different[] = $name;
}
}
if (!empty($different)) {
$feature
->setState(FeaturesManagerInterface::STATE_OVERRIDDEN);
}
return $different;
}
/**
* {@inheritdoc}
*/
public function detectNew(Package $feature) {
$result = [];
foreach ($feature
->getConfig() as $name) {
$extension = $this->extensionStorages
->read($name);
if (empty($extension)) {
$result[] = $name;
}
}
return $result;
}
/**
* {@inheritdoc}
*/
public function detectMissing(Package $feature) {
$config = $this
->getConfigCollection();
$result = [];
foreach ($feature
->getConfigOrig() as $name) {
if (!isset($config[$name])) {
$result[] = $name;
}
}
return $result;
}
/**
* {@inheritdoc}
*/
public function reorderMissing(array $missing) {
$list = [];
$result = [];
foreach ($missing as $full_name) {
$this
->addConfigList($full_name, $list);
}
foreach ($list as $full_name) {
if (in_array($full_name, $missing)) {
$result[] = $full_name;
}
}
return $result;
}
/**
* {@inheritDoc}
*/
protected function addConfigList($full_name, &$list) {
$index = array_search($full_name, $list);
if ($index !== FALSE) {
unset($list[$index]);
}
array_unshift($list, $full_name);
$value = $this->extensionStorages
->read($full_name);
if (isset($value['dependencies']['config'])) {
foreach ($value['dependencies']['config'] as $config_name) {
$this
->addConfigList($config_name, $list);
}
}
}
/**
* {@inheritdoc}
*/
public function statusLabel($status) {
switch ($status) {
case FeaturesManagerInterface::STATUS_NO_EXPORT:
return $this
->t('Not exported');
case FeaturesManagerInterface::STATUS_UNINSTALLED:
return $this
->t('Uninstalled');
case FeaturesManagerInterface::STATUS_INSTALLED:
return $this
->t('Installed');
}
}
/**
* {@inheritdoc}
*/
public function stateLabel($state) {
switch ($state) {
case FeaturesManagerInterface::STATE_DEFAULT:
return $this
->t('Default');
case FeaturesManagerInterface::STATE_OVERRIDDEN:
return $this
->t('Changed');
}
}
/**
* {@inheritdoc}
*/
public function getFeaturesInfo(Extension $extension) {
$module_name = $extension
->getName();
if (isset($this->featureInfoCache[$module_name])) {
return $this->featureInfoCache[$module_name];
}
$features_info = NULL;
$filename = $this->root . '/' . $extension
->getPath() . '/' . $module_name . '.features.yml';
if (file_exists($filename)) {
$features_info = Yaml::decode(file_get_contents($filename));
}
$this->featureInfoCache[$module_name] = $features_info;
return $features_info;
}
/**
* {@inheritdoc}
*/
public function createConfiguration(array $config_to_create) {
$existing_config = $this
->getConfigCollection();
// If config data is not specified, load it from the extension storage.
foreach ($config_to_create as $name => $item) {
if (empty($item)) {
$config = $this->configReverter
->getFromExtension('', $name);
// For testing purposes, if it couldn't load from a module, get config
// from the cached Config Collection.
if (empty($config) && isset($existing_config[$name])) {
$config = $existing_config[$name]
->getData();
}
$config_to_create[$name] = $config;
}
}
// Determine which config is new vs existing.
$existing = array_intersect_key($config_to_create, $existing_config);
$new = array_diff_key($config_to_create, $existing);
// The FeaturesConfigInstaller exposes the normally protected
// createConfiguration
// function from Core ConfigInstaller than handles the creation of new
// config or the changing of existing config.
/** @var \Drupal\features\FeaturesConfigInstaller $config_installer */
$config_installer = \Drupal::service('features.config.installer');
$config_installer
->createConfiguration(StorageInterface::DEFAULT_COLLECTION, $config_to_create);
// Collect results for new and updated config.
$new_config = $this
->getConfigCollection(TRUE);
$result['updated'] = array_intersect_key($new_config, $existing);
$result['new'] = array_intersect_key($new_config, $new);
return $result;
}
/**
* {@inheritdoc}
*/
public function import($modules, $any = FALSE) {
$result = [];
foreach ($modules as $module_name) {
$package = $this
->loadPackage($module_name, $any);
$components = isset($package) ? $package
->getConfigOrig() : [];
if (empty($components)) {
continue;
}
$result[$module_name] = $this
->createConfiguration(array_fill_keys($components, []));
}
return $result;
}
}
Members
Name | Modifiers | Type | Description | Overrides |
---|---|---|---|---|
FeaturesManager:: |
protected | property | The package assigner. | |
FeaturesManager:: |
private | property | The configuration present on the site. | |
FeaturesManager:: |
protected | property | The configuration factory. | |
FeaturesManager:: |
protected | property | The configuration manager. | |
FeaturesManager:: |
protected | property | The config reverter. | |
FeaturesManager:: |
protected | property | The target storage. | |
FeaturesManager:: |
protected | property | The entity type manager. | |
FeaturesManager:: |
protected | property | The extension storages. | |
FeaturesManager:: |
protected | property | Cache module.features.yml data keyed by module name. | |
FeaturesManager:: |
protected | property | The module extension list service. | |
FeaturesManager:: |
protected | property | The module handler. | |
FeaturesManager:: |
protected | property | The packages to be generated. | |
FeaturesManager:: |
protected | property | Whether the packages have been assigned a bundle prefix. | |
FeaturesManager:: |
protected | property | The app root. | |
FeaturesManager:: |
protected | property | The Features settings. | |
FeaturesManager:: |
protected | function | ||
FeaturesManager:: |
protected | function | Generates and adds .info.yml files to a package. | |
FeaturesManager:: |
protected | function | Generates and adds files to a given package or profile. | |
FeaturesManager:: |
public | function |
Assigns configuration items with names matching given strings to given
packages. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
For given configuration items, assigns any dependent configuration to the
same package. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Assigns a set of configuration items to a given package or profile. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Assigns dependencies between packages based on configuration dependencies. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Assigns dependencies from config items into the package. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Creates configuration in a collection based on the provided list. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Determines which config is exported in the feature but not in the active. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Determines which config has not been exported to the feature. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Determines which config is overridden in a package. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
protected | function | Gets the name of the currently active installation profile. | 1 |
FeaturesManager:: |
public | function |
Determine if extension is enabled. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Filters the supplied package list by the given namespace. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Gets a specific package.
Similar to getPackage but will also match package FullName. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Returns the active config store. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Returns a list of all modules present on the site's file system. Overrides FeaturesManagerInterface:: |
1 |
FeaturesManager:: |
public | function |
Gets a reference to a package assigner. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Gets an array of site configuration. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
protected | function | Helper function to update dependencies array for a specific config item. | |
FeaturesManager:: |
public | function |
Returns the short name and type of a full config name. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
protected | function | Convert a Dependency object back to a string value. | |
FeaturesManager:: |
public | function |
Returns the full machine name and directory for exporting a package. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Returns the current export settings. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Returns the contents of an extensions info.yml file. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Returns a set of config storages. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
protected | function | Creates a high performant version of the ConfigDependencyManager. | |
FeaturesManager:: |
public | function |
Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Returns a list of Features modules regardless of if they are installed. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Returns the full name of a config item. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Gets a reference to a package generator. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Gets a specific package. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
protected | function | Initializes and returns a package or profile array. | |
FeaturesManager:: |
public | function |
Gets an array of packages. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Returns the current general features settings. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
The import function. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
protected | function | Loads configuration from storage into a property. | |
FeaturesManager:: |
public | function |
Initializes a configuration package. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Initializes a configuration package using module info data. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Determines if the module is a Features package, optionally testing by
bundle. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Lists stored configuration for a given configuration type. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Lists the types of configuration available on the site. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Lists names of configuration items provided by existing Features modules. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Lists names of configuration objects provided by a given extension. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Lists directories in which packages are present. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Load a specific package. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Merges two info arrays and processes the resulting array. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
protected | function | Merges a set of new item into an array. | |
FeaturesManager:: |
public | function |
Iterates through packages and prepares file names and contents. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Sort the Missing config into order by dependencies. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Resets packages and configuration assignment. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Injects the package assigner. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Sets an array of site configuration. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Injects the package generator. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Updates a package definition in the package list. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Adds the optional bundle prefix to package machine names. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Sets an array of packages. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Set the app.root. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Helper function that returns a translatable label for the different state
constants. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function |
Helper function that returns a translatable label for the different status
constants. Overrides FeaturesManagerInterface:: |
|
FeaturesManager:: |
public | function | Constructs a FeaturesManager object. | |
FeaturesManagerInterface:: |
constant | Constants for package/module state. | ||
FeaturesManagerInterface:: |
constant | |||
FeaturesManagerInterface:: |
constant | |||
FeaturesManagerInterface:: |
constant | |||
FeaturesManagerInterface:: |
constant | Constants for package/module status. | ||
FeaturesManagerInterface:: |
constant | |||
FeaturesManagerInterface:: |
constant | Simple configuration. | ||
StringTranslationTrait:: |
protected | property | The string translation service. | 1 |
StringTranslationTrait:: |
protected | function | Formats a string containing a count of items. | |
StringTranslationTrait:: |
protected | function | Returns the number of plurals supported by a given language. | |
StringTranslationTrait:: |
protected | function | Gets the string translation service. | |
StringTranslationTrait:: |
public | function | Sets the string translation service to use. | 2 |
StringTranslationTrait:: |
protected | function | Translates a string to the current language or to a given language. |