BlockViewBuilder.php in Drupal 8
Same filename and directory in other branches
Namespace
Drupal\blockFile
core/modules/block/src/BlockViewBuilder.phpView source
<?php
namespace Drupal\block;
use Drupal\Core\Block\MainContentBlockPluginInterface;
use Drupal\Core\Block\TitleBlockPluginInterface;
use Drupal\Core\Cache\Cache;
use Drupal\Core\Cache\CacheableMetadata;
use Drupal\Core\Entity\EntityViewBuilder;
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Extension\ModuleHandlerInterface;
use Drupal\Core\Plugin\ContextAwarePluginInterface;
use Drupal\Core\Render\Element;
use Drupal\block\Entity\Block;
use Drupal\Core\Security\TrustedCallbackInterface;
/**
* Provides a Block view builder.
*/
class BlockViewBuilder extends EntityViewBuilder implements TrustedCallbackInterface {
/**
* {@inheritdoc}
*/
public function buildComponents(array &$build, array $entities, array $displays, $view_mode) {
}
/**
* {@inheritdoc}
*/
public function view(EntityInterface $entity, $view_mode = 'full', $langcode = NULL) {
$build = $this
->viewMultiple([
$entity,
], $view_mode, $langcode);
return reset($build);
}
/**
* {@inheritdoc}
*/
public function viewMultiple(array $entities = [], $view_mode = 'full', $langcode = NULL) {
/** @var \Drupal\block\BlockInterface[] $entities */
$build = [];
foreach ($entities as $entity) {
$entity_id = $entity
->id();
$plugin = $entity
->getPlugin();
$cache_tags = Cache::mergeTags($this
->getCacheTags(), $entity
->getCacheTags());
$cache_tags = Cache::mergeTags($cache_tags, $plugin
->getCacheTags());
// Create the render array for the block as a whole.
// @see template_preprocess_block().
$build[$entity_id] = [
'#cache' => [
'keys' => [
'entity_view',
'block',
$entity
->id(),
],
'contexts' => Cache::mergeContexts($entity
->getCacheContexts(), $plugin
->getCacheContexts()),
'tags' => $cache_tags,
'max-age' => $plugin
->getCacheMaxAge(),
],
'#weight' => $entity
->getWeight(),
];
// Allow altering of cacheability metadata or setting #create_placeholder.
$this->moduleHandler
->alter([
'block_build',
"block_build_" . $plugin
->getBaseId(),
], $build[$entity_id], $plugin);
if ($plugin instanceof MainContentBlockPluginInterface || $plugin instanceof TitleBlockPluginInterface) {
// Immediately build a #pre_render-able block, since this block cannot
// be built lazily.
$build[$entity_id] += static::buildPreRenderableBlock($entity, $this
->moduleHandler());
}
else {
// Assign a #lazy_builder callback, which will generate a #pre_render-
// able block lazily (when necessary).
$build[$entity_id] += [
'#lazy_builder' => [
static::class . '::lazyBuilder',
[
$entity_id,
$view_mode,
$langcode,
],
],
];
}
}
return $build;
}
/**
* Builds a #pre_render-able block render array.
*
* @param \Drupal\block\BlockInterface $entity
* A block config entity.
* @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
* The module handler service.
*
* @return array
* A render array with a #pre_render callback to render the block.
*/
protected static function buildPreRenderableBlock($entity, ModuleHandlerInterface $module_handler) {
$plugin = $entity
->getPlugin();
$plugin_id = $plugin
->getPluginId();
$base_id = $plugin
->getBaseId();
$derivative_id = $plugin
->getDerivativeId();
$configuration = $plugin
->getConfiguration();
// Inject runtime contexts.
if ($plugin instanceof ContextAwarePluginInterface) {
$contexts = \Drupal::service('context.repository')
->getRuntimeContexts($plugin
->getContextMapping());
\Drupal::service('context.handler')
->applyContextMapping($plugin, $contexts);
}
// Create the render array for the block as a whole.
// @see template_preprocess_block().
$build = [
'#theme' => 'block',
'#attributes' => [],
// All blocks get a "Configure block" contextual link.
'#contextual_links' => [
'block' => [
'route_parameters' => [
'block' => $entity
->id(),
],
],
],
'#weight' => $entity
->getWeight(),
'#configuration' => $configuration,
'#plugin_id' => $plugin_id,
'#base_plugin_id' => $base_id,
'#derivative_plugin_id' => $derivative_id,
'#id' => $entity
->id(),
'#pre_render' => [
static::class . '::preRender',
],
// Add the entity so that it can be used in the #pre_render method.
'#block' => $entity,
];
// If an alter hook wants to modify the block contents, it can append
// another #pre_render hook.
$module_handler
->alter([
'block_view',
"block_view_{$base_id}",
], $build, $plugin);
return $build;
}
/**
* {@inheritdoc}
*/
public static function trustedCallbacks() {
return [
'preRender',
'lazyBuilder',
];
}
/**
* #lazy_builder callback; builds a #pre_render-able block.
*
* @param $entity_id
* A block config entity ID.
* @param $view_mode
* The view mode the block is being viewed in.
*
* @return array
* A render array with a #pre_render callback to render the block.
*/
public static function lazyBuilder($entity_id, $view_mode) {
return static::buildPreRenderableBlock(Block::load($entity_id), \Drupal::service('module_handler'));
}
/**
* #pre_render callback for building a block.
*
* Renders the content using the provided block plugin, and then:
* - if there is no content, aborts rendering, and makes sure the block won't
* be rendered.
* - if there is content, moves the contextual links from the block content to
* the block itself.
*/
public static function preRender($build) {
$content = $build['#block']
->getPlugin()
->build();
// Remove the block entity from the render array, to ensure that blocks
// can be rendered without the block config entity.
unset($build['#block']);
if ($content !== NULL && !Element::isEmpty($content)) {
// Place the $content returned by the block plugin into a 'content' child
// element, as a way to allow the plugin to have complete control of its
// properties and rendering (for instance, its own #theme) without
// conflicting with the properties used above, or alternate ones used by
// alternate block rendering approaches in contrib (for instance, Panels).
// However, the use of a child element is an implementation detail of this
// particular block rendering approach. Semantically, the content returned
// by the plugin "is the" block, and in particular, #attributes and
// #contextual_links is information about the *entire* block. Therefore,
// we must move these properties from $content and merge them into the
// top-level element.
foreach ([
'#attributes',
'#contextual_links',
] as $property) {
if (isset($content[$property])) {
$build[$property] += $content[$property];
unset($content[$property]);
}
}
$build['content'] = $content;
}
else {
// Abort rendering: render as the empty string and ensure this block is
// render cached, so we can avoid the work of having to repeatedly
// determine whether the block is empty. For instance, modifying or adding
// entities could cause the block to no longer be empty.
$build = [
'#markup' => '',
'#cache' => $build['#cache'],
];
// If $content is not empty, then it contains cacheability metadata, and
// we must merge it with the existing cacheability metadata. This allows
// blocks to be empty, yet still bubble cacheability metadata, to indicate
// why they are empty.
if (!empty($content)) {
CacheableMetadata::createFromRenderArray($build)
->merge(CacheableMetadata::createFromRenderArray($content))
->applyTo($build);
}
}
return $build;
}
}
Classes
Name | Description |
---|---|
BlockViewBuilder | Provides a Block view builder. |