WordPress.org
Get WordPress

Make WordPress Core

Changeset 56765


Ignore:
Timestamp:
10/03/2023 03:16:55 PM (18 months ago)
Author:
spacedmonkey
Message:

Editor: Improve performance of _register_theme_block_patterns function.

The _register_theme_block_patterns function imposed a significant resource overhead. This issue primarily stems from themes, such as TT4, that register a substantial number of block patterns. These patterns necessitate numerous file operations, including file lookups, file reading into memory, and related processes. To provide an overview, the _register_theme_block_patterns function performed the following file operations:

  • is_dir
  • is_readable
  • file_exists
  • glob
  • file_get_contents (utilized via get_file_data)

To address these issues, caching using a transient has been added to a new function call _wp_get_block_patterns. If theme development mode is disabled and theme exists, the block patterns are saved in a transient cache. This cache is used all requests after that, saving file lookups and reading files into memory. Cache invalidation is done, when themes are switched, deleted or updated. Meaning that block patterns are not stored in the cache incorrectly.

Props flixos90, joemcgill, peterwilsoncc, costdev, swissspidy, aristath, westonruter, spacedmonkey.
Fixes #59490

Location:
trunk
Files:
5 added
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wp-admin/includes/theme.php

    r56639 r56765  
    8282    do_action( 'delete_theme', $stylesheet );
    8383
     84    $theme = wp_get_theme( $stylesheet );
     85
    8486    $themes_dir = trailingslashit( $themes_dir );
    8587    $theme_dir  = trailingslashit( $themes_dir . $stylesheet );
    … …  
    125127        WP_Theme::network_disable_theme( $stylesheet );
    126128    }
     129
     130    // Clear theme caches.
     131    $theme->cache_delete();
    127132
    128133    // Force refresh of theme update information.

  • trunk/src/wp-includes/block-patterns.php

    r56738 r56765  
    320320/**
    321321 * Register any patterns that the active theme may provide under its
    322  * `./patterns/` directory. Each pattern is defined as a PHP file and defines
    323  * its metadata using plugin-style headers. The minimum required definition is:
    324  *
    325  *     /**
    326  *      * Title: My Pattern
    327  *      * Slug: my-theme/my-pattern
    328  *      *
    329  *
    330  * The output of the PHP source corresponds to the content of the pattern, e.g.:
    331  *
    332  *     <main><p><?php echo "Hello"; ?></p></main>
    333  *
    334  * If applicable, this will collect from both parent and child theme.
    335  *
    336  * Other settable fields include:
    337  *
    338  *   - Description
    339  *   - Viewport Width
    340  *   - Inserter         (yes/no)
    341  *   - Categories       (comma-separated values)
    342  *   - Keywords         (comma-separated values)
    343  *   - Block Types      (comma-separated values)
    344  *   - Post Types       (comma-separated values)
    345  *   - Template Types   (comma-separated values)
     322 * `./patterns/` directory.
    346323 *
    347324 * @since 6.0.0
    348325 * @since 6.1.0 The `postTypes` property was added.
    349326 * @since 6.2.0 The `templateTypes` property was added.
     327 * @since 6.4.0 Uses the `_wp_get_block_patterns` function.
    350328 * @access private
    351329 */
    352330function _register_theme_block_patterns() {
     331    /*
     332     * Register patterns for the active theme. If the theme is a child theme,
     333     * let it override any patterns from the parent theme that shares the same slug.
     334     */
     335    $themes   = array();
     336    $theme    = wp_get_theme();
     337    $themes[] = $theme;
     338    if ( $theme->parent() ) {
     339        $themes[] = $theme->parent();
     340    }
     341    $registry = WP_Block_Patterns_Registry::get_instance();
     342
     343    foreach ( $themes as $theme ) {
     344        $pattern_data = _wp_get_block_patterns( $theme );
     345        $dirpath      = $theme->get_stylesheet_directory() . '/patterns/';
     346        $text_domain  = $theme->get( 'TextDomain' );
     347
     348        foreach ( $pattern_data['patterns'] as $file => $pattern_data ) {
     349            if ( $registry->is_registered( $pattern_data['slug'] ) ) {
     350                continue;
     351            }
     352
     353            // The actual pattern content is the output of the file.
     354            ob_start();
     355            include $dirpath . $file;
     356            $pattern_data['content'] = ob_get_clean();
     357            if ( ! $pattern_data['content'] ) {
     358                continue;
     359            }
     360
     361            // Translate the pattern metadata.
     362            // phpcs:ignore WordPress.WP.I18n.NonSingularStringLiteralText,WordPress.WP.I18n.NonSingularStringLiteralDomain,WordPress.WP.I18n.LowLevelTranslationFunction
     363            $pattern_data['title'] = translate_with_gettext_context( $pattern_data['title'], 'Pattern title', $text_domain );
     364            if ( ! empty( $pattern_data['description'] ) ) {
     365                // phpcs:ignore WordPress.WP.I18n.NonSingularStringLiteralText,WordPress.WP.I18n.NonSingularStringLiteralDomain,WordPress.WP.I18n.LowLevelTranslationFunction
     366                $pattern_data['description'] = translate_with_gettext_context( $pattern_data['description'], 'Pattern description', $text_domain );
     367            }
     368
     369            register_block_pattern( $pattern_data['slug'], $pattern_data );
     370        }
     371    }
     372}
     373add_action( 'init', '_register_theme_block_patterns' );
     374
     375/**
     376 * Gets block pattern data for a specified theme.
     377 * Each pattern is defined as a PHP file and defines
     378 *  its metadata using plugin-style headers. The minimum required definition is:
     379 *
     380 *      /**
     381 *       * Title: My Pattern
     382 *       * Slug: my-theme/my-pattern
     383 *       *
     384 *
     385 *  The output of the PHP source corresponds to the content of the pattern, e.g.:
     386 *
     387 *      <main><p><?php echo "Hello"; ?></p></main>
     388 *
     389 *  If applicable, this will collect from both parent and child theme.
     390 *
     391 *  Other settable fields include:
     392 *
     393 *    - Description
     394 *    - Viewport Width
     395 *    - Inserter         (yes/no)
     396 *    - Categories       (comma-separated values)
     397 *    - Keywords         (comma-separated values)
     398 *    - Block Types      (comma-separated values)
     399 *    - Post Types       (comma-separated values)
     400 *    - Template Types   (comma-separated values)
     401 *
     402 * @since 6.4.0
     403 * @access private
     404 *
     405 * @param WP_Theme $theme Theme object.
     406 * @return array Block pattern data.
     407 */
     408
     409function _wp_get_block_patterns( WP_Theme $theme ) {
     410    if ( ! $theme->exists() ) {
     411        return array(
     412            'version'  => false,
     413            'patterns' => array(),
     414        );
     415    }
     416
     417    $transient_name = 'wp_theme_patterns_' . $theme->get_stylesheet();
     418    $version        = $theme->get( 'Version' );
     419    $can_use_cached = ! wp_is_development_mode( 'theme' );
     420
     421    if ( $can_use_cached ) {
     422        $pattern_data = get_transient( $transient_name );
     423        if ( is_array( $pattern_data ) && $pattern_data['version'] === $version ) {
     424            return $pattern_data;
     425        }
     426    }
     427
     428    $pattern_data = array(
     429        'version'  => $version,
     430        'patterns' => array(),
     431    );
     432    $dirpath      = $theme->get_stylesheet_directory() . '/patterns/';
     433
     434    if ( ! file_exists( $dirpath ) ) {
     435        if ( $can_use_cached ) {
     436            set_transient( $transient_name, $pattern_data );
     437        }
     438        return $pattern_data;
     439    }
     440    $files = glob( $dirpath . '*.php' );
     441    if ( ! $files ) {
     442        if ( $can_use_cached ) {
     443            set_transient( $transient_name, $pattern_data );
     444        }
     445        return $pattern_data;
     446    }
     447
    353448    $default_headers = array(
    354449        'title'         => 'Title',
    … …  
    364459    );
    365460
    366     /*
    367      * Register patterns for the active theme. If the theme is a child theme,
    368      * let it override any patterns from the parent theme that shares the same slug.
    369      */
    370     $themes     = array();
    371     $stylesheet = get_stylesheet();
    372     $template   = get_template();
    373     if ( $stylesheet !== $template ) {
    374         $themes[] = wp_get_theme( $stylesheet );
    375     }
    376     $themes[] = wp_get_theme( $template );
    377 
    378     foreach ( $themes as $theme ) {
    379         $dirpath = $theme->get_stylesheet_directory() . '/patterns/';
    380         if ( ! is_dir( $dirpath ) || ! is_readable( $dirpath ) ) {
     461    $properties_to_parse = array(
     462        'categories',
     463        'keywords',
     464        'blockTypes',
     465        'postTypes',
     466        'templateTypes',
     467    );
     468
     469    foreach ( $files as $file ) {
     470        $pattern = get_file_data( $file, $default_headers );
     471
     472        if ( empty( $pattern['slug'] ) ) {
     473            _doing_it_wrong(
     474                __FUNCTION__,
     475                sprintf(
     476                    /* translators: %s: file name. */
     477                    __( 'Could not register file "%s" as a block pattern ("Slug" field missing)' ),
     478                    $file
     479                ),
     480                '6.0.0'
     481            );
    381482            continue;
    382483        }
    383         if ( file_exists( $dirpath ) ) {
    384             $files = glob( $dirpath . '*.php' );
    385             if ( $files ) {
    386                 foreach ( $files as $file ) {
    387                     $pattern_data = get_file_data( $file, $default_headers );
    388 
    389                     if ( empty( $pattern_data['slug'] ) ) {
    390                         _doing_it_wrong(
    391                             '_register_theme_block_patterns',
    392                             sprintf(
    393                                 /* translators: %s: file name. */
    394                                 __( 'Could not register file "%s" as a block pattern ("Slug" field missing)' ),
    395                                 $file
    396                             ),
    397                             '6.0.0'
    398                         );
    399                         continue;
    400                     }
    401 
    402                     if ( ! preg_match( '/^[A-z0-9\/_-]+$/', $pattern_data['slug'] ) ) {
    403                         _doing_it_wrong(
    404                             '_register_theme_block_patterns',
    405                             sprintf(
    406                                 /* translators: %1s: file name; %2s: slug value found. */
    407                                 __( 'Could not register file "%1$s" as a block pattern (invalid slug "%2$s")' ),
    408                                 $file,
    409                                 $pattern_data['slug']
    410                             ),
    411                             '6.0.0'
    412                         );
    413                     }
    414 
    415                     if ( WP_Block_Patterns_Registry::get_instance()->is_registered( $pattern_data['slug'] ) ) {
    416                         continue;
    417                     }
    418 
    419                     // Title is a required property.
    420                     if ( ! $pattern_data['title'] ) {
    421                         _doing_it_wrong(
    422                             '_register_theme_block_patterns',
    423                             sprintf(
    424                                 /* translators: %1s: file name; %2s: slug value found. */
    425                                 __( 'Could not register file "%s" as a block pattern ("Title" field missing)' ),
    426                                 $file
    427                             ),
    428                             '6.0.0'
    429                         );
    430                         continue;
    431                     }
    432 
    433                     // For properties of type array, parse data as comma-separated.
    434                     foreach ( array( 'categories', 'keywords', 'blockTypes', 'postTypes', 'templateTypes' ) as $property ) {
    435                         if ( ! empty( $pattern_data[ $property ] ) ) {
    436                             $pattern_data[ $property ] = array_filter(
    437                                 preg_split(
    438                                     '/[\s,]+/',
    439                                     (string) $pattern_data[ $property ]
    440                                 )
    441                             );
    442                         } else {
    443                             unset( $pattern_data[ $property ] );
    444                         }
    445                     }
    446 
    447                     // Parse properties of type int.
    448                     foreach ( array( 'viewportWidth' ) as $property ) {
    449                         if ( ! empty( $pattern_data[ $property ] ) ) {
    450                             $pattern_data[ $property ] = (int) $pattern_data[ $property ];
    451                         } else {
    452                             unset( $pattern_data[ $property ] );
    453                         }
    454                     }
    455 
    456                     // Parse properties of type bool.
    457                     foreach ( array( 'inserter' ) as $property ) {
    458                         if ( ! empty( $pattern_data[ $property ] ) ) {
    459                             $pattern_data[ $property ] = in_array(
    460                                 strtolower( $pattern_data[ $property ] ),
    461                                 array( 'yes', 'true' ),
    462                                 true
    463                             );
    464                         } else {
    465                             unset( $pattern_data[ $property ] );
    466                         }
    467                     }
    468 
    469                     // Translate the pattern metadata.
    470                     $text_domain = $theme->get( 'TextDomain' );
    471                     // phpcs:ignore WordPress.WP.I18n.NonSingularStringLiteralText,WordPress.WP.I18n.NonSingularStringLiteralDomain,WordPress.WP.I18n.LowLevelTranslationFunction
    472                     $pattern_data['title'] = translate_with_gettext_context( $pattern_data['title'], 'Pattern title', $text_domain );
    473                     if ( ! empty( $pattern_data['description'] ) ) {
    474                         // phpcs:ignore WordPress.WP.I18n.NonSingularStringLiteralText,WordPress.WP.I18n.NonSingularStringLiteralDomain,WordPress.WP.I18n.LowLevelTranslationFunction
    475                         $pattern_data['description'] = translate_with_gettext_context( $pattern_data['description'], 'Pattern description', $text_domain );
    476                     }
    477 
    478                     // The actual pattern content is the output of the file.
    479                     ob_start();
    480                     include $file;
    481                     $pattern_data['content'] = ob_get_clean();
    482                     if ( ! $pattern_data['content'] ) {
    483                         continue;
    484                     }
    485 
    486                     register_block_pattern( $pattern_data['slug'], $pattern_data );
    487                 }
     484
     485        if ( ! preg_match( '/^[A-z0-9\/_-]+$/', $pattern['slug'] ) ) {
     486            _doing_it_wrong(
     487                __FUNCTION__,
     488                sprintf(
     489                    /* translators: %1s: file name; %2s: slug value found. */
     490                    __( 'Could not register file "%1$s" as a block pattern (invalid slug "%2$s")' ),
     491                    $file,
     492                    $pattern['slug']
     493                ),
     494                '6.0.0'
     495            );
     496        }
     497
     498        // Title is a required property.
     499        if ( ! $pattern['title'] ) {
     500            _doing_it_wrong(
     501                __FUNCTION__,
     502                sprintf(
     503                    /* translators: %1s: file name. */
     504                    __( 'Could not register file "%s" as a block pattern ("Title" field missing)' ),
     505                    $file
     506                ),
     507                '6.0.0'
     508            );
     509            continue;
     510        }
     511
     512        // For properties of type array, parse data as comma-separated.
     513        foreach ( $properties_to_parse as $property ) {
     514            if ( ! empty( $pattern[ $property ] ) ) {
     515                $pattern[ $property ] = array_filter( wp_parse_list( (string) $pattern[ $property ] ) );
     516            } else {
     517                unset( $pattern[ $property ] );
    488518            }
    489519        }
    490     }
    491 }
    492 add_action( 'init', '_register_theme_block_patterns' );
     520
     521        // Parse properties of type int.
     522        $property = 'viewportWidth';
     523        if ( ! empty( $pattern[ $property ] ) ) {
     524            $pattern[ $property ] = (int) $pattern[ $property ];
     525        } else {
     526            unset( $pattern[ $property ] );
     527        }
     528
     529        // Parse properties of type bool.
     530        $property = 'inserter';
     531        if ( ! empty( $pattern[ $property ] ) ) {
     532            $pattern[ $property ] = in_array(
     533                strtolower( $pattern[ $property ] ),
     534                array( 'yes', 'true' ),
     535                true
     536            );
     537        } else {
     538            unset( $pattern[ $property ] );
     539        }
     540
     541        $key = str_replace( $dirpath, '', $file );
     542
     543        $pattern_data['patterns'][ $key ] = $pattern;
     544    }
     545
     546    if ( $can_use_cached ) {
     547        set_transient( $transient_name, $pattern_data );
     548    }
     549
     550    return $pattern_data;
     551}

  • trunk/src/wp-includes/class-wp-theme.php

    r56727 r56765  
    822822        $this->headers                = array();
    823823        $this->__construct( $this->stylesheet, $this->theme_root );
     824        $this->delete_pattern_cache();
     825    }
     826
     827    /**
     828     * Clear block pattern cache.
     829     *
     830     * @since 6.4.0
     831     */
     832    public function delete_pattern_cache() {
     833        delete_transient( 'wp_theme_patterns_' . $this->stylesheet );
    824834    }
    825835

  • trunk/src/wp-includes/theme.php

    r56748 r56765  
    873873    $wp_stylesheet_path = null;
    874874    $wp_template_path   = null;
     875
     876    // Clear pattern caches.
     877    $new_theme->delete_pattern_cache();
     878    $old_theme->delete_pattern_cache();
    875879
    876880    /**

  • trunk/tests/phpunit/tests/theme/themeDir.php

    r56759 r56765  
    186186            'Block Theme [1.0.0] in subdirectory',
    187187            'Block Theme Deprecated Path',
     188            'Block Theme Patterns',
    188189            'Block Theme Post Content Default',
    189190            'Block Theme with defined Typography Fonts',
Note: See TracChangeset for help on using the changeset viewer.