WordPress Plugin Developer Handbook

https://github.com/wordpress/developer-plugins-handbook
Admin
The WordPress Plugin Developer Handbook guides users through creating plugins for the WordPress...
Tokens:144,663
Snippets:1,066
Trust Score:9
License:GPL-2.0
Update:1 week ago
Show doc for...
Tokens:
Raw
### Advanced blueprint.json example

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/wordpress-org/previews-and-blueprints/index.md

A more complex blueprint.json that logs in, installs and activates two plugins, installs a theme, sets site options, and runs PHP code to insert a post. Demonstrates steps like installPlugin, installTheme, setSiteOptions, and runPHP.

```json
{
    "landingPage": "/wp-admin/post.php?post=5&action=edit",
    "preferredVersions": {
        "php": "7.4",
        "wp": "5.9"
    },
    "phpExtensionBundles": [
        "kitchen-sink"
    ],
    "steps": [
        {
            "step": "login",
            "username": "admin",
            "password": "password"
        },
        {
            "step": "installPlugin",
            "pluginZipFile": {
                "resource": "wordpress.org\/plugins",
                "slug": "my-imaginary-plugin-dependency"
            },
            "options": {
                "activate": true
            }
        },
        {
            "step": "installPlugin",
            "pluginZipFile": {
                "resource": "wordpress.org\/plugins",
                "slug": "my-imaginary-plugin"
            },
            "options": {
                "activate": true
            }
        },
        {
            "step": "installTheme",
            "themeZipFile": {
                "resource": "wordpress.org\/themes",
                "slug": "my-imaginary-theme"
            }
        },
        {
            "step": "setSiteOptions",
            "options": {
                "some_required_option_1": "your_favorite_values",
                "some_required_option_2": "your_favorite_values"
            }
        },
        {
            "step": "runPHP",
            "code": "<?php require_once 'wordpress/wp-load.php'; wp_insert_post(array('post_title' => 'wp-load.php required for WP functionality', 'post_status' => 'publish')); ?>"
        }
    ]
}
```

--------------------------------

### Example: Registering the Sub-Menu with add_submenu_page()

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/administration-menus/sub-menus/index.md

The second step of the example: registers the 'WPOrg Options' sub-menu under the Tools menu (parent slug 'tools.php') and hooks it to the admin_menu action. This must be done during the admin_menu hook.

```php
function wporg_options_page() {
  add_submenu_page(
    'tools.php',
    'WPOrg Options',
    'WPOrg Options',
    'manage_options',
    'wporg',
    'wporg_options_page_html'
  );
}
add_action( 'admin_menu', 'wporg_options_page' );
```

--------------------------------

### Example: getting a setting value

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/settings/using-settings-api/index.md

Gets the value of the setting registered with register_setting().

```php
// Get the value of the setting we've registered with register_setting()
$setting = get_option('wporg_setting_name');
```

--------------------------------

### Examples of adding text domain to gettext calls

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/internationalization/how-to-internationalize-your-plugin/index.md

Examples showing how to add a text domain to __(), _e(), and _n() calls. The text domain 'my-theme' is added as the last argument to each function.

```php
__( 'Post' )
```

```php
__( 'Post', 'my-theme' )
```

```php
_e( 'Post' )
```

```php
_e( 'Post', 'my-theme' )
```

```php
_n( '%s post', '%s posts', $count )
```

```php
_n( '%s post', '%s posts', $count, 'my-theme' )
```

--------------------------------

### Example: wporg_options_page_html() Callback

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/administration-menus/sub-menus/index.md

The first step of the example: a callback function that outputs the HTML for the sub-menu page. It checks user capabilities, uses the Settings API to render fields, and includes a form with a submit button. The HTML is wrapped in a div with class 'wrap' as recommended.

```php
function wporg_options_page_html() {
  // check user capabilities
  if ( ! current_user_can( 'manage_options' ) ) {
    return;
  }
  ?>
  <div class="wrap">
    <h1><?php echo esc_html( get_admin_page_title() ); ?></h1>
    <form action="options.php" method="post">
      <?php
      // output security fields for the registered setting "wporg_options"
      settings_fields( 'wporg_options' );
      // output setting sections and their fields
      // (sections are registered for "wporg", each field is registered to a specific section)
      do_settings_sections( 'wporg' );
      // output save settings button
      submit_button( __( 'Save Settings', 'textdomain' ) );
      ?>
    </form>
  </div>
  <?php
}
```

--------------------------------

### Complete Example: WPOrg Top-Level Menu with Settings API

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/settings/custom-settings-page/index.md

This complete example adds a top-level menu named WPOrg, registers a custom option wporg_options, and performs CRUD logic using the Settings API and Options API. It includes callbacks for settings sections and fields, and handles error/update messages via settings_errors().

```php
/**
 * @internal never define functions inside callbacks.
 * these functions could be run multiple times; this would result in a fatal error.
 */

/**
 * custom option and settings
 */
function wporg_settings_init() {
  // Register a new setting for "wporg" page.
  register_setting( 'wporg', 'wporg_options' );

  // Register a new section in the "wporg" page.
  add_settings_section(
    'wporg_section_developers',
    __( 'The Matrix has you.', 'wporg' ), 'wporg_section_developers_callback',
    'wporg'
  );

  // Register a new field in the "wporg_section_developers" section, inside the "wporg" page.
  add_settings_field(
    'wporg_field_pill', // As of WP 4.6 this value is used only internally.
                        // Use $args' label_for to populate the id inside the callback.
    __( 'Pill', 'wporg' ),
    'wporg_field_pill_cb',
    'wporg',
    'wporg_section_developers',
    array(
      'label_for'         => 'wporg_field_pill',
      'class'             => 'wporg_row',
      'wporg_custom_data' => 'custom',
    )
  );
}

/**
 * Register our wporg_settings_init to the admin_init action hook.
 */
add_action( 'admin_init', 'wporg_settings_init' );

/**
 * Custom option and settings:
 *  - callback functions
 */

/**
 * Developers section callback function.
 *
 * @param array $args  The settings array, defining title, id, callback.
 */
function wporg_section_developers_callback( $args ) {
?>
  <p id="<?php echo esc_attr( $args['id'] ); ?>"><?php esc_html_e( 'Follow the white rabbit.', 'wporg' ); ?></p>
<?php
}

/**
 * Pill field callbakc function.
 *
 * WordPress has magic interaction with the following keys: label_for, class.
 * - the "label_for" key value is used for the "for" attribute of the <label>.
 * - the "class" key value is used for the "class" attribute of the <tr> containing the field.
 * Note: you can add custom key value pairs to be used inside your callbacks.
 *
 * @param array $args
 */
function wporg_field_pill_cb( $args ) {
  // Get the value of the setting we've registered with register_setting()
  $options = get_option( 'wporg_options' );
  ?>
  <select
    id="<?php echo esc_attr( $args['label_for'] ); ?>"
    data-custom="<?php echo esc_attr( $args['wporg_custom_data'] ); ?>"
    name="wporg_options[<?php echo esc_attr( $args['label_for'] ); ?>]">
    <option value="red" <?php echo isset( $options[ $args['label_for'] ] ) ? ( selected( $options[ $args['label_for'] ], 'red', false ) ) : ( '' ); ?>>
      <?php esc_html_e( 'red pill', 'wporg' ); ?>
    </option>
    <option value="blue" <?php echo isset( $options[ $args['label_for'] ] ) ? ( selected( $options[ $args['label_for'] ], 'blue', false ) ) : ( '' ); ?>>
      <?php esc_html_e( 'blue pill', 'wporg' ); ?>
    </option>
  </select>
  <p class="description">
    <?php esc_html_e( 'You take the blue pill and the story ends. You wake in your bed and you believe whatever you want to believe.', 'wporg' ); ?>
  </p>
  <p class="description">
    <?php esc_html_e( 'You take the red pill and you stay in Wonderland and I show you how deep the rabbit-hole goes.', 'wporg' ); ?>
  </p>
  <?php
}

/**
 * Add the top level menu page.
 */
function wporg_options_page() {
  add_menu_page(
    'WPOrg',
    'WPOrg Options',
    'manage_options',
    'wporg',
    'wporg_options_page_html'
  );
}

/**
 * Register our wporg_options_page to the admin_menu action hook.
 */
add_action( 'admin_menu', 'wporg_options_page' );

/**
 * Top level menu callback function
 */
function wporg_options_page_html() {
  // check user capabilities
  if ( ! current_user_can( 'manage_options' ) ) {
    return;
  }

  // add error/update messages

  // check if the user have submitted the settings
  // WordPress will add the "settings-updated" $_GET parameter to the url
  if ( isset( $_GET['settings-updated'] ) ) {
    // add settings saved message with the class of "updated"
    add_settings_error( 'wporg_messages', 'wporg_message', __( 'Settings Saved', 'wporg' ), 'updated' );
  }

  // show error/update messages
  settings_errors( 'wporg_messages' );
  ?>
  <div class="wrap">
    <h1><?php echo esc_html( get_admin_page_title() ); ?></h1>
    <form action="options.php" method="post">
      <?php
      // output security fields for the registered setting "wporg"
      settings_fields( 'wporg' );
      // output setting sections and their fields
      // (sections are registered for "wporg", each field is registered to a specific section)
      do_settings_sections( 'wporg' );
      // output save settings button
      submit_button( 'Save Settings' );
      ?>
    </form>
  </div>
  <?php
}
```

--------------------------------

### Complete [wporg] shortcode example with attribute parsing and output escaping

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/shortcodes/shortcodes-with-parameters/index.md

A full example of a shortcode that accepts a title attribute and displays a styled box. It normalizes attribute keys, merges with defaults using shortcode_atts(), escapes the title, and applies the_content filter to the enclosed content. The shortcode is registered on the init hook.

```php
/**
 * The [wporg] shortcode.
 *
 * Accepts a title and will display a box.
 *
 * @param array  $atts    Shortcode attributes. Default empty.
 * @param string $content Shortcode content. Default null.
 * @param string $tag     Shortcode tag (name). Default empty.
 * @return string Shortcode output.
 */
function wporg_shortcode( $atts = [], $content = null, $tag = '' ) {
  // normalize attribute keys, lowercase
  $atts = array_change_key_case( (array) $atts, CASE_LOWER );

  // override default attributes with user attributes
  $wporg_atts = shortcode_atts(
    array(
      'title' => 'WordPress.org',
    ), $atts, $tag
  );

  // start box
  $o = '<div class="wporg-box">';

  // title
  $o .= '<h2>' . esc_html( $wporg_atts['title'] ) . '</h2>';

  // enclosing tags
  if ( ! is_null( $content ) ) {
    // $content here holds everything in between the opening and the closing tags of your shortcode. eg.g [my-shortcode]content[/my-shortcode].
    // Depending on what your shortcode supports, you will parse and append the content to your output in different ways.
    // In this example, we just secure output by executing the_content filter hook on $content.
    $o .= apply_filters( 'the_content', $content );
  }

  // end box
  $o .= '</div>';

  // return output
  return $o;
}

/**
 * Central location to create all shortcodes.
 */
function wporg_shortcodes_init() {
  add_shortcode( 'wporg', 'wporg_shortcode' );
}

add_action( 'init', 'wporg_shortcodes_init' );
```

--------------------------------

### Activation Hook Example: Register Custom Post Type and Flush Rewrite Rules

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/plugin-basics/activation-deactivation-hooks/index.md

Common activation hook example that registers a custom post type and flushes rewrite rules to avoid 404 errors. It defines the post type registration function and the activation function.

```php
/**
 * Register the "book" custom post type
 */
function pluginprefix_setup_post_type() {
  register_post_type( 'book', ['public' => true ] ); 
} 
add_action( 'init', 'pluginprefix_setup_post_type' );

/**
 * Activate the plugin.
 */
function pluginprefix_activate() { 
  // Trigger our function that registers the custom post type plugin.
  pluginprefix_setup_post_type(); 
  // Clear the permalinks after the post type has been registered.
  flush_rewrite_rules(); 
}
register_activation_hook( __FILE__, 'pluginprefix_activate' );
```

--------------------------------

### Create a local directory for SVN repository

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/wordpress-org/how-to-use-subversion/index.md

Creates a local directory to house a copy of the SVN repository. Use this as the first step when starting a new plugin.

```bash
mkdir my-local-dir
```

--------------------------------

### Sample response array from wp_remote_head

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/http-api/index.md

Example of the response structure returned by wp_remote_head, showing the headers array with server information.

```php
Array(
  [headers] => Array(
    [server] => Array(
      [0] => GitHub.com
    )
  )
)
```

--------------------------------

### Complete example: registering settings, sections, and fields

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/settings/using-settings-api/index.md

Shows how to register a setting, add a section and a field, and hook the initialization to admin_init. Includes callback functions for section and field output.

```php
function wporg_settings_init() {
  // register a new setting for "reading" page
  register_setting('reading', 'wporg_setting_name');

  // register a new section in the "reading" page
  add_settings_section(
    'wporg_settings_section',
    'WPOrg Settings Section', 'wporg_settings_section_callback',
    'reading'
  );

  // register a new field in the "wporg_settings_section" section, inside the "reading" page
  add_settings_field(
    'wporg_settings_field',
    'WPOrg Setting', 'wporg_settings_field_callback',
    'reading',
    'wporg_settings_section'
  );
}

/**
 * register wporg_settings_init to the admin_init action hook
 */
add_action('admin_init', 'wporg_settings_init');

/**
 * callback functions
 */

// section content cb
function wporg_settings_section_callback() {
  echo '<p>WPOrg Section Introduction.</p>';
}

// field content cb
function wporg_settings_field_callback() {
  // get the value of the setting we've registered with register_setting()
  $setting = get_option('wporg_setting_name');
  // output the field
  ?>
  <input type="text" name="wporg_setting_name" value="<?php echo isset( $setting ) ? esc_attr( $setting ) : ''; ?>">
  <?php
}
```

--------------------------------

### Create plugin directory and file on Unix command line

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/plugin-basics/index.md

Use these commands to create the plugin directory and a new PHP file inside it. The example uses `vim` as the text editor; substitute any editor you prefer.

```bash
$ cd wp-content/
$ cd plugins/
$ mkdir plugin-name/
$ cd plugin-name/
$ vim plugin-name.php
```

--------------------------------

### Remove the Tools menu example

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/administration-menus/top-level-menus/index.md

Example of removing the 'Tools' menu by hooking into admin_menu with a priority of 99. Ensure the menu is registered before removal and use a higher priority number for add_action().

```php
add_action( 'admin_menu', 'wporg_remove_options_page', 99 );
function wporg_remove_options_page() {
  remove_menu_page( 'tools.php' );
}
```

--------------------------------

### Register GET and POST endpoints with register_rest_route

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/rest-api/routes-endpoints/index.md

Registers two endpoints on the /products route: one for GET (READABLE) and one for POST (CREATABLE). Uses WP_REST_Server constants and rest_ensure_response() to return data. Hooked to rest_api_init.

```php
/**
 * This is our callback function to return our products.
 *
 * @param WP_REST_Request $request This function accepts a rest request to process data.
 */
function prefix_get_products( $request ) {
    // In practice this function would fetch the desired data. Here we are just making stuff up.
    $products = array(
        '1' => 'I am product 1',
        '2' => 'I am product 2',
        '3' => 'I am product 3',
    );

    return rest_ensure_response( $products );
}

/**
 * This is our callback function to return a single product.
 *
 * @param WP_REST_Request $request This function accepts a rest request to process data.
 */
function prefix_create_product( $request ) {
    // In practice this function would create a product. Here we are just making stuff up.
   return rest_ensure_response( 'Product has been created' );
}

/**
 * This function is where we register our routes for our example endpoint.
 */
function prefix_register_product_routes() {
    // Here we are registering our route for a collection of products and creation of products.
    register_rest_route( 'my-shop/v1', '/products', array(
        array(
            // By using this constant we ensure that when the WP_REST_Server changes, our readable endpoints will work as intended.
            'methods'  => WP_REST_Server::READABLE,
            // Here we register our callback. The callback is fired when this endpoint is matched by the WP_REST_Server class.
            'callback' => 'prefix_get_products',
        ),
        array(
            // By using this constant we ensure that when the WP_REST_Server changes, our create endpoints will work as intended.
            'methods'  => WP_REST_Server::CREATABLE,
            // Here we register our callback. The callback is fired when this endpoint is matched by the WP_REST_Server class.
            'callback' => 'prefix_create_product',
        ),
    ) );
}

add_action( 'rest_api_init', 'prefix_register_product_routes' );
```

--------------------------------

### Sample HTML form for jQuery examples

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/javascript/jquery/index.md

HTML form with radio buttons used as the basis for all jQuery examples on this page. It is assumed to appear on the plugin's admin settings screen, defined by the file myplugin_settings.php.

```html
<form id="radioform">
  <table>
    <tbody>
    <tr>
      <td><input class="pref" checked="checked" name="book" type="radio" value="Sycamore Row" />Sycamore Row</td>
      <td>John Grisham</td>
    </tr>
    <tr>
      <td><input class="pref" name="book" type="radio" value="Dark Witch" />Dark Witch</td>
      <td>Nora Roberts</td>
    </tr>
    </tbody>
  </table>
</form>
```

--------------------------------

### Sample folder structure for a plugin

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/plugin-basics/best-practices/index.md

A recommended folder structure for organizing plugin files, including subfolders for languages, includes, admin, and public assets.

```text
/plugin-name
  plugin-name.php
  uninstall.php
  /languages
  /includes
  /admin
    /js
    /css
    /images
  /public
    /js
    /css
    /images
```

--------------------------------

### Get URL to a plugin file with plugins_url()

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/plugin-basics/determining-plugin-and-content-directories/index.md

Use plugins_url() to get the full URL to a file within your plugin, such as a JavaScript or CSS file. Pass the file name and __FILE__ as arguments. This returns a URL like example.com/wp-content/plugins/myplugin/myscript.js.

```php
plugins_url( 'myscript.js', __FILE__ );
```

--------------------------------

### Simple blueprint.json example

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/wordpress-org/previews-and-blueprints/index.md

A minimal blueprint.json that sets the landing page to the admin edit screen, specifies PHP 7.4 and WordPress 5.9, includes the kitchen-sink PHP extension bundle, and logs the user in as admin.

```json
{
    "landingPage": "\/wp-admin\/edit.php",
    "preferredVersions": {
        "php": "7.4",
        "wp": "5.9"
    },
    "phpExtensionBundles": [
        "kitchen-sink"
    ],
    "steps": [
        {
            "step": "login",
            "username": "admin",
            "password": "password"
        }
    ]
}
```

--------------------------------

### Deactivation Hook Example: Unregister Custom Post Type and Flush Rewrite Rules

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/plugin-basics/activation-deactivation-hooks/index.md

Deactivation hook example that reverses the activation process by unregistering the custom post type and flushing rewrite rules to remove rules from the database.

```php
/**
 * Deactivation hook.
 */
function pluginprefix_deactivate() {
  // Unregister the post type, so the rules are no longer in memory.
  unregister_post_type( 'book' );
  // Clear the permalinks to remove our post type's rules from the database.
  flush_rewrite_rules();
}
register_deactivation_hook( __FILE__, 'pluginprefix_deactivate' );
```

--------------------------------

### Add action with add_action()

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/hooks/actions/index.md

Creates a callback function and hooks it to the 'init' action using add_action(). The callback function should be prefixed and placed in functions.php or a callable location. add_action() requires at least the hook name and the callback function name.

```php
function wporg_callback() {
  // do something
}
add_action( 'init', 'wporg_callback' );
```

--------------------------------

### Command with path to add-textdomain.php

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/internationalization/how-to-internationalize-your-plugin/index.md

Command to run the add-textdomain.php script from a different folder by specifying the full path.

```bash
php /path/to/add-textdomain.php my-plugin my-plugin.php > new-my-plugin.php
```

--------------------------------

### Load text domain with load_plugin_textdomain

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/internationalization/how-to-internationalize-your-plugin/index.md

Adds an action on 'init' to load the plugin's text domain from the /languages/ directory. Use this in the main plugin file to enable translation loading.

```php
add_action( 'init', 'wpdocs_load_textdomain' );

function wpdocs_load_textdomain() {
  load_plugin_textdomain( 'wpdocs_textdomain', false, dirname( plugin_basename( __FILE__ ) ) . '/languages' );
}
```

--------------------------------

### wp_remote_get() example

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/http-api/index.md

Retrieves data from the GitHub API for a user. The response contains headers, body, and metadata.

```php
$response = wp_remote_get( 'https://api.github.com/users/blobaugh' );
```

--------------------------------

### Incorrect variable interpolation in string

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/internationalization/how-to-internationalize-your-plugin/index.md

Shows an incorrect example where a variable is directly embedded in a string, which should not be translated.

```php
echo 'Your city is $city.'
```

--------------------------------

### Prefixing Example for Easy Custom Post Types

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/plugin-basics/best-practices/index.md

Shows how to prefix functions, constants, classes, namespaces, and options with a unique identifier like 'ecpt' to avoid conflicts with other plugins. The prefix should be at least 4 letters long and unique to your plugin.

```php
function ecpt_save_post()
define( 'ECPT_LICENSE', true );
class ECPT_Admin{}
namespace EasyCustomPostTypes;
update_option( 'ecpt_settings', $settings );
```

--------------------------------

### Example REST API controller class with register_routes and permission callbacks

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/rest-api/controller-classes/index.md

Example controller class for the WordPress REST API. It uses WP_REST_Request input and returns WP_REST_Response outputtons. Includes custom routes, permission checks, and a response preparation method. Note: the get_item method contains a call to prepare_item_for_response(...) without '$this->', which may be a copypaste typo.

```php
class My_REST_Posts_Controller {

	// Here initialize our namespace and resource name.
	public function __construct() {
		$this->namespace     = '/my-namespace/v1';
		$this->resource_name = 'posts';
	}

	// Register our routes.
	public function register_routes() {
		register_rest_route( $this->namespace, '/' . $this->resource_name, array(
			// Here we register the readable endpoint for collections.
			array(
				'methods'   => 'GET',
				'callback'  => array( $this, 'get_items' ),
				'permission_callback' => array( $this, 'get_items_permissions_check' ),
			),
			// Register our schema callback.
			'schema' => array( $this, 'get_item_schema' ),
		) );
		register_rest_route( $this->namespace, '/' . $this->resource_name . '/(?P<id>[\d]+)', array(
			// Notice how we are registering multiple endpoints the 'schema' equates to an OPTIONS request.
			array(
				'methods'   => 'GET',
				'callback'  => array( $this, 'get_item' ),
				'permission_callback' => array( $this, 'get_item_permissions_check' ),
			),
			// Register our schema callback.
			'schema' => array( $this, 'get_item_schema' ),
		) );
	}

	/**
	 * Check permissions for the posts.
	 *
	 * @param WP_REST_Request $request Current request.
	 */
	public function get_items_permissions_check( $request ) {
		if ( ! current_user_can( 'read' ) ) {
			return new WP_Error( 'rest_forbidden', esc_html__( 'You cannot view the post resource.' ), array( 'status' => $this->authorization_status_code() ) );
		}
		return true;
	}

	/**
	 * Grabs the five most recent posts and outputs them as a rest response.
	 *
	 * @param WP_REST_Request $request Current request.
	 */
	public function get_items( $request ) {
		$args = array(
			'post_per_page' => 5,
		);
		$posts = get_posts( $args );

		$data = array();

		if ( empty( $posts ) ) {
			return rest_ensure_response( $data );
		}

		foreach ( $posts as $post ) {
			$response = $this->prepare_item_for_response( $post, $request );
			$data[] = $this->prepare_response_for_collection( $response );
		}

		// Return all of our comment response data.
		return rest_ensure_response( $data );
	}

	/**
	 * Check permissions for the posts.
	 *
	 * @param WP_REST_Request $request Current request.
	 */
	public function get_item_permissions_check( $request ) {
		if ( ! current_user_can( 'read' ) ) {
			return new WP_Error( 'rest_forbidden', esc_html__( 'You cannot view the post resource.' ), array( 'status' => $this->authorization_status_code() ) );
		}
		return true;
	}

	/**
	 * Grabs the five most recent posts and outputs them as a rest response.
	 *
	 * @param WP_REST_Request $request Current request.
	 */
	public function get_item( $request ) {
		$id = (int) $request['id'];
		$post = get_post( $id );

		if ( empty( $post ) ) {
			return rest_ensure_response( array() );
		}

		$response = prepare_item_for_response( $post );

		// Return all of our post response data.
		return $response;
	}

	/**
	 * Matches the post data to the schema we want.
	 *
	 * @param WP_Post $post The comment object whose response is being prepared.
	 */
	public function prepare_item_for_response( $post, $request ) {
		$post_data = array();

		$schema = $this->get_item_schema( $request );

		// We are also renaming the fields to more understandable names.
		if ( isset( $schema['properties']['id'] ) ) {
			$post_data['id'] = (int) $post->ID;
		}

		if ( isset( $schema['properties']['content'] ) ) {
			$post_data['content'] = apply_filters( 'the_content', $post->post_content, $post );
		}

		return rest_ensure_response( $post_data );
	}
```

--------------------------------

### printf with __() and placeholder for search results

Source: https://github.com/wordpress/developer-plugins-handbook/blob/main/internationalization/how-to-internationalize-your-plugin/index.md

Example of using printf with __() and a placeholder for search results. The placeholder %s is used to insert the search query, and the text domain 'my-plugin' is passed as the second argument to __().

```php
printf(
  __( 'Search results for: %s', 'my-plugin' ),
  get_search_query()
);
```
Tokens:
Raw