mirror of
https://ghproxy.net/https://github.com/elementor/wp2static.git
synced 2026-07-21 11:47:28 +08:00
4899 lines
158 KiB
PHP
4899 lines
158 KiB
PHP
<?php
|
||
|
||
namespace WP_CLI\Loggers {
|
||
/**
|
||
* Base logger class
|
||
*/
|
||
abstract class Base {
|
||
|
||
protected $in_color = false;
|
||
abstract public function info( $message);
|
||
abstract public function success( $message);
|
||
abstract public function warning( $message);
|
||
/**
|
||
* Retrieve the runner instance from the base CLI object. This facilitates
|
||
* unit testing, where the WP_CLI instance isn't available
|
||
*
|
||
* @return Runner Instance of the runner class
|
||
*/
|
||
protected function get_runner() {
|
||
}
|
||
/**
|
||
* Write a message to STDERR, prefixed with "Debug: ".
|
||
*
|
||
* @param string $message Message to write.
|
||
* @param string|bool $group Organize debug message to a specific group.
|
||
* Use `false` for no group.
|
||
*/
|
||
public function debug( $message, $group = false ) {
|
||
}
|
||
/**
|
||
* Write a string to a resource.
|
||
*
|
||
* @param resource $handle Commonly STDOUT or STDERR.
|
||
* @param string $str Message to write.
|
||
*/
|
||
protected function write( $handle, $str ) {
|
||
}
|
||
/**
|
||
* Output one line of message to a resource.
|
||
*
|
||
* @param string $message Message to write.
|
||
* @param string $label Prefix message with a label.
|
||
* @param string $color Colorize label with a given color.
|
||
* @param resource $handle Resource to write to. Defaults to STDOUT.
|
||
*/
|
||
protected function _line( $message, $label, $color, $handle = STDOUT ) {
|
||
}
|
||
}
|
||
/**
|
||
* Quiet logger only logs errors.
|
||
*/
|
||
class Quiet extends \WP_CLI\Loggers\Base {
|
||
|
||
/**
|
||
* Informational messages aren't logged.
|
||
*
|
||
* @param string $message Message to write.
|
||
*/
|
||
public function info( $message ) {
|
||
}
|
||
/**
|
||
* Success messages aren't logged.
|
||
*
|
||
* @param string $message Message to write.
|
||
*/
|
||
public function success( $message ) {
|
||
}
|
||
/**
|
||
* Warning messages aren't logged.
|
||
*
|
||
* @param string $message Message to write.
|
||
*/
|
||
public function warning( $message ) {
|
||
}
|
||
/**
|
||
* Write an error message to STDERR, prefixed with "Error: ".
|
||
*
|
||
* @param string $message Message to write.
|
||
*/
|
||
public function error( $message ) {
|
||
}
|
||
/**
|
||
* Similar to error( $message ), but outputs $message in a red box
|
||
*
|
||
* @param array $message Message to write.
|
||
*/
|
||
public function error_multi_line( $message_lines ) {
|
||
}
|
||
}
|
||
/**
|
||
* Default logger for success, warning, error, and standard messages.
|
||
*/
|
||
class Regular extends \WP_CLI\Loggers\Base {
|
||
|
||
/**
|
||
* @param bool $in_color Whether or not to Colorize strings.
|
||
*/
|
||
public function __construct( $in_color ) {
|
||
}
|
||
/**
|
||
* Write an informational message to STDOUT.
|
||
*
|
||
* @param string $message Message to write.
|
||
*/
|
||
public function info( $message ) {
|
||
}
|
||
/**
|
||
* Write a success message, prefixed with "Success: ".
|
||
*
|
||
* @param string $message Message to write.
|
||
*/
|
||
public function success( $message ) {
|
||
}
|
||
/**
|
||
* Write a warning message to STDERR, prefixed with "Warning: ".
|
||
*
|
||
* @param string $message Message to write.
|
||
*/
|
||
public function warning( $message ) {
|
||
}
|
||
/**
|
||
* Write an message to STDERR, prefixed with "Error: ".
|
||
*
|
||
* @param string $message Message to write.
|
||
*/
|
||
public function error( $message ) {
|
||
}
|
||
/**
|
||
* Similar to error( $message ), but outputs $message in a red box
|
||
*
|
||
* @param array $message Message to write.
|
||
*/
|
||
public function error_multi_line( $message_lines ) {
|
||
}
|
||
}
|
||
/**
|
||
* Execution logger captures all STDOUT and STDERR writes
|
||
*/
|
||
class Execution extends \WP_CLI\Loggers\Regular {
|
||
|
||
/**
|
||
* Captured writes to STDOUT.
|
||
*/
|
||
public $stdout = '';
|
||
/**
|
||
* Captured writes to STDERR.
|
||
*/
|
||
public $stderr = '';
|
||
/**
|
||
* @param bool $in_color Whether or not to Colorize strings.
|
||
*/
|
||
public function __construct( $in_color = false ) {
|
||
}
|
||
/**
|
||
* Similar to error( $message ), but outputs $message in a red box
|
||
*
|
||
* @param array $message Message to write.
|
||
*/
|
||
public function error_multi_line( $message_lines ) {
|
||
}
|
||
/**
|
||
* Write a string to a resource.
|
||
*
|
||
* @param resource $handle Commonly STDOUT or STDERR.
|
||
* @param string $str Message to write.
|
||
*/
|
||
protected function write( $handle, $str ) {
|
||
}
|
||
/**
|
||
* Starts output buffering, using a callback to capture output from `echo`, `print`, `printf` (which write to the output buffer 'php://output' rather than STDOUT).
|
||
*/
|
||
public function ob_start() {
|
||
}
|
||
/**
|
||
* Callback for `ob_start()`.
|
||
*
|
||
* @param string $str String to write.
|
||
* @return string Returns zero-length string so nothing gets written to the output buffer.
|
||
*/
|
||
public function ob_start_callback( $str ) {
|
||
}
|
||
/**
|
||
* To match `ob_start() above. Does an `ob_end_flush()`.
|
||
*/
|
||
public function ob_end() {
|
||
}
|
||
}
|
||
}
|
||
|
||
namespace WP_CLI\Fetchers {
|
||
/**
|
||
* Fetch a WordPress entity for use in a subcommand.
|
||
*/
|
||
abstract class Base {
|
||
|
||
/**
|
||
* @var string $msg The message to display when an item is not found
|
||
*/
|
||
protected $msg;
|
||
/**
|
||
* @param string $arg The raw CLI argument
|
||
* @return mixed|false The item if found; false otherwise
|
||
*/
|
||
abstract public function get( $arg);
|
||
/**
|
||
* Like get(), but calls WP_CLI::error() instead of returning false.
|
||
*
|
||
* @param string $arg The raw CLI argument
|
||
*/
|
||
public function get_check( $arg ) {
|
||
}
|
||
/**
|
||
* @param array The raw CLI arguments
|
||
* @return array The list of found items
|
||
*/
|
||
public function get_many( $args ) {
|
||
}
|
||
}
|
||
}
|
||
|
||
namespace WP_CLI\Iterators {
|
||
/**
|
||
* Applies one or more callbacks to an item before returning it.
|
||
*/
|
||
class Transform extends \IteratorIterator {
|
||
|
||
private $transformers = [];
|
||
public function add_transform( $fn ) {
|
||
}
|
||
public function current() {
|
||
}
|
||
}
|
||
/**
|
||
* Iterates over results of a query, split into many queries via LIMIT and OFFSET
|
||
*
|
||
* @source https://gist.github.com/4060005
|
||
*/
|
||
class Query implements \Iterator {
|
||
|
||
private $chunk_size;
|
||
private $query = '';
|
||
private $count_query = '';
|
||
private $global_index = 0;
|
||
private $index_in_results = 0;
|
||
private $results = [];
|
||
private $row_count = 0;
|
||
private $offset = 0;
|
||
private $db = null;
|
||
private $depleted = false;
|
||
/**
|
||
* Creates a new query iterator
|
||
*
|
||
* This will loop over all users, but will retrieve them 100 by 100:
|
||
* <code>
|
||
* foreach( new Iterators\Query( 'SELECT * FROM users', 100 ) as $user ) {
|
||
* tickle( $user );
|
||
* }
|
||
* </code>
|
||
*
|
||
* @param string $query The query as a string. It shouldn't include any LIMIT clauses
|
||
* @param int $chunk_size How many rows to retrieve at once; default value is 500 (optional)
|
||
*/
|
||
public function __construct( $query, $chunk_size = 500 ) {
|
||
}
|
||
/**
|
||
* Reduces the offset when the query row count shrinks
|
||
*
|
||
* In cases where the iterated rows are being updated such that they will no
|
||
* longer be returned by the original query, the offset must be reduced to
|
||
* iterate over all remaining rows.
|
||
*/
|
||
private function adjust_offset_for_shrinking_result_set() {
|
||
}
|
||
private function load_items_from_db() {
|
||
}
|
||
public function current() {
|
||
}
|
||
public function key() {
|
||
}
|
||
public function next() {
|
||
}
|
||
public function rewind() {
|
||
}
|
||
public function valid() {
|
||
}
|
||
}
|
||
/**
|
||
* @source https://gist.github.com/4060005
|
||
*/
|
||
class Table extends \WP_CLI\Iterators\Query {
|
||
|
||
/**
|
||
* Creates an iterator over a database table.
|
||
*
|
||
* <code>
|
||
* foreach( new Iterators\Table( array( 'table' => $wpdb->posts, 'fields' => array( 'ID', 'post_content' ) ) ) as $post ) {
|
||
* count_words_for( $post->ID, $post->post_content );
|
||
* }
|
||
* </code>
|
||
*
|
||
* <code>
|
||
* foreach( new Iterators\Table( array( 'table' => $wpdb->posts, 'where' => 'ID = 8 OR post_status = "publish"' ) ) as $post ) {
|
||
* …
|
||
* }
|
||
* </code>
|
||
*
|
||
* <code>
|
||
* foreach( new PostIterator( array( 'table' => $wpdb->posts, 'where' => array( 'post_status' => 'publish', 'post_date_gmt BETWEEN x AND y' ) ) ) as $post ) {
|
||
* …
|
||
* }
|
||
* </code>
|
||
*
|
||
* @param array $args Supported arguments:
|
||
* table – the name of the database table
|
||
* fields – an array of columns to get from the table, '*' is a valid value and the default
|
||
* where – conditions for filtering rows. Supports two formats:
|
||
* = string – this will be the where clause
|
||
* = array – each element is treated as a condition if it's positional, or as column => value if
|
||
* it's a key/value pair. In the latter case the value is automatically quoted and escaped
|
||
* append - add arbitrary extra SQL
|
||
*/
|
||
public function __construct( $args = [] ) {
|
||
}
|
||
private static function build_fields( $fields ) {
|
||
}
|
||
private static function build_where_conditions( $where ) {
|
||
}
|
||
}
|
||
/**
|
||
* Allows incrementally reading and parsing lines from a CSV file.
|
||
*/
|
||
class CSV implements \Iterator {
|
||
|
||
const ROW_SIZE = 4096;
|
||
private $file_pointer;
|
||
private $delimiter;
|
||
private $columns;
|
||
private $current_index;
|
||
private $current_element;
|
||
public function __construct( $filename, $delimiter = ',' ) {
|
||
}
|
||
public function rewind() {
|
||
}
|
||
public function current() {
|
||
}
|
||
public function key() {
|
||
}
|
||
public function next() {
|
||
}
|
||
public function valid() {
|
||
}
|
||
}
|
||
class Exception extends \RuntimeException {
|
||
|
||
}
|
||
}
|
||
|
||
namespace WP_CLI {
|
||
class ExitException extends \Exception {
|
||
|
||
}
|
||
/**
|
||
* Extract a provided archive file.
|
||
*/
|
||
class Extractor {
|
||
|
||
/**
|
||
* Extract the archive file to a specific destination.
|
||
*
|
||
* @param string $dest
|
||
*/
|
||
public static function extract( $tarball_or_zip, $dest ) {
|
||
}
|
||
/**
|
||
* Extract a ZIP file to a specific destination.
|
||
*
|
||
* @param string $zipfile
|
||
* @param string $dest
|
||
*/
|
||
private static function extract_zip( $zipfile, $dest ) {
|
||
}
|
||
/**
|
||
* Extract a tarball to a specific destination.
|
||
*
|
||
* @param string $tarball
|
||
* @param string $dest
|
||
*/
|
||
private static function extract_tarball( $tarball, $dest ) {
|
||
}
|
||
/**
|
||
* Copy files from source directory to destination directory. Source directory must exist.
|
||
*
|
||
* @param string $source
|
||
* @param string $dest
|
||
*/
|
||
public static function copy_overwrite_files( $source, $dest ) {
|
||
}
|
||
/**
|
||
* Delete all files and directories recursively from directory. Directory must exist.
|
||
*
|
||
* @param string $dir
|
||
*/
|
||
public static function rmdir( $dir ) {
|
||
}
|
||
/**
|
||
* Return formatted ZipArchive error message from error code.
|
||
*
|
||
* @param int $error_code
|
||
* @return string|int The error message corresponding to the specified code, if found;
|
||
* Other wise the same error code, unmodified.
|
||
*/
|
||
public static function zip_error_msg( $error_code ) {
|
||
}
|
||
/**
|
||
* Return formatted error message from ProcessRun of tar command.
|
||
*
|
||
* @param Processrun $process_run
|
||
* @return string|int The error message of the process, if available;
|
||
* otherwise the return code.
|
||
*/
|
||
public static function tar_error_msg( $process_run ) {
|
||
}
|
||
}
|
||
/**
|
||
* Doctrine inflector has static methods for inflecting text.
|
||
*
|
||
* The methods in these classes are from several different sources collected
|
||
* across several different php projects and several different authors. The
|
||
* original author names and emails are not known.
|
||
*
|
||
* Pluralize & Singularize implementation are borrowed from CakePHP with some modifications.
|
||
*
|
||
* @link www.doctrine-project.org
|
||
* @since 1.0
|
||
* @author Konsta Vesterinen <kvesteri@cc.hut.fi>
|
||
* @author Jonathan H. Wage <jonwage@gmail.com>
|
||
*/
|
||
class Inflector {
|
||
|
||
/**
|
||
* Plural inflector rules.
|
||
*
|
||
* @var array
|
||
*/
|
||
private static $plural = [
|
||
'rules' => [
|
||
'/(s)tatus$/i' => '\\1\\2tatuses',
|
||
'/(quiz)$/i' => '\\1zes',
|
||
'/^(ox)$/i' => '\\1\\2en',
|
||
'/([m|l])ouse$/i' => '\\1ice',
|
||
'/(matr|vert|ind)(ix|ex)$/i' => '\\1ices',
|
||
'/(x|ch|ss|sh)$/i' => '\\1es',
|
||
'/([^aeiouy]|qu)y$/i' => '\\1ies',
|
||
'/(hive)$/i' => '\\1s',
|
||
'/(?:([^f])fe|([lr])f)$/i' => '\\1\\2ves',
|
||
'/sis$/i' => 'ses',
|
||
'/([ti])um$/i' => '\\1a',
|
||
'/(p)erson$/i' => '\\1eople',
|
||
'/(m)an$/i' => '\\1en',
|
||
'/(c)hild$/i' => '\\1hildren',
|
||
'/(f)oot$/i' => '\\1eet',
|
||
'/(buffal|her|potat|tomat|volcan)o$/i' => '\\1\\2oes',
|
||
'/(alumn|bacill|cact|foc|fung|nucle|radi|stimul|syllab|termin|vir)us$/i' => '\\1i',
|
||
'/us$/i' => 'uses',
|
||
'/(alias)$/i' => '\\1es',
|
||
'/(analys|ax|cris|test|thes)is$/i' => '\\1es',
|
||
'/s$/' => 's',
|
||
'/^$/' => '',
|
||
'/$/' => 's',
|
||
],
|
||
'uninflected' => [ '.*[nrlm]ese', '.*deer', '.*fish', '.*measles', '.*ois', '.*pox', '.*sheep', 'people', 'cookie' ],
|
||
'irregular' => [
|
||
'atlas' => 'atlases',
|
||
'axe' => 'axes',
|
||
'beef' => 'beefs',
|
||
'brother' => 'brothers',
|
||
'cafe' => 'cafes',
|
||
'chateau' => 'chateaux',
|
||
'child' => 'children',
|
||
'cookie' => 'cookies',
|
||
'corpus' => 'corpuses',
|
||
'cow' => 'cows',
|
||
'criterion' => 'criteria',
|
||
'curriculum' => 'curricula',
|
||
'demo' => 'demos',
|
||
'domino' => 'dominoes',
|
||
'echo' => 'echoes',
|
||
'foot' => 'feet',
|
||
'fungus' => 'fungi',
|
||
'ganglion' => 'ganglions',
|
||
'genie' => 'genies',
|
||
'genus' => 'genera',
|
||
'graffito' => 'graffiti',
|
||
'hippopotamus' => 'hippopotami',
|
||
'hoof' => 'hoofs',
|
||
'human' => 'humans',
|
||
'iris' => 'irises',
|
||
'leaf' => 'leaves',
|
||
'loaf' => 'loaves',
|
||
'man' => 'men',
|
||
'medium' => 'media',
|
||
'memorandum' => 'memoranda',
|
||
'money' => 'monies',
|
||
'mongoose' => 'mongooses',
|
||
'motto' => 'mottoes',
|
||
'move' => 'moves',
|
||
'mythos' => 'mythoi',
|
||
'niche' => 'niches',
|
||
'nucleus' => 'nuclei',
|
||
'numen' => 'numina',
|
||
'occiput' => 'occiputs',
|
||
'octopus' => 'octopuses',
|
||
'opus' => 'opuses',
|
||
'ox' => 'oxen',
|
||
'penis' => 'penises',
|
||
'person' => 'people',
|
||
'plateau' => 'plateaux',
|
||
'runner-up' => 'runners-up',
|
||
'sex' => 'sexes',
|
||
'soliloquy' => 'soliloquies',
|
||
'son-in-law' => 'sons-in-law',
|
||
'syllabus' => 'syllabi',
|
||
'testis' => 'testes',
|
||
'thief' => 'thieves',
|
||
'tooth' => 'teeth',
|
||
'tornado' => 'tornadoes',
|
||
'trilby' => 'trilbys',
|
||
'turf' => 'turfs',
|
||
'volcano' => 'volcanoes',
|
||
],
|
||
];
|
||
/**
|
||
* Singular inflector rules.
|
||
*
|
||
* @var array
|
||
*/
|
||
private static $singular = [
|
||
'rules' => [
|
||
'/(s)tatuses$/i' => '\\1\\2tatus',
|
||
'/^(.*)(menu)s$/i' => '\\1\\2',
|
||
'/(quiz)zes$/i' => '\\1',
|
||
'/(matr)ices$/i' => '\\1ix',
|
||
'/(vert|ind)ices$/i' => '\\1ex',
|
||
'/^(ox)en/i' => '\\1',
|
||
'/(alias)(es)*$/i' => '\\1',
|
||
'/(buffal|her|potat|tomat|volcan)oes$/i' => '\\1o',
|
||
'/(alumn|bacill|cact|foc|fung|nucle|radi|stimul|syllab|termin|viri?)i$/i' => '\\1us',
|
||
'/([ftw]ax)es/i' => '\\1',
|
||
'/(analys|ax|cris|test|thes)es$/i' => '\\1is',
|
||
'/(shoe|slave)s$/i' => '\\1',
|
||
'/(o)es$/i' => '\\1',
|
||
'/ouses$/' => 'ouse',
|
||
'/([^a])uses$/' => '\\1us',
|
||
'/([m|l])ice$/i' => '\\1ouse',
|
||
'/(x|ch|ss|sh)es$/i' => '\\1',
|
||
'/(m)ovies$/i' => '\\1\\2ovie',
|
||
'/(s)eries$/i' => '\\1\\2eries',
|
||
'/([^aeiouy]|qu)ies$/i' => '\\1y',
|
||
'/([lr])ves$/i' => '\\1f',
|
||
'/(tive)s$/i' => '\\1',
|
||
'/(hive)s$/i' => '\\1',
|
||
'/(drive)s$/i' => '\\1',
|
||
'/([^fo])ves$/i' => '\\1fe',
|
||
'/(^analy)ses$/i' => '\\1sis',
|
||
'/(analy|diagno|^ba|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i' => '\\1\\2sis',
|
||
'/([ti])a$/i' => '\\1um',
|
||
'/(p)eople$/i' => '\\1\\2erson',
|
||
'/(m)en$/i' => '\\1an',
|
||
'/(c)hildren$/i' => '\\1\\2hild',
|
||
'/(f)eet$/i' => '\\1oot',
|
||
'/(n)ews$/i' => '\\1\\2ews',
|
||
'/eaus$/' => 'eau',
|
||
'/^(.*us)$/' => '\\1',
|
||
'/s$/i' => '',
|
||
],
|
||
'uninflected' => [ '.*[nrlm]ese', '.*deer', '.*fish', '.*measles', '.*ois', '.*pox', '.*sheep', '.*ss' ],
|
||
'irregular' => [
|
||
'criteria' => 'criterion',
|
||
'curves' => 'curve',
|
||
'emphases' => 'emphasis',
|
||
'foes' => 'foe',
|
||
'hoaxes' => 'hoax',
|
||
'media' => 'medium',
|
||
'neuroses' => 'neurosis',
|
||
'waves' => 'wave',
|
||
'oases' => 'oasis',
|
||
],
|
||
];
|
||
/**
|
||
* Words that should not be inflected.
|
||
*
|
||
* @var array
|
||
*/
|
||
private static $uninflected = [ 'Amoyese', 'bison', 'Borghese', 'bream', 'breeches', 'britches', 'buffalo', 'cantus', 'carp', 'chassis', 'clippers', 'cod', 'coitus', 'Congoese', 'contretemps', 'corps', 'debris', 'diabetes', 'djinn', 'eland', 'elk', 'equipment', 'Faroese', 'flounder', 'Foochowese', 'gallows', 'Genevese', 'Genoese', 'Gilbertese', 'graffiti', 'headquarters', 'herpes', 'hijinks', 'Hottentotese', 'information', 'innings', 'jackanapes', 'Kiplingese', 'Kongoese', 'Lucchese', 'mackerel', 'Maltese', '.*?media', 'mews', 'moose', 'mumps', 'Nankingese', 'news', 'nexus', 'Niasese', 'Pekingese', 'Piedmontese', 'pincers', 'Pistoiese', 'pliers', 'Portuguese', 'proceedings', 'rabies', 'rice', 'rhinoceros', 'salmon', 'Sarawakese', 'scissors', 'sea[- ]bass', 'series', 'Shavese', 'shears', 'siemens', 'species', 'staff', 'swine', 'testes', 'trousers', 'trout', 'tuna', 'Vermontese', 'Wenchowese', 'whiting', 'wildebeest', 'Yengeese' ];
|
||
/**
|
||
* Method cache array.
|
||
*
|
||
* @var array
|
||
*/
|
||
private static $cache = [];
|
||
/**
|
||
* The initial state of Inflector so reset() works.
|
||
*
|
||
* @var array
|
||
*/
|
||
private static $initial_state = [];
|
||
/**
|
||
* Converts a word into the format for a Doctrine table name. Converts 'ModelName' to 'model_name'.
|
||
*
|
||
* @param string $word The word to tableize.
|
||
*
|
||
* @return string The tableized word.
|
||
*/
|
||
public static function tableize( $word ) {
|
||
}
|
||
/**
|
||
* Converts a word into the format for a Doctrine class name. Converts 'table_name' to 'TableName'.
|
||
*
|
||
* @param string $word The word to classify.
|
||
*
|
||
* @return string The classified word.
|
||
*/
|
||
public static function classify( $word ) {
|
||
}
|
||
/**
|
||
* Camelizes a word. This uses the classify() method and turns the first character to lowercase.
|
||
*
|
||
* @param string $word The word to camelize.
|
||
*
|
||
* @return string The camelized word.
|
||
*/
|
||
public static function camelize( $word ) {
|
||
}
|
||
/**
|
||
* Uppercases words with configurable delimeters between words.
|
||
*
|
||
* Takes a string and capitalizes all of the words, like PHP's built-in
|
||
* ucwords function. This extends that behavior, however, by allowing the
|
||
* word delimeters to be configured, rather than only separating on
|
||
* whitespace.
|
||
*
|
||
* Here is an example:
|
||
* <code>
|
||
* <?php
|
||
* $string = 'top-o-the-morning to all_of_you!';
|
||
* echo \Doctrine\Common\Inflector\Inflector::ucwords($string);
|
||
* // Top-O-The-Morning To All_of_you!
|
||
*
|
||
* echo \Doctrine\Common\Inflector\Inflector::ucwords($string, '-_ ');
|
||
* // Top-O-The-Morning To All_Of_You!
|
||
* ?>
|
||
* </code>
|
||
*
|
||
* @param string $string The string to operate on.
|
||
* @param string $delimiters A list of word separators.
|
||
*
|
||
* @return string The string with all delimeter-separated words capitalized.
|
||
*/
|
||
public static function ucwords( $string, $delimiters = " \n\t\r\0\v-" ) {
|
||
}
|
||
/**
|
||
* Clears Inflectors inflected value caches, and resets the inflection
|
||
* rules to the initial values.
|
||
*
|
||
* @return void
|
||
*/
|
||
public static function reset() {
|
||
}
|
||
/**
|
||
* Adds custom inflection $rules, of either 'plural' or 'singular' $type.
|
||
*
|
||
* ### Usage:
|
||
*
|
||
* {{{
|
||
* Inflector::rules('plural', array('/^(inflect)or$/i' => '\1ables'));
|
||
* Inflector::rules('plural', array(
|
||
* 'rules' => array('/^(inflect)ors$/i' => '\1ables'),
|
||
* 'uninflected' => array('dontinflectme'),
|
||
* 'irregular' => array('red' => 'redlings')
|
||
* ));
|
||
* }}}
|
||
*
|
||
* @param string $type The type of inflection, either 'plural' or 'singular'
|
||
* @param array $rules An array of rules to be added.
|
||
* @param boolean $reset If true, will unset default inflections for all
|
||
* new rules that are being defined in $rules.
|
||
*
|
||
* @return void
|
||
*/
|
||
public static function rules( $type, $rules, $reset = false ) {
|
||
}
|
||
/**
|
||
* Returns a word in plural form.
|
||
*
|
||
* @param string $word The word in singular form.
|
||
*
|
||
* @return string The word in plural form.
|
||
*/
|
||
public static function pluralize( $word ) {
|
||
}
|
||
/**
|
||
* Returns a word in singular form.
|
||
*
|
||
* @param string $word The word in plural form.
|
||
*
|
||
* @return string The word in singular form.
|
||
*/
|
||
public static function singularize( $word ) {
|
||
}
|
||
}
|
||
/**
|
||
* Output one or more items in a given format (e.g. table, JSON).
|
||
*/
|
||
class Formatter {
|
||
|
||
/**
|
||
* @var array $args How the items should be output.
|
||
*/
|
||
private $args;
|
||
/**
|
||
* @var string $prefix Standard prefix for object fields.
|
||
*/
|
||
private $prefix;
|
||
/**
|
||
* @param array $assoc_args Output format arguments.
|
||
* @param array $fields Fields to display of each item.
|
||
* @param string|bool $prefix Check if fields have a standard prefix.
|
||
* False indicates empty prefix.
|
||
*/
|
||
public function __construct( &$assoc_args, $fields = null, $prefix = false ) {
|
||
}
|
||
/**
|
||
* Magic getter for arguments.
|
||
*
|
||
* @param string $key
|
||
* @return mixed
|
||
*/
|
||
public function __get( $key ) {
|
||
}
|
||
/**
|
||
* Display multiple items according to the output arguments.
|
||
*
|
||
* @param array $items
|
||
* @param bool|array $ascii_pre_colorized Optional. A boolean or an array of booleans to pass to `format()` if items in the table are pre-colorized. Default false.
|
||
*/
|
||
public function display_items( $items, $ascii_pre_colorized = false ) {
|
||
}
|
||
/**
|
||
* Display a single item according to the output arguments.
|
||
*
|
||
* @param mixed $item
|
||
* @param bool|array $ascii_pre_colorized Optional. A boolean or an array of booleans to pass to `show_multiple_fields()` if the item in the table is pre-colorized. Default false.
|
||
*/
|
||
public function display_item( $item, $ascii_pre_colorized = false ) {
|
||
}
|
||
/**
|
||
* Format items according to arguments.
|
||
*
|
||
* @param array $items
|
||
* @param bool|array $ascii_pre_colorized Optional. A boolean or an array of booleans to pass to `show_table()` if items in the table are pre-colorized. Default false.
|
||
*/
|
||
private function format( $items, $ascii_pre_colorized = false ) {
|
||
}
|
||
/**
|
||
* Show a single field from a list of items.
|
||
*
|
||
* @param array Array of objects to show fields from
|
||
* @param string The field to show
|
||
*/
|
||
private function show_single_field( $items, $field ) {
|
||
}
|
||
/**
|
||
* Find an object's key.
|
||
* If $prefix is set, a key with that prefix will be prioritized.
|
||
*
|
||
* @param object $item
|
||
* @param string $field
|
||
* @return string $key
|
||
*/
|
||
private function find_item_key( $item, $field ) {
|
||
}
|
||
/**
|
||
* Show multiple fields of an object.
|
||
*
|
||
* @param object|array $data Data to display
|
||
* @param string $format Format to display the data in
|
||
* @param bool|array $ascii_pre_colorized Optional. A boolean or an array of booleans to pass to `show_table()` if the item in the table is pre-colorized. Default false.
|
||
*/
|
||
private function show_multiple_fields( $data, $format, $ascii_pre_colorized = false ) {
|
||
}
|
||
/**
|
||
* Show items in a \cli\Table.
|
||
*
|
||
* @param array $items
|
||
* @param array $fields
|
||
* @param bool|array $ascii_pre_colorized Optional. A boolean or an array of booleans to pass to `Table::setAsciiPreColorized()` if items in the table are pre-colorized. Default false.
|
||
*/
|
||
private static function show_table( $items, $fields, $ascii_pre_colorized = false ) {
|
||
}
|
||
/**
|
||
* Format an associative array as a table.
|
||
*
|
||
* @param array $fields Fields and values to format
|
||
* @return array $rows
|
||
*/
|
||
private function assoc_array_to_rows( $fields ) {
|
||
}
|
||
/**
|
||
* Transforms objects and arrays to JSON as necessary
|
||
*
|
||
* @param mixed $item
|
||
* @return mixed
|
||
*/
|
||
public function transform_item_values_to_json( $item ) {
|
||
}
|
||
}
|
||
/**
|
||
* Generate a synopsis from a command's PHPdoc arguments.
|
||
* Turns something like "<object-id>..."
|
||
* into [ optional=>false, type=>positional, repeating=>true, name=>object-id ]
|
||
*/
|
||
class SynopsisParser {
|
||
|
||
/**
|
||
* @param string A synopsis
|
||
* @return array List of parameters
|
||
*/
|
||
public static function parse( $synopsis ) {
|
||
}
|
||
/**
|
||
* Render the Synopsis into a format string.
|
||
*
|
||
* @param array $synopsis A structured synopsis. This might get reordered
|
||
* to match the parsed output.
|
||
* @return string Rendered synopsis.
|
||
*/
|
||
public static function render( &$synopsis ) {
|
||
}
|
||
/**
|
||
* Classify argument attributes based on its syntax.
|
||
*
|
||
* @param string $token
|
||
* @return array $param
|
||
*/
|
||
private static function classify_token( $token ) {
|
||
}
|
||
/**
|
||
* An optional parameter is surrounded by square brackets.
|
||
*
|
||
* @param string $token
|
||
* @return array
|
||
*/
|
||
private static function is_optional( $token ) {
|
||
}
|
||
/**
|
||
* A repeating parameter is followed by an ellipsis.
|
||
*
|
||
* @param string $token
|
||
* @return array
|
||
*/
|
||
private static function is_repeating( $token ) {
|
||
}
|
||
}
|
||
/**
|
||
* Checks if the list of parameters matches the specification defined in the synopsis.
|
||
*/
|
||
class SynopsisValidator {
|
||
|
||
/**
|
||
* @var array $spec Structured representation of command synopsis.
|
||
*/
|
||
private $spec = [];
|
||
/**
|
||
* @param string $synopsis Command's synopsis.
|
||
*/
|
||
public function __construct( $synopsis ) {
|
||
}
|
||
/**
|
||
* Get any unknown arguments.
|
||
*
|
||
* @return array
|
||
*/
|
||
public function get_unknown() {
|
||
}
|
||
/**
|
||
* Check whether there are enough positional arguments.
|
||
*
|
||
* @param array $args Positional arguments.
|
||
* @return bool
|
||
*/
|
||
public function enough_positionals( $args ) {
|
||
}
|
||
/**
|
||
* Check for any unknown positionals.
|
||
*
|
||
* @param array $args Positional arguments.
|
||
* @return array
|
||
*/
|
||
public function unknown_positionals( $args ) {
|
||
}
|
||
/**
|
||
* Check that all required keys are present and that they have values.
|
||
*
|
||
* @param array $assoc_args Parameters passed to command.
|
||
* @return array
|
||
*/
|
||
public function validate_assoc( $assoc_args ) {
|
||
}
|
||
/**
|
||
* Check whether there are unknown parameters supplied.
|
||
*
|
||
* @param array $assoc_args Parameters passed to command.
|
||
* @return array|false
|
||
*/
|
||
public function unknown_assoc( $assoc_args ) {
|
||
}
|
||
/**
|
||
* Filters a list of associative arrays, based on a set of key => value arguments.
|
||
*
|
||
* @param array $args An array of key => value arguments to match against
|
||
* @param string $operator
|
||
* @return array
|
||
*/
|
||
private function query_spec( $args, $operator = 'AND' ) {
|
||
}
|
||
}
|
||
/**
|
||
* A Upgrader Skin for WordPress that only generates plain-text
|
||
*
|
||
* @package wp-cli
|
||
*/
|
||
class UpgraderSkin extends \WP_Upgrader_Skin {
|
||
|
||
public $api;
|
||
public function header() {
|
||
}
|
||
public function footer() {
|
||
}
|
||
public function bulk_header() {
|
||
}
|
||
public function bulk_footer() {
|
||
}
|
||
public function error( $error ) {
|
||
}
|
||
public function feedback( $string, ...$args ) {
|
||
}
|
||
}
|
||
}
|
||
|
||
namespace WP_CLI\Dispatcher {
|
||
/**
|
||
* A non-leaf node in the command tree.
|
||
* Contains one or more Subcommands.
|
||
*
|
||
* @package WP_CLI
|
||
*/
|
||
class CompositeCommand {
|
||
|
||
protected $name;
|
||
protected $shortdesc;
|
||
protected $synopsis;
|
||
protected $docparser;
|
||
protected $parent;
|
||
protected $subcommands = [];
|
||
/**
|
||
* Instantiate a new CompositeCommand
|
||
*
|
||
* @param mixed $parent Parent command (either Root or Composite)
|
||
* @param string $name Represents how command should be invoked
|
||
* @param \WP_CLI\DocParser
|
||
*/
|
||
public function __construct( $parent, $name, $docparser ) {
|
||
}
|
||
/**
|
||
* Get the parent composite (or root) command
|
||
*
|
||
* @return mixed
|
||
*/
|
||
public function get_parent() {
|
||
}
|
||
/**
|
||
* Add a named subcommand to this composite command's
|
||
* set of contained subcommands.
|
||
*
|
||
* @param string $name Represents how subcommand should be invoked
|
||
* @param Subcommand|CompositeCommand
|
||
*/
|
||
public function add_subcommand( $name, $command ) {
|
||
}
|
||
/**
|
||
* Remove a named subcommand from this composite command's set of contained
|
||
* subcommands
|
||
*
|
||
* @param string $name Represents how subcommand should be invoked
|
||
*/
|
||
public function remove_subcommand( $name ) {
|
||
}
|
||
/**
|
||
* Composite commands always contain subcommands.
|
||
*
|
||
* @return true
|
||
*/
|
||
public function can_have_subcommands() {
|
||
}
|
||
/**
|
||
* Get the subcommands contained by this composite
|
||
* command.
|
||
*
|
||
* @return array
|
||
*/
|
||
public function get_subcommands() {
|
||
}
|
||
/**
|
||
* Get the name of this composite command.
|
||
*
|
||
* @return string
|
||
*/
|
||
public function get_name() {
|
||
}
|
||
/**
|
||
* Get the short description for this composite
|
||
* command.
|
||
*
|
||
* @return string
|
||
*/
|
||
public function get_shortdesc() {
|
||
}
|
||
/**
|
||
* Set the short description for this composite command.
|
||
*
|
||
* @param string
|
||
*/
|
||
public function set_shortdesc( $shortdesc ) {
|
||
}
|
||
/**
|
||
* Get the long description for this composite
|
||
* command.
|
||
*
|
||
* @return string
|
||
*/
|
||
public function get_longdesc() {
|
||
}
|
||
/**
|
||
* Set the long description for this composite command
|
||
*
|
||
* @param string
|
||
*/
|
||
public function set_longdesc( $longdesc ) {
|
||
}
|
||
/**
|
||
* Get the synopsis for this composite command.
|
||
* As a collection of subcommands, the composite
|
||
* command is only intended to invoke those
|
||
* subcommands.
|
||
*
|
||
* @return string
|
||
*/
|
||
public function get_synopsis() {
|
||
}
|
||
/**
|
||
* Get the usage for this composite command.
|
||
*
|
||
* @return string
|
||
*/
|
||
public function get_usage( $prefix ) {
|
||
}
|
||
/**
|
||
* Show the usage for all subcommands contained
|
||
* by the composite command.
|
||
*/
|
||
public function show_usage() {
|
||
}
|
||
/**
|
||
* When a composite command is invoked, it shows usage
|
||
* docs for its subcommands.
|
||
*
|
||
* @param array $args
|
||
* @param array $assoc_args
|
||
* @param array $extra_args
|
||
*/
|
||
public function invoke( $args, $assoc_args, $extra_args ) {
|
||
}
|
||
/**
|
||
* Given supplied arguments, find a contained
|
||
* subcommand
|
||
*
|
||
* @param array $args
|
||
* @return \WP_CLI\Dispatcher\Subcommand|false
|
||
*/
|
||
public function find_subcommand( &$args ) {
|
||
}
|
||
/**
|
||
* Get any registered aliases for this composite command's
|
||
* subcommands.
|
||
*
|
||
* @param array $subcommands
|
||
* @return array
|
||
*/
|
||
private static function get_aliases( $subcommands ) {
|
||
}
|
||
/**
|
||
* Composite commands can only be known by one name.
|
||
*
|
||
* @return false
|
||
*/
|
||
public function get_alias() {
|
||
}
|
||
/***
|
||
* Get the list of global parameters
|
||
*
|
||
* @param string $root_command whether to include or not root command specific description
|
||
* @return string
|
||
*/
|
||
protected function get_global_params( $root_command = false ) {
|
||
}
|
||
}
|
||
/**
|
||
* A leaf node in the command tree.
|
||
*
|
||
* @package WP_CLI
|
||
*/
|
||
class Subcommand extends \WP_CLI\Dispatcher\CompositeCommand {
|
||
|
||
private $alias;
|
||
private $when_invoked;
|
||
public function __construct( $parent, $name, $docparser, $when_invoked ) {
|
||
}
|
||
/**
|
||
* Extract the synopsis from PHPdoc string.
|
||
*
|
||
* @param string $longdesc Command docs via PHPdoc
|
||
* @return string
|
||
*/
|
||
private static function extract_synopsis( $longdesc ) {
|
||
}
|
||
/**
|
||
* Subcommands can't have subcommands because they
|
||
* represent code to be executed.
|
||
*
|
||
* @return bool
|
||
*/
|
||
public function can_have_subcommands() {
|
||
}
|
||
/**
|
||
* Get the synopsis string for this subcommand.
|
||
* A synopsis defines what runtime arguments are
|
||
* expected, useful to humans and argument validation.
|
||
*
|
||
* @return string
|
||
*/
|
||
public function get_synopsis() {
|
||
}
|
||
/**
|
||
* Set the synopsis string for this subcommand.
|
||
*
|
||
* @param string
|
||
*/
|
||
public function set_synopsis( $synopsis ) {
|
||
}
|
||
/**
|
||
* If an alias is set, grant access to it.
|
||
* Aliases permit subcommands to be instantiated
|
||
* with a secondary identity.
|
||
*
|
||
* @return string
|
||
*/
|
||
public function get_alias() {
|
||
}
|
||
/**
|
||
* Print the usage details to the end user.
|
||
*
|
||
* @param string $prefix
|
||
*/
|
||
public function show_usage( $prefix = 'usage: ' ) {
|
||
}
|
||
/**
|
||
* Get the usage of the subcommand as a formatted string.
|
||
*
|
||
* @param string $prefix
|
||
* @return string
|
||
*/
|
||
public function get_usage( $prefix ) {
|
||
}
|
||
/**
|
||
* Wrapper for CLI Tools' prompt() method.
|
||
*
|
||
* @param string $question
|
||
* @param string $default
|
||
* @return string|false
|
||
*/
|
||
private function prompt( $question, $default ) {
|
||
}
|
||
/**
|
||
* Interactively prompt the user for input
|
||
* based on defined synopsis and passed arguments.
|
||
*
|
||
* @param array $args
|
||
* @param array $assoc_args
|
||
* @return array
|
||
*/
|
||
private function prompt_args( $args, $assoc_args ) {
|
||
}
|
||
/**
|
||
* Validate the supplied arguments to the command.
|
||
* Throws warnings or errors if arguments are missing
|
||
* or invalid.
|
||
*
|
||
* @param array $args
|
||
* @param array $assoc_args
|
||
* @param array $extra_args
|
||
* @return array list of invalid $assoc_args keys to unset
|
||
*/
|
||
private function validate_args( $args, $assoc_args, $extra_args ) {
|
||
}
|
||
/**
|
||
* Invoke the subcommand with the supplied arguments.
|
||
* Given a --prompt argument, interactively request input
|
||
* from the end user.
|
||
*
|
||
* @param array $args
|
||
* @param array $assoc_args
|
||
*/
|
||
public function invoke( $args, $assoc_args, $extra_args ) {
|
||
}
|
||
/**
|
||
* Get an array of parameter names, by merging the command-specific and the
|
||
* global parameters.
|
||
*
|
||
* @param array $spec Optional. Specification of the current command.
|
||
*
|
||
* @return array Array of parameter names
|
||
*/
|
||
private function get_parameters( $spec = [] ) {
|
||
}
|
||
}
|
||
/**
|
||
* Adds a command namespace without actual functionality.
|
||
*
|
||
* This is meant to provide the means to attach meta information to a namespace
|
||
* when there's no actual command needed.
|
||
*
|
||
* In case a real command gets registered for the same name, it replaces the
|
||
* command namespace.
|
||
*
|
||
* @package WP_CLI
|
||
*/
|
||
class CommandNamespace extends \WP_CLI\Dispatcher\CompositeCommand {
|
||
|
||
/**
|
||
* Show the usage for all subcommands contained
|
||
* by the composite command.
|
||
*/
|
||
public function show_usage() {
|
||
}
|
||
}
|
||
/**
|
||
* The root node in the command tree.
|
||
*
|
||
* @package WP_CLI
|
||
*/
|
||
class RootCommand extends \WP_CLI\Dispatcher\CompositeCommand {
|
||
|
||
public function __construct() {
|
||
}
|
||
/**
|
||
* Get the human-readable long description.
|
||
*
|
||
* @return string
|
||
*/
|
||
public function get_longdesc() {
|
||
}
|
||
/**
|
||
* Find a subcommand registered on the root
|
||
* command.
|
||
*
|
||
* @param array $args
|
||
* @return \WP_CLI\Dispatcher\Subcommand|false
|
||
*/
|
||
public function find_subcommand( &$args ) {
|
||
}
|
||
}
|
||
/**
|
||
* Controls whether adding of a command should be completed or not.
|
||
*
|
||
* This is needed because we can't reliably pass scalar values by reference
|
||
* through the hooks mechanism. An object is always passed by reference.
|
||
*
|
||
* @package WP_CLI
|
||
*/
|
||
final class CommandAddition {
|
||
|
||
/**
|
||
* Whether the command addition was aborted or not.
|
||
*
|
||
* @var bool
|
||
*/
|
||
private $abort = false;
|
||
/**
|
||
* Reason for which the addition was aborted.
|
||
*
|
||
* @var string
|
||
*/
|
||
private $reason = '';
|
||
/**
|
||
* Abort the current command addition.
|
||
*
|
||
* @param string $reason Reason as to why the addition was aborted.
|
||
*/
|
||
public function abort( $reason = '' ) {
|
||
}
|
||
/**
|
||
* Check whether the command addition was aborted.
|
||
*
|
||
* @return bool
|
||
*/
|
||
public function was_aborted() {
|
||
}
|
||
/**
|
||
* Get the reason as to why the addition was aborted.
|
||
*
|
||
* @return string
|
||
*/
|
||
public function get_reason() {
|
||
}
|
||
}
|
||
/**
|
||
* Creates CompositeCommand or Subcommand instances.
|
||
*
|
||
* @package WP_CLI
|
||
*/
|
||
class CommandFactory {
|
||
|
||
// Cache of file contents, indexed by filename. Only used if opcache.save_comments is disabled.
|
||
private static $file_contents = [];
|
||
/**
|
||
* Create a new CompositeCommand (or Subcommand if class has __invoke())
|
||
*
|
||
* @param string $name Represents how the command should be invoked
|
||
* @param string $callable A subclass of WP_CLI_Command, a function, or a closure
|
||
* @param mixed $parent The new command's parent Composite (or Root) command
|
||
*/
|
||
public static function create( $name, $callable, $parent ) {
|
||
}
|
||
/**
|
||
* Clear the file contents cache.
|
||
*/
|
||
public static function clear_file_contents_cache() {
|
||
}
|
||
/**
|
||
* Create a new Subcommand instance.
|
||
*
|
||
* @param mixed $parent The new command's parent Composite command
|
||
* @param string|bool $name Represents how the command should be invoked.
|
||
* If false, will be determined from the documented subject, represented by `$reflection`.
|
||
* @param mixed $callable A callable function or closure, or class name and method
|
||
* @param object $reflection Reflection instance, for doc parsing
|
||
* @param string $class A subclass of WP_CLI_Command
|
||
* @param string $method Class method to be called upon invocation.
|
||
*/
|
||
private static function create_subcommand( $parent, $name, $callable, $reflection ) {
|
||
}
|
||
/**
|
||
* Create a new Composite command instance.
|
||
*
|
||
* @param mixed $parent The new command's parent Root or Composite command
|
||
* @param string $name Represents how the command should be invoked
|
||
* @param mixed $callable
|
||
*/
|
||
private static function create_composite_command( $parent, $name, $callable ) {
|
||
}
|
||
/**
|
||
* Create a new command namespace instance.
|
||
*
|
||
* @param mixed $parent The new namespace's parent Root or Composite command.
|
||
* @param string $name Represents how the command should be invoked
|
||
* @param mixed $callable
|
||
*/
|
||
private static function create_namespace( $parent, $name, $callable ) {
|
||
}
|
||
/**
|
||
* Check whether a method is actually callable.
|
||
*
|
||
* @param ReflectionMethod $method
|
||
* @return bool
|
||
*/
|
||
private static function is_good_method( $method ) {
|
||
}
|
||
/**
|
||
* Gets the document comment. Caters for PHP directive `opcache.save comments` being disabled.
|
||
*
|
||
* @param ReflectionMethod|ReflectionClass|ReflectionFunction $reflection Reflection instance.
|
||
* @return string|false|null Doc comment string if any, false if none (same as `Reflection*::getDocComment()`), null if error.
|
||
*/
|
||
private static function get_doc_comment( $reflection ) {
|
||
}
|
||
/**
|
||
* Returns the last doc comment if any in `$content`.
|
||
*
|
||
* @param string $content The content, which should end at the class or function declaration.
|
||
* @return string|bool The last doc comment if any, or false if none.
|
||
*/
|
||
private static function extract_last_doc_comment( $content ) {
|
||
}
|
||
}
|
||
}
|
||
|
||
namespace WP_CLI {
|
||
/**
|
||
* Escape route for not doing anything.
|
||
*/
|
||
final class NoOp {
|
||
|
||
public function __set( $key, $value ) {
|
||
}
|
||
public function __call( $method, $args ) {
|
||
}
|
||
}
|
||
/**
|
||
* Handles file- and runtime-based configuration values.
|
||
*
|
||
* @package WP_CLI
|
||
*/
|
||
class Configurator {
|
||
|
||
/**
|
||
* @var array $spec Configurator argument specification.
|
||
*/
|
||
private $spec;
|
||
/**
|
||
* @var array $config Values for keys defined in Configurator spec.
|
||
*/
|
||
private $config = [];
|
||
/**
|
||
* @var array $extra_config Extra config values not specified in spec.
|
||
*/
|
||
private $extra_config = [];
|
||
/**
|
||
* @var array $aliases Any aliases defined in config files.
|
||
*/
|
||
private $aliases = [];
|
||
/**
|
||
* @var string ALIAS_REGEX Regex pattern used to define an alias
|
||
*/
|
||
const ALIAS_REGEX = '^@[A-Za-z0-9-_\\.\\-]+$';
|
||
/**
|
||
* @var array ALIAS_SPEC Arguments that can be used in an alias
|
||
*/
|
||
private static $alias_spec = [ 'user', 'url', 'path', 'ssh', 'http' ];
|
||
/**
|
||
* @param string $path Path to config spec file.
|
||
*/
|
||
public function __construct( $path ) {
|
||
}
|
||
/**
|
||
* Get declared configuration values as an array.
|
||
*
|
||
* @return array
|
||
*/
|
||
public function to_array() {
|
||
}
|
||
/**
|
||
* Get configuration specification, i.e. list of accepted keys.
|
||
*
|
||
* @return array
|
||
*/
|
||
public function get_spec() {
|
||
}
|
||
/**
|
||
* Get any aliases defined in config files.
|
||
*
|
||
* @return array
|
||
*/
|
||
public function get_aliases() {
|
||
}
|
||
/**
|
||
* Splits a list of arguments into positional, associative and config.
|
||
*
|
||
* @param array(string)
|
||
* @return array(array)
|
||
*/
|
||
public function parse_args( $arguments ) {
|
||
}
|
||
/**
|
||
* Splits positional args from associative args.
|
||
*
|
||
* @param array
|
||
* @return array(array)
|
||
*/
|
||
public static function extract_assoc( $arguments ) {
|
||
}
|
||
/**
|
||
* Separate runtime parameters from command-specific parameters.
|
||
*
|
||
* @param array $mixed_args
|
||
* @return array
|
||
*/
|
||
private function unmix_assoc_args( $mixed_args, $global_assoc = [], $local_assoc = [] ) {
|
||
}
|
||
/**
|
||
* Handle turning an $assoc_arg into a runtime arg.
|
||
*/
|
||
private function assoc_arg_to_runtime_config( $key, $value, &$runtime_config ) {
|
||
}
|
||
/**
|
||
* Load a YAML file of parameters into scope.
|
||
*
|
||
* @param string $path Path to YAML file.
|
||
*/
|
||
public function merge_yml( $path, $current_alias = null ) {
|
||
}
|
||
/**
|
||
* Merge an array of values into the configurator config.
|
||
*
|
||
* @param array $config
|
||
*/
|
||
public function merge_array( $config ) {
|
||
}
|
||
/**
|
||
* Load values from a YAML file.
|
||
*
|
||
* @param string $yml_file Path to the YAML file
|
||
* @return array $config Declared configuration values
|
||
*/
|
||
private static function load_yml( $yml_file ) {
|
||
}
|
||
/**
|
||
* Conform a variable to an array.
|
||
*
|
||
* @param mixed $val A string or an array
|
||
*/
|
||
private static function arrayify( &$val ) {
|
||
}
|
||
/**
|
||
* Make a path absolute.
|
||
*
|
||
* @param string $path Path to file.
|
||
* @param string $base Base path to prepend.
|
||
*/
|
||
private static function absolutize( &$path, $base ) {
|
||
}
|
||
}
|
||
/**
|
||
* Run a system process, and learn what happened.
|
||
*/
|
||
class Process {
|
||
|
||
/**
|
||
* @var string The full command to execute by the system.
|
||
*/
|
||
private $command;
|
||
/**
|
||
* @var string|null The path of the working directory for the process or NULL if not specified (defaults to current working directory).
|
||
*/
|
||
private $cwd;
|
||
/**
|
||
* @var array Environment variables to set when running the command.
|
||
*/
|
||
private $env;
|
||
/**
|
||
* @var array Descriptor spec for `proc_open()`.
|
||
*/
|
||
private static $descriptors = [
|
||
0 => STDIN,
|
||
1 => [ 'pipe', 'w' ],
|
||
2 => [ 'pipe', 'w' ],
|
||
];
|
||
/**
|
||
* @var bool Whether to log run time info or not.
|
||
*/
|
||
public static $log_run_times = false;
|
||
/**
|
||
* @var array Array of process run time info, keyed by process command, each a 2-element array containing run time and run count.
|
||
*/
|
||
public static $run_times = [];
|
||
/**
|
||
* @param string $command Command to execute.
|
||
* @param string $cwd Directory to execute the command in.
|
||
* @param array $env Environment variables to set when running the command.
|
||
*
|
||
* @return Process
|
||
*/
|
||
public static function create( $command, $cwd = null, $env = [] ) {
|
||
}
|
||
private function __construct() {
|
||
}
|
||
/**
|
||
* Run the command.
|
||
*
|
||
* @return ProcessRun
|
||
*/
|
||
public function run() {
|
||
}
|
||
/**
|
||
* Run the command, but throw an Exception on error.
|
||
*
|
||
* @return ProcessRun
|
||
*/
|
||
public function run_check() {
|
||
}
|
||
/**
|
||
* Run the command, but throw an Exception on error.
|
||
* Same as `run_check()` above, but checks the correct stderr.
|
||
*
|
||
* @return ProcessRun
|
||
*/
|
||
public function run_check_stderr() {
|
||
}
|
||
}
|
||
/**
|
||
* Parse command attributes from its PHPdoc.
|
||
* Used to determine execution characteristics (arguments, etc.).
|
||
*/
|
||
class DocParser {
|
||
|
||
/**
|
||
* @var string $docComment PHPdoc command for the command.
|
||
*/
|
||
protected $doc_comment;
|
||
/**
|
||
* @param string $doc_comment
|
||
*/
|
||
public function __construct( $doc_comment ) {
|
||
}
|
||
/**
|
||
* Remove unused cruft from PHPdoc comment.
|
||
*
|
||
* @param string $comment PHPdoc comment.
|
||
* @return string
|
||
*/
|
||
private static function remove_decorations( $comment ) {
|
||
}
|
||
/**
|
||
* Get the command's short description (e.g. summary).
|
||
*
|
||
* @return string
|
||
*/
|
||
public function get_shortdesc() {
|
||
}
|
||
/**
|
||
* Get the command's full description
|
||
*
|
||
* @return string
|
||
*/
|
||
public function get_longdesc() {
|
||
}
|
||
/**
|
||
* Get the value for a given tag (e.g. "@alias" or "@subcommand")
|
||
*
|
||
* @param string $name Name for the tag, without '@'
|
||
* @return string
|
||
*/
|
||
public function get_tag( $name ) {
|
||
}
|
||
/**
|
||
* Get the command's synopsis.
|
||
*
|
||
* @return string
|
||
*/
|
||
public function get_synopsis() {
|
||
}
|
||
/**
|
||
* Get the description for a given argument.
|
||
*
|
||
* @param string $name Argument's doc name.
|
||
* @return string
|
||
*/
|
||
public function get_arg_desc( $name ) {
|
||
}
|
||
/**
|
||
* Get the arguments for a given argument.
|
||
*
|
||
* @param string $name Argument's doc name.
|
||
* @return mixed|null
|
||
*/
|
||
public function get_arg_args( $name ) {
|
||
}
|
||
/**
|
||
* Get the description for a given parameter.
|
||
*
|
||
* @param string $key Parameter's key.
|
||
* @return string
|
||
*/
|
||
public function get_param_desc( $key ) {
|
||
}
|
||
/**
|
||
* Get the arguments for a given parameter.
|
||
*
|
||
* @param string $key Parameter's key.
|
||
* @return mixed|null
|
||
*/
|
||
public function get_param_args( $key ) {
|
||
}
|
||
/**
|
||
* Get the args for an arg or param
|
||
*
|
||
* @param string $regex Pattern to match against
|
||
* @return array|null Interpreted YAML document, or null.
|
||
*/
|
||
private function get_arg_or_param_args( $regex ) {
|
||
}
|
||
}
|
||
}
|
||
|
||
namespace WP_CLI\Bootstrap {
|
||
/**
|
||
* Class RunnerInstance.
|
||
*
|
||
* Convenience class for steps that make use of the `WP_CLI\Runner` object.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class RunnerInstance {
|
||
|
||
/**
|
||
* Return an instance of the `WP_CLI\Runner` object.
|
||
*
|
||
* Includes necessary class files first as needed.
|
||
*
|
||
* @return \WP_CLI\Runner
|
||
*/
|
||
public function __invoke() {
|
||
}
|
||
}
|
||
/**
|
||
* Interface BootstrapStep.
|
||
*
|
||
* Represents a single bootstrapping step that can be processed.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
interface BootstrapStep {
|
||
|
||
/**
|
||
* Process this single bootstrapping step.
|
||
*
|
||
* @param BootstrapState $state Contextual state to pass into the step.
|
||
*
|
||
* @return BootstrapState Modified state to pass to the next step.
|
||
*/
|
||
public function process( \WP_CLI\Bootstrap\BootstrapState $state);
|
||
}
|
||
/**
|
||
* Class RegisterFrameworkCommands.
|
||
*
|
||
* Register the commands that are directly included with the framework.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class RegisterFrameworkCommands implements \WP_CLI\Bootstrap\BootstrapStep {
|
||
|
||
/**
|
||
* Process this single bootstrapping step.
|
||
*
|
||
* @param BootstrapState $state Contextual state to pass into the step.
|
||
*
|
||
* @return BootstrapState Modified state to pass to the next step.
|
||
*/
|
||
public function process( \WP_CLI\Bootstrap\BootstrapState $state ) {
|
||
}
|
||
}
|
||
/**
|
||
* Class RegisterDeferredCommands.
|
||
*
|
||
* Registers the deferred commands that for which no parent was registered yet.
|
||
* This is necessary, because we can have sub-commands that have no direct
|
||
* parent, like `wp network meta`.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class RegisterDeferredCommands implements \WP_CLI\Bootstrap\BootstrapStep {
|
||
|
||
/**
|
||
* Process this single bootstrapping step.
|
||
*
|
||
* @param BootstrapState $state Contextual state to pass into the step.
|
||
*
|
||
* @return BootstrapState Modified state to pass to the next step.
|
||
*/
|
||
public function process( \WP_CLI\Bootstrap\BootstrapState $state ) {
|
||
}
|
||
/**
|
||
* Add deferred commands that are still waiting to be processed.
|
||
*/
|
||
public function add_deferred_commands() {
|
||
}
|
||
}
|
||
/**
|
||
* Class IncludeFrameworkAutoloader.
|
||
*
|
||
* Loads the framework autoloader through an autolaoder separate from the
|
||
* Composer one, to avoid coupling the loading of the framework with bundled
|
||
* commands.
|
||
*
|
||
* This only contains classes for the framework.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class IncludeFrameworkAutoloader implements \WP_CLI\Bootstrap\BootstrapStep {
|
||
|
||
/**
|
||
* Process this single bootstrapping step.
|
||
*
|
||
* @param BootstrapState $state Contextual state to pass into the step.
|
||
*
|
||
* @return BootstrapState Modified state to pass to the next step.
|
||
*/
|
||
public function process( \WP_CLI\Bootstrap\BootstrapState $state ) {
|
||
}
|
||
}
|
||
/**
|
||
* Abstract class AutoloaderStep.
|
||
*
|
||
* Abstract base class for steps that include an autoloader.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
abstract class AutoloaderStep implements \WP_CLI\Bootstrap\BootstrapStep {
|
||
|
||
/**
|
||
* Store state for subclasses to have access.
|
||
*
|
||
* @var BootstrapState
|
||
*/
|
||
protected $state;
|
||
/**
|
||
* Process this single bootstrapping step.
|
||
*
|
||
* @param BootstrapState $state Contextual state to pass into the step.
|
||
*
|
||
* @return BootstrapState Modified state to pass to the next step.
|
||
*/
|
||
public function process( \WP_CLI\Bootstrap\BootstrapState $state ) {
|
||
}
|
||
/**
|
||
* Get the name of the custom vendor folder as set in `composer.json`.
|
||
*
|
||
* @return string|false Name of the custom vendor folder or false if none.
|
||
*/
|
||
protected function get_custom_vendor_folder() {
|
||
}
|
||
/**
|
||
* Handle the failure to find an autoloader.
|
||
*
|
||
* @return void
|
||
*/
|
||
protected function handle_failure() {
|
||
}
|
||
/**
|
||
* Get the autoloader paths to scan for an autoloader.
|
||
*
|
||
* @return string[]|false Array of strings with autoloader paths, or false
|
||
* to skip.
|
||
*/
|
||
abstract protected function get_autoloader_paths();
|
||
}
|
||
/**
|
||
* Class IncludePackageAutoloader.
|
||
*
|
||
* Loads the package autoloader that includes all the external packages.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class IncludePackageAutoloader extends \WP_CLI\Bootstrap\AutoloaderStep {
|
||
|
||
/**
|
||
* Get the autoloader paths to scan for an autoloader.
|
||
*
|
||
* @return string[]|false Array of strings with autoloader paths, or false
|
||
* to skip.
|
||
*/
|
||
protected function get_autoloader_paths() {
|
||
}
|
||
/**
|
||
* Handle the failure to find an autoloader.
|
||
*
|
||
* @return void
|
||
*/
|
||
protected function handle_failure() {
|
||
}
|
||
}
|
||
/**
|
||
* Class InitializeLogger.
|
||
*
|
||
* Initialize the logger through the `WP_CLI\Runner` object.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class InitializeLogger implements \WP_CLI\Bootstrap\BootstrapStep {
|
||
|
||
/**
|
||
* Process this single bootstrapping step.
|
||
*
|
||
* @param BootstrapState $state Contextual state to pass into the step.
|
||
*
|
||
* @return BootstrapState Modified state to pass to the next step.
|
||
*/
|
||
public function process( \WP_CLI\Bootstrap\BootstrapState $state ) {
|
||
}
|
||
/**
|
||
* Load the class declarations for the loggers.
|
||
*/
|
||
private function declare_loggers() {
|
||
}
|
||
}
|
||
/**
|
||
* Class DefineProtectedCommands.
|
||
*
|
||
* Define the commands that are "protected", meaning that they shouldn't be able
|
||
* to break due to extension code.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class DefineProtectedCommands implements \WP_CLI\Bootstrap\BootstrapStep {
|
||
|
||
/**
|
||
* Process this single bootstrapping step.
|
||
*
|
||
* @param BootstrapState $state Contextual state to pass into the step.
|
||
*
|
||
* @return BootstrapState Modified state to pass to the next step.
|
||
*/
|
||
public function process( \WP_CLI\Bootstrap\BootstrapState $state ) {
|
||
}
|
||
/**
|
||
* Get the list of protected commands.
|
||
*
|
||
* @return array
|
||
*/
|
||
private function get_protected_commands() {
|
||
}
|
||
/**
|
||
* Get the current command as a string.
|
||
*
|
||
* @return string Current command to be executed.
|
||
*/
|
||
private function get_current_command() {
|
||
}
|
||
}
|
||
/**
|
||
* Class BootstrapState.
|
||
*
|
||
* Represents the state that is passed from one bootstrap step to the next.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*
|
||
* Maintain BC: Changing the method names in this class breaks autoload interactions between Phar
|
||
* & framework/commands you use outside of Phar (like when running the Phar WP inside of a command folder).
|
||
* @phpcs:disable WordPress.NamingConventions.ValidFunctionName.MethodNameInvalid
|
||
*/
|
||
class BootstrapState {
|
||
|
||
/**
|
||
* Whether the command currently being run is "protected".
|
||
*
|
||
* This means that the command should not be allowed to break due to
|
||
* extension code.
|
||
*/
|
||
const IS_PROTECTED_COMMAND = 'is_protected_command';
|
||
/**
|
||
* Internal storage of the state values.
|
||
*
|
||
* @var array
|
||
*/
|
||
private $state = [];
|
||
/**
|
||
* Get the state value for a given key.
|
||
*
|
||
* @param string $key Key to get the state from.
|
||
* @param mixed $fallback Fallback value to use if the key is not defined.
|
||
*
|
||
* @return mixed
|
||
*/
|
||
public function getValue( $key, $fallback = null ) {
|
||
}
|
||
/**
|
||
* Set the state value for a given key.
|
||
*
|
||
* @param string $key Key to set the state for.
|
||
* @param mixed $value Value to set the state for the given key to.
|
||
*
|
||
* @return void
|
||
*/
|
||
public function setValue( $key, $value ) {
|
||
}
|
||
}
|
||
/**
|
||
* Class LoadUtilityFunctions.
|
||
*
|
||
* Loads the functions available through `WP_CLI\Utils`.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class LoadUtilityFunctions implements \WP_CLI\Bootstrap\BootstrapStep {
|
||
|
||
/**
|
||
* Process this single bootstrapping step.
|
||
*
|
||
* @param BootstrapState $state Contextual state to pass into the step.
|
||
*
|
||
* @return BootstrapState Modified state to pass to the next step.
|
||
*/
|
||
public function process( \WP_CLI\Bootstrap\BootstrapState $state ) {
|
||
}
|
||
}
|
||
/**
|
||
* Class IncludeFallbackAutoloader.
|
||
*
|
||
* Loads the fallback autoloader that is provided through the `composer.json`
|
||
* file.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class IncludeFallbackAutoloader extends \WP_CLI\Bootstrap\AutoloaderStep {
|
||
|
||
/**
|
||
* Get the autoloader paths to scan for an autoloader.
|
||
*
|
||
* @return string[]|false Array of strings with autoloader paths, or false
|
||
* to skip.
|
||
*/
|
||
protected function get_autoloader_paths() {
|
||
}
|
||
}
|
||
/**
|
||
* Class LoadDispatcher.
|
||
*
|
||
* Loads the dispatcher that will dispatch command names to file locations.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class LoadDispatcher implements \WP_CLI\Bootstrap\BootstrapStep {
|
||
|
||
/**
|
||
* Process this single bootstrapping step.
|
||
*
|
||
* @param BootstrapState $state Contextual state to pass into the step.
|
||
*
|
||
* @return BootstrapState Modified state to pass to the next step.
|
||
*/
|
||
public function process( \WP_CLI\Bootstrap\BootstrapState $state ) {
|
||
}
|
||
}
|
||
/**
|
||
* Class DeclareMainClass.
|
||
*
|
||
* Declares the main `WP_CLI` class.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class DeclareMainClass implements \WP_CLI\Bootstrap\BootstrapStep {
|
||
|
||
/**
|
||
* Process this single bootstrapping step.
|
||
*
|
||
* @param BootstrapState $state Contextual state to pass into the step.
|
||
*
|
||
* @return BootstrapState Modified state to pass to the next step.
|
||
*/
|
||
public function process( \WP_CLI\Bootstrap\BootstrapState $state ) {
|
||
}
|
||
}
|
||
/**
|
||
* Class LaunchRunner.
|
||
*
|
||
* Kick off the Runner object that starts the actual commands.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class LaunchRunner implements \WP_CLI\Bootstrap\BootstrapStep {
|
||
|
||
/**
|
||
* Process this single bootstrapping step.
|
||
*
|
||
* @param BootstrapState $state Contextual state to pass into the step.
|
||
*
|
||
* @return BootstrapState Modified state to pass to the next step.
|
||
*/
|
||
public function process( \WP_CLI\Bootstrap\BootstrapState $state ) {
|
||
}
|
||
}
|
||
/**
|
||
* Class DeclareAbstractBaseCommand.
|
||
*
|
||
* Declares the abstract `WP_CLI_Command` base class.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class DeclareAbstractBaseCommand implements \WP_CLI\Bootstrap\BootstrapStep {
|
||
|
||
/**
|
||
* Process this single bootstrapping step.
|
||
*
|
||
* @param BootstrapState $state Contextual state to pass into the step.
|
||
*
|
||
* @return BootstrapState Modified state to pass to the next step.
|
||
*/
|
||
public function process( \WP_CLI\Bootstrap\BootstrapState $state ) {
|
||
}
|
||
}
|
||
/**
|
||
* Class InitializeColorization.
|
||
*
|
||
* Initialize the colorization through the `WP_CLI\Runner` object.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class InitializeColorization implements \WP_CLI\Bootstrap\BootstrapStep {
|
||
|
||
/**
|
||
* Process this single bootstrapping step.
|
||
*
|
||
* @param BootstrapState $state Contextual state to pass into the step.
|
||
*
|
||
* @return BootstrapState Modified state to pass to the next step.
|
||
*/
|
||
public function process( \WP_CLI\Bootstrap\BootstrapState $state ) {
|
||
}
|
||
}
|
||
/**
|
||
* Class ConfigureRunner.
|
||
*
|
||
* Initialize the configuration for the `WP_CLI\Runner` object.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class ConfigureRunner implements \WP_CLI\Bootstrap\BootstrapStep {
|
||
|
||
/**
|
||
* Process this single bootstrapping step.
|
||
*
|
||
* @param BootstrapState $state Contextual state to pass into the step.
|
||
*
|
||
* @return BootstrapState Modified state to pass to the next step.
|
||
*/
|
||
public function process( \WP_CLI\Bootstrap\BootstrapState $state ) {
|
||
}
|
||
}
|
||
/**
|
||
* Class LoadRequiredCommand.
|
||
*
|
||
* Loads a command that was passed through the `--require=<command>` option.
|
||
*
|
||
* @package WP_CLI\Bootstrap
|
||
*/
|
||
final class LoadRequiredCommand implements \WP_CLI\Bootstrap\BootstrapStep {
|
||
|
||
/**
|
||
* Process this single bootstrapping step.
|
||
*
|
||
* @param BootstrapState $state Contextual state to pass into the step.
|
||
*
|
||
* @return BootstrapState Modified state to pass to the next step.
|
||
*/
|
||
public function process( \WP_CLI\Bootstrap\BootstrapState $state ) {
|
||
}
|
||
}
|
||
}
|
||
|
||
namespace WP_CLI {
|
||
/**
|
||
* Results of an executed command.
|
||
*/
|
||
class ProcessRun {
|
||
|
||
/**
|
||
* @var string The full command executed by the system.
|
||
*/
|
||
public $command;
|
||
/**
|
||
* @var string Captured output from the process' STDOUT.
|
||
*/
|
||
public $stdout;
|
||
/**
|
||
* @var string Captured output from the process' STDERR.
|
||
*/
|
||
public $stderr;
|
||
/**
|
||
* @var string|null The path of the working directory for the process or NULL if not specified (defaults to current working directory).
|
||
*/
|
||
public $cwd;
|
||
/**
|
||
* @var array Environment variables set for this process.
|
||
*/
|
||
public $env;
|
||
/**
|
||
* @var int Exit code of the process.
|
||
*/
|
||
public $return_code;
|
||
/**
|
||
* @var float The run time of the process.
|
||
*/
|
||
public $run_time;
|
||
/**
|
||
* @var array $props Properties of executed command.
|
||
*/
|
||
public function __construct( $props ) {
|
||
}
|
||
/**
|
||
* Return properties of executed command as a string.
|
||
*
|
||
* @return string
|
||
*/
|
||
public function __toString() {
|
||
}
|
||
}
|
||
/**
|
||
* Performs the execution of a command.
|
||
*
|
||
* @package WP_CLI
|
||
*/
|
||
class Runner {
|
||
|
||
private $global_config_path;
|
||
private $project_config_path;
|
||
private $config;
|
||
private $extra_config;
|
||
private $alias;
|
||
private $aliases;
|
||
private $arguments;
|
||
private $assoc_args;
|
||
private $runtime_config;
|
||
private $colorize = false;
|
||
private $early_invoke = [];
|
||
private $global_config_path_debug;
|
||
private $project_config_path_debug;
|
||
private $required_files;
|
||
public function __get( $key ) {
|
||
}
|
||
/**
|
||
* Register a command for early invocation, generally before WordPress loads.
|
||
*
|
||
* @param string $when Named execution hook
|
||
* @param WP_CLI\Dispatcher\Subcommand $command
|
||
*/
|
||
public function register_early_invoke( $when, $command ) {
|
||
}
|
||
/**
|
||
* Perform the early invocation of a command.
|
||
*
|
||
* @param string $when Named execution hook
|
||
*/
|
||
private function do_early_invoke( $when ) {
|
||
}
|
||
/**
|
||
* Get the path to the global configuration YAML file.
|
||
*
|
||
* @return string|false
|
||
*/
|
||
public function get_global_config_path() {
|
||
}
|
||
/**
|
||
* Get the path to the project-specific configuration
|
||
* YAML file.
|
||
* wp-cli.local.yml takes priority over wp-cli.yml.
|
||
*
|
||
* @return string|false
|
||
*/
|
||
public function get_project_config_path() {
|
||
}
|
||
/**
|
||
* Get the path to the packages directory
|
||
*
|
||
* @return string
|
||
*/
|
||
public function get_packages_dir_path() {
|
||
}
|
||
/**
|
||
* Attempts to find the path to the WP installation inside index.php
|
||
*
|
||
* @param string $index_path
|
||
* @return string|false
|
||
*/
|
||
private static function extract_subdir_path( $index_path ) {
|
||
}
|
||
/**
|
||
* Find the directory that contains the WordPress files.
|
||
* Defaults to the current working dir.
|
||
*
|
||
* @return string An absolute path
|
||
*/
|
||
private function find_wp_root() {
|
||
}
|
||
/**
|
||
* Set WordPress root as a given path.
|
||
*
|
||
* @param string $path
|
||
*/
|
||
private static function set_wp_root( $path ) {
|
||
}
|
||
/**
|
||
* Guess which URL context WP-CLI has been invoked under.
|
||
*
|
||
* @param array $assoc_args
|
||
* @return string|false
|
||
*/
|
||
private static function guess_url( $assoc_args ) {
|
||
}
|
||
private function cmd_starts_with( $prefix ) {
|
||
}
|
||
/**
|
||
* Given positional arguments, find the command to execute.
|
||
*
|
||
* @param array $args
|
||
* @return array|string Command, args, and path on success; error message on failure
|
||
*/
|
||
public function find_command_to_run( $args ) {
|
||
}
|
||
/**
|
||
* Find the WP-CLI command to run given arguments, and invoke it.
|
||
*
|
||
* @param array $args Positional arguments including command name
|
||
* @param array $assoc_args Associative arguments for the command.
|
||
* @param array $options Configuration options for the function.
|
||
*/
|
||
public function run_command( $args, $assoc_args = [], $options = [] ) {
|
||
}
|
||
/**
|
||
* Show synopsis if the called command is a composite command
|
||
*/
|
||
public function show_synopsis_if_composite_command() {
|
||
}
|
||
private function run_command_and_exit( $help_exit_warning = '' ) {
|
||
}
|
||
/**
|
||
* Perform a command against a remote server over SSH (or a container using
|
||
* scheme of "docker" or "docker-compose").
|
||
*
|
||
* @param string $connection_string Passed connection string.
|
||
* @return void
|
||
*/
|
||
private function run_ssh_command( $connection_string ) {
|
||
}
|
||
/**
|
||
* Generate a shell command from the parsed connection string.
|
||
*
|
||
* @param array $bits Parsed connection string.
|
||
* @param string $wp_command WP-CLI command to run.
|
||
* @return string
|
||
*/
|
||
private function generate_ssh_command( $bits, $wp_command ) {
|
||
}
|
||
/**
|
||
* Check whether a given command is disabled by the config
|
||
*
|
||
* @return bool
|
||
*/
|
||
public function is_command_disabled( $command ) {
|
||
}
|
||
/**
|
||
* Returns wp-config.php code, skipping the loading of wp-settings.php
|
||
*
|
||
* @return string
|
||
*/
|
||
public function get_wp_config_code() {
|
||
}
|
||
/**
|
||
* Transparently convert deprecated syntaxes
|
||
*
|
||
* @param array $args
|
||
* @param array $assoc_args
|
||
* @return array
|
||
*/
|
||
private static function back_compat_conversions( $args, $assoc_args ) {
|
||
}
|
||
/**
|
||
* Whether or not the output should be rendered in color
|
||
*
|
||
* @return bool
|
||
*/
|
||
public function in_color() {
|
||
}
|
||
public function init_colorization() {
|
||
}
|
||
public function init_logger() {
|
||
}
|
||
public function get_required_files() {
|
||
}
|
||
/**
|
||
* Do WordPress core files exist?
|
||
*
|
||
* @return bool
|
||
*/
|
||
private function wp_exists() {
|
||
}
|
||
/**
|
||
* Are WordPress core files readable?
|
||
*
|
||
* @return bool
|
||
*/
|
||
private function wp_is_readable() {
|
||
}
|
||
private function check_wp_version() {
|
||
}
|
||
public function init_config() {
|
||
}
|
||
private function check_root() {
|
||
}
|
||
private function run_alias_group( $aliases ) {
|
||
}
|
||
private function set_alias( $alias ) {
|
||
}
|
||
public function start() {
|
||
}
|
||
/**
|
||
* Load WordPress, if it hasn't already been loaded
|
||
*/
|
||
public function load_wordpress() {
|
||
}
|
||
private static function fake_current_site_blog( $url_parts ) {
|
||
}
|
||
/**
|
||
* Called after wp-config.php is eval'd, to potentially reset `--url`
|
||
*/
|
||
private function maybe_update_url_from_domain_constant() {
|
||
}
|
||
/**
|
||
* Set up hooks meant to run during the WordPress bootstrap process
|
||
*/
|
||
private function setup_bootstrap_hooks() {
|
||
}
|
||
/**
|
||
* Set up the filters to skip the loaded plugins
|
||
*/
|
||
private function setup_skip_plugins_filters() {
|
||
}
|
||
/**
|
||
* Set up the filters to skip the loaded theme
|
||
*/
|
||
public function action_setup_theme_wp_cli_skip_themes() {
|
||
}
|
||
/**
|
||
* Whether or not this WordPress installation is multisite.
|
||
*
|
||
* For use after wp-config.php has loaded, but before the rest of WordPress
|
||
* is loaded.
|
||
*/
|
||
private function is_multisite() {
|
||
}
|
||
/**
|
||
* Error handler for `wp_die()` when the command is help to try to trap errors (db connection failure in particular) during WordPress load.
|
||
*/
|
||
public function help_wp_die_handler( $message ) {
|
||
}
|
||
/**
|
||
* Check whether there's a WP-CLI update available, and suggest update if so.
|
||
*/
|
||
private function auto_check_update() {
|
||
}
|
||
/**
|
||
* Get a suggestion on similar (sub)commands when the user entered an
|
||
* unknown (sub)command.
|
||
*
|
||
* @param string $entry User entry that didn't match an
|
||
* existing command.
|
||
* @param CompositeCommand $root_command Root command to start search for
|
||
* suggestions at.
|
||
*
|
||
* @return string Suggestion that fits the user entry, or an empty string.
|
||
*/
|
||
private function get_subcommand_suggestion( $entry, \WP_CLI\Dispatcher\CompositeCommand $root_command = null ) {
|
||
}
|
||
/**
|
||
* Recursive method to enumerate all known commands.
|
||
*
|
||
* @param CompositeCommand $command Composite command to recurse over.
|
||
* @param array $list Reference to list accumulating results.
|
||
* @param string $parent Parent command to use as prefix.
|
||
*/
|
||
private function enumerate_commands( \WP_CLI\Dispatcher\CompositeCommand $command, array &$list, $parent = '' ) {
|
||
}
|
||
/**
|
||
* Enables (almost) full PHP error reporting to stderr.
|
||
*/
|
||
private function enable_error_reporting() {
|
||
}
|
||
}
|
||
/**
|
||
* Class Autoloader.
|
||
*
|
||
* This is a custom autoloader to replace the functionality that we would
|
||
* normally get through the autoloader generated by Composer.
|
||
*
|
||
* We need this separate autoloader for the bootstrapping process, which happens
|
||
* before the Composer autoloader(s) could be loaded.
|
||
*
|
||
* @package WP_CLI
|
||
*/
|
||
class Autoloader {
|
||
|
||
/**
|
||
* Array containing the registered namespace structures
|
||
*
|
||
* @var array
|
||
*/
|
||
protected $namespaces = [];
|
||
/**
|
||
* Destructor for the Autoloader class.
|
||
*
|
||
* The destructor automatically unregisters the autoload callback function
|
||
* with the SPL autoload system.
|
||
*/
|
||
public function __destruct() {
|
||
}
|
||
/**
|
||
* Registers the autoload callback with the SPL autoload system.
|
||
*/
|
||
public function register() {
|
||
}
|
||
/**
|
||
* Unregisters the autoload callback with the SPL autoload system.
|
||
*/
|
||
public function unregister() {
|
||
}
|
||
/**
|
||
* Add a specific namespace structure with our custom autoloader.
|
||
*
|
||
* @param string $root Root namespace name.
|
||
* @param string $base_dir Directory containing the class files.
|
||
* @param string $prefix Prefix to be added before the class.
|
||
* @param string $suffix Suffix to be added after the class.
|
||
* @param boolean $lowercase Whether the class should be changed to
|
||
* lowercase.
|
||
* @param boolean $underscores Whether the underscores should be changed to
|
||
* hyphens.
|
||
*
|
||
* @return self
|
||
*/
|
||
public function add_namespace( $root, $base_dir, $prefix = '', $suffix = '.php', $lowercase = false, $underscores = false ) {
|
||
}
|
||
/**
|
||
* The autoload function that gets registered with the SPL Autoloader
|
||
* system.
|
||
*
|
||
* @param string $class The class that got requested by the spl_autoloader.
|
||
*/
|
||
public function autoload( $class ) {
|
||
}
|
||
/**
|
||
* Normalize a namespace root.
|
||
*
|
||
* @param string $root Namespace root that needs to be normalized.
|
||
*
|
||
* @return string Normalized namespace root.
|
||
*/
|
||
protected function normalize_root( $root ) {
|
||
}
|
||
/**
|
||
* Remove a leading backslash from a string.
|
||
*
|
||
* @param string $string String to remove the leading backslash from.
|
||
*
|
||
* @return string Modified string.
|
||
*/
|
||
protected function remove_leading_backslash( $string ) {
|
||
}
|
||
/**
|
||
* Make sure a string ends with a trailing backslash.
|
||
*
|
||
* @param string $string String to check the trailing backslash of.
|
||
*
|
||
* @return string Modified string.
|
||
*/
|
||
protected function add_trailing_backslash( $string ) {
|
||
}
|
||
/**
|
||
* Make sure a string ends with a trailing slash.
|
||
*
|
||
* @param string $string String to check the trailing slash of.
|
||
*
|
||
* @return string Modified string.
|
||
*/
|
||
protected function add_trailing_slash( $string ) {
|
||
}
|
||
}
|
||
/**
|
||
* Reads/writes to a filesystem cache
|
||
*/
|
||
class FileCache {
|
||
|
||
/**
|
||
* @var string cache path
|
||
*/
|
||
protected $root;
|
||
/**
|
||
* @var bool
|
||
*/
|
||
protected $enabled = true;
|
||
/**
|
||
* @var int files time to live
|
||
*/
|
||
protected $ttl;
|
||
/**
|
||
* @var int max total size
|
||
*/
|
||
protected $max_size;
|
||
/**
|
||
* @var string key allowed chars (regex class)
|
||
*/
|
||
protected $whitelist;
|
||
/**
|
||
* @param string $cache_dir location of the cache
|
||
* @param int $ttl cache files default time to live (expiration)
|
||
* @param int $max_size max total cache size
|
||
* @param string $whitelist List of characters that are allowed in path names (used in a regex character class)
|
||
*/
|
||
public function __construct( $cache_dir, $ttl, $max_size, $whitelist = 'a-z0-9._-' ) {
|
||
}
|
||
/**
|
||
* Cache is enabled
|
||
*
|
||
* @return bool
|
||
*/
|
||
public function is_enabled() {
|
||
}
|
||
/**
|
||
* Cache root
|
||
*
|
||
* @return string
|
||
*/
|
||
public function get_root() {
|
||
}
|
||
/**
|
||
* Check if a file is in cache and return its filename
|
||
*
|
||
* @param string $key cache key
|
||
* @param int $ttl time to live
|
||
* @return bool|string filename or false
|
||
*/
|
||
public function has( $key, $ttl = null ) {
|
||
}
|
||
/**
|
||
* Write to cache file
|
||
*
|
||
* @param string $key cache key
|
||
* @param string $contents file contents
|
||
* @return bool
|
||
*/
|
||
public function write( $key, $contents ) {
|
||
}
|
||
/**
|
||
* Read from cache file
|
||
*
|
||
* @param string $key cache key
|
||
* @param int $ttl time to live
|
||
* @return bool|string file contents or false
|
||
*/
|
||
public function read( $key, $ttl = null ) {
|
||
}
|
||
/**
|
||
* Copy a file into the cache
|
||
*
|
||
* @param string $key cache key
|
||
* @param string $source source filename
|
||
* @return bool
|
||
*/
|
||
public function import( $key, $source ) {
|
||
}
|
||
/**
|
||
* Copy a file out of the cache
|
||
*
|
||
* @param string $key cache key
|
||
* @param string $target target filename
|
||
* @param int $ttl time to live
|
||
* @return bool
|
||
*/
|
||
public function export( $key, $target, $ttl = null ) {
|
||
}
|
||
/**
|
||
* Remove file from cache
|
||
*
|
||
* @param string $key cache key
|
||
* @return bool
|
||
*/
|
||
public function remove( $key ) {
|
||
}
|
||
/**
|
||
* Clean cache based on time to live and max size
|
||
*
|
||
* @return bool
|
||
*/
|
||
public function clean() {
|
||
}
|
||
/**
|
||
* Remove all cached files.
|
||
*
|
||
* @return bool
|
||
*/
|
||
public function clear() {
|
||
}
|
||
/**
|
||
* Remove all cached files except for the newest version of one.
|
||
*
|
||
* @return bool
|
||
*/
|
||
public function prune() {
|
||
}
|
||
/**
|
||
* Ensure directory exists
|
||
*
|
||
* @param string $dir directory
|
||
* @return bool
|
||
*/
|
||
protected function ensure_dir_exists( $dir ) {
|
||
}
|
||
/**
|
||
* Prepare cache write
|
||
*
|
||
* @param string $key cache key
|
||
* @return bool|string filename or false
|
||
*/
|
||
protected function prepare_write( $key ) {
|
||
}
|
||
/**
|
||
* Validate cache key
|
||
*
|
||
* @param string $key cache key
|
||
* @return string relative filename
|
||
*/
|
||
protected function validate_key( $key ) {
|
||
}
|
||
/**
|
||
* Filename from key
|
||
*
|
||
* @param string $key
|
||
* @return string filename
|
||
*/
|
||
protected function filename( $key ) {
|
||
}
|
||
/**
|
||
* Get a Finder that iterates in cache root only the files
|
||
*
|
||
* @return Finder
|
||
*/
|
||
protected function get_finder() {
|
||
}
|
||
}
|
||
/**
|
||
* Manage caching with whitelisting
|
||
*
|
||
* @package WP_CLI
|
||
*/
|
||
class WpHttpCacheManager {
|
||
|
||
/**
|
||
* @var array map whitelisted urls to keys and ttls
|
||
*/
|
||
protected $whitelist = [];
|
||
/**
|
||
* @var FileCache
|
||
*/
|
||
protected $cache;
|
||
/**
|
||
* @param FileCache $cache
|
||
*/
|
||
public function __construct( \WP_CLI\FileCache $cache ) {
|
||
}
|
||
/**
|
||
* short circuit wp http api with cached file
|
||
*/
|
||
public function filter_pre_http_request( $response, $args, $url ) {
|
||
}
|
||
/**
|
||
* cache wp http api downloads
|
||
*
|
||
* @param array $response
|
||
* @param array $args
|
||
* @param string $url
|
||
*/
|
||
public function filter_http_response( $response, $args, $url ) {
|
||
}
|
||
/**
|
||
* whitelist a package url
|
||
*
|
||
* @param string $url
|
||
* @param string $group package group (themes, plugins, ...)
|
||
* @param string $slug package slug
|
||
* @param string $version package version
|
||
* @param int $ttl
|
||
*/
|
||
public function whitelist_package( $url, $group, $slug, $version, $ttl = null ) {
|
||
}
|
||
/**
|
||
* whitelist a url
|
||
*
|
||
* @param string $url
|
||
* @param string $key
|
||
* @param int $ttl
|
||
*/
|
||
public function whitelist_url( $url, $key = null, $ttl = null ) {
|
||
}
|
||
/**
|
||
* check if url is whitelisted
|
||
*
|
||
* @param string $url
|
||
* @return bool
|
||
*/
|
||
public function is_whitelisted( $url ) {
|
||
}
|
||
}
|
||
class Completions {
|
||
|
||
private $words;
|
||
private $opts = [];
|
||
public function __construct( $line ) {
|
||
}
|
||
private function get_command( $words ) {
|
||
}
|
||
private function get_global_parameters() {
|
||
}
|
||
private function add( $opt ) {
|
||
}
|
||
public function render() {
|
||
}
|
||
}
|
||
}
|
||
|
||
namespace {
|
||
/**
|
||
* Base class for WP-CLI commands
|
||
*
|
||
* @package wp-cli
|
||
*/
|
||
abstract class WP_CLI_Command {
|
||
|
||
public function __construct() {
|
||
}
|
||
}
|
||
/**
|
||
* Review current WP-CLI info, check for updates, or see defined aliases.
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # Display the version currently installed.
|
||
* $ wp cli version
|
||
* WP-CLI 0.24.1
|
||
*
|
||
* # Check for updates to WP-CLI.
|
||
* $ wp cli check-update
|
||
* Success: WP-CLI is at the latest version.
|
||
*
|
||
* # Update WP-CLI to the latest stable release.
|
||
* $ wp cli update
|
||
* You have version 0.24.0. Would you like to update to 0.24.1? [y/n] y
|
||
* Downloading from https://github.com/wp-cli/wp-cli/releases/download/v0.24.1/wp-cli-0.24.1.phar...
|
||
* New version works. Proceeding to replace.
|
||
* Success: Updated WP-CLI to 0.24.1.
|
||
*
|
||
* # Clear the internal WP-CLI cache.
|
||
* $ wp cli cache clear
|
||
* Success: Cache cleared.
|
||
*
|
||
* @when before_wp_load
|
||
*/
|
||
class CLI_Command extends \WP_CLI_Command {
|
||
|
||
private function command_to_array( $command ) {
|
||
}
|
||
/**
|
||
* Print WP-CLI version.
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # Display CLI version.
|
||
* $ wp cli version
|
||
* WP-CLI 0.24.1
|
||
*/
|
||
public function version() {
|
||
}
|
||
/**
|
||
* Print various details about the WP-CLI environment.
|
||
*
|
||
* Helpful for diagnostic purposes, this command shares:
|
||
*
|
||
* * OS information.
|
||
* * Shell information.
|
||
* * PHP binary used.
|
||
* * PHP binary version.
|
||
* * php.ini configuration file used (which is typically different than web).
|
||
* * WP-CLI root dir: where WP-CLI is installed (if non-Phar install).
|
||
* * WP-CLI global config: where the global config YAML file is located.
|
||
* * WP-CLI project config: where the project config YAML file is located.
|
||
* * WP-CLI version: currently installed version.
|
||
*
|
||
* See [config docs](https://wp-cli.org/config/) for more details on global
|
||
* and project config YAML files.
|
||
*
|
||
* ## OPTIONS
|
||
*
|
||
* [--format=<format>]
|
||
* : Render output in a particular format.
|
||
* ---
|
||
* default: list
|
||
* options:
|
||
* - list
|
||
* - json
|
||
* ---
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # Display various data about the CLI environment.
|
||
* $ wp cli info
|
||
* OS: Linux 4.10.0-42-generic #46~16.04.1-Ubuntu SMP Mon Dec 4 15:57:59 UTC 2017 x86_64
|
||
* Shell: /usr/bin/zsh
|
||
* PHP binary: /usr/bin/php
|
||
* PHP version: 7.1.12-1+ubuntu16.04.1+deb.sury.org+1
|
||
* php.ini used: /etc/php/7.1/cli/php.ini
|
||
* WP-CLI root dir: phar://wp-cli.phar
|
||
* WP-CLI packages dir: /home/person/.wp-cli/packages/
|
||
* WP-CLI global config:
|
||
* WP-CLI project config:
|
||
* WP-CLI version: 1.5.0
|
||
*/
|
||
public function info( $_, $assoc_args ) {
|
||
}
|
||
/**
|
||
* Check to see if there is a newer version of WP-CLI available.
|
||
*
|
||
* Queries the Github releases API. Returns available versions if there are
|
||
* updates available, or success message if using the latest release.
|
||
*
|
||
* ## OPTIONS
|
||
*
|
||
* [--patch]
|
||
* : Only list patch updates.
|
||
*
|
||
* [--minor]
|
||
* : Only list minor updates.
|
||
*
|
||
* [--major]
|
||
* : Only list major updates.
|
||
*
|
||
* [--field=<field>]
|
||
* : Prints the value of a single field for each update.
|
||
*
|
||
* [--fields=<fields>]
|
||
* : Limit the output to specific object fields. Defaults to version,update_type,package_url.
|
||
*
|
||
* [--format=<format>]
|
||
* : Render output in a particular format.
|
||
* ---
|
||
* default: table
|
||
* options:
|
||
* - table
|
||
* - csv
|
||
* - json
|
||
* - count
|
||
* - yaml
|
||
* ---
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # Check for update.
|
||
* $ wp cli check-update
|
||
* Success: WP-CLI is at the latest version.
|
||
*
|
||
* # Check for update and new version is available.
|
||
* $ wp cli check-update
|
||
* +---------+-------------+-------------------------------------------------------------------------------+
|
||
* | version | update_type | package_url |
|
||
* +---------+-------------+-------------------------------------------------------------------------------+
|
||
* | 0.24.1 | patch | https://github.com/wp-cli/wp-cli/releases/download/v0.24.1/wp-cli-0.24.1.phar |
|
||
* +---------+-------------+-------------------------------------------------------------------------------+
|
||
*
|
||
* @subcommand check-update
|
||
*/
|
||
public function check_update( $_, $assoc_args ) {
|
||
}
|
||
/**
|
||
* Update WP-CLI to the latest release.
|
||
*
|
||
* Default behavior is to check the releases API for the newest stable
|
||
* version, and prompt if one is available.
|
||
*
|
||
* Use `--stable` to install or reinstall the latest stable version.
|
||
*
|
||
* Use `--nightly` to install the latest built version of the master branch.
|
||
* While not recommended for production, nightly contains the latest and
|
||
* greatest, and should be stable enough for development and staging
|
||
* environments.
|
||
*
|
||
* Only works for the Phar installation mechanism.
|
||
*
|
||
* ## OPTIONS
|
||
*
|
||
* [--patch]
|
||
* : Only perform patch updates.
|
||
*
|
||
* [--minor]
|
||
* : Only perform minor updates.
|
||
*
|
||
* [--major]
|
||
* : Only perform major updates.
|
||
*
|
||
* [--stable]
|
||
* : Update to the latest stable release. Skips update check.
|
||
*
|
||
* [--nightly]
|
||
* : Update to the latest built version of the master branch. Potentially unstable.
|
||
*
|
||
* [--yes]
|
||
* : Do not prompt for confirmation.
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # Update CLI.
|
||
* $ wp cli update
|
||
* You have version 0.24.0. Would you like to update to 0.24.1? [y/n] y
|
||
* Downloading from https://github.com/wp-cli/wp-cli/releases/download/v0.24.1/wp-cli-0.24.1.phar...
|
||
* New version works. Proceeding to replace.
|
||
* Success: Updated WP-CLI to 0.24.1.
|
||
*/
|
||
public function update( $_, $assoc_args ) {
|
||
}
|
||
/**
|
||
* Returns update information.
|
||
*/
|
||
private function get_updates( $assoc_args ) {
|
||
}
|
||
/**
|
||
* Dump the list of global parameters, as JSON or in var_export format.
|
||
*
|
||
* ## OPTIONS
|
||
*
|
||
* [--with-values]
|
||
* : Display current values also.
|
||
*
|
||
* [--format=<format>]
|
||
* : Render output in a particular format.
|
||
* ---
|
||
* default: json
|
||
* options:
|
||
* - var_export
|
||
* - json
|
||
* ---
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # Dump the list of global parameters.
|
||
* $ wp cli param-dump --format=var_export
|
||
* array (
|
||
* 'path' =>
|
||
* array (
|
||
* 'runtime' => '=<path>',
|
||
* 'file' => '<path>',
|
||
* 'synopsis' => '',
|
||
* 'default' => NULL,
|
||
* 'multiple' => false,
|
||
* 'desc' => 'Path to the WordPress files.',
|
||
* ),
|
||
* 'url' =>
|
||
* array (
|
||
*
|
||
* @subcommand param-dump
|
||
*/
|
||
public function param_dump( $_, $assoc_args ) {
|
||
}
|
||
/**
|
||
* Dump the list of installed commands, as JSON.
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # Dump the list of installed commands.
|
||
* $ wp cli cmd-dump
|
||
* {"name":"wp","description":"Manage WordPress through the command-line.","longdesc":"\n\n## GLOBAL PARAMETERS\n\n --path=<path>\n Path to the WordPress files.\n\n --ssh=<ssh>\n Perform operation against a remote server over SSH (or a container using scheme of "docker" or "docker-compose").\n\n --url=<url>\n Pretend request came from given URL. In multisite, this argument is how the target site is specified. \n\n --user=<id|login|email>\n
|
||
*
|
||
* @subcommand cmd-dump
|
||
*/
|
||
public function cmd_dump() {
|
||
}
|
||
/**
|
||
* Generate tab completion strings.
|
||
*
|
||
* ## OPTIONS
|
||
*
|
||
* --line=<line>
|
||
* : The current command line to be executed.
|
||
*
|
||
* --point=<point>
|
||
* : The index to the current cursor position relative to the beginning of the command.
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # Generate tab completion strings.
|
||
* $ wp cli completions --line='wp eva' --point=100
|
||
* eval
|
||
* eval-file
|
||
*/
|
||
public function completions( $_, $assoc_args ) {
|
||
}
|
||
/**
|
||
* Get a string representing the type of update being checked for.
|
||
*/
|
||
private function get_update_type_str( $assoc_args ) {
|
||
}
|
||
/**
|
||
* Detects if a command exists
|
||
*
|
||
* This commands checks if a command is registered with WP-CLI.
|
||
* If the command is found then it returns with exit status 0.
|
||
* If the command doesn't exist, then it will exit with status 1.
|
||
*
|
||
* ## OPTIONS
|
||
* <command_name>...
|
||
* : The command
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # The "site delete" command is registered.
|
||
* $ wp cli has-command "site delete"
|
||
* $ echo $?
|
||
* 0
|
||
*
|
||
* # The "foo bar" command is not registered.
|
||
* $ wp cli has-command "foo bar"
|
||
* $ echo $?
|
||
* 1
|
||
*
|
||
* @subcommand has-command
|
||
*
|
||
* @when after_wp_load
|
||
*/
|
||
public function has_command( $_, $assoc_args ) {
|
||
}
|
||
}
|
||
/**
|
||
* Manages the internal WP-CLI cache,.
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # Remove all cached files.
|
||
* $ wp cli cache clear
|
||
* Success: Cache cleared.
|
||
*
|
||
* # Remove all cached files except for the newest version of each one.
|
||
* $ wp cli cache prune
|
||
* Success: Cache pruned.
|
||
*
|
||
* @when before_wp_load
|
||
*/
|
||
class CLI_Cache_Command extends \WP_CLI_Command {
|
||
|
||
/**
|
||
* Clear the internal cache.
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* $ wp cli cache clear
|
||
* Success: Cache cleared.
|
||
*
|
||
* @subcommand clear
|
||
*/
|
||
public function cache_clear() {
|
||
}
|
||
/**
|
||
* Prune the internal cache.
|
||
*
|
||
* Removes all cached files except for the newest version of each one.
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* $ wp cli cache prune
|
||
* Success: Cache pruned.
|
||
*
|
||
* @subcommand prune
|
||
*/
|
||
public function cache_prune() {
|
||
}
|
||
}
|
||
/**
|
||
* Retrieves, sets and updates aliases for WordPress Installations.
|
||
*
|
||
* Aliases are shorthand references to WordPress installs. For instance,
|
||
* `@dev` could refer to a development install and `@prod` could refer to a production install.
|
||
* This command gives you and option to add, update and delete, the registered aliases you have available.
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # List alias information.
|
||
* $ wp cli alias list
|
||
* list
|
||
* ---
|
||
*
|
||
* @all: Run command against every registered alias.
|
||
* @local:
|
||
* user: wpcli
|
||
* path: /Users/wpcli/sites/testsite
|
||
*
|
||
* # Get alias information.
|
||
* $ wp cli alias get @dev
|
||
* ssh: dev@somedeve.env:12345/home/dev/
|
||
*
|
||
* # Add alias.
|
||
* $ wp cli alias add prod --set-ssh=login@host --set-path=/path/to/wordpress/install/ --set-user=wpcli
|
||
* Success: Added '@prod' alias.
|
||
*
|
||
* # Update alias.
|
||
* $ wp cli alias update @prod --set-user=newuser --set-path=/new/path/to/wordpress/install/
|
||
* Success: Updated 'prod' alias.
|
||
*
|
||
* # Delete alias.
|
||
* $ wp cli alias delete @prod
|
||
* Success: Deleted '@prod' alias.
|
||
*
|
||
* @package wp-cli
|
||
* @when before_wp_load
|
||
*/
|
||
class CLI_Alias_Command extends \WP_CLI_Command {
|
||
|
||
/**
|
||
* List available WP-CLI aliases.
|
||
*
|
||
* ## OPTIONS
|
||
*
|
||
* [--format=<format>]
|
||
* : Render output in a particular format.
|
||
* ---
|
||
* default: yaml
|
||
* options:
|
||
* - yaml
|
||
* - json
|
||
* - var_export
|
||
* ---
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # List all available aliases.
|
||
* $ wp cli alias list
|
||
* ---
|
||
*
|
||
* @all: Run command against every registered alias.
|
||
* @prod:
|
||
* ssh: runcommand@runcommand.io~/webapps/production
|
||
* @dev:
|
||
* ssh: vagrant@192.168.50.10/srv/www/runcommand.dev
|
||
* @both:
|
||
* - @prod
|
||
* - @dev
|
||
*
|
||
* @subcommand list
|
||
*/
|
||
public function list_( $args, $assoc_args ) {
|
||
}
|
||
/**
|
||
* Gets the value for an alias.
|
||
*
|
||
* ## OPTIONS
|
||
*
|
||
* <key>
|
||
* : Key for the alias.
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # Get alias.
|
||
* $ wp cli alias get @prod
|
||
* ssh: dev@somedeve.env:12345/home/dev/
|
||
*/
|
||
public function get( $args, $assoc_args ) {
|
||
}
|
||
/**
|
||
* Creates an alias.
|
||
*
|
||
* ## OPTIONS
|
||
*
|
||
* <key>
|
||
* : Key for the alias.
|
||
*
|
||
* [--set-user=<user>]
|
||
* : Set user for alias.
|
||
*
|
||
* [--set-url=<url>]
|
||
* : Set url for alias.
|
||
*
|
||
* [--set-path=<path>]
|
||
* : Set path for alias.
|
||
*
|
||
* [--set-ssh=<ssh>]
|
||
* : Set ssh for alias.
|
||
*
|
||
* [--set-http=<http>]
|
||
* : Set http for alias.
|
||
*
|
||
* [--grouping=<grouping>]
|
||
* : For grouping multiple aliases.
|
||
*
|
||
* [--config=<config>]
|
||
* : Config file to be considered for operations.
|
||
* ---
|
||
* default: global
|
||
* options:
|
||
* - global
|
||
* - project
|
||
* ---
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # Add alias to global config.
|
||
* $ wp cli alias add @prod --set-ssh=login@host --set-path=/path/to/wordpress/install/ --set-user=wpcli
|
||
* Success: Added '@prod' alias.
|
||
*
|
||
* # Add alias to project config.
|
||
* $ wp cli alias add @prod --set-ssh=login@host --set-path=/path/to/wordpress/install/ --set-user=wpcli --config=project
|
||
* Success: Added '@prod' alias.
|
||
*
|
||
* # Add group of aliases.
|
||
* $ wp cli alias add @multiservers --grouping=servera,serverb
|
||
* Success: Added '@multiservers' alias.
|
||
*/
|
||
public function add( $args, $assoc_args ) {
|
||
}
|
||
/**
|
||
* Deletes an alias.
|
||
*
|
||
* ## OPTIONS
|
||
*
|
||
* <key>
|
||
* : Key for the alias.
|
||
*
|
||
* [--config=<config>]
|
||
* : Config file to be considered for operations.
|
||
* ---
|
||
* options:
|
||
* - global
|
||
* - project
|
||
* ---
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # Delete alias.
|
||
* $ wp cli alias delete @prod
|
||
* Success: Deleted '@prod' alias.
|
||
*
|
||
* # Delete project alias.
|
||
* $ wp cli alias delete @prod --config=project
|
||
* Success: Deleted '@prod' alias.
|
||
*/
|
||
public function delete( $args, $assoc_args ) {
|
||
}
|
||
/**
|
||
* Updates an alias.
|
||
*
|
||
* ## OPTIONS
|
||
*
|
||
* <key>
|
||
* : Key for the alias.
|
||
*
|
||
* [--set-user=<user>]
|
||
* : Set user for alias.
|
||
*
|
||
* [--set-url=<url>]
|
||
* : Set url for alias.
|
||
*
|
||
* [--set-path=<path>]
|
||
* : Set path for alias.
|
||
*
|
||
* [--set-ssh=<ssh>]
|
||
* : Set ssh for alias.
|
||
*
|
||
* [--set-http=<http>]
|
||
* : Set http for alias.
|
||
*
|
||
* [--grouping=<grouping>]
|
||
* : For grouping multiple aliases.
|
||
*
|
||
* [--config=<config>]
|
||
* : Config file to be considered for operations.
|
||
* ---
|
||
* options:
|
||
* - global
|
||
* - project
|
||
* ---
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # Update alias.
|
||
* $ wp cli alias update @prod --set-user=newuser --set-path=/new/path/to/wordpress/install/
|
||
* Success: Updated 'prod' alias.
|
||
*
|
||
* # Update project alias.
|
||
* $ wp cli alias update @prod --set-user=newuser --set-path=/new/path/to/wordpress/install/ --config=project
|
||
* Success: Updated 'prod' alias.
|
||
*/
|
||
public function update( $args, $assoc_args ) {
|
||
}
|
||
/**
|
||
* Get config path and aliases data based on config type.
|
||
*
|
||
* @param string $config Type of config to get data from.
|
||
* @param string $alias Alias to be used for Add/Update/Delete.
|
||
*
|
||
* @return array Config Path and Aliases in it.
|
||
*/
|
||
private function get_aliases_data( $config, $alias ) {
|
||
}
|
||
/**
|
||
* Check if the config file exists and is writable.
|
||
*
|
||
* @param string $config_path Path to config file.
|
||
*
|
||
* @return void
|
||
*/
|
||
private function validate_config_file( $config_path ) {
|
||
}
|
||
/**
|
||
* Return aliases array.
|
||
*
|
||
* @param array $aliases Current aliases data.
|
||
* @param string $alias Name of alias.
|
||
* @param array $key_args Associative arguments.
|
||
* @param bool $is_grouping Check if its a grouping operation.
|
||
* @param string $grouping Grouping value.
|
||
* @param bool $is_update Is this an update operation?
|
||
*
|
||
* @return mixed
|
||
*/
|
||
private function build_aliases( $aliases, $alias, $assoc_args, $is_grouping, $grouping = '', $is_update = \false ) {
|
||
}
|
||
/**
|
||
* Validate input of passed arguments.
|
||
*
|
||
* @param array $assoc_args Arguments array.
|
||
* @param string $grouping Grouping argument value.
|
||
*
|
||
* @throws WP_CLI\ExitException
|
||
*/
|
||
private function validate_input( $assoc_args, $grouping ) {
|
||
}
|
||
/**
|
||
* Validate alias type before update.
|
||
*
|
||
* @param array $aliases Existing aliases data.
|
||
* @param string $alias Alias Name.
|
||
* @param array $assoc_args Arguments array.
|
||
* @param string $grouping Grouping argument value.
|
||
*
|
||
* @throws WP_CLI\ExitException
|
||
*/
|
||
private function validate_alias_type( $aliases, $alias, $assoc_args, $grouping ) {
|
||
}
|
||
/**
|
||
* Save aliases data to config file.
|
||
*
|
||
* @param array $aliases Current aliases data.
|
||
* @param string $alias Name of alias.
|
||
* @param string $config_path Path to config file.
|
||
* @param string $operation Current operation string fro message.
|
||
*/
|
||
private function process_aliases( $aliases, $alias, $config_path, $operation = '' ) {
|
||
}
|
||
}
|
||
class Help_Command extends \WP_CLI_Command {
|
||
|
||
/**
|
||
* Get help on WP-CLI, or on a specific command.
|
||
*
|
||
* ## OPTIONS
|
||
*
|
||
* [<command>...]
|
||
* : Get help on a specific command.
|
||
*
|
||
* ## EXAMPLES
|
||
*
|
||
* # get help for `core` command
|
||
* wp help core
|
||
*
|
||
* # get help for `core download` subcommand
|
||
* wp help core download
|
||
*/
|
||
public function __invoke( $args, $assoc_args ) {
|
||
}
|
||
private static function show_help( $command ) {
|
||
}
|
||
private static function rewrap_param_desc( $matches ) {
|
||
}
|
||
private static function indent( $whitespace, $text ) {
|
||
}
|
||
private static function pass_through_pager( $out ) {
|
||
}
|
||
private static function get_initial_markdown( $command ) {
|
||
}
|
||
private static function render_subcommands( $command ) {
|
||
}
|
||
private static function get_max_len( $strings ) {
|
||
}
|
||
/**
|
||
* Parse reference links from longdescription.
|
||
*
|
||
* @param string $longdesc The longdescription from the `$command->get_longdesc()`.
|
||
* @return string The longdescription which has links as footnote.
|
||
*/
|
||
private static function parse_reference_links( $longdesc ) {
|
||
}
|
||
}
|
||
/**
|
||
* Various utilities for WP-CLI commands.
|
||
*/
|
||
class WP_CLI {
|
||
|
||
private static $configurator;
|
||
private static $logger;
|
||
private static $hooks = [];
|
||
private static $hooks_passed = [];
|
||
private static $capture_exit = \false;
|
||
private static $deferred_additions = [];
|
||
/**
|
||
* Set the logger instance.
|
||
*
|
||
* @param object $logger
|
||
*/
|
||
public static function set_logger( $logger ) {
|
||
}
|
||
/**
|
||
* Get the Configurator instance
|
||
*
|
||
* @return \WP_CLI\Configurator
|
||
*/
|
||
public static function get_configurator() {
|
||
}
|
||
public static function get_root_command() {
|
||
}
|
||
public static function get_runner() {
|
||
}
|
||
/**
|
||
* @return FileCache
|
||
*/
|
||
public static function get_cache() {
|
||
}
|
||
/**
|
||
* Set the context in which WP-CLI should be run
|
||
*/
|
||
public static function set_url( $url ) {
|
||
}
|
||
private static function set_url_params( $url_parts ) {
|
||
}
|
||
/**
|
||
* @return WpHttpCacheManager
|
||
*/
|
||
public static function get_http_cache_manager() {
|
||
}
|
||
/**
|
||
* Colorize a string for output.
|
||
*
|
||
* Yes, you can change the color of command line text too. For instance,
|
||
* here's how `WP_CLI::success()` colorizes "Success: "
|
||
*
|
||
* ```
|
||
* WP_CLI::colorize( "%GSuccess:%n " )
|
||
* ```
|
||
*
|
||
* Uses `\cli\Colors::colorize()` to transform color tokens to display
|
||
* settings. Choose from the following tokens (and note 'reset'):
|
||
*
|
||
* * %y => ['color' => 'yellow'],
|
||
* * %g => ['color' => 'green'],
|
||
* * %b => ['color' => 'blue'],
|
||
* * %r => ['color' => 'red'],
|
||
* * %p => ['color' => 'magenta'],
|
||
* * %m => ['color' => 'magenta'],
|
||
* * %c => ['color' => 'cyan'],
|
||
* * %w => ['color' => 'grey'],
|
||
* * %k => ['color' => 'black'],
|
||
* * %n => ['color' => 'reset'],
|
||
* * %Y => ['color' => 'yellow', 'style' => 'bright'],
|
||
* * %G => ['color' => 'green', 'style' => 'bright'],
|
||
* * %B => ['color' => 'blue', 'style' => 'bright'],
|
||
* * %R => ['color' => 'red', 'style' => 'bright'],
|
||
* * %P => ['color' => 'magenta', 'style' => 'bright'],
|
||
* * %M => ['color' => 'magenta', 'style' => 'bright'],
|
||
* * %C => ['color' => 'cyan', 'style' => 'bright'],
|
||
* * %W => ['color' => 'grey', 'style' => 'bright'],
|
||
* * %K => ['color' => 'black', 'style' => 'bright'],
|
||
* * %N => ['color' => 'reset', 'style' => 'bright'],
|
||
* * %3 => ['background' => 'yellow'],
|
||
* * %2 => ['background' => 'green'],
|
||
* * %4 => ['background' => 'blue'],
|
||
* * %1 => ['background' => 'red'],
|
||
* * %5 => ['background' => 'magenta'],
|
||
* * %6 => ['background' => 'cyan'],
|
||
* * %7 => ['background' => 'grey'],
|
||
* * %0 => ['background' => 'black'],
|
||
* * %F => ['style' => 'blink'],
|
||
* * %U => ['style' => 'underline'],
|
||
* * %8 => ['style' => 'inverse'],
|
||
* * %9 => ['style' => 'bright'],
|
||
* * %_ => ['style' => 'bright']
|
||
*
|
||
* @access public
|
||
* @category Output
|
||
*
|
||
* @param string $string String to colorize for output, with color tokens.
|
||
* @return string Colorized string.
|
||
*/
|
||
public static function colorize( $string ) {
|
||
}
|
||
/**
|
||
* Schedule a callback to be executed at a certain point.
|
||
*
|
||
* Hooks conceptually are very similar to WordPress actions. WP-CLI hooks
|
||
* are typically called before WordPress is loaded.
|
||
*
|
||
* WP-CLI hooks include:
|
||
*
|
||
* * `before_add_command:<command>` - Before the command is added.
|
||
* * `after_add_command:<command>` - After the command was added.
|
||
* * `before_invoke:<command>` - Just before a command is invoked.
|
||
* * `after_invoke:<command>` - Just after a command is invoked.
|
||
* * `find_command_to_run_pre` - Just before WP-CLI finds the command to run.
|
||
* * `before_wp_load` - Just before the WP load process begins.
|
||
* * `before_wp_config_load` - After wp-config.php has been located.
|
||
* * `after_wp_config_load` - After wp-config.php has been loaded into scope.
|
||
* * `after_wp_load` - Just after the WP load process has completed.
|
||
* * `before_run_command` - Just before the command is executed.
|
||
*
|
||
* WP-CLI commands can create their own hooks with `WP_CLI::do_hook()`.
|
||
*
|
||
* If additional arguments are passed through the `WP_CLI::do_hook()` call,
|
||
* these will be passed on to the callback provided by `WP_CLI::add_hook()`.
|
||
*
|
||
* ```
|
||
* # `wp network meta` confirms command is executing in multisite context.
|
||
* WP_CLI::add_command( 'network meta', 'Network_Meta_Command', array(
|
||
* 'before_invoke' => function () {
|
||
* if ( !is_multisite() ) {
|
||
* WP_CLI::error( 'This is not a multisite installation.' );
|
||
* }
|
||
* }
|
||
* ) );
|
||
* ```
|
||
*
|
||
* @access public
|
||
* @category Registration
|
||
*
|
||
* @param string $when Identifier for the hook.
|
||
* @param mixed $callback Callback to execute when hook is called.
|
||
* @return null
|
||
*/
|
||
public static function add_hook( $when, $callback ) {
|
||
}
|
||
/**
|
||
* Execute callbacks registered to a given hook.
|
||
*
|
||
* See `WP_CLI::add_hook()` for details on WP-CLI's internal hook system.
|
||
* Commands can provide and call their own hooks.
|
||
*
|
||
* @access public
|
||
* @category Registration
|
||
*
|
||
* @param string $when Identifier for the hook.
|
||
* @param mixed ... Optional. Arguments that will be passed onto the
|
||
* callback provided by `WP_CLI::add_hook()`.
|
||
* @return null
|
||
*/
|
||
public static function do_hook( $when ) {
|
||
}
|
||
/**
|
||
* Add a callback to a WordPress action or filter.
|
||
*
|
||
* `add_action()` without needing access to `add_action()`. If WordPress is
|
||
* already loaded though, you should use `add_action()` (and `add_filter()`)
|
||
* instead.
|
||
*
|
||
* @access public
|
||
* @category Registration
|
||
*
|
||
* @param string $tag Named WordPress action or filter.
|
||
* @param mixed $function_to_add Callable to execute when the action or filter is evaluated.
|
||
* @param integer $priority Priority to add the callback as.
|
||
* @param integer $accepted_args Number of arguments to pass to callback.
|
||
* @return true
|
||
*/
|
||
public static function add_wp_hook( $tag, $function_to_add, $priority = 10, $accepted_args = 1 ) {
|
||
}
|
||
/**
|
||
* Build Unique ID for storage and retrieval.
|
||
*
|
||
* Essentially _wp_filter_build_unique_id() without needing access to _wp_filter_build_unique_id()
|
||
*/
|
||
private static function wp_hook_build_unique_id( $tag, $function, $priority ) {
|
||
}
|
||
/**
|
||
* Register a command to WP-CLI.
|
||
*
|
||
* WP-CLI supports using any callable class, function, or closure as a
|
||
* command. `WP_CLI::add_command()` is used for both internal and
|
||
* third-party command registration.
|
||
*
|
||
* Command arguments are parsed from PHPDoc by default, but also can be
|
||
* supplied as an optional third argument during registration.
|
||
*
|
||
* ```
|
||
* # Register a custom 'foo' command to output a supplied positional param.
|
||
* #
|
||
* # $ wp foo bar --append=qux
|
||
* # Success: bar qux
|
||
*
|
||
* /**
|
||
* * My awesome closure command
|
||
* *
|
||
* * <message>
|
||
* * : An awesome message to display
|
||
* *
|
||
* * --append=<message>
|
||
* * : An awesome message to append to the original message.
|
||
* *
|
||
* * @when before_wp_load
|
||
* *\/
|
||
* $foo = function( $args, $assoc_args ) {
|
||
* WP_CLI::success( $args[0] . ' ' . $assoc_args['append'] );
|
||
* };
|
||
* WP_CLI::add_command( 'foo', $foo );
|
||
* ```
|
||
*
|
||
* @access public
|
||
* @category Registration
|
||
*
|
||
* @param string $name Name for the command (e.g. "post list" or "site empty").
|
||
* @param callable $callable Command implementation as a class, function or closure.
|
||
* @param array $args {
|
||
* Optional. An associative array with additional registration parameters.
|
||
*
|
||
* @type callable $before_invoke Callback to execute before invoking the command.
|
||
* @type callable $after_invoke Callback to execute after invoking the command.
|
||
* @type string $shortdesc Short description (80 char or less) for the command.
|
||
* @type string $longdesc Description of arbitrary length for examples, etc.
|
||
* @type string $synopsis The synopsis for the command (string or array).
|
||
* @type string $when Execute callback on a named WP-CLI hook (e.g. before_wp_load).
|
||
* @type bool $is_deferred Whether the command addition had already been deferred.
|
||
* }
|
||
* @return bool True on success, false if deferred, hard error if registration failed.
|
||
*/
|
||
public static function add_command( $name, $callable, $args = [] ) {
|
||
}
|
||
/**
|
||
* Defer command addition for a sub-command if the parent command is not yet
|
||
* registered.
|
||
*
|
||
* @param string $name Name for the sub-command.
|
||
* @param string $parent Name for the parent command.
|
||
* @param string $callable Command implementation as a class, function or closure.
|
||
* @param array $args Optional. See `WP_CLI::add_command()` for details.
|
||
*/
|
||
private static function defer_command_addition( $name, $parent, $callable, $args = [] ) {
|
||
}
|
||
/**
|
||
* Get the list of outstanding deferred command additions.
|
||
*
|
||
* @return array Array of outstanding command additions.
|
||
*/
|
||
public static function get_deferred_additions() {
|
||
}
|
||
/**
|
||
* Remove a command addition from the list of outstanding deferred additions.
|
||
*/
|
||
public static function remove_deferred_addition( $name ) {
|
||
}
|
||
/**
|
||
* Display informational message without prefix, and ignore `--quiet`.
|
||
*
|
||
* Message is written to STDOUT. `WP_CLI::log()` is typically recommended;
|
||
* `WP_CLI::line()` is included for historical compat.
|
||
*
|
||
* @access public
|
||
* @category Output
|
||
*
|
||
* @param string $message Message to display to the end user.
|
||
* @return null
|
||
*/
|
||
public static function line( $message = '' ) {
|
||
}
|
||
/**
|
||
* Display informational message without prefix.
|
||
*
|
||
* Message is written to STDOUT, or discarded when `--quiet` flag is supplied.
|
||
*
|
||
* ```
|
||
* # `wp cli update` lets user know of each step in the update process.
|
||
* WP_CLI::log( sprintf( 'Downloading from %s...', $download_url ) );
|
||
* ```
|
||
*
|
||
* @access public
|
||
* @category Output
|
||
*
|
||
* @param string $message Message to write to STDOUT.
|
||
*/
|
||
public static function log( $message ) {
|
||
}
|
||
/**
|
||
* Display success message prefixed with "Success: ".
|
||
*
|
||
* Success message is written to STDOUT.
|
||
*
|
||
* Typically recommended to inform user of successful script conclusion.
|
||
*
|
||
* ```
|
||
* # wp rewrite flush expects 'rewriteRules' option to be set after flush.
|
||
* flush_rewriteRules( \WP_CLI\Utils\get_flag_value( $assoc_args, 'hard' ) );
|
||
* if ( ! get_option( 'rewriteRules' ) ) {
|
||
* WP_CLI::warning( "Rewrite rules are empty." );
|
||
* } else {
|
||
* WP_CLI::success( 'Rewrite rules flushed.' );
|
||
* }
|
||
* ```
|
||
*
|
||
* @access public
|
||
* @category Output
|
||
*
|
||
* @param string $message Message to write to STDOUT.
|
||
* @return null
|
||
*/
|
||
public static function success( $message ) {
|
||
}
|
||
/**
|
||
* Display debug message prefixed with "Debug: " when `--debug` is used.
|
||
*
|
||
* Debug message is written to STDERR, and includes script execution time.
|
||
*
|
||
* Helpful for optionally showing greater detail when needed. Used throughout
|
||
* WP-CLI bootstrap process for easier debugging and profiling.
|
||
*
|
||
* ```
|
||
* # Called in `WP_CLI\Runner::set_wp_root()`.
|
||
* private static function set_wp_root( $path ) {
|
||
* define( 'ABSPATH', Utils\trailingslashit( $path ) );
|
||
* WP_CLI::debug( 'ABSPATH defined: ' . ABSPATH );
|
||
* $_SERVER['DOCUMENT_ROOT'] = realpath( $path );
|
||
* }
|
||
*
|
||
* # Debug details only appear when `--debug` is used.
|
||
* # $ wp --debug
|
||
* # [...]
|
||
* # Debug: ABSPATH defined: /srv/www/wordpress-develop.dev/src/ (0.225s)
|
||
* ```
|
||
*
|
||
* @access public
|
||
* @category Output
|
||
*
|
||
* @param string $message Message to write to STDERR.
|
||
* @param string|bool $group Organize debug message to a specific group.
|
||
* Use `false` to not group the message.
|
||
* @return null
|
||
*/
|
||
public static function debug( $message, $group = \false ) {
|
||
}
|
||
/**
|
||
* Display warning message prefixed with "Warning: ".
|
||
*
|
||
* Warning message is written to STDERR.
|
||
*
|
||
* Use instead of `WP_CLI::debug()` when script execution should be permitted
|
||
* to continue.
|
||
*
|
||
* ```
|
||
* # `wp plugin activate` skips activation when plugin is network active.
|
||
* $status = $this->get_status( $plugin->file );
|
||
* // Network-active is the highest level of activation status
|
||
* if ( 'active-network' === $status ) {
|
||
* WP_CLI::warning( "Plugin '{$plugin->name}' is already network active." );
|
||
* continue;
|
||
* }
|
||
* ```
|
||
*
|
||
* @access public
|
||
* @category Output
|
||
*
|
||
* @param string $message Message to write to STDERR.
|
||
* @return null
|
||
*/
|
||
public static function warning( $message ) {
|
||
}
|
||
/**
|
||
* Display error message prefixed with "Error: " and exit script.
|
||
*
|
||
* Error message is written to STDERR. Defaults to halting script execution
|
||
* with return code 1.
|
||
*
|
||
* Use `WP_CLI::warning()` instead when script execution should be permitted
|
||
* to continue.
|
||
*
|
||
* ```
|
||
* # `wp cache flush` considers flush failure to be a fatal error.
|
||
* if ( false === wp_cache_flush() ) {
|
||
* WP_CLI::error( 'The object cache could not be flushed.' );
|
||
* }
|
||
* ```
|
||
*
|
||
* @access public
|
||
* @category Output
|
||
*
|
||
* @param string|WP_Error $message Message to write to STDERR.
|
||
* @param boolean|integer $exit True defaults to exit(1).
|
||
* @return null
|
||
*/
|
||
public static function error( $message, $exit = \true ) {
|
||
}
|
||
/**
|
||
* Halt script execution with a specific return code.
|
||
*
|
||
* Permits script execution to be overloaded by `WP_CLI::runcommand()`
|
||
*
|
||
* @access public
|
||
* @category Output
|
||
*
|
||
* @param integer $return_code
|
||
*/
|
||
public static function halt( $return_code ) {
|
||
}
|
||
/**
|
||
* Display a multi-line error message in a red box. Doesn't exit script.
|
||
*
|
||
* Error message is written to STDERR.
|
||
*
|
||
* @access public
|
||
* @category Output
|
||
*
|
||
* @param array $message Multi-line error message to be displayed.
|
||
*/
|
||
public static function error_multi_line( $message_lines ) {
|
||
}
|
||
/**
|
||
* Ask for confirmation before running a destructive operation.
|
||
*
|
||
* If 'y' is provided to the question, the script execution continues. If
|
||
* 'n' or any other response is provided to the question, script exits.
|
||
*
|
||
* ```
|
||
* # `wp db drop` asks for confirmation before dropping the database.
|
||
*
|
||
* WP_CLI::confirm( "Are you sure you want to drop the database?", $assoc_args );
|
||
* ```
|
||
*
|
||
* @access public
|
||
* @category Input
|
||
*
|
||
* @param string $question Question to display before the prompt.
|
||
* @param array $assoc_args Skips prompt if 'yes' is provided.
|
||
*/
|
||
public static function confirm( $question, $assoc_args = [] ) {
|
||
}
|
||
/**
|
||
* Read value from a positional argument or from STDIN.
|
||
*
|
||
* @param array $args The list of positional arguments.
|
||
* @param int $index At which position to check for the value.
|
||
*
|
||
* @return string
|
||
*/
|
||
public static function get_value_from_arg_or_stdin( $args, $index ) {
|
||
}
|
||
/**
|
||
* Read a value, from various formats.
|
||
*
|
||
* @access public
|
||
* @category Input
|
||
*
|
||
* @param mixed $value
|
||
* @param array $assoc_args
|
||
*/
|
||
public static function read_value( $raw_value, $assoc_args = [] ) {
|
||
}
|
||
/**
|
||
* Display a value, in various formats
|
||
*
|
||
* @param mixed $value Value to display.
|
||
* @param array $assoc_args Arguments passed to the command, determining format.
|
||
*/
|
||
public static function print_value( $value, $assoc_args = [] ) {
|
||
}
|
||
/**
|
||
* Convert a wp_error into a string
|
||
*
|
||
* @param mixed $errors
|
||
* @return string
|
||
*/
|
||
public static function error_to_string( $errors ) {
|
||
}
|
||
/**
|
||
* Launch an arbitrary external process that takes over I/O.
|
||
*
|
||
* ```
|
||
* # `wp core download` falls back to the `tar` binary when PharData isn't available
|
||
* if ( ! class_exists( 'PharData' ) ) {
|
||
* $cmd = "tar xz --strip-components=1 --directory=%s -f $tarball";
|
||
* WP_CLI::launch( Utils\esc_cmd( $cmd, $dest ) );
|
||
* return;
|
||
* }
|
||
* ```
|
||
*
|
||
* @access public
|
||
* @category Execution
|
||
*
|
||
* @param string $command External process to launch.
|
||
* @param boolean $exit_on_error Whether to exit if the command returns an elevated return code.
|
||
* @param boolean $return_detailed Whether to return an exit status (default) or detailed execution results.
|
||
* @return int|WP_CLI\ProcessRun The command exit status, or a ProcessRun object for full details.
|
||
*/
|
||
public static function launch( $command, $exit_on_error = \true, $return_detailed = \false ) {
|
||
}
|
||
/**
|
||
* Run a WP-CLI command in a new process reusing the current runtime arguments.
|
||
*
|
||
* Use `WP_CLI::runcommand()` instead, which is easier to use and works better.
|
||
*
|
||
* Note: While this command does persist a limited set of runtime arguments,
|
||
* it *does not* persist environment variables. Practically speaking, WP-CLI
|
||
* packages won't be loaded when using WP_CLI::launch_self() because the
|
||
* launched process doesn't have access to the current process $HOME.
|
||
*
|
||
* @access public
|
||
* @category Execution
|
||
*
|
||
* @param string $command WP-CLI command to call.
|
||
* @param array $args Positional arguments to include when calling the command.
|
||
* @param array $assoc_args Associative arguments to include when calling the command.
|
||
* @param bool $exit_on_error Whether to exit if the command returns an elevated return code.
|
||
* @param bool $return_detailed Whether to return an exit status (default) or detailed execution results.
|
||
* @param array $runtime_args Override one or more global args (path,url,user,allow-root)
|
||
* @return int|WP_CLI\ProcessRun The command exit status, or a ProcessRun instance
|
||
*/
|
||
public static function launch_self( $command, $args = [], $assoc_args = [], $exit_on_error = \true, $return_detailed = \false, $runtime_args = [] ) {
|
||
}
|
||
/**
|
||
* Get the path to the PHP binary used when executing WP-CLI.
|
||
*
|
||
* Environment values permit specific binaries to be indicated.
|
||
*
|
||
* Note: moved to Utils, left for BC.
|
||
*
|
||
* @access public
|
||
* @category System
|
||
*
|
||
* @return string
|
||
*/
|
||
public static function get_php_binary() {
|
||
}
|
||
/**
|
||
* Confirm that a global configuration parameter does exist.
|
||
*
|
||
* @access public
|
||
* @category Input
|
||
*
|
||
* @param string $key Config parameter key to check.
|
||
*
|
||
* @return bool
|
||
*/
|
||
public static function has_config( $key ) {
|
||
}
|
||
/**
|
||
* Get values of global configuration parameters.
|
||
*
|
||
* Provides access to `--path=<path>`, `--url=<url>`, and other values of
|
||
* the [global configuration parameters](https://wp-cli.org/config/).
|
||
*
|
||
* ```
|
||
* WP_CLI::log( 'The --url=<url> value is: ' . WP_CLI::get_config( 'url' ) );
|
||
* ```
|
||
*
|
||
* @access public
|
||
* @category Input
|
||
*
|
||
* @param string $key Get value for a specific global configuration parameter.
|
||
* @return mixed
|
||
*/
|
||
public static function get_config( $key = \null ) {
|
||
}
|
||
/**
|
||
* Run a WP-CLI command.
|
||
*
|
||
* Launches a new child process to run a specified WP-CLI command.
|
||
* Optionally:
|
||
*
|
||
* * Run the command in an existing process.
|
||
* * Prevent halting script execution on error.
|
||
* * Capture and return STDOUT, or full details about command execution.
|
||
* * Parse JSON output if the command rendered it.
|
||
*
|
||
* ```
|
||
* $options = array(
|
||
* 'return' => true, // Return 'STDOUT'; use 'all' for full object.
|
||
* 'parse' => 'json', // Parse captured STDOUT to JSON array.
|
||
* 'launch' => false, // Reuse the current process.
|
||
* 'exit_error' => true, // Halt script execution on error.
|
||
* );
|
||
* $plugins = WP_CLI::runcommand( 'plugin list --format=json', $options );
|
||
* ```
|
||
*
|
||
* @access public
|
||
* @category Execution
|
||
*
|
||
* @param string $command WP-CLI command to run, including arguments.
|
||
* @param array $options Configuration options for command execution.
|
||
* @return mixed
|
||
*/
|
||
public static function runcommand( $command, $options = [] ) {
|
||
}
|
||
/**
|
||
* Run a given command within the current process using the same global
|
||
* parameters.
|
||
*
|
||
* Use `WP_CLI::runcommand()` instead, which is easier to use and works better.
|
||
*
|
||
* To run a command using a new process with the same global parameters,
|
||
* use WP_CLI::launch_self(). To run a command using a new process with
|
||
* different global parameters, use WP_CLI::launch().
|
||
*
|
||
* ```
|
||
* ob_start();
|
||
* WP_CLI::run_command( array( 'cli', 'cmd-dump' ) );
|
||
* $ret = ob_get_clean();
|
||
* ```
|
||
*
|
||
* @access public
|
||
* @category Execution
|
||
*
|
||
* @param array $args Positional arguments including command name.
|
||
* @param array $assoc_args
|
||
*/
|
||
public static function run_command( $args, $assoc_args = [] ) {
|
||
}
|
||
// DEPRECATED STUFF
|
||
public static function add_man_dir() {
|
||
}
|
||
// back-compat
|
||
public static function out( $str ) {
|
||
}
|
||
// back-compat
|
||
// phpcs:ignore WordPress.NamingConventions.ValidFunctionName.MethodNameInvalid -- Deprecated method.
|
||
public static function addCommand( $name, $class ) {
|
||
}
|
||
}
|
||
}
|
||
|
||
// Utilities that do NOT depend on WordPress code.
|
||
namespace WP_CLI\Utils {
|
||
function inside_phar() {
|
||
}
|
||
// Files that need to be read by external programs have to be extracted from the Phar archive.
|
||
function extract_from_phar( $path ) {
|
||
}
|
||
function load_dependencies() {
|
||
}
|
||
function get_vendor_paths() {
|
||
}
|
||
// Using require() directly inside a class grants access to private methods to the loaded code.
|
||
function load_file( $path ) {
|
||
}
|
||
function load_command( $name ) {
|
||
}
|
||
/**
|
||
* Like array_map(), except it returns a new iterator, instead of a modified array.
|
||
*
|
||
* Example:
|
||
*
|
||
* $arr = array('Football', 'Socker');
|
||
*
|
||
* $it = iterator_map($arr, 'strtolower', function($val) {
|
||
* return str_replace('foo', 'bar', $val);
|
||
* });
|
||
*
|
||
* foreach ( $it as $val ) {
|
||
* var_dump($val);
|
||
* }
|
||
*
|
||
* @param array|object Either a plain array or another iterator.
|
||
* @param callback The function to apply to an element.
|
||
* @return object An iterator that applies the given callback(s).
|
||
*/
|
||
function iterator_map( $it, $fn ) {
|
||
}
|
||
/**
|
||
* Search for file by walking up the directory tree until the first file is found or until $stop_check($dir) returns true.
|
||
*
|
||
* @param string|array The files (or file) to search for.
|
||
* @param string|null The directory to start searching from; defaults to CWD.
|
||
* @param callable Function which is passed the current dir each time a directory level is traversed.
|
||
* @return null|string Null if the file was not found.
|
||
*/
|
||
function find_file_upward( $files, $dir = null, $stop_check = null ) {
|
||
}
|
||
function is_path_absolute( $path ) {
|
||
}
|
||
/**
|
||
* Composes positional arguments into a command string.
|
||
*
|
||
* @param array
|
||
* @return string
|
||
*/
|
||
function args_to_str( $args ) {
|
||
}
|
||
/**
|
||
* Composes associative arguments into a command string.
|
||
*
|
||
* @param array
|
||
* @return string
|
||
*/
|
||
function assoc_args_to_str( $assoc_args ) {
|
||
}
|
||
/**
|
||
* Given a template string and an arbitrary number of arguments,
|
||
* returns the final command, with the parameters escaped.
|
||
*/
|
||
function esc_cmd( $cmd ) {
|
||
}
|
||
/**
|
||
* Gets path to WordPress configuration.
|
||
*
|
||
* @return string
|
||
*/
|
||
function locate_wp_config() {
|
||
}
|
||
function wp_version_compare( $since, $operator ) {
|
||
}
|
||
/**
|
||
* Render a collection of items as an ASCII table, JSON, CSV, YAML, list of ids, or count.
|
||
*
|
||
* Given a collection of items with a consistent data structure:
|
||
*
|
||
* ```
|
||
* $items = array(
|
||
* array(
|
||
* 'key' => 'foo',
|
||
* 'value' => 'bar',
|
||
* )
|
||
* );
|
||
* ```
|
||
*
|
||
* Render `$items` as an ASCII table:
|
||
*
|
||
* ```
|
||
* WP_CLI\Utils\format_items( 'table', $items, array( 'key', 'value' ) );
|
||
*
|
||
* # +-----+-------+
|
||
* # | key | value |
|
||
* # +-----+-------+
|
||
* # | foo | bar |
|
||
* # +-----+-------+
|
||
* ```
|
||
*
|
||
* Or render `$items` as YAML:
|
||
*
|
||
* ```
|
||
* WP_CLI\Utils\format_items( 'yaml', $items, array( 'key', 'value' ) );
|
||
*
|
||
* # ---
|
||
* # -
|
||
* # key: foo
|
||
* # value: bar
|
||
* ```
|
||
*
|
||
* @access public
|
||
* @category Output
|
||
*
|
||
* @param string $format Format to use: 'table', 'json', 'csv', 'yaml', 'ids', 'count'
|
||
* @param array $items An array of items to output.
|
||
* @param array|string $fields Named fields for each item of data. Can be array or comma-separated list.
|
||
* @return null
|
||
*/
|
||
function format_items( $format, $items, $fields ) {
|
||
}
|
||
/**
|
||
* Write data as CSV to a given file.
|
||
*
|
||
* @access public
|
||
*
|
||
* @param resource $fd File descriptor
|
||
* @param array $rows Array of rows to output
|
||
* @param array $headers List of CSV columns (optional)
|
||
*/
|
||
function write_csv( $fd, $rows, $headers = [] ) {
|
||
}
|
||
/**
|
||
* Pick fields from an associative array or object.
|
||
*
|
||
* @param array|object Associative array or object to pick fields from.
|
||
* @param array List of fields to pick.
|
||
* @return array
|
||
*/
|
||
function pick_fields( $item, $fields ) {
|
||
}
|
||
/**
|
||
* Launch system's $EDITOR for the user to edit some text.
|
||
*
|
||
* @access public
|
||
* @category Input
|
||
*
|
||
* @param string $content Some form of text to edit (e.g. post content).
|
||
* @param string $title Title to display in the editor.
|
||
* @param string $ext Extension to use with the temp file.
|
||
* @return string|bool Edited text, if file is saved from editor; false, if no change to file.
|
||
*/
|
||
function launch_editor_for_input( $input, $title = 'WP-CLI', $ext = 'tmp' ) {
|
||
}
|
||
/**
|
||
* @param string MySQL host string, as defined in wp-config.php
|
||
*
|
||
* @return array
|
||
*/
|
||
function mysql_host_to_cli_args( $raw_host ) {
|
||
}
|
||
function run_mysql_command( $cmd, $assoc_args, $descriptors = null ) {
|
||
}
|
||
/**
|
||
* Render PHP or other types of files using Mustache templates.
|
||
*
|
||
* IMPORTANT: Automatic HTML escaping is disabled!
|
||
*/
|
||
function mustache_render( $template_name, $data = [] ) {
|
||
}
|
||
/**
|
||
* Create a progress bar to display percent completion of a given operation.
|
||
*
|
||
* Progress bar is written to STDOUT, and disabled when command is piped. Progress
|
||
* advances with `$progress->tick()`, and completes with `$progress->finish()`.
|
||
* Process bar also indicates elapsed time and expected total time.
|
||
*
|
||
* ```
|
||
* # `wp user generate` ticks progress bar each time a new user is created.
|
||
* #
|
||
* # $ wp user generate --count=500
|
||
* # Generating users 22 % [=======> ] 0:05 / 0:23
|
||
*
|
||
* $progress = \WP_CLI\Utils\make_progress_bar( 'Generating users', $count );
|
||
* for ( $i = 0; $i < $count; $i++ ) {
|
||
* // uses wp_insert_user() to insert the user
|
||
* $progress->tick();
|
||
* }
|
||
* $progress->finish();
|
||
* ```
|
||
*
|
||
* @access public
|
||
* @category Output
|
||
*
|
||
* @param string $message Text to display before the progress bar.
|
||
* @param integer $count Total number of ticks to be performed.
|
||
* @param int $interval Optional. The interval in milliseconds between updates. Default 100.
|
||
* @return \cli\progress\Bar|WP_CLI\NoOp
|
||
*/
|
||
function make_progress_bar( $message, $count, $interval = 100 ) {
|
||
}
|
||
/**
|
||
* Helper function to use wp_parse_url when available or fall back to PHP's
|
||
* parse_url if not.
|
||
*
|
||
* Additionally, this adds 'http://' to the URL if no scheme was found.
|
||
*
|
||
* @param string $url The URL to parse.
|
||
* @param int $component Optional. The specific component to retrieve.
|
||
* Use one of the PHP predefined constants to
|
||
* specify which one. Defaults to -1 (= return
|
||
* all parts as an array).
|
||
* @param bool $auto_add_scheme Optional. Automatically add an http:// scheme if
|
||
* none was found. Defaults to true.
|
||
* @return mixed False on parse failure; Array of URL components on success;
|
||
* When a specific component has been requested: null if the
|
||
* component doesn't exist in the given URL; a string or - in the
|
||
* case of PHP_URL_PORT - integer when it does. See parse_url()'s
|
||
* return values.
|
||
*/
|
||
function parse_url( $url, $component = -1, $auto_add_scheme = true ) {
|
||
}
|
||
/**
|
||
* Check if we're running in a Windows environment (cmd.exe).
|
||
*
|
||
* @return bool
|
||
*/
|
||
function is_windows() {
|
||
}
|
||
/**
|
||
* Replace magic constants in some PHP source code.
|
||
*
|
||
* @param string $source The PHP code to manipulate.
|
||
* @param string $path The path to use instead of the magic constants
|
||
*/
|
||
function replace_path_consts( $source, $path ) {
|
||
}
|
||
/**
|
||
* Make a HTTP request to a remote URL.
|
||
*
|
||
* Wraps the Requests HTTP library to ensure every request includes a cert.
|
||
*
|
||
* ```
|
||
* # `wp core download` verifies the hash for a downloaded WordPress archive
|
||
*
|
||
* $md5_response = Utils\http_request( 'GET', $download_url . '.md5' );
|
||
* if ( 20 != substr( $md5_response->status_code, 0, 2 ) ) {
|
||
* WP_CLI::error( "Couldn't access md5 hash for release (HTTP code {$response->status_code})" );
|
||
* }
|
||
* ```
|
||
*
|
||
* @access public
|
||
*
|
||
* @param string $method HTTP method (GET, POST, DELETE, etc.)
|
||
* @param string $url URL to make the HTTP request to.
|
||
* @param array $headers Add specific headers to the request.
|
||
* @param array $options
|
||
* @return object
|
||
*/
|
||
function http_request( $method, $url, $data = null, $headers = [], $options = [] ) {
|
||
}
|
||
/**
|
||
* Increments a version string using the "x.y.z-pre" format.
|
||
*
|
||
* Can increment the major, minor or patch number by one.
|
||
* If $new_version == "same" the version string is not changed.
|
||
* If $new_version is not a known keyword, it will be used as the new version string directly.
|
||
*
|
||
* @param string $current_version
|
||
* @param string $new_version
|
||
* @return string
|
||
*/
|
||
function increment_version( $current_version, $new_version ) {
|
||
}
|
||
/**
|
||
* Compare two version strings to get the named semantic version.
|
||
*
|
||
* @access public
|
||
*
|
||
* @param string $new_version
|
||
* @param string $original_version
|
||
* @return string $name 'major', 'minor', 'patch'
|
||
*/
|
||
function get_named_sem_ver( $new_version, $original_version ) {
|
||
}
|
||
/**
|
||
* Return the flag value or, if it's not set, the $default value.
|
||
*
|
||
* Because flags can be negated (e.g. --no-quiet to negate --quiet), this
|
||
* function provides a safer alternative to using
|
||
* `isset( $assoc_args['quiet'] )` or similar.
|
||
*
|
||
* @access public
|
||
* @category Input
|
||
*
|
||
* @param array $assoc_args Arguments array.
|
||
* @param string $flag Flag to get the value.
|
||
* @param mixed $default Default value for the flag. Default: NULL
|
||
* @return mixed
|
||
*/
|
||
function get_flag_value( $assoc_args, $flag, $default = null ) {
|
||
}
|
||
/**
|
||
* Get the home directory.
|
||
*
|
||
* @access public
|
||
* @category System
|
||
*
|
||
* @return string
|
||
*/
|
||
function get_home_dir() {
|
||
}
|
||
/**
|
||
* Appends a trailing slash.
|
||
*
|
||
* @access public
|
||
* @category System
|
||
*
|
||
* @param string $string What to add the trailing slash to.
|
||
* @return string String with trailing slash added.
|
||
*/
|
||
function trailingslashit( $string ) {
|
||
}
|
||
/**
|
||
* Normalize a filesystem path.
|
||
*
|
||
* On Windows systems, replaces backslashes with forward slashes
|
||
* and forces upper-case drive letters.
|
||
* Allows for two leading slashes for Windows network shares, but
|
||
* ensures that all other duplicate slashes are reduced to a single one.
|
||
* Ensures upper-case drive letters on Windows systems.
|
||
*
|
||
* @access public
|
||
* @category System
|
||
*
|
||
* @param string $path Path to normalize.
|
||
* @return string Normalized path.
|
||
*/
|
||
function normalize_path( $path ) {
|
||
}
|
||
/**
|
||
* Convert Windows EOLs to *nix.
|
||
*
|
||
* @param string $str String to convert.
|
||
* @return string String with carriage return / newline pairs reduced to newlines.
|
||
*/
|
||
function normalize_eols( $str ) {
|
||
}
|
||
/**
|
||
* Get the system's temp directory. Warns user if it isn't writable.
|
||
*
|
||
* @access public
|
||
* @category System
|
||
*
|
||
* @return string
|
||
*/
|
||
function get_temp_dir() {
|
||
}
|
||
/**
|
||
* Parse a SSH url for its host, port, and path.
|
||
*
|
||
* Similar to parse_url(), but adds support for defined SSH aliases.
|
||
*
|
||
* ```
|
||
* host OR host/path/to/wordpress OR host:port/path/to/wordpress
|
||
* ```
|
||
*
|
||
* @access public
|
||
*
|
||
* @return mixed
|
||
*/
|
||
function parse_ssh_url( $url, $component = -1 ) {
|
||
}
|
||
/**
|
||
* Report the results of the same operation against multiple resources.
|
||
*
|
||
* @access public
|
||
* @category Input
|
||
*
|
||
* @param string $noun Resource being affected (e.g. plugin)
|
||
* @param string $verb Type of action happening to the noun (e.g. activate)
|
||
* @param integer $total Total number of resource being affected.
|
||
* @param integer $successes Number of successful operations.
|
||
* @param integer $failures Number of failures.
|
||
* @param null|integer $skips Optional. Number of skipped operations. Default null (don't show skips).
|
||
*/
|
||
function report_batch_operation_results( $noun, $verb, $total, $successes, $failures, $skips = null ) {
|
||
}
|
||
/**
|
||
* Parse a string of command line arguments into an $argv-esqe variable.
|
||
*
|
||
* @access public
|
||
* @category Input
|
||
*
|
||
* @param string $arguments
|
||
* @return array
|
||
*/
|
||
function parse_str_to_argv( $arguments ) {
|
||
}
|
||
/**
|
||
* Locale-independent version of basename()
|
||
*
|
||
* @access public
|
||
*
|
||
* @param string $path
|
||
* @param string $suffix
|
||
* @return string
|
||
*/
|
||
function basename( $path, $suffix = '' ) {
|
||
}
|
||
/**
|
||
* Checks whether the output of the current script is a TTY or a pipe / redirect
|
||
*
|
||
* Returns true if STDOUT output is being redirected to a pipe or a file; false is
|
||
* output is being sent directly to the terminal.
|
||
*
|
||
* If an env variable SHELL_PIPE exists, returned result depends on its
|
||
* value. Strings like 1, 0, yes, no, that validate to booleans are accepted.
|
||
*
|
||
* To enable ASCII formatting even when the shell is piped, use the
|
||
* ENV variable SHELL_PIPE=0.
|
||
*
|
||
* @access public
|
||
*
|
||
* @return bool
|
||
*/
|
||
function isPiped() {
|
||
}
|
||
/**
|
||
* Expand within paths to their matching paths.
|
||
*
|
||
* Has no effect on paths which do not use glob patterns.
|
||
*
|
||
* @param string|array $paths Single path as a string, or an array of paths.
|
||
* @param int $flags Optional. Flags to pass to glob. Defaults to GLOB_BRACE.
|
||
* @return array Expanded paths.
|
||
*/
|
||
function expand_globs( $paths, $flags = 'default' ) {
|
||
}
|
||
/**
|
||
* Simulate a `glob()` with the `GLOB_BRACE` flag set. For systems (eg Alpine Linux) built against a libc library (eg https://www.musl-libc.org/) that lacks it.
|
||
* Copied and adapted from Zend Framework's `Glob::fallbackGlob()` and Glob::nextBraceSub()`.
|
||
*
|
||
* Zend Framework (http://framework.zend.com/)
|
||
*
|
||
* @link http://github.com/zendframework/zf2 for the canonical source repository
|
||
* @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
|
||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||
*
|
||
* @param string $pattern Filename pattern.
|
||
* @param void $dummy_flags Not used.
|
||
* @return array Array of paths.
|
||
*/
|
||
function glob_brace( $pattern, $dummy_flags = null ) {
|
||
}
|
||
/**
|
||
* Get the closest suggestion for a mis-typed target term amongst a list of
|
||
* options.
|
||
*
|
||
* Uses the Levenshtein algorithm to calculate the relative "distance" between
|
||
* terms.
|
||
*
|
||
* If the "distance" to the closest term is higher than the threshold, an empty
|
||
* string is returned.
|
||
*
|
||
* @param string $target Target term to get a suggestion for.
|
||
* @param array $options Array with possible options.
|
||
* @param int $threshold Threshold above which to return an empty string.
|
||
* @return string
|
||
*/
|
||
function get_suggestion( $target, array $options, $threshold = 2 ) {
|
||
}
|
||
/**
|
||
* Get a Phar-safe version of a path.
|
||
*
|
||
* For paths inside a Phar, this strips the outer filesystem's location to
|
||
* reduce the path to what it needs to be within the Phar archive.
|
||
*
|
||
* Use the __FILE__ or __DIR__ constants as a starting point.
|
||
*
|
||
* @param string $path An absolute path that might be within a Phar.
|
||
* @return string A Phar-safe version of the path.
|
||
*/
|
||
function phar_safe_path( $path ) {
|
||
}
|
||
/**
|
||
* Check whether a given Command object is part of the bundled set of
|
||
* commands.
|
||
*
|
||
* This function accepts both a fully qualified class name as a string as
|
||
* well as an object that extends `WP_CLI\Dispatcher\CompositeCommand`.
|
||
*
|
||
* @param \WP_CLI\Dispatcher\CompositeCommand|string $command
|
||
* @return bool
|
||
*/
|
||
function is_bundled_command( $command ) {
|
||
}
|
||
/**
|
||
* Maybe prefix command string with "/usr/bin/env".
|
||
* Removes (if there) if Windows, adds (if not there) if not.
|
||
*
|
||
* @param string $command
|
||
* @return string
|
||
*/
|
||
function force_env_on_nix_systems( $command ) {
|
||
}
|
||
/**
|
||
* Check that `proc_open()` and `proc_close()` haven't been disabled.
|
||
*
|
||
* @param string $context Optional. If set will appear in error message. Default null.
|
||
* @param bool $return Optional. If set will return false rather than error out. Default false.
|
||
* @return bool
|
||
*/
|
||
function check_proc_available( $context = null, $return = false ) {
|
||
}
|
||
/**
|
||
* Returns past tense of verb, with limited accuracy. Only regular verbs catered for, apart from "reset".
|
||
*
|
||
* @param string $verb Verb to return past tense of.
|
||
* @return string
|
||
*/
|
||
function past_tense_verb( $verb ) {
|
||
}
|
||
/**
|
||
* Get the path to the PHP binary used when executing WP-CLI.
|
||
*
|
||
* Environment values permit specific binaries to be indicated.
|
||
*
|
||
* @access public
|
||
* @category System
|
||
*
|
||
* @return string
|
||
*/
|
||
function get_php_binary() {
|
||
}
|
||
/**
|
||
* Windows compatible `proc_open()`.
|
||
* Works around bug in PHP, and also deals with *nix-like `ENV_VAR=blah cmd` environment variable prefixes.
|
||
*
|
||
* @access public
|
||
*
|
||
* @param string $command Command to execute.
|
||
* @param array $descriptorspec Indexed array of descriptor numbers and their values.
|
||
* @param array &$pipes Indexed array of file pointers that correspond to PHP's end of any pipes that are created.
|
||
* @param string $cwd Initial working directory for the command.
|
||
* @param array $env Array of environment variables.
|
||
* @param array $other_options Array of additional options (Windows only).
|
||
* @return resource Command stripped of any environment variable settings.
|
||
*/
|
||
function proc_open_compat( $cmd, $descriptorspec, &$pipes, $cwd = null, $env = null, $other_options = null ) {
|
||
}
|
||
/**
|
||
* For use by `proc_open_compat()` only. Separated out for ease of testing. Windows only.
|
||
* Turns *nix-like `ENV_VAR=blah command` environment variable prefixes into stripped `cmd` with prefixed environment variables added to passed in environment array.
|
||
*
|
||
* @access private
|
||
*
|
||
* @param string $command Command to execute.
|
||
* @param array &$env Array of existing environment variables. Will be modified if any settings in command.
|
||
* @return string Command stripped of any environment variable settings.
|
||
*/
|
||
function _proc_open_compat_win_env( $cmd, &$env ) {
|
||
}
|
||
/**
|
||
* First half of escaping for LIKE special characters % and _ before preparing for MySQL.
|
||
*
|
||
* Use this only before wpdb::prepare() or esc_sql(). Reversing the order is very bad for security.
|
||
*
|
||
* Copied from core "wp-includes/wp-db.php". Avoids dependency on WP 4.4 wpdb.
|
||
*
|
||
* @access public
|
||
*
|
||
* @param string $text The raw text to be escaped. The input typed by the user should have no
|
||
* extra or deleted slashes.
|
||
* @return string Text in the form of a LIKE phrase. The output is not SQL safe. Call $wpdb::prepare()
|
||
* or real_escape next.
|
||
*/
|
||
function esc_like( $text ) {
|
||
}
|
||
/**
|
||
* Escapes (backticks) MySQL identifiers (aka schema object names) - i.e. column names, table names, and database/index/alias/view etc names.
|
||
* See https://dev.mysql.com/doc/refman/5.5/en/identifiers.html
|
||
*
|
||
* @param string|array $idents A single identifier or an array of identifiers.
|
||
* @return string|array An escaped string if given a string, or an array of escaped strings if given an array of strings.
|
||
*/
|
||
function esc_sql_ident( $idents ) {
|
||
}
|
||
/**
|
||
* Check whether a given string is a valid JSON representation.
|
||
*
|
||
* @param string $argument String to evaluate.
|
||
* @param bool $ignore_scalars Optional. Whether to ignore scalar values.
|
||
* Defaults to true.
|
||
* @return bool Whether the provided string is a valid JSON representation.
|
||
*/
|
||
function is_json( $argument, $ignore_scalars = true ) {
|
||
}
|
||
/**
|
||
* Parse known shell arrays included in the $assoc_args array.
|
||
*
|
||
* @param array $assoc_args Associative array of arguments.
|
||
* @param array $array_arguments Array of argument keys that should receive an
|
||
* array through the shell.
|
||
* @return array
|
||
*/
|
||
function parse_shell_arrays( $assoc_args, $array_arguments ) {
|
||
}
|
||
/**
|
||
* Describe a callable as a string.
|
||
*
|
||
* @param callable $callable The callable to describe.
|
||
* @return string String description of the callable.
|
||
*/
|
||
function describe_callable( $callable ) {
|
||
}
|
||
/**
|
||
* Pluralizes a noun in a grammatically correct way.
|
||
*
|
||
* @param string $noun Noun to be pluralized. Needs to be in singular form.
|
||
* @param int|null $count Optional. Count of the nouns, to decide whether to
|
||
* pluralize. Will pluralize unconditionally if none
|
||
* provided.
|
||
* @return string Pluralized noun.
|
||
*/
|
||
function pluralize( $noun, $count = null ) {
|
||
}
|
||
}
|
||
|
||
namespace WP_CLI {
|
||
/**
|
||
* Get the list of ordered steps that need to be processed to bootstrap WP-CLI.
|
||
*
|
||
* Each entry is a fully qualified class name for a class implementing the
|
||
* `WP_CLI\Bootstrap\BootstrapStep` interface.
|
||
*
|
||
* @return string[]
|
||
*/
|
||
function get_bootstrap_steps() {
|
||
}
|
||
/**
|
||
* Register the classes needed for the bootstrap process.
|
||
*
|
||
* The Composer autoloader is not active yet at this point, so we need to use a
|
||
* custom autoloader to fetch the bootstrap classes in a flexible way.
|
||
*/
|
||
function prepare_bootstrap() {
|
||
}
|
||
/**
|
||
* Initialize and return the bootstrap state to pass from step to step.
|
||
*
|
||
* @return BootstrapState
|
||
*/
|
||
function initialize_bootstrap_state() {
|
||
}
|
||
/**
|
||
* Process the bootstrapping steps.
|
||
*
|
||
* Loops over each of the provided steps, instantiates it and then calls its
|
||
* `process()` method.
|
||
*/
|
||
function bootstrap() {
|
||
}
|
||
}
|
||
|
||
// Utilities that depend on WordPress code.
|
||
namespace WP_CLI\Utils {
|
||
function wp_not_installed() {
|
||
}
|
||
// phpcs:disable WordPress.PHP.IniSet -- Intentional & correct usage.
|
||
function wp_debug_mode() {
|
||
}
|
||
// phpcs:enable
|
||
function replace_wp_die_handler() {
|
||
}
|
||
function wp_die_handler( $message ) {
|
||
}
|
||
/**
|
||
* Clean HTML error message so suitable for text display.
|
||
*/
|
||
function wp_clean_error_message( $message ) {
|
||
}
|
||
function wp_redirect_handler( $url ) {
|
||
}
|
||
function maybe_require( $since, $path ) {
|
||
}
|
||
function get_upgrader( $class ) {
|
||
}
|
||
/**
|
||
* Converts a plugin basename back into a friendly slug.
|
||
*/
|
||
function get_plugin_name( $basename ) {
|
||
}
|
||
function is_plugin_skipped( $file ) {
|
||
}
|
||
function get_theme_name( $path ) {
|
||
}
|
||
function is_theme_skipped( $path ) {
|
||
}
|
||
/**
|
||
* Register the sidebar for unused widgets.
|
||
* Core does this in /wp-admin/widgets.php, which isn't helpful.
|
||
*/
|
||
function wp_register_unused_sidebar() {
|
||
}
|
||
/**
|
||
* Attempts to determine which object cache is being used.
|
||
*
|
||
* Note that the guesses made by this function are based on the WP_Object_Cache classes
|
||
* that define the 3rd party object cache extension. Changes to those classes could render
|
||
* problems with this function's ability to determine which object cache is being used.
|
||
*
|
||
* @return string
|
||
*/
|
||
function wp_get_cache_type() {
|
||
}
|
||
/**
|
||
* Clear WordPress internal object caches.
|
||
*
|
||
* In long-running scripts, the internal caches on `$wp_object_cache` and `$wpdb`
|
||
* can grow to consume gigabytes of memory. Periodically calling this utility
|
||
* can help with memory management.
|
||
*
|
||
* @access public
|
||
* @category System
|
||
* @deprecated 1.5.0
|
||
*/
|
||
function wp_clear_object_cache() {
|
||
}
|
||
/**
|
||
* Get a set of tables in the database.
|
||
*
|
||
* Interprets common command-line options into a resolved set of table names.
|
||
*
|
||
* @param array $args Provided table names, or tables with wildcards.
|
||
* @param array $assoc_args Optional flags for groups of tables (e.g. --network)
|
||
* @return array $tables
|
||
*/
|
||
function wp_get_table_names( $args, $assoc_args = [] ) {
|
||
}
|
||
/**
|
||
* Failsafe use of the WordPress wp_strip_all_tags() function.
|
||
*
|
||
* Automatically falls back to strip_tags() function if the WP function is not
|
||
* available.
|
||
*
|
||
* @param string $string String to strip the tags from.
|
||
* @return string String devoid of tags.
|
||
*/
|
||
function strip_tags( $string ) {
|
||
}
|
||
}
|
||
|
||
namespace WP_CLI\Dispatcher {
|
||
/**
|
||
* Get the path to a command, e.g. "core download"
|
||
*
|
||
* @param Subcommand|CompositeCommand $command
|
||
* @return string[]
|
||
*/
|
||
function get_path( $command ) {
|
||
}
|
||
}
|
