Jetpack_Gutenberg::remove_extension_prefix() - Code Metrics - Inspection of "UI Review: Remove title from Mailchimp block." - Automattic/jetpack - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — update/mailchimp-ui-changes ( f4a7d6...e71283 )

unknown

created 2019-02-11 14:40 UTC

Jetpack_Gutenberg::remove_extension_prefix() A

↳ Parent: Jetpack_Gutenberg

Complexity

Conditions	3
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
nc	2
nop	1
dl	0
loc	6
rs	10
c	0
b	0
f	0

<?php
/**
 * Handles server-side registration and use of all blocks and plugins available in Jetpack for the block editor, aka Gutenberg.
 * Works in tandem with client-side block registration via `index.json`
 *
 * @package Jetpack
 */

/**
 * Helper function to register a Jetpack Gutenberg block
 *
 * @deprecated 7.1.0 Use (Gutenberg's) register_block_type() instead
 *
 * @param string $slug Slug of the block.
 * @param array  $args Arguments that are passed into register_block_type.
 *
 * @see register_block_type
 *
 * @since 6.7.0
 *
 * @return void
 */
function jetpack_register_block( $slug, $args = array() ) {
	_deprecated_function( __FUNCTION__, '7.1', 'register_block_type' );

	Jetpack_Gutenberg::register_block( $slug, $args );

}

/**
 * Helper function to register a Jetpack Gutenberg plugin
 *
 * @deprecated 7.1.0 Use Jetpack_Gutenberg::set_extension_available() instead
 *
 * @param string $slug Slug of the plugin.
 *
 * @since 6.9.0
 *
 * @return void
 */
function jetpack_register_plugin( $slug ) {
	_deprecated_function( __FUNCTION__, '7.1', 'Jetpack_Gutenberg::set_extension_available' );

	Jetpack_Gutenberg::register_plugin( $slug );

}

/**
 * Set the reason why an extension (block or plugin) is unavailable
 *
 * @deprecated 7.1.0 Use Jetpack_Gutenberg::set_extension_unavailable() instead
 *
 * @param string $slug Slug of the block.
 * @param string $reason A string representation of why the extension is unavailable.
 *
 * @since 7.0.0
 *
 * @return void
 */
function jetpack_set_extension_unavailability_reason( $slug, $reason ) {
	_deprecated_function( __FUNCTION__, '7.1', 'Jetpack_Gutenberg::set_extension_unavailable' );

	Jetpack_Gutenberg::set_extension_unavailability_reason( $slug, $reason );

}

/**
 * General Gutenberg editor specific functionality
 */
class Jetpack_Gutenberg {

	/**
	 * Only these extensions can be registered. Used to control availability of beta blocks.
	 *
	 * @var array Extensions whitelist
	 */
	private static $extensions = array();

	/**
	 * Keeps track of the reasons why a given extension is unavailable.
	 *
	 * @var array Extensions availability information
	 */
	private static $availability = array();

	/**
	 * Prepend the 'jetpack/' prefix to a block name
	 *
	 * @param string $block_name The block name.
	 *
	 * @return string The prefixed block name.
	 */
	private static function prepend_block_prefix( $block_name ) {
		return 'jetpack/' . $block_name;
	}

	/**
	 * Remove the 'jetpack/' or jetpack-' prefix from an extension name
	 *
	 * @param string $extension_name The extension name.
	 *
	 * @return string The unprefixed extension name.
	 */
	private static function remove_extension_prefix( $extension_name ) {
		if ( wp_startswith( $extension_name, 'jetpack/' ) || wp_startswith( $extension_name, 'jetpack-' ) ) {
			return substr( $extension_name, strlen( 'jetpack/' ) );
		}
		return $extension_name;
	}

	/**
	 * Whether two arrays share at least one item
	 *
	 * @param array $a An array.
	 * @param array $b Another array.
	 *
	 * @return boolean True if $a and $b share at least one item
	 */
	protected static function share_items( $a, $b ) {
		return count( array_intersect( $a, $b ) ) > 0;
	}

	/**
	 * Register a block
	 *
	 * @deprecated 7.1.0 Use (Gutenberg's) register_block_type() instead
	 *
	 * @param string $slug Slug of the block.
	 * @param array  $args Arguments that are passed into register_block_type().
	 */
	public static function register_block( $slug, $args ) {
		_deprecated_function( __METHOD__, '7.1', 'register_block_type' );

		register_block_type( 'jetpack/' . $slug, $args );
	}

	/**
	 * Register a plugin
	 *
	 * @deprecated 7.1.0 Use Jetpack_Gutenberg::set_extension_available() instead
	 *
	 * @param string $slug Slug of the plugin.
	 */
	public static function register_plugin( $slug ) {
		_deprecated_function( __METHOD__, '7.1', 'Jetpack_Gutenberg::set_extension_available' );

		self::set_extension_available( $slug );
	}

	/**
	 * Register a block
	 *
	 * @deprecated 7.0.0 Use register_block_type() instead
	 *
	 * @param string $slug Slug of the block.
	 * @param array  $args Arguments that are passed into the register_block_type.
	 * @param array  $availability array containing if a block is available and the reason when it is not.
	 */
	public static function register( $slug, $args, $availability ) {
		_deprecated_function( __METHOD__, '7.0', 'register_block_type' );

		if ( isset( $availability['available'] ) && ! $availability['available'] ) {
			self::set_extension_unavailability_reason( $slug, $availability['unavailable_reason'] );

		} else {
			self::register_block( $slug, $args );

		}
	}

	/**
	 * Set a (non-block) extension as available
	 *
	 * @param string $slug Slug of the extension.
	 */
	public static function set_extension_available( $slug ) {
		self::$availability[ self::remove_extension_prefix( $slug ) ] = true;
	}

	/**
	 * Set the reason why an extension (block or plugin) is unavailable
	 *
	 * @param string $slug Slug of the extension.
	 * @param string $reason A string representation of why the extension is unavailable.
	 */
	public static function set_extension_unavailable( $slug, $reason ) {
		self::$availability[ self::remove_extension_prefix( $slug ) ] = $reason;
	}

	/**
	 * Set the reason why an extension (block or plugin) is unavailable
	 *
	 * @deprecated 7.1.0 Use set_extension_unavailable() instead
	 *
	 * @param string $slug Slug of the extension.
	 * @param string $reason A string representation of why the extension is unavailable.
	 */
	public static function set_extension_unavailability_reason( $slug, $reason ) {
		_deprecated_function( __METHOD__, '7.1', 'Jetpack_Gutenberg::set_extension_unavailable' );

		self::set_extension_unavailable( $slug, $reason );
	}

	/**
	 * Set up a whitelist of allowed block editor extensions
	 *
	 * @return void
	 */
	public static function init() {
		if ( ! self::is_gutenberg_available() ) {
			return;
		}

		if ( ! self::should_load() ) {
			return;
		}

		/**
		 * Alternative to `JETPACK_BETA_BLOCKS`, set to `true` to load Beta Blocks.
		 *
		 * @since 6.9.0
		 *
		 * @param boolean
		 */
		if ( apply_filters( 'jetpack_load_beta_blocks', false ) ) {
			Jetpack_Constants::set_constant( 'JETPACK_BETA_BLOCKS', true );
		}

		/**
		 * Filter the whitelist of block editor extensions that are available through Jetpack.
		 *
		 * @since 7.0.0
		 *
		 * @param array
		 */
		self::$extensions = apply_filters( 'jetpack_set_available_extensions', self::get_jetpack_gutenberg_extensions_whitelist() );

		/**
		 * Filter the whitelist of block editor plugins that are available through Jetpack.
		 *
		 * @deprecated 7.0.0 Use jetpack_set_available_extensions instead
		 *
		 * @since 6.8.0
		 *
		 * @param array
		 */
		self::$extensions = apply_filters( 'jetpack_set_available_blocks', self::$extensions );

		/**
		 * Filter the whitelist of block editor plugins that are available through Jetpack.
		 *
		 * @deprecated 7.0.0 Use jetpack_set_available_extensions instead
		 *
		 * @since 6.9.0
		 *
		 * @param array
		 */
		self::$extensions = apply_filters( 'jetpack_set_available_plugins', self::$extensions );
	}

	/**
	 * Resets the class to its original state
	 *
	 * Used in unit tests
	 *
	 * @return void
	 */
	public static function reset() {
		self::$extensions         = array();
		self::$availability       = array();
	}

	/**
	 * Return the Gutenberg extensions (blocks and plugins) directory
	 *
	 * @return string The Gutenberg extensions directory
	 */
	public static function get_blocks_directory() {
		/**
		 * Filter to select Gutenberg blocks directory
		 *
		 * @since 6.9.0
		 *
		 * @param string default: '_inc/blocks/'
		 */
		return apply_filters( 'jetpack_blocks_directory', '_inc/blocks/' );
	}

	/**
	 * Checks for a given .json file in the blocks folder.
	 *
	 * @param string $preset The name of the .json file to look for.
	 *
	 * @return bool True if the file is found.
	 */
	public static function preset_exists( $preset ) {
		return file_exists( JETPACK__PLUGIN_DIR . self::get_blocks_directory() . $preset . '.json' );
	}

	/**
	 * Decodes JSON loaded from a preset file in the blocks folder
	 *
	 * @param string $preset The name of the .json file to load.
	 *
	 * @return mixed Returns an object if the file is present, or false if a valid .json file is not present.
	 */
	public static function get_preset( $preset ) {
		return json_decode( file_get_contents( JETPACK__PLUGIN_DIR . self::get_blocks_directory() . $preset . '.json' ) );
	}

	/**
	 * Returns a whitelist of Jetpack Gutenberg extensions (blocks and plugins), based on index.json
	 *
	 * @return array A list of blocks: eg [ 'publicize', 'markdown' ]
	 */
	public static function get_jetpack_gutenberg_extensions_whitelist() {
		$preset_extensions_manifest = self::preset_exists( 'index' ) ? self::get_preset( 'index' ) : (object) array();

		$preset_extensions = isset( $preset_extensions_manifest->production ) ? (array) $preset_extensions_manifest->production : array();

		if ( Jetpack_Constants::is_true( 'JETPACK_BETA_BLOCKS' ) ) {
			$beta_extensions = isset( $preset_extensions_manifest->beta ) ? (array) $preset_extensions_manifest->beta : array();
			return array_unique( array_merge( $preset_extensions, $beta_extensions ) );
		}

		return $preset_extensions;
	}

	/**
	 * Get availability of each block / plugin.
	 *
	 * @return array A list of block and plugins and their availablity status
	 */
	public static function get_availability() {
		if ( ! self::is_gutenberg_available() ) {
			return array();
		}

		/**
		 * Fires before Gutenberg extensions availability is computed.
		 *
		 * In the function call you supply, use `register_block_type()` to set a block as available.
		 * Alternatively, use `Jetpack_Gutenberg::set_extension_available()` (for a non-block plugin), and
		 * `Jetpack_Gutenberg::set_extension_unavailable()` (if the block or plugin should not be registered
		 * but marked as unavailable).
		 *
		 * @since 7.0.0
		 */
		do_action( 'jetpack_register_gutenberg_extensions' );

		$available_extensions = array();

		foreach ( self::$extensions as $extension ) {
			$is_available = WP_Block_Type_Registry::get_instance()->is_registered( 'jetpack/' . $extension ) ||
			( isset( self::$availability[ $extension ] ) && self::$availability[ $extension ] === true );

			$available_extensions[ $extension ] = array(
				'available' => $is_available,
			);

			if ( ! $is_available ) {
				$reason = isset( self::$availability[ $extension ] ) ? self::$availability[ $extension ] : 'missing_module';
				$available_extensions[ $extension ]['unavailable_reason'] = $reason;
			}
		}

		$unwhitelisted_blocks = array();
		$all_registered_blocks = WP_Block_Type_Registry::get_instance()->get_all_registered();
		foreach ( $all_registered_blocks as $block_name => $block_type ) {
			if ( ! wp_startswith( $block_name, 'jetpack/' ) || isset( $block_type->parent ) ) {
				continue;
			}

			$unprefixed_block_name = self::remove_extension_prefix( $block_name );

			if ( in_array( $unprefixed_block_name, self::$extensions ) ) {
				continue;
			}

			$unwhitelisted_blocks[ $unprefixed_block_name ] = array(
				'available'          => false,
				'unavailable_reason' => 'not_whitelisted',
			);
		}

		// Finally: Unwhitelisted non-block extensions. These are in $availability.
		$unwhitelisted_extensions = array_fill_keys(
			array_diff( array_keys( self::$availability ), self::$extensions ),
			array(
				'available'          => false,
				'unavailable_reason' => 'not_whitelisted',
			)
		);
		return array_merge( $available_extensions, $unwhitelisted_blocks, $unwhitelisted_extensions );
	}

	/**
	 * Check if Gutenberg editor is available
	 *
	 * @since 6.7.0
	 *
	 * @return bool
	 */
	public static function is_gutenberg_available() {
		return function_exists( 'register_block_type' );
	}

	/**
	 * Check whether conditions indicate Gutenberg Extensions (blocks and plugins) should be loaded
	 *
	 * Loading blocks and plugins is enabled by default and may be disabled via filter:
	 *   add_filter( 'jetpack_gutenberg', '__return_false' );
	 *
	 * @since 6.9.0
	 *
	 * @return bool
	 */
	public static function should_load() {
		if ( ! Jetpack::is_active() && ! Jetpack::is_development_mode() ) {
			return false;
		}

		/**
		 * Filter to disable Gutenberg blocks
		 *
		 * @since 6.5.0
		 *
		 * @param bool true Whether to load Gutenberg blocks
		 */
		return (bool) apply_filters( 'jetpack_gutenberg', true );
	}

	/**
	 * Only enqueue block assets when needed.
	 *
	 * @param string $type slug of the block.
	 * @param array  $script_dependencies An array of view-side Javascript dependencies to be enqueued.
	 *
	 * @return void
	 */
	public static function load_assets_as_required( $type, $script_dependencies = array() ) {
		if ( is_admin() ) {
			// A block's view assets will not be required in wp-admin.
			return;
		}

		$type = sanitize_title_with_dashes( $type );
		// Enqueue styles.
		$style_relative_path = self::get_blocks_directory() . $type . '/view' . ( is_rtl() ? '.rtl' : '' ) . '.css';
		if ( self::block_has_asset( $style_relative_path ) ) {
			$style_version = self::get_asset_version( $style_relative_path );
			$view_style    = plugins_url( $style_relative_path, JETPACK__PLUGIN_FILE );
			wp_enqueue_style( 'jetpack-block-' . $type, $view_style, array(), $style_version );
		}

		// Enqueue script.
		$script_relative_path = self::get_blocks_directory() . $type . '/view.js';
		if ( self::block_has_asset( $script_relative_path ) ) {
			$script_version = self::get_asset_version( $script_relative_path );
			$view_script    = plugins_url( $script_relative_path, JETPACK__PLUGIN_FILE );
			wp_enqueue_script( 'jetpack-block-' . $type, $view_script, $script_dependencies, $script_version, false );
		}

		wp_localize_script(
			'jetpack-block-' . $type,
			'Jetpack_Block_Assets_Base_Url',
			plugins_url( self::get_blocks_directory(), JETPACK__PLUGIN_FILE )
		);
	}

	/**
	 * Check if an asset exists for a block.
	 *
	 * @param string $file Path of the file we are looking for.
	 *
	 * @return bool $block_has_asset Does the file exist.
	 */
	public static function block_has_asset( $file ) {
		return file_exists( JETPACK__PLUGIN_DIR . $file );
	}

	/**
	 * Get the version number to use when loading the file. Allows us to bypass cache when developing.
	 *
	 * @param string $file Path of the file we are looking for.
	 *
	 * @return string $script_version Version number.
	 */
	public static function get_asset_version( $file ) {
		return Jetpack::is_development_version() && self::block_has_asset( $file )
			? filemtime( JETPACK__PLUGIN_DIR . $file )
			: JETPACK__VERSION;
	}

	/**
	 * Load Gutenberg editor assets
	 *
	 * @since 6.7.0
	 *
	 * @return void
	 */
	public static function enqueue_block_editor_assets() {
		if ( ! self::should_load() ) {
			return;
		}

		$rtl        = is_rtl() ? '.rtl' : '';
		$beta       = Jetpack_Constants::is_true( 'JETPACK_BETA_BLOCKS' ) ? '-beta' : '';
		$blocks_dir = self::get_blocks_directory();

		$editor_script = plugins_url( "{$blocks_dir}editor{$beta}.js", JETPACK__PLUGIN_FILE );
		$editor_style  = plugins_url( "{$blocks_dir}editor{$beta}{$rtl}.css", JETPACK__PLUGIN_FILE );

		$version = Jetpack::is_development_version() && file_exists( JETPACK__PLUGIN_DIR . $blocks_dir . 'editor.js' )
			? filemtime( JETPACK__PLUGIN_DIR . $blocks_dir . 'editor.js' )
			: JETPACK__VERSION;

		wp_enqueue_script(
			'jetpack-blocks-editor',
			$editor_script,
			array(
				'lodash',
				'wp-api-fetch',
				'wp-blob',
				'wp-blocks',
				'wp-components',
				'wp-compose',
				'wp-data',
				'wp-date',
				'wp-edit-post',
				'wp-editor',
				'wp-element',
				'wp-hooks',
				'wp-i18n',
				'wp-keycodes',
				'wp-plugins',
				'wp-rich-text',
				'wp-token-list',
				'wp-url',
			),
			$version,
			false
		);

		wp_localize_script(
			'jetpack-blocks-editor',
			'Jetpack_Block_Assets_Base_Url',
			plugins_url( $blocks_dir . '/', JETPACK__PLUGIN_FILE )
		);

		wp_localize_script(
			'jetpack-blocks-editor',
			'Jetpack_Editor_Initial_State',
			array(
				'available_blocks' => self::get_availability(),
				'jetpack'          => array( 'is_active' => Jetpack::is_active() ),
			)
		);

		Jetpack::setup_wp_i18n_locale_data();

		wp_enqueue_style( 'jetpack-blocks-editor', $editor_style, array(), $version );
	}

	/**
	 * Some blocks do not depend on a specific module,
	 * and can consequently be loaded outside of the usual modules.
	 * We will look for such modules in the extensions/ directory.
	 *
	 * @since 7.1.0
	 */
	public static function load_independent_blocks() {
		if ( self::should_load() && self::is_gutenberg_available() ) {
			/**
			 * Look for files that match our list of available Jetpack Gutenberg extensions (blocks and plugins).
			 * If available, load them.
			 */
			foreach ( self::$extensions as $extension ) {
				$extension_file_glob = glob( JETPACK__PLUGIN_DIR . 'extensions/*/' . $extension . '/' . $extension . '.php' );
				if ( ! empty( $extension_file_glob ) ) {
					include_once $extension_file_glob[0];
				}
			}
		}
	}
}


1		<?php
2		/**
3		* Handles server-side registration and use of all blocks and plugins available in Jetpack for the block editor, aka Gutenberg.
4		* Works in tandem with client-side block registration via `index.json`
5		*
6		* @package Jetpack
7		*/
8
9		/**
10		* Helper function to register a Jetpack Gutenberg block
11		*
12		* @deprecated 7.1.0 Use (Gutenberg's) register_block_type() instead
13		*
14		* @param string $slug Slug of the block.
15		* @param array $args Arguments that are passed into register_block_type.
16		*
17		* @see register_block_type
18		*
19		* @since 6.7.0
20		*
21		* @return void
22		*/
23		function jetpack_register_block( $slug, $args = array() ) {
24		_deprecated_function( __FUNCTION__, '7.1', 'register_block_type' );
25
26		Jetpack_Gutenberg::register_block( $slug, $args );
		0 ignored issues – show Deprecated Code introduced 2019-01-27 17:10 UTC by Report Bug Copy Issue Report The method `Jetpack_Gutenberg::register_block()` has been deprecated with message: 7.1.0 Use (Gutenberg's) register_block_type() instead This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
27		}
28
29		/**
30		* Helper function to register a Jetpack Gutenberg plugin
31		*
32		* @deprecated 7.1.0 Use Jetpack_Gutenberg::set_extension_available() instead
33		*
34		* @param string $slug Slug of the plugin.
35		*
36		* @since 6.9.0
37		*
38		* @return void
39		*/
40		function jetpack_register_plugin( $slug ) {
41		_deprecated_function( __FUNCTION__, '7.1', 'Jetpack_Gutenberg::set_extension_available' );
42
43		Jetpack_Gutenberg::register_plugin( $slug );
		0 ignored issues – show Deprecated Code introduced 2019-02-08 11:45 UTC by Report Bug Copy Issue Report The method `Jetpack_Gutenberg::register_plugin()` has been deprecated with message: 7.1.0 Use Jetpack_Gutenberg::set_extension_available() instead This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
44		}
45
46		/**
47		* Set the reason why an extension (block or plugin) is unavailable
48		*
49		* @deprecated 7.1.0 Use Jetpack_Gutenberg::set_extension_unavailable() instead
50		*
51		* @param string $slug Slug of the block.
52		* @param string $reason A string representation of why the extension is unavailable.
53		*
54		* @since 7.0.0
55		*
56		* @return void
57		*/
58		function jetpack_set_extension_unavailability_reason( $slug, $reason ) {
59		_deprecated_function( __FUNCTION__, '7.1', 'Jetpack_Gutenberg::set_extension_unavailable' );
60
61		Jetpack_Gutenberg::set_extension_unavailability_reason( $slug, $reason );
		0 ignored issues – show Deprecated Code introduced 2019-01-27 17:10 UTC by Report Bug Copy Issue Report The method `Jetpack_Gutenberg::set_e...unavailability_reason()` has been deprecated with message: 7.1.0 Use set_extension_unavailable() instead This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
62		}
63
64		/**
65		* General Gutenberg editor specific functionality
66		*/
67		class Jetpack_Gutenberg {
68
69		/**
70		* Only these extensions can be registered. Used to control availability of beta blocks.
71		*
72		* @var array Extensions whitelist
73		*/
74		private static $extensions = array();
75
76		/**
77		* Keeps track of the reasons why a given extension is unavailable.
78		*
79		* @var array Extensions availability information
80		*/
81		private static $availability = array();
82
83		/**
84		* Prepend the 'jetpack/' prefix to a block name
85		*
86		* @param string $block_name The block name.
87		*
88		* @return string The prefixed block name.
89		*/
90		private static function prepend_block_prefix( $block_name ) {
91		return 'jetpack/' . $block_name;
92		}
93
94		/**
95		* Remove the 'jetpack/' or jetpack-' prefix from an extension name
96		*
97		* @param string $extension_name The extension name.
98		*
99		* @return string The unprefixed extension name.
100		*/
101		private static function remove_extension_prefix( $extension_name ) {
102		if ( wp_startswith( $extension_name, 'jetpack/' ) \|\| wp_startswith( $extension_name, 'jetpack-' ) ) {
103		return substr( $extension_name, strlen( 'jetpack/' ) );
104		}
105		return $extension_name;
106		}
107
108		/**
109		* Whether two arrays share at least one item
110		*
111		* @param array $a An array.
112		* @param array $b Another array.
113		*
114		* @return boolean True if $a and $b share at least one item
115		*/
116		protected static function share_items( $a, $b ) {
117		return count( array_intersect( $a, $b ) ) > 0;
118		}
119
120		/**
121		* Register a block
122		*
123		* @deprecated 7.1.0 Use (Gutenberg's) register_block_type() instead
124		*
125		* @param string $slug Slug of the block.
126		* @param array $args Arguments that are passed into register_block_type().
127		*/
128		public static function register_block( $slug, $args ) {
129		_deprecated_function( __METHOD__, '7.1', 'register_block_type' );
130
131		register_block_type( 'jetpack/' . $slug, $args );
132		}
133
134		/**
135		* Register a plugin
136		*
137		* @deprecated 7.1.0 Use Jetpack_Gutenberg::set_extension_available() instead
138		*
139		* @param string $slug Slug of the plugin.
140		*/
141		public static function register_plugin( $slug ) {
142		_deprecated_function( __METHOD__, '7.1', 'Jetpack_Gutenberg::set_extension_available' );
143
144		self::set_extension_available( $slug );
145		}
146
147		/**
148		* Register a block
149		*
150		* @deprecated 7.0.0 Use register_block_type() instead
151		*
152		* @param string $slug Slug of the block.
153		* @param array $args Arguments that are passed into the register_block_type.
154		* @param array $availability array containing if a block is available and the reason when it is not.
155		*/
156		public static function register( $slug, $args, $availability ) {
157		_deprecated_function( __METHOD__, '7.0', 'register_block_type' );
158
159		if ( isset( $availability['available'] ) && ! $availability['available'] ) {
160		self::set_extension_unavailability_reason( $slug, $availability['unavailable_reason'] );
		0 ignored issues – show Deprecated Code introduced 2019-01-27 17:10 UTC by Report Bug Copy Issue Report The method `Jetpack_Gutenberg::set_e...unavailability_reason()` has been deprecated with message: 7.1.0 Use set_extension_unavailable() instead This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
161		} else {
162		self::register_block( $slug, $args );
		0 ignored issues – show Deprecated Code introduced 2019-01-27 17:10 UTC by Report Bug Copy Issue Report The method `Jetpack_Gutenberg::register_block()` has been deprecated with message: 7.1.0 Use (Gutenberg's) register_block_type() instead This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
163		}
164		}
165
166		/**
167		* Set a (non-block) extension as available
168		*
169		* @param string $slug Slug of the extension.
170		*/
171		public static function set_extension_available( $slug ) {
172		self::$availability[ self::remove_extension_prefix( $slug ) ] = true;
173		}
174
175		/**
176		* Set the reason why an extension (block or plugin) is unavailable
177		*
178		* @param string $slug Slug of the extension.
179		* @param string $reason A string representation of why the extension is unavailable.
180		*/
181		public static function set_extension_unavailable( $slug, $reason ) {
182		self::$availability[ self::remove_extension_prefix( $slug ) ] = $reason;
183		}
184
185		/**
186		* Set the reason why an extension (block or plugin) is unavailable
187		*
188		* @deprecated 7.1.0 Use set_extension_unavailable() instead
189		*
190		* @param string $slug Slug of the extension.
191		* @param string $reason A string representation of why the extension is unavailable.
192		*/
193		public static function set_extension_unavailability_reason( $slug, $reason ) {
194		_deprecated_function( __METHOD__, '7.1', 'Jetpack_Gutenberg::set_extension_unavailable' );
195
196		self::set_extension_unavailable( $slug, $reason );
197		}
198
199		/**
200		* Set up a whitelist of allowed block editor extensions
201		*
202		* @return void
203		*/
204		public static function init() {
205		if ( ! self::is_gutenberg_available() ) {
206		return;
207		}
208
209		if ( ! self::should_load() ) {
210		return;
211		}
212
213		/**
214		* Alternative to `JETPACK_BETA_BLOCKS`, set to `true` to load Beta Blocks.
215		*
216		* @since 6.9.0
217		*
218		* @param boolean
219		*/
220		if ( apply_filters( 'jetpack_load_beta_blocks', false ) ) {
221		Jetpack_Constants::set_constant( 'JETPACK_BETA_BLOCKS', true );
222		}
223
224		/**
225		* Filter the whitelist of block editor extensions that are available through Jetpack.
226		*
227		* @since 7.0.0
228		*
229		* @param array
230		*/
231		self::$extensions = apply_filters( 'jetpack_set_available_extensions', self::get_jetpack_gutenberg_extensions_whitelist() );
232
233		/**
234		* Filter the whitelist of block editor plugins that are available through Jetpack.
235		*
236		* @deprecated 7.0.0 Use jetpack_set_available_extensions instead
237		*
238		* @since 6.8.0
239		*
240		* @param array
241		*/
242		self::$extensions = apply_filters( 'jetpack_set_available_blocks', self::$extensions );
243
244		/**
245		* Filter the whitelist of block editor plugins that are available through Jetpack.
246		*
247		* @deprecated 7.0.0 Use jetpack_set_available_extensions instead
248		*
249		* @since 6.9.0
250		*
251		* @param array
252		*/
253		self::$extensions = apply_filters( 'jetpack_set_available_plugins', self::$extensions );
254		}
255
256		/**
257		* Resets the class to its original state
258		*
259		* Used in unit tests
260		*
261		* @return void
262		*/
263		public static function reset() {
264		self::$extensions = array();
265		self::$availability = array();
266		}
267
268		/**
269		* Return the Gutenberg extensions (blocks and plugins) directory
270		*
271		* @return string The Gutenberg extensions directory
272		*/
273		public static function get_blocks_directory() {
274		/**
275		* Filter to select Gutenberg blocks directory
276		*
277		* @since 6.9.0
278		*
279		* @param string default: '_inc/blocks/'
280		*/
281		return apply_filters( 'jetpack_blocks_directory', '_inc/blocks/' );
282		}
283
284		/**
285		* Checks for a given .json file in the blocks folder.
286		*
287		* @param string $preset The name of the .json file to look for.
288		*
289		* @return bool True if the file is found.
290		*/
291		public static function preset_exists( $preset ) {
292		return file_exists( JETPACK__PLUGIN_DIR . self::get_blocks_directory() . $preset . '.json' );
293		}
294
295		/**
296		* Decodes JSON loaded from a preset file in the blocks folder
297		*
298		* @param string $preset The name of the .json file to load.
299		*
300		* @return mixed Returns an object if the file is present, or false if a valid .json file is not present.
301		*/
302		public static function get_preset( $preset ) {
303		return json_decode( file_get_contents( JETPACK__PLUGIN_DIR . self::get_blocks_directory() . $preset . '.json' ) );
304		}
305
306		/**
307		* Returns a whitelist of Jetpack Gutenberg extensions (blocks and plugins), based on index.json
308		*
309		* @return array A list of blocks: eg [ 'publicize', 'markdown' ]
310		*/
311		public static function get_jetpack_gutenberg_extensions_whitelist() {
312		$preset_extensions_manifest = self::preset_exists( 'index' ) ? self::get_preset( 'index' ) : (object) array();
313
314		$preset_extensions = isset( $preset_extensions_manifest->production ) ? (array) $preset_extensions_manifest->production : array();
315
316		if ( Jetpack_Constants::is_true( 'JETPACK_BETA_BLOCKS' ) ) {
317		$beta_extensions = isset( $preset_extensions_manifest->beta ) ? (array) $preset_extensions_manifest->beta : array();
318		return array_unique( array_merge( $preset_extensions, $beta_extensions ) );
319		}
320
321		return $preset_extensions;
322		}
323
324		/**
325		* Get availability of each block / plugin.
326		*
327		* @return array A list of block and plugins and their availablity status
328		*/
329		public static function get_availability() {
330		if ( ! self::is_gutenberg_available() ) {
331		return array();
332		}
333
334		/**
335		* Fires before Gutenberg extensions availability is computed.
336		*
337		* In the function call you supply, use `register_block_type()` to set a block as available.
338		* Alternatively, use `Jetpack_Gutenberg::set_extension_available()` (for a non-block plugin), and
339		* `Jetpack_Gutenberg::set_extension_unavailable()` (if the block or plugin should not be registered
340		* but marked as unavailable).
341		*
342		* @since 7.0.0
343		*/
344		do_action( 'jetpack_register_gutenberg_extensions' );
345
346		$available_extensions = array();
347
348		foreach ( self::$extensions as $extension ) {
349		$is_available = WP_Block_Type_Registry::get_instance()->is_registered( 'jetpack/' . $extension ) \|\|
350		( isset( self::$availability[ $extension ] ) && self::$availability[ $extension ] === true );
351
352		$available_extensions[ $extension ] = array(
353		'available' => $is_available,
354		);
355
356		if ( ! $is_available ) {
357		$reason = isset( self::$availability[ $extension ] ) ? self::$availability[ $extension ] : 'missing_module';
358		$available_extensions[ $extension ]['unavailable_reason'] = $reason;
359		}
360		}
361
362		$unwhitelisted_blocks = array();
363		$all_registered_blocks = WP_Block_Type_Registry::get_instance()->get_all_registered();
364		foreach ( $all_registered_blocks as $block_name => $block_type ) {
365		if ( ! wp_startswith( $block_name, 'jetpack/' ) \|\| isset( $block_type->parent ) ) {
366		continue;
367		}
368
369		$unprefixed_block_name = self::remove_extension_prefix( $block_name );
370
371		if ( in_array( $unprefixed_block_name, self::$extensions ) ) {
372		continue;
373		}
374
375		$unwhitelisted_blocks[ $unprefixed_block_name ] = array(
376		'available' => false,
377		'unavailable_reason' => 'not_whitelisted',
378		);
379		}
380
381		// Finally: Unwhitelisted non-block extensions. These are in $availability.
382		$unwhitelisted_extensions = array_fill_keys(
383		array_diff( array_keys( self::$availability ), self::$extensions ),
384		array(
385		'available' => false,
386		'unavailable_reason' => 'not_whitelisted',
387		)
388		);
389		return array_merge( $available_extensions, $unwhitelisted_blocks, $unwhitelisted_extensions );
390		}
391
392		/**
393		* Check if Gutenberg editor is available
394		*
395		* @since 6.7.0
396		*
397		* @return bool
398		*/
399		public static function is_gutenberg_available() {
400		return function_exists( 'register_block_type' );
401		}
402
403		/**
404		* Check whether conditions indicate Gutenberg Extensions (blocks and plugins) should be loaded
405		*
406		* Loading blocks and plugins is enabled by default and may be disabled via filter:
407		* add_filter( 'jetpack_gutenberg', '__return_false' );
408		*
409		* @since 6.9.0
410		*
411		* @return bool
412		*/
413		public static function should_load() {
414		if ( ! Jetpack::is_active() && ! Jetpack::is_development_mode() ) {
415		return false;
416		}
417
418		/**
419		* Filter to disable Gutenberg blocks
420		*
421		* @since 6.5.0
422		*
423		* @param bool true Whether to load Gutenberg blocks
424		*/
425		return (bool) apply_filters( 'jetpack_gutenberg', true );
426		}
427
428		/**
429		* Only enqueue block assets when needed.
430		*
431		* @param string $type slug of the block.
432		* @param array $script_dependencies An array of view-side Javascript dependencies to be enqueued.
433		*
434		* @return void
435		*/
436		public static function load_assets_as_required( $type, $script_dependencies = array() ) {
437		if ( is_admin() ) {
438		// A block's view assets will not be required in wp-admin.
439		return;
440		}
441
442		$type = sanitize_title_with_dashes( $type );
443		// Enqueue styles.
444		$style_relative_path = self::get_blocks_directory() . $type . '/view' . ( is_rtl() ? '.rtl' : '' ) . '.css';
445	View Code Duplication	if ( self::block_has_asset( $style_relative_path ) ) {
446		$style_version = self::get_asset_version( $style_relative_path );
447		$view_style = plugins_url( $style_relative_path, JETPACK__PLUGIN_FILE );
448		wp_enqueue_style( 'jetpack-block-' . $type, $view_style, array(), $style_version );
449		}
450
451		// Enqueue script.
452		$script_relative_path = self::get_blocks_directory() . $type . '/view.js';
453	View Code Duplication	if ( self::block_has_asset( $script_relative_path ) ) {
454		$script_version = self::get_asset_version( $script_relative_path );
455		$view_script = plugins_url( $script_relative_path, JETPACK__PLUGIN_FILE );
456		wp_enqueue_script( 'jetpack-block-' . $type, $view_script, $script_dependencies, $script_version, false );
457		}
458
459		wp_localize_script(
460		'jetpack-block-' . $type,
461		'Jetpack_Block_Assets_Base_Url',
462		plugins_url( self::get_blocks_directory(), JETPACK__PLUGIN_FILE )
463		);
464		}
465
466		/**
467		* Check if an asset exists for a block.
468		*
469		* @param string $file Path of the file we are looking for.
470		*
471		* @return bool $block_has_asset Does the file exist.
472		*/
473		public static function block_has_asset( $file ) {
474		return file_exists( JETPACK__PLUGIN_DIR . $file );
475		}
476
477		/**
478		* Get the version number to use when loading the file. Allows us to bypass cache when developing.
479		*
480		* @param string $file Path of the file we are looking for.
481		*
482		* @return string $script_version Version number.
483		*/
484		public static function get_asset_version( $file ) {
485		return Jetpack::is_development_version() && self::block_has_asset( $file )
486		? filemtime( JETPACK__PLUGIN_DIR . $file )
487		: JETPACK__VERSION;
488		}
489
490		/**
491		* Load Gutenberg editor assets
492		*
493		* @since 6.7.0
494		*
495		* @return void
496		*/
497		public static function enqueue_block_editor_assets() {
498		if ( ! self::should_load() ) {
499		return;
500		}
501
502		$rtl = is_rtl() ? '.rtl' : '';
503		$beta = Jetpack_Constants::is_true( 'JETPACK_BETA_BLOCKS' ) ? '-beta' : '';
504		$blocks_dir = self::get_blocks_directory();
505
506		$editor_script = plugins_url( "{$blocks_dir}editor{$beta}.js", JETPACK__PLUGIN_FILE );
507		$editor_style = plugins_url( "{$blocks_dir}editor{$beta}{$rtl}.css", JETPACK__PLUGIN_FILE );
508
509		$version = Jetpack::is_development_version() && file_exists( JETPACK__PLUGIN_DIR . $blocks_dir . 'editor.js' )
510		? filemtime( JETPACK__PLUGIN_DIR . $blocks_dir . 'editor.js' )
511		: JETPACK__VERSION;
512
513		wp_enqueue_script(
514		'jetpack-blocks-editor',
515		$editor_script,
516		array(
517		'lodash',
518		'wp-api-fetch',
519		'wp-blob',
520		'wp-blocks',
521		'wp-components',
522		'wp-compose',
523		'wp-data',
524		'wp-date',
525		'wp-edit-post',
526		'wp-editor',
527		'wp-element',
528		'wp-hooks',
529		'wp-i18n',
530		'wp-keycodes',
531		'wp-plugins',
532		'wp-rich-text',
533		'wp-token-list',
534		'wp-url',
535		),
536		$version,
537		false
538		);
539
540		wp_localize_script(
541		'jetpack-blocks-editor',
542		'Jetpack_Block_Assets_Base_Url',
543		plugins_url( $blocks_dir . '/', JETPACK__PLUGIN_FILE )
544		);
545
546		wp_localize_script(
547		'jetpack-blocks-editor',
548		'Jetpack_Editor_Initial_State',
549		array(
550		'available_blocks' => self::get_availability(),
551		'jetpack' => array( 'is_active' => Jetpack::is_active() ),
552		)
553		);
554
555		Jetpack::setup_wp_i18n_locale_data();
556
557		wp_enqueue_style( 'jetpack-blocks-editor', $editor_style, array(), $version );
558		}
559
560		/**
561		* Some blocks do not depend on a specific module,
562		* and can consequently be loaded outside of the usual modules.
563		* We will look for such modules in the extensions/ directory.
564		*
565		* @since 7.1.0
566		*/
567		public static function load_independent_blocks() {
568		if ( self::should_load() && self::is_gutenberg_available() ) {
569		/**
570		* Look for files that match our list of available Jetpack Gutenberg extensions (blocks and plugins).
571		* If available, load them.
572		*/
573		foreach ( self::$extensions as $extension ) {
574		$extension_file_glob = glob( JETPACK__PLUGIN_DIR . 'extensions/*/' . $extension . '/' . $extension . '.php' );
575		if ( ! empty( $extension_file_glob ) ) {
576		include_once $extension_file_glob[0];
577		}
578		}
579		}
580		}
581		}
582

Automattic / jetpack

Push — update/mailchimp-ui-changes ( f4a7d6...e71283 )

Jetpack_Gutenberg::remove_extension_prefix() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like