X-Git-Url: http://www.aleph1.co.uk/gitweb/?a=blobdiff_plain;f=web%2Fcore%2Flib%2FDrupal.php;fp=web%2Fcore%2Flib%2FDrupal.php;h=9371f1e5f1c98d300780ffb4bbbffa60430d8c4e;hb=a2bd1bf0c2c1f1a17d188f4dc0726a45494cefae;hp=0000000000000000000000000000000000000000;hpb=57c063afa3f66b07c4bbddc2d6129a96d90f0aad;p=yaffs-website diff --git a/web/core/lib/Drupal.php b/web/core/lib/Drupal.php new file mode 100644 index 000000000..9371f1e5f --- /dev/null +++ b/web/core/lib/Drupal.php @@ -0,0 +1,760 @@ +acquire('stuff_lock'); + * // ... + * } + * + * // Correct procedural code. + * function hook_do_stuff() { + * $lock = \Drupal::lock()->acquire('stuff_lock'); + * // ... + * } + * + * // The preferred way: dependency injected code. + * function hook_do_stuff() { + * // Move the actual implementation to a class and instantiate it. + * $instance = new StuffDoingClass(\Drupal::lock()); + * $instance->doStuff(); + * + * // Or, even better, rely on the service container to avoid hard coding a + * // specific interface implementation, so that the actual logic can be + * // swapped. This might not always make sense, but in general it is a good + * // practice. + * \Drupal::service('stuff.doing')->doStuff(); + * } + * + * interface StuffDoingInterface { + * public function doStuff(); + * } + * + * class StuffDoingClass implements StuffDoingInterface { + * protected $lockBackend; + * + * public function __construct(LockBackendInterface $lock_backend) { + * $this->lockBackend = $lock_backend; + * } + * + * public function doStuff() { + * $lock = $this->lockBackend->acquire('stuff_lock'); + * // ... + * } + * } + * @endcode + * + * @see \Drupal\Core\DrupalKernel + */ +class Drupal { + + /** + * The current system version. + */ + const VERSION = '8.3.4'; + + /** + * Core API compatibility. + */ + const CORE_COMPATIBILITY = '8.x'; + + /** + * Core minimum schema version. + */ + const CORE_MINIMUM_SCHEMA_VERSION = 8000; + + /** + * The currently active container object, or NULL if not initialized yet. + * + * @var \Symfony\Component\DependencyInjection\ContainerInterface|null + */ + protected static $container; + + /** + * Sets a new global container. + * + * @param \Symfony\Component\DependencyInjection\ContainerInterface $container + * A new container instance to replace the current. + */ + public static function setContainer(ContainerInterface $container) { + static::$container = $container; + } + + /** + * Unsets the global container. + */ + public static function unsetContainer() { + static::$container = NULL; + } + + /** + * Returns the currently active global container. + * + * @return \Symfony\Component\DependencyInjection\ContainerInterface|null + * + * @throws \Drupal\Core\DependencyInjection\ContainerNotInitializedException + */ + public static function getContainer() { + if (static::$container === NULL) { + throw new ContainerNotInitializedException('\Drupal::$container is not initialized yet. \Drupal::setContainer() must be called with a real container.'); + } + return static::$container; + } + + /** + * Returns TRUE if the container has been initialized, FALSE otherwise. + * + * @return bool + */ + public static function hasContainer() { + return static::$container !== NULL; + } + + + /** + * Retrieves a service from the container. + * + * Use this method if the desired service is not one of those with a dedicated + * accessor method below. If it is listed below, those methods are preferred + * as they can return useful type hints. + * + * @param string $id + * The ID of the service to retrieve. + * + * @return mixed + * The specified service. + */ + public static function service($id) { + return static::getContainer()->get($id); + } + + /** + * Indicates if a service is defined in the container. + * + * @param string $id + * The ID of the service to check. + * + * @return bool + * TRUE if the specified service exists, FALSE otherwise. + */ + public static function hasService($id) { + // Check hasContainer() first in order to always return a Boolean. + return static::hasContainer() && static::getContainer()->has($id); + } + + /** + * Gets the app root. + * + * @return string + */ + public static function root() { + return static::getContainer()->get('app.root'); + } + + /** + * Gets the active install profile. + * + * @return string|null + * The name of the active install profile. + */ + public static function installProfile() { + return static::getContainer()->getParameter('install_profile'); + } + + /** + * Indicates if there is a currently active request object. + * + * @return bool + * TRUE if there is a currently active request object, FALSE otherwise. + */ + public static function hasRequest() { + // Check hasContainer() first in order to always return a Boolean. + return static::hasContainer() && static::getContainer()->has('request_stack') && static::getContainer()->get('request_stack')->getCurrentRequest() !== NULL; + } + + /** + * Retrieves the currently active request object. + * + * Note: The use of this wrapper in particular is especially discouraged. Most + * code should not need to access the request directly. Doing so means it + * will only function when handling an HTTP request, and will require special + * modification or wrapping when run from a command line tool, from certain + * queue processors, or from automated tests. + * + * If code must access the request, it is considerably better to register + * an object with the Service Container and give it a setRequest() method + * that is configured to run when the service is created. That way, the + * correct request object can always be provided by the container and the + * service can still be unit tested. + * + * If this method must be used, never save the request object that is + * returned. Doing so may lead to inconsistencies as the request object is + * volatile and may change at various times, such as during a subrequest. + * + * @return \Symfony\Component\HttpFoundation\Request + * The currently active request object. + */ + public static function request() { + return static::getContainer()->get('request_stack')->getCurrentRequest(); + } + + /** + * Retrives the request stack. + * + * @return \Symfony\Component\HttpFoundation\RequestStack + * The request stack + */ + public static function requestStack() { + return static::getContainer()->get('request_stack'); + } + + /** + * Retrieves the currently active route match object. + * + * @return \Drupal\Core\Routing\RouteMatchInterface + * The currently active route match object. + */ + public static function routeMatch() { + return static::getContainer()->get('current_route_match'); + } + + /** + * Gets the current active user. + * + * @return \Drupal\Core\Session\AccountProxyInterface + */ + public static function currentUser() { + return static::getContainer()->get('current_user'); + } + + /** + * Retrieves the entity manager service. + * + * @return \Drupal\Core\Entity\EntityManagerInterface + * The entity manager service. + * + * @deprecated in Drupal 8.0.0 and will be removed before Drupal 9.0.0. + * Use \Drupal::entityTypeManager() instead in most cases. If the needed + * method is not on \Drupal\Core\Entity\EntityTypeManagerInterface, see the + * deprecated \Drupal\Core\Entity\EntityManager to find the + * correct interface or service. + */ + public static function entityManager() { + return static::getContainer()->get('entity.manager'); + } + + /** + * Retrieves the entity type manager. + * + * @return \Drupal\Core\Entity\EntityTypeManagerInterface + * The entity type manager. + */ + public static function entityTypeManager() { + return static::getContainer()->get('entity_type.manager'); + } + + /** + * Returns the current primary database. + * + * @return \Drupal\Core\Database\Connection + * The current active database's master connection. + */ + public static function database() { + return static::getContainer()->get('database'); + } + + /** + * Returns the requested cache bin. + * + * @param string $bin + * (optional) The cache bin for which the cache object should be returned, + * defaults to 'default'. + * + * @return \Drupal\Core\Cache\CacheBackendInterface + * The cache object associated with the specified bin. + * + * @ingroup cache + */ + public static function cache($bin = 'default') { + return static::getContainer()->get('cache.' . $bin); + } + + /** + * Retrieves the class resolver. + * + * This is to be used in procedural code such as module files to instantiate + * an object of a class that implements + * \Drupal\Core\DependencyInjection\ContainerInjectionInterface. + * + * One common usecase is to provide a class which contains the actual code + * of a hook implementation, without having to create a service. + * + * @return \Drupal\Core\DependencyInjection\ClassResolverInterface + * The class resolver. + */ + public static function classResolver() { + return static::getContainer()->get('class_resolver'); + } + + /** + * Returns an expirable key value store collection. + * + * @param string $collection + * The name of the collection holding key and value pairs. + * + * @return \Drupal\Core\KeyValueStore\KeyValueStoreExpirableInterface + * An expirable key value store collection. + */ + public static function keyValueExpirable($collection) { + return static::getContainer()->get('keyvalue.expirable')->get($collection); + } + + /** + * Returns the locking layer instance. + * + * @return \Drupal\Core\Lock\LockBackendInterface + * + * @ingroup lock + */ + public static function lock() { + return static::getContainer()->get('lock'); + } + + /** + * Retrieves a configuration object. + * + * This is the main entry point to the configuration API. Calling + * @code \Drupal::config('book.admin') @endcode will return a configuration + * object in which the book module can store its administrative settings. + * + * @param string $name + * The name of the configuration object to retrieve. The name corresponds to + * a configuration file. For @code \Drupal::config('book.admin') @endcode, the config + * object returned will contain the contents of book.admin configuration file. + * + * @return \Drupal\Core\Config\ImmutableConfig + * An immutable configuration object. + */ + public static function config($name) { + return static::getContainer()->get('config.factory')->get($name); + } + + /** + * Retrieves the configuration factory. + * + * This is mostly used to change the override settings on the configuration + * factory. For example, changing the language, or turning all overrides on + * or off. + * + * @return \Drupal\Core\Config\ConfigFactoryInterface + * The configuration factory service. + */ + public static function configFactory() { + return static::getContainer()->get('config.factory'); + } + + /** + * Returns a queue for the given queue name. + * + * The following values can be set in your settings.php file's $settings + * array to define which services are used for queues: + * - queue_reliable_service_$name: The container service to use for the + * reliable queue $name. + * - queue_service_$name: The container service to use for the + * queue $name. + * - queue_default: The container service to use by default for queues + * without overrides. This defaults to 'queue.database'. + * + * @param string $name + * The name of the queue to work with. + * @param bool $reliable + * (optional) TRUE if the ordering of items and guaranteeing every item + * executes at least once is important, FALSE if scalability is the main + * concern. Defaults to FALSE. + * + * @return \Drupal\Core\Queue\QueueInterface + * The queue object for a given name. + */ + public static function queue($name, $reliable = FALSE) { + return static::getContainer()->get('queue')->get($name, $reliable); + } + + /** + * Returns a key/value storage collection. + * + * @param string $collection + * Name of the key/value collection to return. + * + * @return \Drupal\Core\KeyValueStore\KeyValueStoreInterface + */ + public static function keyValue($collection) { + return static::getContainer()->get('keyvalue')->get($collection); + } + + /** + * Returns the state storage service. + * + * Use this to store machine-generated data, local to a specific environment + * that does not need deploying and does not need human editing; for example, + * the last time cron was run. Data which needs to be edited by humans and + * needs to be the same across development, production, etc. environments + * (for example, the system maintenance message) should use \Drupal::config() instead. + * + * @return \Drupal\Core\State\StateInterface + */ + public static function state() { + return static::getContainer()->get('state'); + } + + /** + * Returns the default http client. + * + * @return \GuzzleHttp\Client + * A guzzle http client instance. + */ + public static function httpClient() { + return static::getContainer()->get('http_client'); + } + + /** + * Returns the entity query object for this entity type. + * + * @param string $entity_type + * The entity type (for example, node) for which the query object should be + * returned. + * @param string $conjunction + * (optional) Either 'AND' if all conditions in the query need to apply, or + * 'OR' if any of them is sufficient. Defaults to 'AND'. + * + * @return \Drupal\Core\Entity\Query\QueryInterface + * The query object that can query the given entity type. + */ + public static function entityQuery($entity_type, $conjunction = 'AND') { + return static::entityTypeManager()->getStorage($entity_type)->getQuery($conjunction); + } + + /** + * Returns the entity query aggregate object for this entity type. + * + * @param string $entity_type + * The entity type (for example, node) for which the query object should be + * returned. + * @param string $conjunction + * (optional) Either 'AND' if all conditions in the query need to apply, or + * 'OR' if any of them is sufficient. Defaults to 'AND'. + * + * @return \Drupal\Core\Entity\Query\QueryAggregateInterface + * The query object that can query the given entity type. + */ + public static function entityQueryAggregate($entity_type, $conjunction = 'AND') { + return static::entityTypeManager()->getStorage($entity_type)->getAggregateQuery($conjunction); + } + + /** + * Returns the flood instance. + * + * @return \Drupal\Core\Flood\FloodInterface + */ + public static function flood() { + return static::getContainer()->get('flood'); + } + + /** + * Returns the module handler. + * + * @return \Drupal\Core\Extension\ModuleHandlerInterface + */ + public static function moduleHandler() { + return static::getContainer()->get('module_handler'); + } + + /** + * Returns the typed data manager service. + * + * Use the typed data manager service for creating typed data objects. + * + * @return \Drupal\Core\TypedData\TypedDataManagerInterface + * The typed data manager. + * + * @see \Drupal\Core\TypedData\TypedDataManager::create() + */ + public static function typedDataManager() { + return static::getContainer()->get('typed_data_manager'); + } + + /** + * Returns the token service. + * + * @return \Drupal\Core\Utility\Token + * The token service. + */ + public static function token() { + return static::getContainer()->get('token'); + } + + /** + * Returns the url generator service. + * + * @return \Drupal\Core\Routing\UrlGeneratorInterface + * The url generator service. + */ + public static function urlGenerator() { + return static::getContainer()->get('url_generator'); + } + + /** + * Generates a URL string for a specific route based on the given parameters. + * + * This method is a convenience wrapper for generating URL strings for URLs + * that have Drupal routes (that is, most pages generated by Drupal) using + * the \Drupal\Core\Url object. See \Drupal\Core\Url::fromRoute() for + * detailed documentation. For non-routed local URIs relative to + * the base path (like robots.txt) use Url::fromUri()->toString() with the + * base: scheme. + * + * @param string $route_name + * The name of the route. + * @param array $route_parameters + * (optional) An associative array of parameter names and values. + * @param array $options + * (optional) An associative array of additional options. + * @param bool $collect_bubbleable_metadata + * (optional) Defaults to FALSE. When TRUE, both the generated URL and its + * associated bubbleable metadata are returned. + * + * @return string|\Drupal\Core\GeneratedUrl + * A string containing a URL to the given path. + * When $collect_bubbleable_metadata is TRUE, a GeneratedUrl object is + * returned, containing the generated URL plus bubbleable metadata. + * + * @see \Drupal\Core\Routing\UrlGeneratorInterface::generateFromRoute() + * @see \Drupal\Core\Url + * @see \Drupal\Core\Url::fromRoute() + * @see \Drupal\Core\Url::fromUri() + * + * @deprecated as of Drupal 8.0.x, will be removed before Drupal 9.0.0. + * Instead create a \Drupal\Core\Url object directly, for example using + * Url::fromRoute(). + */ + public static function url($route_name, $route_parameters = [], $options = [], $collect_bubbleable_metadata = FALSE) { + return static::getContainer()->get('url_generator')->generateFromRoute($route_name, $route_parameters, $options, $collect_bubbleable_metadata); + } + + /** + * Returns the link generator service. + * + * @return \Drupal\Core\Utility\LinkGeneratorInterface + */ + public static function linkGenerator() { + return static::getContainer()->get('link_generator'); + } + + /** + * Renders a link with a given link text and Url object. + * + * This method is a convenience wrapper for the link generator service's + * generate() method. + * + * @param string $text + * The link text for the anchor tag. + * @param \Drupal\Core\Url $url + * The URL object used for the link. + * + * @return \Drupal\Core\GeneratedLink + * A GeneratedLink object containing a link to the given route and + * parameters and bubbleable metadata. + * + * @see \Drupal\Core\Utility\LinkGeneratorInterface::generate() + * @see \Drupal\Core\Url + * + * @deprecated in Drupal 8.0.0 and will be removed before Drupal 9.0.0. + * Use \Drupal\Core\Link instead. + * Example: + * @code + * $link = Link::fromTextAndUrl($text, $url); + * @endcode + */ + public static function l($text, Url $url) { + return static::getContainer()->get('link_generator')->generate($text, $url); + } + + /** + * Returns the string translation service. + * + * @return \Drupal\Core\StringTranslation\TranslationManager + * The string translation manager. + */ + public static function translation() { + return static::getContainer()->get('string_translation'); + } + + /** + * Returns the language manager service. + * + * @return \Drupal\Core\Language\LanguageManagerInterface + * The language manager. + */ + public static function languageManager() { + return static::getContainer()->get('language_manager'); + } + + /** + * Returns the CSRF token manager service. + * + * The generated token is based on the session ID of the current user. Normally, + * anonymous users do not have a session, so the generated token will be + * different on every page request. To generate a token for users without a + * session, manually start a session prior to calling this function. + * + * @return \Drupal\Core\Access\CsrfTokenGenerator + * The CSRF token manager. + * + * @see \Drupal\Core\Session\SessionManager::start() + */ + public static function csrfToken() { + return static::getContainer()->get('csrf_token'); + } + + /** + * Returns the transliteration service. + * + * @return \Drupal\Core\Transliteration\PhpTransliteration + * The transliteration manager. + */ + public static function transliteration() { + return static::getContainer()->get('transliteration'); + } + + /** + * Returns the form builder service. + * + * @return \Drupal\Core\Form\FormBuilderInterface + * The form builder. + */ + public static function formBuilder() { + return static::getContainer()->get('form_builder'); + } + + /** + * Gets the theme service. + * + * @return \Drupal\Core\Theme\ThemeManagerInterface + */ + public static function theme() { + return static::getContainer()->get('theme.manager'); + } + + /** + * Gets the syncing state. + * + * @return bool + * Returns TRUE is syncing flag set. + */ + public static function isConfigSyncing() { + return static::getContainer()->get('config.installer')->isSyncing(); + } + + /** + * Returns a channel logger object. + * + * @param string $channel + * The name of the channel. Can be any string, but the general practice is + * to use the name of the subsystem calling this. + * + * @return \Psr\Log\LoggerInterface + * The logger for this channel. + */ + public static function logger($channel) { + return static::getContainer()->get('logger.factory')->get($channel); + } + + /** + * Returns the menu tree. + * + * @return \Drupal\Core\Menu\MenuLinkTreeInterface + * The menu tree. + */ + public static function menuTree() { + return static::getContainer()->get('menu.link_tree'); + } + + /** + * Returns the path validator. + * + * @return \Drupal\Core\Path\PathValidatorInterface + */ + public static function pathValidator() { + return static::getContainer()->get('path.validator'); + } + + /** + * Returns the access manager service. + * + * @return \Drupal\Core\Access\AccessManagerInterface + * The access manager service. + */ + public static function accessManager() { + return static::getContainer()->get('access_manager'); + } + + /** + * Returns the redirect destination helper. + * + * @return \Drupal\Core\Routing\RedirectDestinationInterface + * The redirect destination helper. + */ + public static function destination() { + return static::getContainer()->get('redirect.destination'); + } + + /** + * Returns the entity definition update manager. + * + * @return \Drupal\Core\Entity\EntityDefinitionUpdateManagerInterface + * The entity definition update manager. + */ + public static function entityDefinitionUpdateManager() { + return static::getContainer()->get('entity.definition_update_manager'); + } + + /** + * Returns the time service. + * + * @return \Drupal\Component\Datetime\TimeInterface + * The time service. + */ + public static function time() { + return static::getContainer()->get('datetime.time'); + } + +}