Prototype: Server-side block attributes sourcing

gutenberg.php

@@ -87,7 +87,7 @@ function gutenberg_menu() {
 function gutenberg_wordpress_version_notice() {
 	echo '<div class="error"><p>';
 	/* translators: %s: Minimum required version */
-	printf( __( 'Gutenberg requires WordPress %s or later to function properly. Please upgrade WordPress before activating Gutenberg.', 'gutenberg' ), '5.0.0' );
+	printf( __( 'Gutenberg requires WordPress %s or later to function properly. Please upgrade WordPress before activating Gutenberg.', 'gutenberg' ), '5.2.0' );
 	echo '</p></div>';
 
 	deactivate_plugins( array( 'gutenberg/gutenberg.php' ) );
@@ -122,7 +122,7 @@ function gutenberg_pre_init() {
 	// Strip '-src' from the version string. Messes up version_compare().
 	$version = str_replace( '-src', '', $wp_version );
 
-	if ( version_compare( $version, '5.0.0', '<' ) ) {
+	if ( version_compare( $version, '5.2.0', '<' ) ) {
 		add_action( 'admin_notices', 'gutenberg_wordpress_version_notice' );
 		return;
 	}

lib/blocks.php

@@ -27,6 +27,39 @@ function gutenberg_get_registered_social_link_blocks() {
 	return $registered_social_link_blocks;
 }
 
+/**
+ * Registers blocks using block manifests discovered in block library.
+ *
+ * @since 6.9.0
+ */
+function gutenberg_register_block_types() {
+	$registry = WP_Block_Type_Registry::get_instance();
+
+	$block_manifests = glob( dirname( dirname( __FILE__ ) ) . '/packages/block-library/src/*/block.json' );
+	foreach ( $block_manifests as $block_manifest ) {
+		$block_settings = json_decode( file_get_contents( $block_manifest ), true );
+		if ( is_null( $block_settings ) || ! isset( $block_settings['name'] ) ) {
+			continue;
+		}
+
+		if ( $registry->is_registered( $block_settings['name'] ) ) {
+			$block_settings = array_merge(
+				(array) $registry->get_registered( $block_settings['name'] ),
+				$block_settings
+			);
+
+			$registry->unregister( $block_settings['name'] );
+		}
+
+		register_block_type(
+			$block_settings['name'],
+			// Apply default attributes manually, as it isn't currently possible
+			// to filter block registration.
+			gutenberg_add_default_attributes( $block_settings )
+		);
+	}
+}
+
 /**
  * Substitutes the implementation of a core-registered block type, if exists,
  * with the built result from the plugin.
@@ -76,6 +109,12 @@ function gutenberg_reregister_core_block_types() {
 
 		require $blocks_dir . $file;
 	}
+
+	// Add block library registration only after this is reached, since the
+	// above `require` calls may attach their own `init` actions which are
+	// deferred to run at the latest priority. Thus, to correctly merge block
+	// settings from manifests, it must be the last to run.
+	add_action( 'init', 'gutenberg_register_block_types', 20 );
 }
 add_action( 'init', 'gutenberg_reregister_core_block_types' );
 

lib/class-wp-sourced-attributes-block-parser.php

@@ -0,0 +1,200 @@
+<?php
+/**
+ * Block Serialization Parser
+ *
+ * @package Gutenberg
+ */
+
+/**
+ * Class WP_Sourced_Attributes_Block_Parser
+ *
+ * Parses a document and constructs a list of parsed block objects
+ *
+ * @since 6.9.0
+ */
+class WP_Sourced_Attributes_Block_Parser extends WP_Block_Parser {
+
+	/**
+	 * Parses a document and returns a list of block structures
+	 *
+	 * When encountering an invalid parse will return a best-effort
+	 * parse. In contrast to the specification parser this does not
+	 * return an error on invalid inputs.
+	 *
+	 * @since 6.9.0
+	 *
+	 * @param string                 $document Input document being parsed.
+	 * @param WP_Block_Type_Registry $registry Block type registry from which
+	 *                                         block attributes schema can be
+	 *                                         retrieved.
+	 * @param int|null               $post_id  Optional post ID.
+	 * @return WP_Block_Parser_Block[]
+	 */
+	function parse( $document, $registry = null, $post_id = null ) {
+		if ( is_null( $registry ) ) {
+			$registry = WP_Block_Type_Registry::get_instance();
+		}
+
+		$blocks = parent::parse( $document );
+
+		foreach ( $blocks as $i => $block ) {
+			$block_type = $registry->get_registered( $block['blockName'] );
+			if ( is_null( $block_type ) || ! isset( $block_type->attributes ) ) {
+				continue;
+			}
+
+			$sourced_attributes = $this->get_sourced_attributes(
+				$block,
+				$block_type->attributes,
+				$post_id
+			);
+
+			$blocks[ $i ]['attrs'] = array_merge( $block['attrs'], $sourced_attributes );
+		}
+
+		return $blocks;
+	}
+
+	/**
+	 * Returns an array of sourced attribute values for a block.
+	 *
+	 * @param WP_Block_Parser_Block $block             Parsed block object.
+	 * @param array                 $attributes_schema Attributes of registered
+	 *                                                 block type for block.
+	 * @param int|null              $post_id           Optional post ID.
+	 * @return array                                   Sourced attribute values.
+	 */
+	function get_sourced_attributes( $block, $attributes_schema, $post_id ) {
+		$attributes = array();
+
+		foreach ( $attributes_schema as $key => $attribute_schema ) {
+			if ( isset( $attribute_schema['source'] ) ) {
+				$attributes[ $key ] = $this->get_sourced_attribute(
+					$block,
+					$attribute_schema,
+					$post_id
+				);
+			}
+		}
+
+		return $attributes;
+	}
+
+	/**
+	 * Returns a sourced attribute value for a block, for attribute type which
+	 * sources from HTML.
+	 *
+	 * @param WP_Block_Parser_Block $block            Parsed block object.
+	 * @param array                 $attribute_schema Attribute schema for
+	 *                                                individual attribute to
+	 *                                                be parsed.
+	 * @return mixed                                  Sourced attribute value.
+	 */
+	function get_html_sourced_attribute( $block, $attribute_schema ) {
+		$document = new DOMDocument();
+		try {
+			// loadHTML may log warnings for unexpected markup.
+			// phpcs:ignore
+			@$document->loadHTML( '<html><body>' . $block['innerHTML'] . '</body></html>' );
+		} catch ( Exception $e ) {
+			return null;
+		}
+
+		$selector = 'body';
+		if ( isset( $attribute_schema['selector'] ) ) {
+			$selector .= ' ' . $attribute_schema['selector'];
+		}
+
+		$xpath_selector = _wp_css_selector_to_xpath( $selector );
+		$xpath          = new DOMXpath( $document );
+		$match          = $xpath->evaluate( $xpath_selector );
+
+		if ( 0 === $match->count() ) {
+			return null;
+		}
+
+		$element = $match->item( 0 );
+
+		switch ( $attribute_schema['source'] ) {
+			case 'text':
+				/*
+				 * See: https://github.com/WordPress/WordPress-Coding-Standards/issues/574
+				 */
+				// phpcs:ignore
+				return $element->textContent;
+
+			case 'html':
+				$inner_html = '';
+
+				/*
+				 * See: https://github.com/WordPress/WordPress-Coding-Standards/issues/574
+				 */
+				// phpcs:ignore
+				foreach ( $element->childNodes as $child ) {
+					/*
+					 * See: https://github.com/WordPress/WordPress-Coding-Standards/issues/574
+					 */
+					// phpcs:ignore
+					$inner_html .= $child->ownerDocument->saveXML( $child );
+				}
+
+				return $inner_html;
+
+			case 'attribute':
+				if ( ! isset( $attribute_schema['attribute'] ) ||
+						is_null( $element->attributes ) ) {
+					return null;
+				}
+
+				$attribute = $element->attributes->getNamedItem( $attribute_schema['attribute'] );
+
+				/*
+				 * See: https://github.com/WordPress/WordPress-Coding-Standards/issues/574
+				 */
+				// phpcs:ignore
+				return is_null( $attribute ) ? null : $attribute->nodeValue;
+		}
+
+		return null;
+	}
+
+	/**
+	 * Returns a sourced attribute value for a block.
+	 *
+	 * @param WP_Block_Parser_Block $block            Parsed block object.
+	 * @param array                 $attribute_schema Attribute schema for
+	 *                                                individual attribute to
+	 *                                                be parsed.
+	 * @param int|null              $post_id          Optional post ID.
+	 * @return mixed                                  Sourced attribute value.
+	 */
+	function get_sourced_attribute( $block, $attribute_schema, $post_id ) {
+		switch ( $attribute_schema['source'] ) {
+			case 'text':
+			case 'html':
+			case 'attribute':
+				return $this->get_html_sourced_attribute( $block, $attribute_schema );
+
+			case 'query':
+				// TODO: Implement.
+				return null;
+
+			case 'property':
+			case 'node':
+			case 'children':
+			case 'tag':
+				// Unsupported or deprecated.
+				return null;
+
+			case 'meta':
+				if ( ! is_null( $post_id ) && isset( $attribute_schema['meta'] ) ) {
+					return get_post_meta( $post_id, $attribute_schema['meta'] );
+				}
+
+				return null;
+		}
+
+		return null;
+	}
+
+}

lib/load.php

@@ -51,7 +51,8 @@ function gutenberg_is_experiment_enabled( $name ) {
 }
 
 require dirname( __FILE__ ) . '/compat.php';
-
+require dirname( __FILE__ ) . '/class-wp-sourced-attributes-block-parser.php';
+require dirname( __FILE__ ) . '/parser.php';
 require dirname( __FILE__ ) . '/blocks.php';
 require dirname( __FILE__ ) . '/templates.php';
 require dirname( __FILE__ ) . '/template-loader.php';