wp-includes/class-wp-theme.php

   1 <?php
   2 /**
   3  * WP_Theme Class
   4  *
   5  * @package WordPress
   6  * @subpackage Theme
   7  */
   8
   9 final class WP_Theme implements ArrayAccess {
  10
  11         /**
  12          * Headers for style.css files.
  13          *
  14          * @static
  15          * @access private
  16          * @var array
  17          */
  18         private static $file_headers = array(
  19                 'Name'        => 'Theme Name',
  20                 'ThemeURI'    => 'Theme URI',
  21                 'Description' => 'Description',
  22                 'Author'      => 'Author',
  23                 'AuthorURI'   => 'Author URI',
  24                 'Version'     => 'Version',
  25                 'Template'    => 'Template',
  26                 'Status'      => 'Status',
  27                 'Tags'        => 'Tags',
  28                 'TextDomain'  => 'Text Domain',
  29                 'DomainPath'  => 'Domain Path',
  30         );
  31
  32         /**
  33          * Default themes.
  34          *
  35          * @static
  36          * @access private
  37          * @var array
  38          */
  39         private static $default_themes = array(
  40                 'classic'        => 'WordPress Classic',
  41                 'default'        => 'WordPress Default',
  42                 'twentyten'      => 'Twenty Ten',
  43                 'twentyeleven'   => 'Twenty Eleven',
  44                 'twentytwelve'   => 'Twenty Twelve',
  45                 'twentythirteen' => 'Twenty Thirteen',
  46                 'twentyfourteen' => 'Twenty Fourteen',
  47                 'twentyfifteen'  => 'Twenty Fifteen',
  48         );
  49
  50         /**
  51          * Renamed theme tags.
  52          */
  53         private static $tag_map = array(
  54                 'fixed-width'    => 'fixed-layout',
  55                 'flexible-width' => 'fluid-layout',
  56         );
  57
  58         /**
  59          * Absolute path to the theme root, usually wp-content/themes
  60          *
  61          * @access private
  62          * @var string
  63          */
  64         private $theme_root;
  65
  66         /**
  67          * Header data from the theme's style.css file.
  68          *
  69          * @access private
  70          * @var array
  71          */
  72         private $headers = array();
  73
  74         /**
  75          * Header data from the theme's style.css file after being sanitized.
  76          *
  77          * @access private
  78          * @var array
  79          */
  80         private $headers_sanitized;
  81
  82         /**
  83          * Header name from the theme's style.css after being translated.
  84          *
  85          * Cached due to sorting functions running over the translated name.
  86          */
  87         private $name_translated;
  88
  89         /**
  90          * Errors encountered when initializing the theme.
  91          *
  92          * @access private
  93          * @var WP_Error
  94          */
  95         private $errors;
  96
  97         /**
  98          * The directory name of the theme's files, inside the theme root.
  99          *
 100          * In the case of a child theme, this is directory name of the child theme.
 101          * Otherwise, 'stylesheet' is the same as 'template'.
 102          *
 103          * @access private
 104          * @var string
 105          */
 106         private $stylesheet;
 107
 108         /**
 109          * The directory name of the theme's files, inside the theme root.
 110          *
 111          * In the case of a child theme, this is the directory name of the parent theme.
 112          * Otherwise, 'template' is the same as 'stylesheet'.
 113          *
 114          * @access private
 115          * @var string
 116          */
 117         private $template;
 118
 119         /**
 120          * A reference to the parent theme, in the case of a child theme.
 121          *
 122          * @access private
 123          * @var WP_Theme
 124          */
 125         private $parent;
 126
 127         /**
 128          * URL to the theme root, usually an absolute URL to wp-content/themes
 129          *
 130          * @access private
 131          * var string
 132          */
 133         private $theme_root_uri;
 134
 135         /**
 136          * Flag for whether the theme's textdomain is loaded.
 137          *
 138          * @access private
 139          * @var bool
 140          */
 141         private $textdomain_loaded;
 142
 143         /**
 144          * Stores an md5 hash of the theme root, to function as the cache key.
 145          *
 146          * @access private
 147          * @var string
 148          */
 149         private $cache_hash;
 150
 151         /**
 152          * Flag for whether the themes cache bucket should be persistently cached.
 153          *
 154          * Default is false. Can be set with the wp_cache_themes_persistently filter.
 155          *
 156          * @access private
 157          * @var bool
 158          */
 159         private static $persistently_cache;
 160
 161         /**
 162          * Expiration time for the themes cache bucket.
 163          *
 164          * By default the bucket is not cached, so this value is useless.
 165          *
 166          * @access private
 167          * @var bool
 168          */
 169         private static $cache_expiration = 1800;
 170
 171         /**
 172          * Constructor for WP_Theme.
 173          *
 174          * @param string $theme_dir Directory of the theme within the theme_root.
 175          * @param string $theme_root Theme root.
 176          * @param WP_Error|null $_child If this theme is a parent theme, the child may be passed for validation purposes.
 177          */
 178         public function __construct( $theme_dir, $theme_root, $_child = null ) {
 179                 global $wp_theme_directories;
 180
 181                 // Initialize caching on first run.
 182                 if ( ! isset( self::$persistently_cache ) ) {
 183                         /** This action is documented in wp-includes/theme.php */
 184                         self::$persistently_cache = apply_filters( 'wp_cache_themes_persistently', false, 'WP_Theme' );
 185                         if ( self::$persistently_cache ) {
 186                                 wp_cache_add_global_groups( 'themes' );
 187                                 if ( is_int( self::$persistently_cache ) )
 188                                         self::$cache_expiration = self::$persistently_cache;
 189                         } else {
 190                                 wp_cache_add_non_persistent_groups( 'themes' );
 191                         }
 192                 }
 193
 194                 $this->theme_root = $theme_root;
 195                 $this->stylesheet = $theme_dir;
 196
 197                 // Correct a situation where the theme is 'some-directory/some-theme' but 'some-directory' was passed in as part of the theme root instead.
 198                 if ( ! in_array( $theme_root, (array) $wp_theme_directories ) && in_array( dirname( $theme_root ), (array) $wp_theme_directories ) ) {
 199                         $this->stylesheet = basename( $this->theme_root ) . '/' . $this->stylesheet;
 200                         $this->theme_root = dirname( $theme_root );
 201                 }
 202
 203                 $this->cache_hash = md5( $this->theme_root . '/' . $this->stylesheet );
 204                 $theme_file = $this->stylesheet . '/style.css';
 205
 206                 $cache = $this->cache_get( 'theme' );
 207
 208                 if ( is_array( $cache ) ) {
 209                         foreach ( array( 'errors', 'headers', 'template' ) as $key ) {
 210                                 if ( isset( $cache[ $key ] ) )
 211                                         $this->$key = $cache[ $key ];
 212                         }
 213                         if ( $this->errors )
 214                                 return;
 215                         if ( isset( $cache['theme_root_template'] ) )
 216                                 $theme_root_template = $cache['theme_root_template'];
 217                 } elseif ( ! file_exists( $this->theme_root . '/' . $theme_file ) ) {
 218                         $this->headers['Name'] = $this->stylesheet;
 219                         if ( ! file_exists( $this->theme_root . '/' . $this->stylesheet ) )
 220                                 $this->errors = new WP_Error( 'theme_not_found', sprintf( __( 'The theme directory "%s" does not exist.' ), $this->stylesheet ) );
 221                         else
 222                                 $this->errors = new WP_Error( 'theme_no_stylesheet', __( 'Stylesheet is missing.' ) );
 223                         $this->template = $this->stylesheet;
 224                         $this->cache_add( 'theme', array( 'headers' => $this->headers, 'errors' => $this->errors, 'stylesheet' => $this->stylesheet, 'template' => $this->template ) );
 225                         if ( ! file_exists( $this->theme_root ) ) // Don't cache this one.
 226                                 $this->errors->add( 'theme_root_missing', __( 'ERROR: The themes directory is either empty or doesn&#8217;t exist. Please check your installation.' ) );
 227                         return;
 228                 } elseif ( ! is_readable( $this->theme_root . '/' . $theme_file ) ) {
 229                         $this->headers['Name'] = $this->stylesheet;
 230                         $this->errors = new WP_Error( 'theme_stylesheet_not_readable', __( 'Stylesheet is not readable.' ) );
 231                         $this->template = $this->stylesheet;
 232                         $this->cache_add( 'theme', array( 'headers' => $this->headers, 'errors' => $this->errors, 'stylesheet' => $this->stylesheet, 'template' => $this->template ) );
 233                         return;
 234                 } else {
 235                         $this->headers = get_file_data( $this->theme_root . '/' . $theme_file, self::$file_headers, 'theme' );
 236                         // Default themes always trump their pretenders.
 237                         // Properly identify default themes that are inside a directory within wp-content/themes.
 238                         if ( $default_theme_slug = array_search( $this->headers['Name'], self::$default_themes ) ) {
 239                                 if ( basename( $this->stylesheet ) != $default_theme_slug )
 240                                         $this->headers['Name'] .= '/' . $this->stylesheet;
 241                         }
 242                 }
 243
 244                 // (If template is set from cache [and there are no errors], we know it's good.)
 245                 if ( ! $this->template && ! ( $this->template = $this->headers['Template'] ) ) {
 246                         $this->template = $this->stylesheet;
 247                         if ( ! file_exists( $this->theme_root . '/' . $this->stylesheet . '/index.php' ) ) {
 248                                 $this->errors = new WP_Error( 'theme_no_index', __( 'Template is missing.' ) );
 249                                 $this->cache_add( 'theme', array( 'headers' => $this->headers, 'errors' => $this->errors, 'stylesheet' => $this->stylesheet, 'template' => $this->template ) );
 250                                 return;
 251                         }
 252                 }
 253
 254                 // If we got our data from cache, we can assume that 'template' is pointing to the right place.
 255                 if ( ! is_array( $cache ) && $this->template != $this->stylesheet && ! file_exists( $this->theme_root . '/' . $this->template . '/index.php' ) ) {
 256                         // If we're in a directory of themes inside /themes, look for the parent nearby.
 257                         // wp-content/themes/directory-of-themes/*
 258                         $parent_dir = dirname( $this->stylesheet );
 259                         if ( '.' != $parent_dir && file_exists( $this->theme_root . '/' . $parent_dir . '/' . $this->template . '/index.php' ) ) {
 260                                 $this->template = $parent_dir . '/' . $this->template;
 261                         } elseif ( ( $directories = search_theme_directories() ) && isset( $directories[ $this->template ] ) ) {
 262                                 // Look for the template in the search_theme_directories() results, in case it is in another theme root.
 263                                 // We don't look into directories of themes, just the theme root.
 264                                 $theme_root_template = $directories[ $this->template ]['theme_root'];
 265                         } else {
 266                                 // Parent theme is missing.
 267                                 $this->errors = new WP_Error( 'theme_no_parent', sprintf( __( 'The parent theme is missing. Please install the "%s" parent theme.' ), $this->template ) );
 268                                 $this->cache_add( 'theme', array( 'headers' => $this->headers, 'errors' => $this->errors, 'stylesheet' => $this->stylesheet, 'template' => $this->template ) );
 269                                 $this->parent = new WP_Theme( $this->template, $this->theme_root, $this );
 270                                 return;
 271                         }
 272                 }
 273
 274                 // Set the parent, if we're a child theme.
 275                 if ( $this->template != $this->stylesheet ) {
 276                         // If we are a parent, then there is a problem. Only two generations allowed! Cancel things out.
 277                         if ( $_child instanceof WP_Theme && $_child->template == $this->stylesheet ) {
 278                                 $_child->parent = null;
 279                                 $_child->errors = new WP_Error( 'theme_parent_invalid', sprintf( __( 'The "%s" theme is not a valid parent theme.' ), $_child->template ) );
 280                                 $_child->cache_add( 'theme', array( 'headers' => $_child->headers, 'errors' => $_child->errors, 'stylesheet' => $_child->stylesheet, 'template' => $_child->template ) );
 281                                 // The two themes actually reference each other with the Template header.
 282                                 if ( $_child->stylesheet == $this->template ) {
 283                                         $this->errors = new WP_Error( 'theme_parent_invalid', sprintf( __( 'The "%s" theme is not a valid parent theme.' ), $this->template ) );
 284                                         $this->cache_add( 'theme', array( 'headers' => $this->headers, 'errors' => $this->errors, 'stylesheet' => $this->stylesheet, 'template' => $this->template ) );
 285                                 }
 286                                 return;
 287                         }
 288                         // Set the parent. Pass the current instance so we can do the crazy checks above and assess errors.
 289                         $this->parent = new WP_Theme( $this->template, isset( $theme_root_template ) ? $theme_root_template : $this->theme_root, $this );
 290                 }
 291
 292                 // We're good. If we didn't retrieve from cache, set it.
 293                 if ( ! is_array( $cache ) ) {
 294                         $cache = array( 'headers' => $this->headers, 'errors' => $this->errors, 'stylesheet' => $this->stylesheet, 'template' => $this->template );
 295                         // If the parent theme is in another root, we'll want to cache this. Avoids an entire branch of filesystem calls above.
 296                         if ( isset( $theme_root_template ) )
 297                                 $cache['theme_root_template'] = $theme_root_template;
 298                         $this->cache_add( 'theme', $cache );
 299                 }
 300         }
 301
 302         /**
 303          * When converting the object to a string, the theme name is returned.
 304          *
 305          * @return string Theme name, ready for display (translated)
 306          */
 307         public function __toString() {
 308                 return (string) $this->display('Name');
 309         }
 310
 311         /**
 312          * __isset() magic method for properties formerly returned by current_theme_info()
 313          */
 314         public function __isset( $offset ) {
 315                 static $properties = array(
 316                         'name', 'title', 'version', 'parent_theme', 'template_dir', 'stylesheet_dir', 'template', 'stylesheet',
 317                         'screenshot', 'description', 'author', 'tags', 'theme_root', 'theme_root_uri',
 318                 );
 319
 320                 return in_array( $offset, $properties );
 321         }
 322
 323         /**
 324          * __get() magic method for properties formerly returned by current_theme_info()
 325          */
 326         public function __get( $offset ) {
 327                 switch ( $offset ) {
 328                         case 'name' :
 329                         case 'title' :
 330                                 return $this->get('Name');
 331                         case 'version' :
 332                                 return $this->get('Version');
 333                         case 'parent_theme' :
 334                                 return $this->parent() ? $this->parent()->get('Name') : '';
 335                         case 'template_dir' :
 336                                 return $this->get_template_directory();
 337                         case 'stylesheet_dir' :
 338                                 return $this->get_stylesheet_directory();
 339                         case 'template' :
 340                                 return $this->get_template();
 341                         case 'stylesheet' :
 342                                 return $this->get_stylesheet();
 343                         case 'screenshot' :
 344                                 return $this->get_screenshot( 'relative' );
 345                         // 'author' and 'description' did not previously return translated data.
 346                         case 'description' :
 347                                 return $this->display('Description');
 348                         case 'author' :
 349                                 return $this->display('Author');
 350                         case 'tags' :
 351                                 return $this->get( 'Tags' );
 352                         case 'theme_root' :
 353                                 return $this->get_theme_root();
 354                         case 'theme_root_uri' :
 355                                 return $this->get_theme_root_uri();
 356                         // For cases where the array was converted to an object.
 357                         default :
 358                                 return $this->offsetGet( $offset );
 359                 }
 360         }
 361
 362         /**
 363          * Method to implement ArrayAccess for keys formerly returned by get_themes()
 364          */
 365         public function offsetSet( $offset, $value ) {}
 366
 367         /**
 368          * Method to implement ArrayAccess for keys formerly returned by get_themes()
 369          */
 370         public function offsetUnset( $offset ) {}
 371
 372         /**
 373          * Method to implement ArrayAccess for keys formerly returned by get_themes()
 374          */
 375         public function offsetExists( $offset ) {
 376                 static $keys = array(
 377                         'Name', 'Version', 'Status', 'Title', 'Author', 'Author Name', 'Author URI', 'Description',
 378                         'Template', 'Stylesheet', 'Template Files', 'Stylesheet Files', 'Template Dir', 'Stylesheet Dir',
 379                          'Screenshot', 'Tags', 'Theme Root', 'Theme Root URI', 'Parent Theme',
 380                 );
 381
 382                 return in_array( $offset, $keys );
 383         }
 384
 385         /**
 386          * Method to implement ArrayAccess for keys formerly returned by get_themes().
 387          *
 388          * Author, Author Name, Author URI, and Description did not previously return
 389          * translated data. We are doing so now as it is safe to do. However, as
 390          * Name and Title could have been used as the key for get_themes(), both remain
 391          * untranslated for back compatibility. This means that ['Name'] is not ideal,
 392          * and care should be taken to use $theme->display('Name') to get a properly
 393          * translated header.
 394          */
 395         public function offsetGet( $offset ) {
 396                 switch ( $offset ) {
 397                         case 'Name' :
 398                         case 'Title' :
 399                                 // See note above about using translated data. get() is not ideal.
 400                                 // It is only for backwards compatibility. Use display().
 401                                 return $this->get('Name');
 402                         case 'Author' :
 403                                 return $this->display( 'Author');
 404                         case 'Author Name' :
 405                                 return $this->display( 'Author', false);
 406                         case 'Author URI' :
 407                                 return $this->display('AuthorURI');
 408                         case 'Description' :
 409                                 return $this->display( 'Description');
 410                         case 'Version' :
 411                         case 'Status' :
 412                                 return $this->get( $offset );
 413                         case 'Template' :
 414                                 return $this->get_template();
 415                         case 'Stylesheet' :
 416                                 return $this->get_stylesheet();
 417                         case 'Template Files' :
 418                                 return $this->get_files( 'php', 1, true );
 419                         case 'Stylesheet Files' :
 420                                 return $this->get_files( 'css', 0, false );
 421                         case 'Template Dir' :
 422                                 return $this->get_template_directory();
 423                         case 'Stylesheet Dir' :
 424                                 return $this->get_stylesheet_directory();
 425                         case 'Screenshot' :
 426                                 return $this->get_screenshot( 'relative' );
 427                         case 'Tags' :
 428                                 return $this->get('Tags');
 429                         case 'Theme Root' :
 430                                 return $this->get_theme_root();
 431                         case 'Theme Root URI' :
 432                                 return $this->get_theme_root_uri();
 433                         case 'Parent Theme' :
 434                                 return $this->parent() ? $this->parent()->get('Name') : '';
 435                         default :
 436                                 return null;
 437                 }
 438         }
 439
 440         /**
 441          * Returns errors property.
 442          *
 443          * @since 3.4.0
 444          * @access public
 445          *
 446          * @return WP_Error|bool WP_Error if there are errors, or false.
 447          */
 448         public function errors() {
 449                 return is_wp_error( $this->errors ) ? $this->errors : false;
 450         }
 451
 452         /**
 453          * Whether the theme exists.
 454          *
 455          * A theme with errors exists. A theme with the error of 'theme_not_found',
 456          * meaning that the theme's directory was not found, does not exist.
 457          *
 458          * @since 3.4.0
 459          * @access public
 460          *
 461          * @return bool Whether the theme exists.
 462          */
 463         public function exists() {
 464                 return ! ( $this->errors() && in_array( 'theme_not_found', $this->errors()->get_error_codes() ) );
 465         }
 466
 467         /**
 468          * Returns reference to the parent theme.
 469          *
 470          * @since 3.4.0
 471          * @access public
 472          *
 473          * @return WP_Theme|bool Parent theme, or false if the current theme is not a child theme.
 474          */
 475         public function parent() {
 476                 return isset( $this->parent ) ? $this->parent : false;
 477         }
 478
 479         /**
 480          * Adds theme data to cache.
 481          *
 482          * Cache entries keyed by the theme and the type of data.
 483          *
 484          * @access private
 485          * @since 3.4.0
 486          *
 487          * @param string $key Type of data to store (theme, screenshot, headers, page_templates)
 488          * @param string $data Data to store
 489          * @return bool Return value from wp_cache_add()
 490          */
 491         private function cache_add( $key, $data ) {
 492                 return wp_cache_add( $key . '-' . $this->cache_hash, $data, 'themes', self::$cache_expiration );
 493         }
 494
 495         /**
 496          * Gets theme data from cache.
 497          *
 498          * Cache entries are keyed by the theme and the type of data.
 499          *
 500          * @access private
 501          * @since 3.4.0
 502          *
 503          * @param string $key Type of data to retrieve (theme, screenshot, headers, page_templates)
 504          * @return mixed Retrieved data
 505          */
 506         private function cache_get( $key ) {
 507                 return wp_cache_get( $key . '-' . $this->cache_hash, 'themes' );
 508         }
 509
 510         /**
 511          * Clears the cache for the theme.
 512          *
 513          * @access public
 514          * @since 3.4.0
 515          */
 516         public function cache_delete() {
 517                 foreach ( array( 'theme', 'screenshot', 'headers', 'page_templates' ) as $key )
 518                         wp_cache_delete( $key . '-' . $this->cache_hash, 'themes' );
 519                 $this->template = $this->textdomain_loaded = $this->theme_root_uri = $this->parent = $this->errors = $this->headers_sanitized = $this->name_translated = null;
 520                 $this->headers = array();
 521                 $this->__construct( $this->stylesheet, $this->theme_root );
 522         }
 523
 524         /**
 525          * Get a raw, unformatted theme header.
 526          *
 527          * The header is sanitized, but is not translated, and is not marked up for display.
 528          * To get a theme header for display, use the display() method.
 529          *
 530          * Use the get_template() method, not the 'Template' header, for finding the template.
 531          * The 'Template' header is only good for what was written in the style.css, while
 532          * get_template() takes into account where WordPress actually located the theme and
 533          * whether it is actually valid.
 534          *
 535          * @access public
 536          * @since 3.4.0
 537          *
 538          * @param string $header Theme header. Name, Description, Author, Version, ThemeURI, AuthorURI, Status, Tags.
 539          * @return string|bool String on success, false on failure.
 540          */
 541         public function get( $header ) {
 542                 if ( ! isset( $this->headers[ $header ] ) )
 543                         return false;
 544
 545                 if ( ! isset( $this->headers_sanitized ) ) {
 546                         $this->headers_sanitized = $this->cache_get( 'headers' );
 547                         if ( ! is_array( $this->headers_sanitized ) )
 548                                 $this->headers_sanitized = array();
 549                 }
 550
 551                 if ( isset( $this->headers_sanitized[ $header ] ) )
 552                         return $this->headers_sanitized[ $header ];
 553
 554                 // If themes are a persistent group, sanitize everything and cache it. One cache add is better than many cache sets.
 555                 if ( self::$persistently_cache ) {
 556                         foreach ( array_keys( $this->headers ) as $_header )
 557                                 $this->headers_sanitized[ $_header ] = $this->sanitize_header( $_header, $this->headers[ $_header ] );
 558                         $this->cache_add( 'headers', $this->headers_sanitized );
 559                 } else {
 560                         $this->headers_sanitized[ $header ] = $this->sanitize_header( $header, $this->headers[ $header ] );
 561                 }
 562
 563                 return $this->headers_sanitized[ $header ];
 564         }
 565
 566         /**
 567          * Gets a theme header, formatted and translated for display.
 568          *
 569          * @access public
 570          * @since 3.4.0
 571          *
 572          * @param string $header Theme header. Name, Description, Author, Version, ThemeURI, AuthorURI, Status, Tags.
 573          * @param bool $markup Optional. Whether to mark up the header. Defaults to true.
 574          * @param bool $translate Optional. Whether to translate the header. Defaults to true.
 575          * @return string|bool Processed header, false on failure.
 576          */
 577         public function display( $header, $markup = true, $translate = true ) {
 578                 $value = $this->get( $header );
 579                 if ( false === $value ) {
 580                         return false;
 581                 }
 582
 583                 if ( $translate && ( empty( $value ) || ! $this->load_textdomain() ) )
 584                         $translate = false;
 585
 586                 if ( $translate )
 587                         $value = $this->translate_header( $header, $value );
 588
 589                 if ( $markup )
 590                         $value = $this->markup_header( $header, $value, $translate );
 591
 592                 return $value;
 593         }
 594
 595         /**
 596          * Sanitize a theme header.
 597          *
 598          * @param string $header Theme header. Name, Description, Author, Version, ThemeURI, AuthorURI, Status, Tags.
 599          * @param string $value Value to sanitize.
 600          */
 601         private function sanitize_header( $header, $value ) {
 602                 switch ( $header ) {
 603                         case 'Status' :
 604                                 if ( ! $value ) {
 605                                         $value = 'publish';
 606                                         break;
 607                                 }
 608                                 // Fall through otherwise.
 609                         case 'Name' :
 610                                 static $header_tags = array(
 611                                         'abbr'    => array( 'title' => true ),
 612                                         'acronym' => array( 'title' => true ),
 613                                         'code'    => true,
 614                                         'em'      => true,
 615                                         'strong'  => true,
 616                                 );
 617                                 $value = wp_kses( $value, $header_tags );
 618                                 break;
 619                         case 'Author' :
 620                                 // There shouldn't be anchor tags in Author, but some themes like to be challenging.
 621                         case 'Description' :
 622                                 static $header_tags_with_a = array(
 623                                         'a'       => array( 'href' => true, 'title' => true ),
 624                                         'abbr'    => array( 'title' => true ),
 625                                         'acronym' => array( 'title' => true ),
 626                                         'code'    => true,
 627                                         'em'      => true,
 628                                         'strong'  => true,
 629                                 );
 630                                 $value = wp_kses( $value, $header_tags_with_a );
 631                                 break;
 632                         case 'ThemeURI' :
 633                         case 'AuthorURI' :
 634                                 $value = esc_url_raw( $value );
 635                                 break;
 636                         case 'Tags' :
 637                                 $value = array_filter( array_map( 'trim', explode( ',', strip_tags( $value ) ) ) );
 638                                 break;
 639                         case 'Version' :
 640                                 $value = strip_tags( $value );
 641                                 break;
 642                 }
 643
 644                 return $value;
 645         }
 646
 647         /**
 648          * Mark up a theme header.
 649          *
 650          * @access private
 651          * @since 3.4.0
 652          *
 653          * @param string $header Theme header. Name, Description, Author, Version, ThemeURI, AuthorURI, Status, Tags.
 654          * @param string $value Value to mark up.
 655          * @param string $translate Whether the header has been translated.
 656          * @return string Value, marked up.
 657          */
 658         private function markup_header( $header, $value, $translate ) {
 659                 switch ( $header ) {
 660                         case 'Name' :
 661                                 if ( empty( $value ) )
 662                                         $value = $this->get_stylesheet();
 663                                 break;
 664                         case 'Description' :
 665                                 $value = wptexturize( $value );
 666                                 break;
 667                         case 'Author' :
 668                                 if ( $this->get('AuthorURI') ) {
 669                                         $value = sprintf( '<a href="%1$s">%2$s</a>', $this->display( 'AuthorURI', true, $translate ), $value );
 670                                 } elseif ( ! $value ) {
 671                                         $value = __( 'Anonymous' );
 672                                 }
 673                                 break;
 674                         case 'Tags' :
 675                                 static $comma = null;
 676                                 if ( ! isset( $comma ) ) {
 677                                         /* translators: used between list items, there is a space after the comma */
 678                                         $comma = __( ', ' );
 679                                 }
 680                                 $value = implode( $comma, $value );
 681                                 break;
 682                         case 'ThemeURI' :
 683                         case 'AuthorURI' :
 684                                 $value = esc_url( $value );
 685                                 break;
 686                 }
 687
 688                 return $value;
 689         }
 690
 691         /**
 692          * Translate a theme header.
 693          *
 694          * @access private
 695          * @since 3.4.0
 696          *
 697          * @param string $header Theme header. Name, Description, Author, Version, ThemeURI, AuthorURI, Status, Tags.
 698          * @param string $value Value to translate.
 699          * @return string Translated value.
 700          */
 701         private function translate_header( $header, $value ) {
 702                 switch ( $header ) {
 703                         case 'Name' :
 704                                 // Cached for sorting reasons.
 705                                 if ( isset( $this->name_translated ) )
 706                                         return $this->name_translated;
 707                                 $this->name_translated = translate( $value, $this->get('TextDomain' ) );
 708                                 return $this->name_translated;
 709                         case 'Tags' :
 710                                 if ( empty( $value ) || ! function_exists( 'get_theme_feature_list' ) )
 711                                         return $value;
 712
 713                                 static $tags_list;
 714                                 if ( ! isset( $tags_list ) ) {
 715                                         $tags_list = array();
 716                                         $feature_list = get_theme_feature_list( false ); // No API
 717                                         foreach ( $feature_list as $tags )
 718                                                 $tags_list += $tags;
 719                                 }
 720
 721                                 foreach ( $value as &$tag ) {
 722                                         if ( isset( $tags_list[ $tag ] ) ) {
 723                                                 $tag = $tags_list[ $tag ];
 724                                         } elseif ( isset( self::$tag_map[ $tag ] ) ) {
 725                                                 $tag = $tags_list[ self::$tag_map[ $tag ] ];
 726                                         }
 727                                 }
 728
 729                                 return $value;
 730
 731                         default :
 732                                 $value = translate( $value, $this->get('TextDomain') );
 733                 }
 734                 return $value;
 735         }
 736
 737         /**
 738          * The directory name of the theme's "stylesheet" files, inside the theme root.
 739          *
 740          * In the case of a child theme, this is directory name of the child theme.
 741          * Otherwise, get_stylesheet() is the same as get_template().
 742          *
 743          * @since 3.4.0
 744          * @access public
 745          *
 746          * @return string Stylesheet
 747          */
 748         public function get_stylesheet() {
 749                 return $this->stylesheet;
 750         }
 751
 752         /**
 753          * The directory name of the theme's "template" files, inside the theme root.
 754          *
 755          * In the case of a child theme, this is the directory name of the parent theme.
 756          * Otherwise, the get_template() is the same as get_stylesheet().
 757          *
 758          * @since 3.4.0
 759          * @access public
 760          *
 761          * @return string Template
 762          */
 763         public function get_template() {
 764                 return $this->template;
 765         }
 766
 767         /**
 768          * Returns the absolute path to the directory of a theme's "stylesheet" files.
 769          *
 770          * In the case of a child theme, this is the absolute path to the directory
 771          * of the child theme's files.
 772          *
 773          * @since 3.4.0
 774          * @access public
 775          *
 776          * @return string Absolute path of the stylesheet directory.
 777          */
 778         public function get_stylesheet_directory() {
 779                 if ( $this->errors() && in_array( 'theme_root_missing', $this->errors()->get_error_codes() ) )
 780                         return '';
 781
 782                 return $this->theme_root . '/' . $this->stylesheet;
 783         }
 784
 785         /**
 786          * Returns the absolute path to the directory of a theme's "template" files.
 787          *
 788          * In the case of a child theme, this is the absolute path to the directory
 789          * of the parent theme's files.
 790          *
 791          * @since 3.4.0
 792          * @access public
 793          *
 794          * @return string Absolute path of the template directory.
 795          */
 796         public function get_template_directory() {
 797                 if ( $this->parent() )
 798                         $theme_root = $this->parent()->theme_root;
 799                 else
 800                         $theme_root = $this->theme_root;
 801
 802                 return $theme_root . '/' . $this->template;
 803         }
 804
 805         /**
 806          * Returns the URL to the directory of a theme's "stylesheet" files.
 807          *
 808          * In the case of a child theme, this is the URL to the directory of the
 809          * child theme's files.
 810          *
 811          * @since 3.4.0
 812          * @access public
 813          *
 814          * @return string URL to the stylesheet directory.
 815          */
 816         public function get_stylesheet_directory_uri() {
 817                 return $this->get_theme_root_uri() . '/' . str_replace( '%2F', '/', rawurlencode( $this->stylesheet ) );
 818         }
 819
 820         /**
 821          * Returns the URL to the directory of a theme's "template" files.
 822          *
 823          * In the case of a child theme, this is the URL to the directory of the
 824          * parent theme's files.
 825          *
 826          * @since 3.4.0
 827          * @access public
 828          *
 829          * @return string URL to the template directory.
 830          */
 831         public function get_template_directory_uri() {
 832                 if ( $this->parent() )
 833                         $theme_root_uri = $this->parent()->get_theme_root_uri();
 834                 else
 835                         $theme_root_uri = $this->get_theme_root_uri();
 836
 837                 return $theme_root_uri . '/' . str_replace( '%2F', '/', rawurlencode( $this->template ) );
 838         }
 839
 840         /**
 841          * The absolute path to the directory of the theme root.
 842          *
 843          * This is typically the absolute path to wp-content/themes.
 844          *
 845          * @since 3.4.0
 846          * @access public
 847          *
 848          * @return string Theme root.
 849          */
 850         public function get_theme_root() {
 851                 return $this->theme_root;
 852         }
 853
 854         /**
 855          * Returns the URL to the directory of the theme root.
 856          *
 857          * This is typically the absolute URL to wp-content/themes. This forms the basis
 858          * for all other URLs returned by WP_Theme, so we pass it to the public function
 859          * get_theme_root_uri() and allow it to run the theme_root_uri filter.
 860          *
 861          * @since 3.4.0
 862          * @access public
 863          *
 864          * @return string Theme root URI.
 865          */
 866         public function get_theme_root_uri() {
 867                 if ( ! isset( $this->theme_root_uri ) )
 868                         $this->theme_root_uri = get_theme_root_uri( $this->stylesheet, $this->theme_root );
 869                 return $this->theme_root_uri;
 870         }
 871
 872         /**
 873          * Returns the main screenshot file for the theme.
 874          *
 875          * The main screenshot is called screenshot.png. gif and jpg extensions are also allowed.
 876          *
 877          * Screenshots for a theme must be in the stylesheet directory. (In the case of child
 878          * themes, parent theme screenshots are not inherited.)
 879          *
 880          * @since 3.4.0
 881          * @access public
 882          *
 883          * @param string $uri Type of URL to return, either 'relative' or an absolute URI. Defaults to absolute URI.
 884          * @return mixed Screenshot file. False if the theme does not have a screenshot.
 885          */
 886         public function get_screenshot( $uri = 'uri' ) {
 887                 $screenshot = $this->cache_get( 'screenshot' );
 888                 if ( $screenshot ) {
 889                         if ( 'relative' == $uri )
 890                                 return $screenshot;
 891                         return $this->get_stylesheet_directory_uri() . '/' . $screenshot;
 892                 } elseif ( 0 === $screenshot ) {
 893                         return false;
 894                 }
 895
 896                 foreach ( array( 'png', 'gif', 'jpg', 'jpeg' ) as $ext ) {
 897                         if ( file_exists( $this->get_stylesheet_directory() . "/screenshot.$ext" ) ) {
 898                                 $this->cache_add( 'screenshot', 'screenshot.' . $ext );
 899                                 if ( 'relative' == $uri )
 900                                         return 'screenshot.' . $ext;
 901                                 return $this->get_stylesheet_directory_uri() . '/' . 'screenshot.' . $ext;
 902                         }
 903                 }
 904
 905                 $this->cache_add( 'screenshot', 0 );
 906                 return false;
 907         }
 908
 909         /**
 910          * Return files in the theme's directory.
 911          *
 912          * @since 3.4.0
 913          * @access public
 914          *
 915          * @param mixed $type Optional. Array of extensions to return. Defaults to all files (null).
 916          * @param int $depth Optional. How deep to search for files. Defaults to a flat scan (0 depth). -1 depth is infinite.
 917          * @param bool $search_parent Optional. Whether to return parent files. Defaults to false.
 918          * @return array Array of files, keyed by the path to the file relative to the theme's directory, with the values
 919          *      being absolute paths.
 920          */
 921         public function get_files( $type = null, $depth = 0, $search_parent = false ) {
 922                 $files = (array) self::scandir( $this->get_stylesheet_directory(), $type, $depth );
 923
 924                 if ( $search_parent && $this->parent() )
 925                         $files += (array) self::scandir( $this->get_template_directory(), $type, $depth );
 926
 927                 return $files;
 928         }
 929
 930         /**
 931          * Returns the theme's page templates.
 932          *
 933          * @since 3.4.0
 934          * @access public
 935          *
 936          * @param WP_Post|null $post Optional. The post being edited, provided for context.
 937          * @return array Array of page templates, keyed by filename, with the value of the translated header name.
 938          */
 939         public function get_page_templates( $post = null ) {
 940                 // If you screw up your current theme and we invalidate your parent, most things still work. Let it slide.
 941                 if ( $this->errors() && $this->errors()->get_error_codes() !== array( 'theme_parent_invalid' ) )
 942                         return array();
 943
 944                 $page_templates = $this->cache_get( 'page_templates' );
 945
 946                 if ( ! is_array( $page_templates ) ) {
 947                         $page_templates = array();
 948
 949                         $files = (array) $this->get_files( 'php', 1 );
 950
 951                         foreach ( $files as $file => $full_path ) {
 952                                 if ( ! preg_match( '|Template Name:(.*)$|mi', file_get_contents( $full_path ), $header ) )
 953                                         continue;
 954                                 $page_templates[ $file ] = _cleanup_header_comment( $header[1] );
 955                         }
 956
 957                         $this->cache_add( 'page_templates', $page_templates );
 958                 }
 959
 960                 if ( $this->load_textdomain() ) {
 961                         foreach ( $page_templates as &$page_template ) {
 962                                 $page_template = $this->translate_header( 'Template Name', $page_template );
 963                         }
 964                 }
 965
 966                 if ( $this->parent() )
 967                         $page_templates += $this->parent()->get_page_templates( $post );
 968
 969                 /**
 970                  * Filter list of page templates for a theme.
 971                  *
 972                  * This filter does not currently allow for page templates to be added.
 973                  *
 974                  * @since 3.9.0
 975                  *
 976                  * @param array        $page_templates Array of page templates. Keys are filenames,
 977                  *                                     values are translated names.
 978                  * @param WP_Theme     $this           The theme object.
 979                  * @param WP_Post|null $post           The post being edited, provided for context, or null.
 980                  */
 981                 $return = apply_filters( 'theme_page_templates', $page_templates, $this, $post );
 982
 983                 return array_intersect_assoc( $return, $page_templates );
 984         }
 985
 986         /**
 987          * Scans a directory for files of a certain extension.
 988          *
 989          * @since 3.4.0
 990          * @access private
 991          *
 992          * @param string $path Absolute path to search.
 993          * @param mixed  Array of extensions to find, string of a single extension, or null for all extensions.
 994          * @param int $depth How deep to search for files. Optional, defaults to a flat scan (0 depth). -1 depth is infinite.
 995          * @param string $relative_path The basename of the absolute path. Used to control the returned path
 996          *      for the found files, particularly when this function recurses to lower depths.
 997          */
 998         private static function scandir( $path, $extensions = null, $depth = 0, $relative_path = '' ) {
 999                 if ( ! is_dir( $path ) )
1000                         return false;
1001
1002                 if ( $extensions ) {
1003                         $extensions = (array) $extensions;
1004                         $_extensions = implode( '|', $extensions );
1005                 }
1006
1007                 $relative_path = trailingslashit( $relative_path );
1008                 if ( '/' == $relative_path )
1009                         $relative_path = '';
1010
1011                 $results = scandir( $path );
1012                 $files = array();
1013
1014                 foreach ( $results as $result ) {
1015                         if ( '.' == $result[0] )
1016                                 continue;
1017                         if ( is_dir( $path . '/' . $result ) ) {
1018                                 if ( ! $depth || 'CVS' == $result )
1019                                         continue;
1020                                 $found = self::scandir( $path . '/' . $result, $extensions, $depth - 1 , $relative_path . $result );
1021                                 $files = array_merge_recursive( $files, $found );
1022                         } elseif ( ! $extensions || preg_match( '~\.(' . $_extensions . ')$~', $result ) ) {
1023                                 $files[ $relative_path . $result ] = $path . '/' . $result;
1024                         }
1025                 }
1026
1027                 return $files;
1028         }
1029
1030         /**
1031          * Loads the theme's textdomain.
1032          *
1033          * Translation files are not inherited from the parent theme. Todo: if this fails for the
1034          * child theme, it should probably try to load the parent theme's translations.
1035          *
1036          * @since 3.4.0
1037          * @access public
1038          *
1039          * @return bool True if the textdomain was successfully loaded or has already been loaded.
1040          *      False if no textdomain was specified in the file headers, or if the domain could not be loaded.
1041          */
1042         public function load_textdomain() {
1043                 if ( isset( $this->textdomain_loaded ) )
1044                         return $this->textdomain_loaded;
1045
1046                 $textdomain = $this->get('TextDomain');
1047                 if ( ! $textdomain ) {
1048                         $this->textdomain_loaded = false;
1049                         return false;
1050                 }
1051
1052                 if ( is_textdomain_loaded( $textdomain ) ) {
1053                         $this->textdomain_loaded = true;
1054                         return true;
1055                 }
1056
1057                 $path = $this->get_stylesheet_directory();
1058                 if ( $domainpath = $this->get('DomainPath') )
1059                         $path .= $domainpath;
1060                 else
1061                         $path .= '/languages';
1062
1063                 $this->textdomain_loaded = load_theme_textdomain( $textdomain, $path );
1064                 return $this->textdomain_loaded;
1065         }
1066
1067         /**
1068          * Whether the theme is allowed (multisite only).
1069          *
1070          * @since 3.4.0
1071          * @access public
1072          *
1073          * @param string $check Optional. Whether to check only the 'network'-wide settings, the 'site'
1074          *      settings, or 'both'. Defaults to 'both'.
1075          * @param int $blog_id Optional. Ignored if only network-wide settings are checked. Defaults to current blog.
1076          * @return bool Whether the theme is allowed for the network. Returns true in single-site.
1077          */
1078         public function is_allowed( $check = 'both', $blog_id = null ) {
1079                 if ( ! is_multisite() )
1080                         return true;
1081
1082                 if ( 'both' == $check || 'network' == $check ) {
1083                         $allowed = self::get_allowed_on_network();
1084                         if ( ! empty( $allowed[ $this->get_stylesheet() ] ) )
1085                                 return true;
1086                 }
1087
1088                 if ( 'both' == $check || 'site' == $check ) {
1089                         $allowed = self::get_allowed_on_site( $blog_id );
1090                         if ( ! empty( $allowed[ $this->get_stylesheet() ] ) )
1091                                 return true;
1092                 }
1093
1094                 return false;
1095         }
1096
1097         /**
1098          * Returns array of stylesheet names of themes allowed on the site or network.
1099          *
1100          * @since 3.4.0
1101          * @access public
1102          *
1103          * @param int $blog_id Optional. Defaults to current blog.
1104          * @return array Array of stylesheet names.
1105          */
1106         public static function get_allowed( $blog_id = null ) {
1107                 /**
1108                  * Filter the array of themes allowed on the site or network.
1109                  *
1110                  * @since MU
1111                  *
1112                  * @param array $allowed_themes An array of theme stylesheet names.
1113                  */
1114                 $network = (array) apply_filters( 'allowed_themes', self::get_allowed_on_network() );
1115                 return $network + self::get_allowed_on_site( $blog_id );
1116         }
1117
1118         /**
1119          * Returns array of stylesheet names of themes allowed on the network.
1120          *
1121          * @since 3.4.0
1122          * @access public
1123          *
1124          * @return array Array of stylesheet names.
1125          */
1126         public static function get_allowed_on_network() {
1127                 static $allowed_themes;
1128                 if ( ! isset( $allowed_themes ) )
1129                         $allowed_themes = (array) get_site_option( 'allowedthemes' );
1130                 return $allowed_themes;
1131         }
1132
1133         /**
1134          * Returns array of stylesheet names of themes allowed on the site.
1135          *
1136          * @since 3.4.0
1137          * @access public
1138          *
1139          * @param int $blog_id Optional. Defaults to current blog.
1140          * @return array Array of stylesheet names.
1141          */
1142         public static function get_allowed_on_site( $blog_id = null ) {
1143                 static $allowed_themes = array();
1144
1145                 if ( ! $blog_id || ! is_multisite() )
1146                         $blog_id = get_current_blog_id();
1147
1148                 if ( isset( $allowed_themes[ $blog_id ] ) )
1149                         return $allowed_themes[ $blog_id ];
1150
1151                 $current = $blog_id == get_current_blog_id();
1152
1153                 if ( $current ) {
1154                         $allowed_themes[ $blog_id ] = get_option( 'allowedthemes' );
1155                 } else {
1156                         switch_to_blog( $blog_id );
1157                         $allowed_themes[ $blog_id ] = get_option( 'allowedthemes' );
1158                         restore_current_blog();
1159                 }
1160
1161                 // This is all super old MU back compat joy.
1162                 // 'allowedthemes' keys things by stylesheet. 'allowed_themes' keyed things by name.
1163                 if ( false === $allowed_themes[ $blog_id ] ) {
1164                         if ( $current ) {
1165                                 $allowed_themes[ $blog_id ] = get_option( 'allowed_themes' );
1166                         } else {
1167                                 switch_to_blog( $blog_id );
1168                                 $allowed_themes[ $blog_id ] = get_option( 'allowed_themes' );
1169                                 restore_current_blog();
1170                         }
1171
1172                         if ( ! is_array( $allowed_themes[ $blog_id ] ) || empty( $allowed_themes[ $blog_id ] ) ) {
1173                                 $allowed_themes[ $blog_id ] = array();
1174                         } else {
1175                                 $converted = array();
1176                                 $themes = wp_get_themes();
1177                                 foreach ( $themes as $stylesheet => $theme_data ) {
1178                                         if ( isset( $allowed_themes[ $blog_id ][ $theme_data->get('Name') ] ) )
1179                                                 $converted[ $stylesheet ] = true;
1180                                 }
1181                                 $allowed_themes[ $blog_id ] = $converted;
1182                         }
1183                         // Set the option so we never have to go through this pain again.
1184                         if ( is_admin() && $allowed_themes[ $blog_id ] ) {
1185                                 if ( $current ) {
1186                                         update_option( 'allowedthemes', $allowed_themes[ $blog_id ] );
1187                                         delete_option( 'allowed_themes' );
1188                                 } else {
1189                                         switch_to_blog( $blog_id );
1190                                         update_option( 'allowedthemes', $allowed_themes[ $blog_id ] );
1191                                         delete_option( 'allowed_themes' );
1192                                         restore_current_blog();
1193                                 }
1194                         }
1195                 }
1196
1197                 return (array) $allowed_themes[ $blog_id ];
1198         }
1199
1200         /**
1201          * Sort themes by name.
1202          *
1203          * @since 3.4.0
1204          * @access public
1205          */
1206         public static function sort_by_name( &$themes ) {
1207                 if ( 0 === strpos( get_locale(), 'en_' ) ) {
1208                         uasort( $themes, array( 'WP_Theme', '_name_sort' ) );
1209                 } else {
1210                         uasort( $themes, array( 'WP_Theme', '_name_sort_i18n' ) );
1211                 }
1212         }
1213
1214         /**
1215          * Callback function for usort() to naturally sort themes by name.
1216          *
1217          * Accesses the Name header directly from the class for maximum speed.
1218          * Would choke on HTML but we don't care enough to slow it down with strip_tags().
1219          *
1220          * @since 3.4.0
1221          * @access private
1222          */
1223         private static function _name_sort( $a, $b ) {
1224                 return strnatcasecmp( $a->headers['Name'], $b->headers['Name'] );
1225         }
1226
1227         /**
1228          * Name sort (with translation).
1229          *
1230          * @since 3.4.0
1231          * @access private
1232          */
1233         private static function _name_sort_i18n( $a, $b ) {
1234                 // Don't mark up; Do translate.
1235                 return strnatcasecmp( $a->display( 'Name', false, true ), $b->display( 'Name', false, true ) );
1236         }
1237 }