$data Variables made available to the template.
+ */
+ public function render(string $templatePath, array $data = []): string
+ {
+ if (! file_exists($templatePath)) {
+ return $this->fallback($templatePath, sprintf('The Blade template "%s" does not exist.', $templatePath));
+ }
+
+ $factory = $this->viewFactory();
+
+ if (null === $factory) {
+ return $this->fallback($templatePath, 'No Blade view engine is available. PHP-only blocks are rendered through the view engine of a Sage/Acorn theme.');
+ }
+
+ return (string) $factory->file($templatePath, $data);
+ }
+
+ /**
+ * Resolve the theme's view factory, or null when there isn't one.
+ *
+ * `app()` is Acorn's own global helper, `Roots\app()` its deprecated
+ * predecessor, and `view()` without arguments returns the factory in both
+ * Acorn and Laravel. Resolving from the container can throw when the view
+ * service provider was never registered, hence the try/catch.
+ *
+ * @return object|null An `Illuminate\View\Factory`-like object.
+ */
+ private function viewFactory(): ?object
+ {
+ foreach (['app', 'Roots\\app'] as $container) {
+ if (! function_exists($container)) {
+ continue;
+ }
+
+ try {
+ $factory = $container('view');
+ } catch (\Throwable $e) {
+ continue;
+ }
+
+ if ($this->isViewFactory($factory)) {
+ return $factory;
+ }
+ }
+
+ if (function_exists('view')) {
+ try {
+ $factory = \view();
+ } catch (\Throwable $e) {
+ return null;
+ }
+
+ if ($this->isViewFactory($factory)) {
+ return $factory;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * @param mixed $factory
+ */
+ private function isViewFactory($factory): bool
+ {
+ return is_object($factory) && method_exists($factory, 'file');
+ }
+
+ /**
+ * Handle a template that can't be rendered.
+ *
+ * The editor previews these blocks over the REST block-renderer endpoint, so
+ * there we return a visible hint. On the front end we stay silent: a theme
+ * without a view engine shouldn't leak diagnostics to visitors.
+ */
+ private function fallback(string $templatePath, string $message): string
+ {
+ if (! isset(self::$reported[$templatePath])) {
+ self::$reported[$templatePath] = true;
+
+ \_doing_it_wrong(__METHOD__, \esc_html($message), '1.8.0');
+ }
+
+ if (defined('REST_REQUEST') && REST_REQUEST) {
+ return '' . \esc_html__('Dit blok kan niet worden weergegeven: er is geen Blade-templateengine beschikbaar.', 'yard-gutenberg') . '
';
+ }
+
+ return '';
+ }
+}
diff --git a/src/PhpBlocks/BlockViewModel.php b/src/PhpBlocks/BlockViewModel.php
new file mode 100644
index 0000000..2ad8320
--- /dev/null
+++ b/src/PhpBlocks/BlockViewModel.php
@@ -0,0 +1,166 @@
+ */
+ private $attributes = [];
+
+ /** @var string */
+ private $content = '';
+
+ /** @var \WP_Block|null */
+ private $block;
+
+ /**
+ * The block's generated class, e.g. `wp-block-yard-greeting`.
+ *
+ * @var string
+ */
+ private $blockClass = '';
+
+ /** @var string */
+ private $wrapperAttributes = '';
+
+ /**
+ * Assemble the data the Blade template is rendered with.
+ *
+ * Following Acorn: `with()` supplies defaults, the block's own render data
+ * beats them, and `override()` beats everything — which is how a block
+ * replaces something it is given, such as `wrapperAttributes`.
+ *
+ * @param array $attributes Attributes, with `block.json` defaults merged in.
+ *
+ * @return array
+ */
+ final public function compose(array $attributes, string $content, ?\WP_Block $block, string $blockClass): array
+ {
+ $this->attributes = $attributes;
+ $this->content = $content;
+ $this->block = $block;
+ $this->blockClass = $blockClass;
+
+ // An empty class is harmless: core splits it with PREG_SPLIT_NO_EMPTY,
+ // so it contributes nothing to the merge.
+ $this->wrapperAttributes = \get_block_wrapper_attributes([
+ 'class' => implode(' ', array_filter($this->classes())),
+ ]);
+
+ $data = [
+ 'attributes' => $attributes,
+ 'content' => $content,
+ 'block' => $block,
+ 'blockClass' => $blockClass,
+ 'wrapperAttributes' => $this->wrapperAttributes,
+ ];
+
+ return array_merge($this->with(), $data, $this->override());
+ }
+
+ /**
+ * Data passed to the Blade template.
+ *
+ * @return array
+ */
+ public function with(): array
+ {
+ return [];
+ }
+
+ /**
+ * Data passed to the Blade template, winning over everything else.
+ *
+ * @return array
+ */
+ public function override(): array
+ {
+ return [];
+ }
+
+ /**
+ * Extra classes for the block's wrapper element.
+ *
+ * `get_block_wrapper_attributes()` merges these ahead of the class
+ * WordPress generates, and de-duplicates.
+ *
+ * @return string[]
+ */
+ public function classes(): array
+ {
+ return [];
+ }
+
+ /**
+ * A BEM modifier on the block's generated class.
+ *
+ * Built from `$blockClass` rather than a literal so it follows the
+ * `block_default_classname` filter, and matches the `$block` variable the
+ * block's SCSS uses.
+ */
+ protected function modifier(string $name): string
+ {
+ $name = \sanitize_html_class($name);
+
+ return '' === $this->blockClass || '' === $name ? '' : $this->blockClass . '--' . $name;
+ }
+
+ /**
+ * The block's attributes, with the defaults from `block.json` already merged
+ * in by `WP_Block_Type::prepare_attributes_for_render()`.
+ *
+ * @return array
+ */
+ protected function attributes(): array
+ {
+ return $this->attributes;
+ }
+
+ /**
+ * @param mixed $default
+ *
+ * @return mixed
+ */
+ protected function attribute(string $name, $default = null)
+ {
+ return array_key_exists($name, $this->attributes) ? $this->attributes[$name] : $default;
+ }
+
+ protected function content(): string
+ {
+ return $this->content;
+ }
+
+ protected function block(): ?\WP_Block
+ {
+ return $this->block;
+ }
+
+ protected function blockClass(): string
+ {
+ return $this->blockClass;
+ }
+
+ protected function wrapperAttributes(): string
+ {
+ return $this->wrapperAttributes;
+ }
+}
diff --git a/src/PhpBlocks/Greeting/Greeting.php b/src/PhpBlocks/Greeting/Greeting.php
new file mode 100644
index 0000000..8b79952
--- /dev/null
+++ b/src/PhpBlocks/Greeting/Greeting.php
@@ -0,0 +1,118 @@
+ $this->period()['greeting'],
+ ];
+ }
+
+ public function classes(): array
+ {
+ return array_filter([$this->modifier($this->period()['slug'])]);
+ }
+
+ /**
+ * The period covering the current hour in the site's timezone.
+ *
+ * `current_datetime()` is already in `wp_timezone()`, so this follows the
+ * site's clock rather than the server's.
+ *
+ * @return array{slug: string, greeting: string}
+ */
+ private function period(): array
+ {
+ if (null !== $this->period) {
+ return $this->period;
+ }
+
+ $periods = $this->periods();
+
+ if ([] === $periods) {
+ return $this->period = ['slug' => '', 'greeting' => ''];
+ }
+
+ $hour = (int) \current_datetime()->format('G');
+
+ // The day wraps: hours before the first period belong to the last one.
+ $slugs = array_keys($periods);
+ $slug = end($slugs);
+
+ foreach ($periods as $candidate => $period) {
+ if ($period['from'] <= $hour) {
+ $slug = $candidate;
+ }
+ }
+
+ return $this->period = [
+ 'slug' => (string) $slug,
+ 'greeting' => $periods[$slug]['greeting'],
+ ];
+ }
+
+ /**
+ * The greeting periods, keyed by slug and sorted by start hour.
+ *
+ * The key doubles as the BEM modifier on the block's class. A site may return
+ * any number of periods and need not start at hour 0 — `period()` wraps
+ * around, so a map starting at 6 leaves the small hours to the final period.
+ *
+ * @return array
+ */
+ private function periods(): array
+ {
+ /**
+ * Filter the greeting periods.
+ *
+ * Keyed by slug, which becomes the BEM modifier on the block's class,
+ * e.g. `morning` renders `wp-block-yard-greeting--morning`.
+ *
+ * @param array $periods
+ */
+ $periods = \apply_filters('yard::gutenberg/greeting-periods', [
+ 'night' => ['from' => 0, 'greeting' => \__('Goedenacht', 'yard-gutenberg')],
+ 'morning' => ['from' => 6, 'greeting' => \__('Goedemorgen', 'yard-gutenberg')],
+ 'afternoon' => ['from' => 12, 'greeting' => \__('Goedemiddag', 'yard-gutenberg')],
+ 'evening' => ['from' => 18, 'greeting' => \__('Goedenavond', 'yard-gutenberg')],
+ ]);
+
+ if (! is_array($periods)) {
+ return [];
+ }
+
+ $normalized = [];
+
+ foreach ($periods as $slug => $period) {
+ if (! is_array($period) || ! isset($period['from']) || ! isset($period['greeting'])) {
+ continue;
+ }
+
+ $normalized[(string) $slug] = [
+ 'from' => (int) $period['from'],
+ 'greeting' => (string) $period['greeting'],
+ ];
+ }
+
+ uasort($normalized, function (array $a, array $b) {
+ return $a['from'] <=> $b['from'];
+ });
+
+ return $normalized;
+ }
+}
diff --git a/src/PhpBlocks/Greeting/block.json b/src/PhpBlocks/Greeting/block.json
new file mode 100644
index 0000000..72f9e67
--- /dev/null
+++ b/src/PhpBlocks/Greeting/block.json
@@ -0,0 +1,24 @@
+{
+ "$schema": "https://schemas.wp.org/trunk/block.json",
+ "apiVersion": 3,
+ "name": "yard/greeting",
+ "version": "0.1.0",
+ "title": "Begroeting",
+ "category": "yard",
+ "icon": "smiley",
+ "description": "Toont een begroeting.",
+ "textdomain": "yard",
+ "supports": {
+ "align": true,
+ "autoRegister": true,
+ "html": false
+ },
+ "attributes": {
+ "suffix": {
+ "label": "Tekst na de begroeting",
+ "type": "string",
+ "default": ""
+ }
+ },
+ "style": "file:./style.css"
+}
diff --git a/src/PhpBlocks/Greeting/greeting.blade.php b/src/PhpBlocks/Greeting/greeting.blade.php
new file mode 100644
index 0000000..ffc8ff6
--- /dev/null
+++ b/src/PhpBlocks/Greeting/greeting.blade.php
@@ -0,0 +1,8 @@
+
+ @if (filled($attributes['suffix']))
+ {{ $greeting }},
+ {{ $attributes['suffix'] }}
+ @else
+ {{ $greeting }}
+ @endif
+
diff --git a/src/PhpBlocks/Greeting/style.css b/src/PhpBlocks/Greeting/style.css
new file mode 100644
index 0000000..2493c0f
--- /dev/null
+++ b/src/PhpBlocks/Greeting/style.css
@@ -0,0 +1,19 @@
+@layer plugins {
+ .wp-block-yard-greeting {
+ color: var( --yard-greeting-color, inherit );
+ font-size: var( --yard-greeting-font-size, inherit );
+ line-height: var( --yard-greeting-line-height, inherit );
+
+ &:has(.wp-block-yard-greeting__suffix) {
+ display: flex;
+ flex-direction: column;
+ row-gap: var( --yard-greeting-spacing, 0 );
+ }
+ }
+
+ .wp-block-yard-greeting__greeting {
+ color: var( --yard-greeting-greeting-color, inherit );
+ font-size: var( --yard-greeting-greeting-font-size, 2rem );
+ font-weight: var( --yard-greeting-greeting-font-weight, 700 );
+ }
+}
diff --git a/src/PhpBlocks/PhpBlockManager.php b/src/PhpBlocks/PhpBlockManager.php
new file mode 100644
index 0000000..fb906dc
--- /dev/null
+++ b/src/PhpBlocks/PhpBlockManager.php
@@ -0,0 +1,168 @@
+renderer = new BladeRenderer();
+ }
+
+ public function boot(): void
+ {
+ \add_action('init', [$this, 'registerBlocks']);
+ }
+
+ public function registerBlocks(): void
+ {
+ foreach ($this->blocks() as $directory => $blockName) {
+ $blockPath = __DIR__ . '/' . $directory;
+
+ \register_block_type($blockPath, [
+ 'render_callback' => $this->renderCallback($directory, $blockName, $blockPath),
+ ]);
+ }
+ }
+
+ /**
+ * The registrable blocks, as folder name => block name.
+ *
+ * The name comes from `block.json`, not from the folder: the folder has to be
+ * a valid namespace segment for the view model to autoload, while the name is
+ * the block's actual identity. Its slug names the template and is the key a
+ * site filters on through `yard::gutenberg/allowed-blocks`, where hyphenated
+ * names like `opening-hours` are perfectly normal.
+ *
+ * @return array
+ */
+ private function blocks(): array
+ {
+ $blocks = [];
+
+ foreach (array_filter(glob(__DIR__ . '/*', GLOB_ONLYDIR) ?: []) as $path) {
+ $blockName = $this->blockName($path . '/block.json');
+
+ if (null !== $blockName) {
+ $blocks[basename($path)] = $blockName;
+ }
+ }
+
+ return $this->filterAllowed($blocks);
+ }
+
+ /**
+ * Apply `yard::gutenberg/allowed-blocks`, which is keyed on the slug.
+ *
+ * `AllowedBlocks::filter()` tests values and preserves keys, so it filters a
+ * folder => slug map, and the surviving keys select from the original.
+ *
+ * @param array $blocks Folder name => block name.
+ *
+ * @return array
+ */
+ private function filterAllowed(array $blocks): array
+ {
+ $allowed = AllowedBlocks::filter(array_map([$this, 'slug'], $blocks));
+
+ return array_intersect_key($blocks, $allowed);
+ }
+
+ /**
+ * The namespaced block name from a `block.json`, e.g. `yard/greeting`.
+ *
+ * Returns null for a folder that holds no readable metadata with a namespaced
+ * block name, so a stray directory is skipped rather than fatal.
+ */
+ private function blockName(string $metadataPath): ?string
+ {
+ if (! file_exists($metadataPath)) {
+ return null;
+ }
+
+ $metadata = json_decode((string) file_get_contents($metadataPath), true);
+ $name = is_array($metadata) && is_string($metadata['name'] ?? null) ? $metadata['name'] : '';
+
+ return '' === $this->slug($name) ? null : $name;
+ }
+
+ /**
+ * The slug of a block name, e.g. `greeting` for `yard/greeting`.
+ */
+ private function slug(string $blockName): string
+ {
+ $separator = strpos($blockName, '/');
+
+ return false === $separator ? '' : substr($blockName, $separator + 1);
+ }
+
+ /**
+ * The class WordPress generates for a block, e.g. `wp-block-yard-greeting`.
+ *
+ * Going through core's function rather than building the string ourselves
+ * means a site filtering `block_default_classname` gets `$blockClass` and
+ * every BEM modifier built on it following along. The function is marked
+ * `@access private`, hence the guard.
+ *
+ * @see wp_get_block_default_classname()
+ */
+ private function blockClass(string $blockName): string
+ {
+ return function_exists('wp_get_block_default_classname')
+ ? (string) \wp_get_block_default_classname($blockName)
+ : 'wp-block-' . str_replace('/', '-', $blockName);
+ }
+
+ /**
+ * Build the render callback for a single block.
+ *
+ * The view model assembles the render data, including the wrapper attributes:
+ * `get_block_wrapper_attributes()` reads the block currently being rendered,
+ * so it has to run inside the callback rather than up front. Blocks without
+ * their own view model get a plain `BlockViewModel`, which adds nothing.
+ */
+ private function renderCallback(string $directory, string $blockName, string $blockPath): callable
+ {
+ $templatePath = $blockPath . '/' . $this->slug($blockName) . '.blade.php';
+ $viewModelClass = __NAMESPACE__ . '\\' . $directory . '\\' . $directory;
+ $blockClass = $this->blockClass($blockName);
+
+ return function ($attributes, $content = '', $block = null) use ($templatePath, $viewModelClass, $blockClass) {
+ $viewModel = is_subclass_of($viewModelClass, BlockViewModel::class)
+ ? new $viewModelClass()
+ : new BlockViewModel();
+
+ return $this->renderer->render($templatePath, $viewModel->compose(
+ is_array($attributes) ? $attributes : [],
+ is_string($content) ? $content : '',
+ $block instanceof \WP_Block ? $block : null,
+ $blockClass
+ ));
+ };
+ }
+}
diff --git a/src/PluginServiceProvider.php b/src/PluginServiceProvider.php
index 0c7fab4..b627630 100644
--- a/src/PluginServiceProvider.php
+++ b/src/PluginServiceProvider.php
@@ -4,6 +4,8 @@
namespace Yard\Gutenberg;
+use Yard\Gutenberg\Support\AllowedBlocks;
+
class PluginServiceProvider
{
public function boot()
@@ -35,6 +37,7 @@ public function bootProviders(): void
Hooks\DefaultHookManager::class,
MyPatterns\MyPatternManager::class,
Patterns\PatternManager::class,
+ PhpBlocks\PhpBlockManager::class,
YardPatterns\YardPatternsManager::class,
];
@@ -89,16 +92,12 @@ public function registerBlocks()
$blockNames = array_map('basename', array_filter(glob($blocksPath . '*', GLOB_ONLYDIR) ?: []));
- if (has_filter('yard::gutenberg/allowed-blocks')) {
- $allowedBlocks = apply_filters('yard::gutenberg/allowed-blocks', []);
+ // Skip leftover directories from an earlier build that no longer hold a block.
+ $blockNames = array_filter($blockNames, function (string $blockName) use ($blocksPath) {
+ return file_exists($blocksPath . $blockName . '/block.json');
+ });
- $blockNames = array_filter(
- $blockNames,
- function (string $blockName) use ($allowedBlocks) {
- return in_array($blockName, $allowedBlocks);
- }
- );
- }
+ $blockNames = AllowedBlocks::filter($blockNames);
foreach ($blockNames as $blockName) {
$blockPath = $blocksPath . $blockName;
diff --git a/src/Support/AllowedBlocks.php b/src/Support/AllowedBlocks.php
new file mode 100644
index 0000000..5ac4ef8
--- /dev/null
+++ b/src/Support/AllowedBlocks.php
@@ -0,0 +1,40 @@
+ {
+ if ( ! Array.isArray( plugin?.patterns ) ) {
+ return;
+ }
+
+ plugin.patterns = plugin.patterns.map( ( pattern ) => ( {
+ ...pattern,
+ globOptions: {
+ ...pattern.globOptions,
+ ignore: [
+ ...( pattern.globOptions?.ignore ?? [] ),
+ '**/PhpBlocks/**',
+ ],
+ },
+ } ) );
+} );
+
+module.exports = config;