wp-includes/class.wp-dependencies.php

   1 <?php
   2 /**
   3  * Dependencies API: WP_Dependencies base class
   4  *
   5  * @since 2.6.0
   6  *
   7  * @package WordPress
   8  * @subpackage Dependencies
   9  */
  10
  11 /**
  12  * Core base class extended to register items.
  13  *
  14  * @package WordPress
  15  * @since 2.6.0
  16  * @uses _WP_Dependency
  17  */
  18 class WP_Dependencies {
  19         /**
  20          * An array of registered handle objects.
  21          *
  22          * @access public
  23          * @since 2.6.8
  24          * @var array
  25          */
  26         public $registered = array();
  27
  28         /**
  29          * An array of queued _WP_Dependency handle objects.
  30          *
  31          * @access public
  32          * @since 2.6.8
  33          * @var array
  34          */
  35         public $queue = array();
  36
  37         /**
  38          * An array of _WP_Dependency handle objects to queue.
  39          *
  40          * @access public
  41          * @since 2.6.0
  42          * @var array
  43          */
  44         public $to_do = array();
  45
  46         /**
  47          * An array of _WP_Dependency handle objects already queued.
  48          *
  49          * @access public
  50          * @since 2.6.0
  51          * @var array
  52          */
  53         public $done = array();
  54
  55         /**
  56          * An array of additional arguments passed when a handle is registered.
  57          *
  58          * Arguments are appended to the item query string.
  59          *
  60          * @access public
  61          * @since 2.6.0
  62          * @var array
  63          */
  64         public $args = array();
  65
  66         /**
  67          * An array of handle groups to enqueue.
  68          *
  69          * @access public
  70          * @since 2.8.0
  71          * @var array
  72          */
  73         public $groups = array();
  74
  75         /**
  76          * A handle group to enqueue.
  77          *
  78          * @access public
  79          * @since 2.8.0
  80          * @deprecated 4.5.0
  81          * @var int
  82          */
  83         public $group = 0;
  84
  85         /**
  86          * Processes the items and dependencies.
  87          *
  88          * Processes the items passed to it or the queue, and their dependencies.
  89          *
  90          * @access public
  91          * @since 2.6.0
  92          * @since 2.8.0 Added the `$group` parameter.
  93          *
  94          * @param mixed $handles Optional. Items to be processed: Process queue (false), process item (string), process items (array of strings).
  95          * @param mixed $group   Group level: level (int), no groups (false).
  96          * @return array Handles of items that have been processed.
  97          */
  98         public function do_items( $handles = false, $group = false ) {
  99                 /*
 100                  * If nothing is passed, print the queue. If a string is passed,
 101                  * print that item. If an array is passed, print those items.
 102                  */
 103                 $handles = false === $handles ? $this->queue : (array) $handles;
 104                 $this->all_deps( $handles );
 105
 106                 foreach ( $this->to_do as $key => $handle ) {
 107                         if ( !in_array($handle, $this->done, true) && isset($this->registered[$handle]) ) {
 108                                 /*
 109                                  * Attempt to process the item. If successful,
 110                                  * add the handle to the done array.
 111                                  *
 112                                  * Unset the item from the to_do array.
 113                                  */
 114                                 if ( $this->do_item( $handle, $group ) )
 115                                         $this->done[] = $handle;
 116
 117                                 unset( $this->to_do[$key] );
 118                         }
 119                 }
 120
 121                 return $this->done;
 122         }
 123
 124         /**
 125          * Processes a dependency.
 126          *
 127          * @access public
 128          * @since 2.6.0
 129          *
 130          * @param string $handle Name of the item. Should be unique.
 131          * @return bool True on success, false if not set.
 132          */
 133         public function do_item( $handle ) {
 134                 return isset($this->registered[$handle]);
 135         }
 136
 137         /**
 138          * Determines dependencies.
 139          *
 140          * Recursively builds an array of items to process taking
 141          * dependencies into account. Does NOT catch infinite loops.
 142          *
 143          * @access public
 144          * @since 2.1.0
 145          * @since 2.6.0 Moved from `WP_Scripts`.
 146          * @since 2.8.0 Added the `$group` parameter.
 147          *
 148          * @param mixed     $handles   Item handle and argument (string) or item handles and arguments (array of strings).
 149          * @param bool      $recursion Internal flag that function is calling itself.
 150          * @param int|false $group     Group level: (int) level, (false) no groups.
 151          * @return bool True on success, false on failure.
 152          */
 153         public function all_deps( $handles, $recursion = false, $group = false ) {
 154                 if ( !$handles = (array) $handles )
 155                         return false;
 156
 157                 foreach ( $handles as $handle ) {
 158                         $handle_parts = explode('?', $handle);
 159                         $handle = $handle_parts[0];
 160                         $queued = in_array($handle, $this->to_do, true);
 161
 162                         if ( in_array($handle, $this->done, true) ) // Already done
 163                                 continue;
 164
 165                         $moved     = $this->set_group( $handle, $recursion, $group );
 166                         $new_group = $this->groups[ $handle ];
 167
 168                         if ( $queued && !$moved ) // already queued and in the right group
 169                                 continue;
 170
 171                         $keep_going = true;
 172                         if ( !isset($this->registered[$handle]) )
 173                                 $keep_going = false; // Item doesn't exist.
 174                         elseif ( $this->registered[$handle]->deps && array_diff($this->registered[$handle]->deps, array_keys($this->registered)) )
 175                                 $keep_going = false; // Item requires dependencies that don't exist.
 176                         elseif ( $this->registered[$handle]->deps && !$this->all_deps( $this->registered[$handle]->deps, true, $new_group ) )
 177                                 $keep_going = false; // Item requires dependencies that don't exist.
 178
 179                         if ( ! $keep_going ) { // Either item or its dependencies don't exist.
 180                                 if ( $recursion )
 181                                         return false; // Abort this branch.
 182                                 else
 183                                         continue; // We're at the top level. Move on to the next one.
 184                         }
 185
 186                         if ( $queued ) // Already grabbed it and its dependencies.
 187                                 continue;
 188
 189                         if ( isset($handle_parts[1]) )
 190                                 $this->args[$handle] = $handle_parts[1];
 191
 192                         $this->to_do[] = $handle;
 193                 }
 194
 195                 return true;
 196         }
 197
 198         /**
 199          * Register an item.
 200          *
 201          * Registers the item if no item of that name already exists.
 202          *
 203          * @access public
 204          * @since 2.1.0
 205          * @since 2.6.0 Moved from `WP_Scripts`.
 206          *
 207          * @param string           $handle Name of the item. Should be unique.
 208          * @param string           $src    Full URL of the item, or path of the item relative to the WordPress root directory.
 209          * @param array            $deps   Optional. An array of registered item handles this item depends on. Default empty array.
 210          * @param string|bool|null $ver    Optional. String specifying item version number, if it has one, which is added to the URL
 211          *                                 as a query string for cache busting purposes. If version is set to false, a version
 212          *                                 number is automatically added equal to current installed WordPress version.
 213          *                                 If set to null, no version is added.
 214          * @param mixed            $args   Optional. Custom property of the item. NOT the class property $args. Examples: $media, $in_footer.
 215          * @return bool Whether the item has been registered. True on success, false on failure.
 216          */
 217         public function add( $handle, $src, $deps = array(), $ver = false, $args = null ) {
 218                 if ( isset($this->registered[$handle]) )
 219                         return false;
 220                 $this->registered[$handle] = new _WP_Dependency( $handle, $src, $deps, $ver, $args );
 221                 return true;
 222         }
 223
 224         /**
 225          * Add extra item data.
 226          *
 227          * Adds data to a registered item.
 228          *
 229          * @access public
 230          * @since 2.6.0
 231          *
 232          * @param string $handle Name of the item. Should be unique.
 233          * @param string $key    The data key.
 234          * @param mixed  $value  The data value.
 235          * @return bool True on success, false on failure.
 236          */
 237         public function add_data( $handle, $key, $value ) {
 238                 if ( !isset( $this->registered[$handle] ) )
 239                         return false;
 240
 241                 return $this->registered[$handle]->add_data( $key, $value );
 242         }
 243
 244         /**
 245          * Get extra item data.
 246          *
 247          * Gets data associated with a registered item.
 248          *
 249          * @access public
 250          * @since 3.3.0
 251          *
 252          * @param string $handle Name of the item. Should be unique.
 253          * @param string $key    The data key.
 254          * @return mixed Extra item data (string), false otherwise.
 255          */
 256         public function get_data( $handle, $key ) {
 257                 if ( !isset( $this->registered[$handle] ) )
 258                         return false;
 259
 260                 if ( !isset( $this->registered[$handle]->extra[$key] ) )
 261                         return false;
 262
 263                 return $this->registered[$handle]->extra[$key];
 264         }
 265
 266         /**
 267          * Un-register an item or items.
 268          *
 269          * @access public
 270          * @since 2.1.0
 271          * @since 2.6.0 Moved from `WP_Scripts`.
 272          *
 273          * @param mixed $handles Item handle and argument (string) or item handles and arguments (array of strings).
 274          * @return void
 275          */
 276         public function remove( $handles ) {
 277                 foreach ( (array) $handles as $handle )
 278                         unset($this->registered[$handle]);
 279         }
 280
 281         /**
 282          * Queue an item or items.
 283          *
 284          * Decodes handles and arguments, then queues handles and stores
 285          * arguments in the class property $args. For example in extending
 286          * classes, $args is appended to the item url as a query string.
 287          * Note $args is NOT the $args property of items in the $registered array.
 288          *
 289          * @access public
 290          * @since 2.1.0
 291          * @since 2.6.0 Moved from `WP_Scripts`.
 292          *
 293          * @param mixed $handles Item handle and argument (string) or item handles and arguments (array of strings).
 294          */
 295         public function enqueue( $handles ) {
 296                 foreach ( (array) $handles as $handle ) {
 297                         $handle = explode('?', $handle);
 298                         if ( !in_array($handle[0], $this->queue) && isset($this->registered[$handle[0]]) ) {
 299                                 $this->queue[] = $handle[0];
 300                                 if ( isset($handle[1]) )
 301                                         $this->args[$handle[0]] = $handle[1];
 302                         }
 303                 }
 304         }
 305
 306         /**
 307          * Dequeue an item or items.
 308          *
 309          * Decodes handles and arguments, then dequeues handles
 310          * and removes arguments from the class property $args.
 311          *
 312          * @access public
 313          * @since 2.1.0
 314          * @since 2.6.0 Moved from `WP_Scripts`.
 315          *
 316          * @param mixed $handles Item handle and argument (string) or item handles and arguments (array of strings).
 317          */
 318         public function dequeue( $handles ) {
 319                 foreach ( (array) $handles as $handle ) {
 320                         $handle = explode('?', $handle);
 321                         $key = array_search($handle[0], $this->queue);
 322                         if ( false !== $key ) {
 323                                 unset($this->queue[$key]);
 324                                 unset($this->args[$handle[0]]);
 325                         }
 326                 }
 327         }
 328
 329         /**
 330          * Recursively search the passed dependency tree for $handle
 331          *
 332          * @since 4.0.0
 333          *
 334          * @param array  $queue  An array of queued _WP_Dependency handle objects.
 335          * @param string $handle Name of the item. Should be unique.
 336          * @return bool Whether the handle is found after recursively searching the dependency tree.
 337          */
 338         protected function recurse_deps( $queue, $handle ) {
 339                 foreach ( $queue as $queued ) {
 340                         if ( ! isset( $this->registered[ $queued ] ) ) {
 341                                 continue;
 342                         }
 343
 344                         if ( in_array( $handle, $this->registered[ $queued ]->deps ) ) {
 345                                 return true;
 346                         } elseif ( $this->recurse_deps( $this->registered[ $queued ]->deps, $handle ) ) {
 347                                 return true;
 348                         }
 349                 }
 350
 351                 return false;
 352         }
 353
 354         /**
 355          * Query list for an item.
 356          *
 357          * @access public
 358          * @since 2.1.0
 359          * @since 2.6.0 Moved from `WP_Scripts`.
 360          *
 361          * @param string $handle Name of the item. Should be unique.
 362          * @param string $list   Property name of list array.
 363          * @return bool|_WP_Dependency Found, or object Item data.
 364          */
 365         public function query( $handle, $list = 'registered' ) {
 366                 switch ( $list ) {
 367                         case 'registered' :
 368                         case 'scripts': // back compat
 369                                 if ( isset( $this->registered[ $handle ] ) )
 370                                         return $this->registered[ $handle ];
 371                                 return false;
 372
 373                         case 'enqueued' :
 374                         case 'queue' :
 375                                 if ( in_array( $handle, $this->queue ) ) {
 376                                         return true;
 377                                 }
 378                                 return $this->recurse_deps( $this->queue, $handle );
 379
 380                         case 'to_do' :
 381                         case 'to_print': // back compat
 382                                 return in_array( $handle, $this->to_do );
 383
 384                         case 'done' :
 385                         case 'printed': // back compat
 386                                 return in_array( $handle, $this->done );
 387                 }
 388                 return false;
 389         }
 390
 391         /**
 392          * Set item group, unless already in a lower group.
 393          *
 394          * @access public
 395          * @since 2.8.0
 396          *
 397          * @param string $handle    Name of the item. Should be unique.
 398          * @param bool   $recursion Internal flag that calling function was called recursively.
 399          * @param mixed  $group     Group level.
 400          * @return bool Not already in the group or a lower group
 401          */
 402         public function set_group( $handle, $recursion, $group ) {
 403                 $group = (int) $group;
 404
 405                 if ( isset( $this->groups[ $handle ] ) && $this->groups[ $handle ] <= $group ) {
 406                         return false;
 407                 }
 408
 409                 $this->groups[ $handle ] = $group;
 410
 411                 return true;
 412         }
 413
 414 }