repo
stringlengths 6
63
| path
stringlengths 5
140
| func_name
stringlengths 3
151
| original_string
stringlengths 84
13k
| language
stringclasses 1
value | code
stringlengths 84
13k
| code_tokens
sequence | docstring
stringlengths 3
47.2k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 91
247
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
wp-cli/wp-cli | php/WP_CLI/SynopsisValidator.php | SynopsisValidator.query_spec | private function query_spec( $args, $operator = 'AND' ) {
$operator = strtoupper( $operator );
$count = count( $args );
$filtered = array();
foreach ( $this->spec as $key => $to_match ) {
$matched = 0;
foreach ( $args as $m_key => $m_value ) {
if ( array_key_exists( $m_key, $to_match ) && $m_value === $to_match[ $m_key ] ) {
$matched++;
}
}
if ( ( 'AND' === $operator && $matched === $count )
|| ( 'OR' === $operator && $matched > 0 )
|| ( 'NOT' === $operator && 0 === $matched ) ) {
$filtered[ $key ] = $to_match;
}
}
return $filtered;
} | php | private function query_spec( $args, $operator = 'AND' ) {
$operator = strtoupper( $operator );
$count = count( $args );
$filtered = array();
foreach ( $this->spec as $key => $to_match ) {
$matched = 0;
foreach ( $args as $m_key => $m_value ) {
if ( array_key_exists( $m_key, $to_match ) && $m_value === $to_match[ $m_key ] ) {
$matched++;
}
}
if ( ( 'AND' === $operator && $matched === $count )
|| ( 'OR' === $operator && $matched > 0 )
|| ( 'NOT' === $operator && 0 === $matched ) ) {
$filtered[ $key ] = $to_match;
}
}
return $filtered;
} | [
"private",
"function",
"query_spec",
"(",
"$",
"args",
",",
"$",
"operator",
"=",
"'AND'",
")",
"{",
"$",
"operator",
"=",
"strtoupper",
"(",
"$",
"operator",
")",
";",
"$",
"count",
"=",
"count",
"(",
"$",
"args",
")",
";",
"$",
"filtered",
"=",
"array",
"(",
")",
";",
"foreach",
"(",
"$",
"this",
"->",
"spec",
"as",
"$",
"key",
"=>",
"$",
"to_match",
")",
"{",
"$",
"matched",
"=",
"0",
";",
"foreach",
"(",
"$",
"args",
"as",
"$",
"m_key",
"=>",
"$",
"m_value",
")",
"{",
"if",
"(",
"array_key_exists",
"(",
"$",
"m_key",
",",
"$",
"to_match",
")",
"&&",
"$",
"m_value",
"===",
"$",
"to_match",
"[",
"$",
"m_key",
"]",
")",
"{",
"$",
"matched",
"++",
";",
"}",
"}",
"if",
"(",
"(",
"'AND'",
"===",
"$",
"operator",
"&&",
"$",
"matched",
"===",
"$",
"count",
")",
"||",
"(",
"'OR'",
"===",
"$",
"operator",
"&&",
"$",
"matched",
">",
"0",
")",
"||",
"(",
"'NOT'",
"===",
"$",
"operator",
"&&",
"0",
"===",
"$",
"matched",
")",
")",
"{",
"$",
"filtered",
"[",
"$",
"key",
"]",
"=",
"$",
"to_match",
";",
"}",
"}",
"return",
"$",
"filtered",
";",
"}"
] | 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 | [
"Filters",
"a",
"list",
"of",
"associative",
"arrays",
"based",
"on",
"a",
"set",
"of",
"key",
"=",
">",
"value",
"arguments",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/SynopsisValidator.php#L159-L180 | train |
wp-cli/wp-cli | php/WP_CLI/Autoloader.php | Autoloader.add_namespace | public function add_namespace(
$root,
$base_dir,
$prefix = '',
$suffix = '.php',
$lowercase = false,
$underscores = false
) {
$this->namespaces[] = array(
'root' => $this->normalize_root( (string) $root ),
'base_dir' => $this->add_trailing_slash( (string) $base_dir ),
'prefix' => (string) $prefix,
'suffix' => (string) $suffix,
'lowercase' => (bool) $lowercase,
'underscores' => (bool) $underscores,
);
return $this;
} | php | public function add_namespace(
$root,
$base_dir,
$prefix = '',
$suffix = '.php',
$lowercase = false,
$underscores = false
) {
$this->namespaces[] = array(
'root' => $this->normalize_root( (string) $root ),
'base_dir' => $this->add_trailing_slash( (string) $base_dir ),
'prefix' => (string) $prefix,
'suffix' => (string) $suffix,
'lowercase' => (bool) $lowercase,
'underscores' => (bool) $underscores,
);
return $this;
} | [
"public",
"function",
"add_namespace",
"(",
"$",
"root",
",",
"$",
"base_dir",
",",
"$",
"prefix",
"=",
"''",
",",
"$",
"suffix",
"=",
"'.php'",
",",
"$",
"lowercase",
"=",
"false",
",",
"$",
"underscores",
"=",
"false",
")",
"{",
"$",
"this",
"->",
"namespaces",
"[",
"]",
"=",
"array",
"(",
"'root'",
"=>",
"$",
"this",
"->",
"normalize_root",
"(",
"(",
"string",
")",
"$",
"root",
")",
",",
"'base_dir'",
"=>",
"$",
"this",
"->",
"add_trailing_slash",
"(",
"(",
"string",
")",
"$",
"base_dir",
")",
",",
"'prefix'",
"=>",
"(",
"string",
")",
"$",
"prefix",
",",
"'suffix'",
"=>",
"(",
"string",
")",
"$",
"suffix",
",",
"'lowercase'",
"=>",
"(",
"bool",
")",
"$",
"lowercase",
",",
"'underscores'",
"=>",
"(",
"bool",
")",
"$",
"underscores",
",",
")",
";",
"return",
"$",
"this",
";",
"}"
] | 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 | [
"Add",
"a",
"specific",
"namespace",
"structure",
"with",
"our",
"custom",
"autoloader",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Autoloader.php#L63-L81 | train |
wp-cli/wp-cli | php/WP_CLI/Autoloader.php | Autoloader.autoload | public function autoload( $class ) {
// Iterate over namespaces to find a match.
foreach ( $this->namespaces as $namespace ) {
// Move on if the object does not belong to the current namespace.
if ( 0 !== strpos( $class, $namespace['root'] ) ) {
continue;
}
// Remove namespace root level to correspond with root filesystem, and
// replace the namespace separator "\" by the system-dependent directory separator.
$filename = str_replace(
array( $namespace['root'], '\\' ),
array( '', DIRECTORY_SEPARATOR ),
$class
);
// Remove a leading backslash from the class name.
$filename = $this->remove_leading_backslash( $filename );
// Change to lower case if requested.
if ( $namespace['lowercase'] ) {
$filename = strtolower( $filename );
}
// Change underscores into hyphens if requested.
if ( $namespace['underscores'] ) {
$filename = str_replace( '_', '-', $filename );
}
// Add base_dir, prefix and suffix.
$filepath = $namespace['base_dir']
. $namespace['prefix']
. $filename
. $namespace['suffix'];
// Throw an exception if the file does not exist or is not readable.
if ( is_readable( $filepath ) ) {
require_once $filepath;
}
}
} | php | public function autoload( $class ) {
// Iterate over namespaces to find a match.
foreach ( $this->namespaces as $namespace ) {
// Move on if the object does not belong to the current namespace.
if ( 0 !== strpos( $class, $namespace['root'] ) ) {
continue;
}
// Remove namespace root level to correspond with root filesystem, and
// replace the namespace separator "\" by the system-dependent directory separator.
$filename = str_replace(
array( $namespace['root'], '\\' ),
array( '', DIRECTORY_SEPARATOR ),
$class
);
// Remove a leading backslash from the class name.
$filename = $this->remove_leading_backslash( $filename );
// Change to lower case if requested.
if ( $namespace['lowercase'] ) {
$filename = strtolower( $filename );
}
// Change underscores into hyphens if requested.
if ( $namespace['underscores'] ) {
$filename = str_replace( '_', '-', $filename );
}
// Add base_dir, prefix and suffix.
$filepath = $namespace['base_dir']
. $namespace['prefix']
. $filename
. $namespace['suffix'];
// Throw an exception if the file does not exist or is not readable.
if ( is_readable( $filepath ) ) {
require_once $filepath;
}
}
} | [
"public",
"function",
"autoload",
"(",
"$",
"class",
")",
"{",
"// Iterate over namespaces to find a match.",
"foreach",
"(",
"$",
"this",
"->",
"namespaces",
"as",
"$",
"namespace",
")",
"{",
"// Move on if the object does not belong to the current namespace.",
"if",
"(",
"0",
"!==",
"strpos",
"(",
"$",
"class",
",",
"$",
"namespace",
"[",
"'root'",
"]",
")",
")",
"{",
"continue",
";",
"}",
"// Remove namespace root level to correspond with root filesystem, and",
"// replace the namespace separator \"\\\" by the system-dependent directory separator.",
"$",
"filename",
"=",
"str_replace",
"(",
"array",
"(",
"$",
"namespace",
"[",
"'root'",
"]",
",",
"'\\\\'",
")",
",",
"array",
"(",
"''",
",",
"DIRECTORY_SEPARATOR",
")",
",",
"$",
"class",
")",
";",
"// Remove a leading backslash from the class name.",
"$",
"filename",
"=",
"$",
"this",
"->",
"remove_leading_backslash",
"(",
"$",
"filename",
")",
";",
"// Change to lower case if requested.",
"if",
"(",
"$",
"namespace",
"[",
"'lowercase'",
"]",
")",
"{",
"$",
"filename",
"=",
"strtolower",
"(",
"$",
"filename",
")",
";",
"}",
"// Change underscores into hyphens if requested.",
"if",
"(",
"$",
"namespace",
"[",
"'underscores'",
"]",
")",
"{",
"$",
"filename",
"=",
"str_replace",
"(",
"'_'",
",",
"'-'",
",",
"$",
"filename",
")",
";",
"}",
"// Add base_dir, prefix and suffix.",
"$",
"filepath",
"=",
"$",
"namespace",
"[",
"'base_dir'",
"]",
".",
"$",
"namespace",
"[",
"'prefix'",
"]",
".",
"$",
"filename",
".",
"$",
"namespace",
"[",
"'suffix'",
"]",
";",
"// Throw an exception if the file does not exist or is not readable.",
"if",
"(",
"is_readable",
"(",
"$",
"filepath",
")",
")",
"{",
"require_once",
"$",
"filepath",
";",
"}",
"}",
"}"
] | The autoload function that gets registered with the SPL Autoloader
system.
@param string $class The class that got requested by the spl_autoloader. | [
"The",
"autoload",
"function",
"that",
"gets",
"registered",
"with",
"the",
"SPL",
"Autoloader",
"system",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Autoloader.php#L89-L131 | train |
wp-cli/wp-cli | php/WP_CLI/WpHttpCacheManager.php | WpHttpCacheManager.filter_pre_http_request | public function filter_pre_http_request( $response, $args, $url ) {
// check if whitelisted
if ( ! isset( $this->whitelist[ $url ] ) ) {
return $response;
}
// check if downloading
if ( 'GET' !== $args['method'] || empty( $args['filename'] ) ) {
return $response;
}
// check cache and export to designated location
$filename = $this->cache->has( $this->whitelist[ $url ]['key'], $this->whitelist[ $url ]['ttl'] );
if ( $filename ) {
WP_CLI::log( sprintf( 'Using cached file \'%s\'...', $filename ) );
if ( copy( $filename, $args['filename'] ) ) {
// simulate successful download response
return array(
'response' => array(
'code' => 200,
'message' => 'OK',
),
'filename' => $args['filename'],
);
}
WP_CLI::error( sprintf( 'Error copying cached file %s to %s', $filename, $url ) );
}
return $response;
} | php | public function filter_pre_http_request( $response, $args, $url ) {
// check if whitelisted
if ( ! isset( $this->whitelist[ $url ] ) ) {
return $response;
}
// check if downloading
if ( 'GET' !== $args['method'] || empty( $args['filename'] ) ) {
return $response;
}
// check cache and export to designated location
$filename = $this->cache->has( $this->whitelist[ $url ]['key'], $this->whitelist[ $url ]['ttl'] );
if ( $filename ) {
WP_CLI::log( sprintf( 'Using cached file \'%s\'...', $filename ) );
if ( copy( $filename, $args['filename'] ) ) {
// simulate successful download response
return array(
'response' => array(
'code' => 200,
'message' => 'OK',
),
'filename' => $args['filename'],
);
}
WP_CLI::error( sprintf( 'Error copying cached file %s to %s', $filename, $url ) );
}
return $response;
} | [
"public",
"function",
"filter_pre_http_request",
"(",
"$",
"response",
",",
"$",
"args",
",",
"$",
"url",
")",
"{",
"// check if whitelisted",
"if",
"(",
"!",
"isset",
"(",
"$",
"this",
"->",
"whitelist",
"[",
"$",
"url",
"]",
")",
")",
"{",
"return",
"$",
"response",
";",
"}",
"// check if downloading",
"if",
"(",
"'GET'",
"!==",
"$",
"args",
"[",
"'method'",
"]",
"||",
"empty",
"(",
"$",
"args",
"[",
"'filename'",
"]",
")",
")",
"{",
"return",
"$",
"response",
";",
"}",
"// check cache and export to designated location",
"$",
"filename",
"=",
"$",
"this",
"->",
"cache",
"->",
"has",
"(",
"$",
"this",
"->",
"whitelist",
"[",
"$",
"url",
"]",
"[",
"'key'",
"]",
",",
"$",
"this",
"->",
"whitelist",
"[",
"$",
"url",
"]",
"[",
"'ttl'",
"]",
")",
";",
"if",
"(",
"$",
"filename",
")",
"{",
"WP_CLI",
"::",
"log",
"(",
"sprintf",
"(",
"'Using cached file \\'%s\\'...'",
",",
"$",
"filename",
")",
")",
";",
"if",
"(",
"copy",
"(",
"$",
"filename",
",",
"$",
"args",
"[",
"'filename'",
"]",
")",
")",
"{",
"// simulate successful download response",
"return",
"array",
"(",
"'response'",
"=>",
"array",
"(",
"'code'",
"=>",
"200",
",",
"'message'",
"=>",
"'OK'",
",",
")",
",",
"'filename'",
"=>",
"$",
"args",
"[",
"'filename'",
"]",
",",
")",
";",
"}",
"WP_CLI",
"::",
"error",
"(",
"sprintf",
"(",
"'Error copying cached file %s to %s'",
",",
"$",
"filename",
",",
"$",
"url",
")",
")",
";",
"}",
"return",
"$",
"response",
";",
"}"
] | short circuit wp http api with cached file | [
"short",
"circuit",
"wp",
"http",
"api",
"with",
"cached",
"file"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/WpHttpCacheManager.php#L40-L67 | train |
wp-cli/wp-cli | php/WP_CLI/WpHttpCacheManager.php | WpHttpCacheManager.filter_http_response | public function filter_http_response( $response, $args, $url ) {
// check if whitelisted
if ( ! isset( $this->whitelist[ $url ] ) ) {
return $response;
}
// check if downloading
if ( 'GET' !== $args['method'] || empty( $args['filename'] ) ) {
return $response;
}
// check if download was successful
if ( is_wp_error( $response ) || 200 !== wp_remote_retrieve_response_code( $response ) ) {
return $response;
}
// cache downloaded file
$this->cache->import( $this->whitelist[ $url ]['key'], $response['filename'] );
return $response;
} | php | public function filter_http_response( $response, $args, $url ) {
// check if whitelisted
if ( ! isset( $this->whitelist[ $url ] ) ) {
return $response;
}
// check if downloading
if ( 'GET' !== $args['method'] || empty( $args['filename'] ) ) {
return $response;
}
// check if download was successful
if ( is_wp_error( $response ) || 200 !== wp_remote_retrieve_response_code( $response ) ) {
return $response;
}
// cache downloaded file
$this->cache->import( $this->whitelist[ $url ]['key'], $response['filename'] );
return $response;
} | [
"public",
"function",
"filter_http_response",
"(",
"$",
"response",
",",
"$",
"args",
",",
"$",
"url",
")",
"{",
"// check if whitelisted",
"if",
"(",
"!",
"isset",
"(",
"$",
"this",
"->",
"whitelist",
"[",
"$",
"url",
"]",
")",
")",
"{",
"return",
"$",
"response",
";",
"}",
"// check if downloading",
"if",
"(",
"'GET'",
"!==",
"$",
"args",
"[",
"'method'",
"]",
"||",
"empty",
"(",
"$",
"args",
"[",
"'filename'",
"]",
")",
")",
"{",
"return",
"$",
"response",
";",
"}",
"// check if download was successful",
"if",
"(",
"is_wp_error",
"(",
"$",
"response",
")",
"||",
"200",
"!==",
"wp_remote_retrieve_response_code",
"(",
"$",
"response",
")",
")",
"{",
"return",
"$",
"response",
";",
"}",
"// cache downloaded file",
"$",
"this",
"->",
"cache",
"->",
"import",
"(",
"$",
"this",
"->",
"whitelist",
"[",
"$",
"url",
"]",
"[",
"'key'",
"]",
",",
"$",
"response",
"[",
"'filename'",
"]",
")",
";",
"return",
"$",
"response",
";",
"}"
] | cache wp http api downloads
@param array $response
@param array $args
@param string $url | [
"cache",
"wp",
"http",
"api",
"downloads"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/WpHttpCacheManager.php#L77-L93 | train |
wp-cli/wp-cli | php/WP_CLI/WpHttpCacheManager.php | WpHttpCacheManager.whitelist_package | public function whitelist_package( $url, $group, $slug, $version, $ttl = null ) {
$ext = pathinfo( Utils\parse_url( $url, PHP_URL_PATH ), PATHINFO_EXTENSION );
$key = "$group/$slug-$version.$ext";
$this->whitelist_url( $url, $key, $ttl );
wp_update_plugins();
} | php | public function whitelist_package( $url, $group, $slug, $version, $ttl = null ) {
$ext = pathinfo( Utils\parse_url( $url, PHP_URL_PATH ), PATHINFO_EXTENSION );
$key = "$group/$slug-$version.$ext";
$this->whitelist_url( $url, $key, $ttl );
wp_update_plugins();
} | [
"public",
"function",
"whitelist_package",
"(",
"$",
"url",
",",
"$",
"group",
",",
"$",
"slug",
",",
"$",
"version",
",",
"$",
"ttl",
"=",
"null",
")",
"{",
"$",
"ext",
"=",
"pathinfo",
"(",
"Utils",
"\\",
"parse_url",
"(",
"$",
"url",
",",
"PHP_URL_PATH",
")",
",",
"PATHINFO_EXTENSION",
")",
";",
"$",
"key",
"=",
"\"$group/$slug-$version.$ext\"",
";",
"$",
"this",
"->",
"whitelist_url",
"(",
"$",
"url",
",",
"$",
"key",
",",
"$",
"ttl",
")",
";",
"wp_update_plugins",
"(",
")",
";",
"}"
] | 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 | [
"whitelist",
"a",
"package",
"url"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/WpHttpCacheManager.php#L104-L109 | train |
wp-cli/wp-cli | php/WP_CLI/WpHttpCacheManager.php | WpHttpCacheManager.whitelist_url | public function whitelist_url( $url, $key = null, $ttl = null ) {
$key = $key ? : $url;
$this->whitelist[ $url ] = compact( 'key', 'ttl' );
} | php | public function whitelist_url( $url, $key = null, $ttl = null ) {
$key = $key ? : $url;
$this->whitelist[ $url ] = compact( 'key', 'ttl' );
} | [
"public",
"function",
"whitelist_url",
"(",
"$",
"url",
",",
"$",
"key",
"=",
"null",
",",
"$",
"ttl",
"=",
"null",
")",
"{",
"$",
"key",
"=",
"$",
"key",
"?",
":",
"$",
"url",
";",
"$",
"this",
"->",
"whitelist",
"[",
"$",
"url",
"]",
"=",
"compact",
"(",
"'key'",
",",
"'ttl'",
")",
";",
"}"
] | whitelist a url
@param string $url
@param string $key
@param int $ttl | [
"whitelist",
"a",
"url"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/WpHttpCacheManager.php#L118-L121 | train |
wp-cli/wp-cli | php/WP_CLI/Bootstrap/AutoloaderStep.php | AutoloaderStep.get_custom_vendor_folder | protected function get_custom_vendor_folder() {
$maybe_composer_json = WP_CLI_ROOT . '/../../../composer.json';
if ( ! is_readable( $maybe_composer_json ) ) {
return false;
}
$composer = json_decode( file_get_contents( $maybe_composer_json ) );
if ( ! empty( $composer->config )
&& ! empty( $composer->config->{'vendor-dir'} )
) {
return $composer->config->{'vendor-dir'};
}
return false;
} | php | protected function get_custom_vendor_folder() {
$maybe_composer_json = WP_CLI_ROOT . '/../../../composer.json';
if ( ! is_readable( $maybe_composer_json ) ) {
return false;
}
$composer = json_decode( file_get_contents( $maybe_composer_json ) );
if ( ! empty( $composer->config )
&& ! empty( $composer->config->{'vendor-dir'} )
) {
return $composer->config->{'vendor-dir'};
}
return false;
} | [
"protected",
"function",
"get_custom_vendor_folder",
"(",
")",
"{",
"$",
"maybe_composer_json",
"=",
"WP_CLI_ROOT",
".",
"'/../../../composer.json'",
";",
"if",
"(",
"!",
"is_readable",
"(",
"$",
"maybe_composer_json",
")",
")",
"{",
"return",
"false",
";",
"}",
"$",
"composer",
"=",
"json_decode",
"(",
"file_get_contents",
"(",
"$",
"maybe_composer_json",
")",
")",
";",
"if",
"(",
"!",
"empty",
"(",
"$",
"composer",
"->",
"config",
")",
"&&",
"!",
"empty",
"(",
"$",
"composer",
"->",
"config",
"->",
"{",
"'vendor-dir'",
"}",
")",
")",
"{",
"return",
"$",
"composer",
"->",
"config",
"->",
"{",
"'vendor-dir'",
"}",
";",
"}",
"return",
"false",
";",
"}"
] | 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. | [
"Get",
"the",
"name",
"of",
"the",
"custom",
"vendor",
"folder",
"as",
"set",
"in",
"composer",
".",
"json",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Bootstrap/AutoloaderStep.php#L72-L87 | train |
wp-cli/wp-cli | php/WP_CLI/Dispatcher/Subcommand.php | Subcommand.get_parameters | private function get_parameters( $spec = array() ) {
$local_parameters = array_column( $spec, 'name' );
$global_parameters = array_column(
WP_CLI\SynopsisParser::parse( $this->get_global_params() ),
'name'
);
return array_unique( array_merge( $local_parameters, $global_parameters ) );
} | php | private function get_parameters( $spec = array() ) {
$local_parameters = array_column( $spec, 'name' );
$global_parameters = array_column(
WP_CLI\SynopsisParser::parse( $this->get_global_params() ),
'name'
);
return array_unique( array_merge( $local_parameters, $global_parameters ) );
} | [
"private",
"function",
"get_parameters",
"(",
"$",
"spec",
"=",
"array",
"(",
")",
")",
"{",
"$",
"local_parameters",
"=",
"array_column",
"(",
"$",
"spec",
",",
"'name'",
")",
";",
"$",
"global_parameters",
"=",
"array_column",
"(",
"WP_CLI",
"\\",
"SynopsisParser",
"::",
"parse",
"(",
"$",
"this",
"->",
"get_global_params",
"(",
")",
")",
",",
"'name'",
")",
";",
"return",
"array_unique",
"(",
"array_merge",
"(",
"$",
"local_parameters",
",",
"$",
"global_parameters",
")",
")",
";",
"}"
] | 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 | [
"Get",
"an",
"array",
"of",
"parameter",
"names",
"by",
"merging",
"the",
"command",
"-",
"specific",
"and",
"the",
"global",
"parameters",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Dispatcher/Subcommand.php#L467-L475 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.register_early_invoke | public function register_early_invoke( $when, $command ) {
$this->early_invoke[ $when ][] = array_slice( Dispatcher\get_path( $command ), 1 );
} | php | public function register_early_invoke( $when, $command ) {
$this->early_invoke[ $when ][] = array_slice( Dispatcher\get_path( $command ), 1 );
} | [
"public",
"function",
"register_early_invoke",
"(",
"$",
"when",
",",
"$",
"command",
")",
"{",
"$",
"this",
"->",
"early_invoke",
"[",
"$",
"when",
"]",
"[",
"]",
"=",
"array_slice",
"(",
"Dispatcher",
"\\",
"get_path",
"(",
"$",
"command",
")",
",",
"1",
")",
";",
"}"
] | Register a command for early invocation, generally before WordPress loads.
@param string $when Named execution hook
@param WP_CLI\Dispatcher\Subcommand $command | [
"Register",
"a",
"command",
"for",
"early",
"invocation",
"generally",
"before",
"WordPress",
"loads",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L55-L57 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.do_early_invoke | private function do_early_invoke( $when ) {
if ( ! isset( $this->early_invoke[ $when ] ) ) {
return;
}
// Search the value of @when from the command method.
$real_when = '';
$r = $this->find_command_to_run( $this->arguments );
if ( is_array( $r ) ) {
list( $command, $final_args, $cmd_path ) = $r;
foreach ( $this->early_invoke as $_when => $_path ) {
foreach ( $_path as $cmd ) {
if ( $cmd === $cmd_path ) {
$real_when = $_when;
}
}
}
}
foreach ( $this->early_invoke[ $when ] as $path ) {
if ( $this->cmd_starts_with( $path ) ) {
if ( empty( $real_when ) || ( $real_when && $real_when === $when ) ) {
$this->run_command_and_exit();
}
}
}
} | php | private function do_early_invoke( $when ) {
if ( ! isset( $this->early_invoke[ $when ] ) ) {
return;
}
// Search the value of @when from the command method.
$real_when = '';
$r = $this->find_command_to_run( $this->arguments );
if ( is_array( $r ) ) {
list( $command, $final_args, $cmd_path ) = $r;
foreach ( $this->early_invoke as $_when => $_path ) {
foreach ( $_path as $cmd ) {
if ( $cmd === $cmd_path ) {
$real_when = $_when;
}
}
}
}
foreach ( $this->early_invoke[ $when ] as $path ) {
if ( $this->cmd_starts_with( $path ) ) {
if ( empty( $real_when ) || ( $real_when && $real_when === $when ) ) {
$this->run_command_and_exit();
}
}
}
} | [
"private",
"function",
"do_early_invoke",
"(",
"$",
"when",
")",
"{",
"if",
"(",
"!",
"isset",
"(",
"$",
"this",
"->",
"early_invoke",
"[",
"$",
"when",
"]",
")",
")",
"{",
"return",
";",
"}",
"// Search the value of @when from the command method.",
"$",
"real_when",
"=",
"''",
";",
"$",
"r",
"=",
"$",
"this",
"->",
"find_command_to_run",
"(",
"$",
"this",
"->",
"arguments",
")",
";",
"if",
"(",
"is_array",
"(",
"$",
"r",
")",
")",
"{",
"list",
"(",
"$",
"command",
",",
"$",
"final_args",
",",
"$",
"cmd_path",
")",
"=",
"$",
"r",
";",
"foreach",
"(",
"$",
"this",
"->",
"early_invoke",
"as",
"$",
"_when",
"=>",
"$",
"_path",
")",
"{",
"foreach",
"(",
"$",
"_path",
"as",
"$",
"cmd",
")",
"{",
"if",
"(",
"$",
"cmd",
"===",
"$",
"cmd_path",
")",
"{",
"$",
"real_when",
"=",
"$",
"_when",
";",
"}",
"}",
"}",
"}",
"foreach",
"(",
"$",
"this",
"->",
"early_invoke",
"[",
"$",
"when",
"]",
"as",
"$",
"path",
")",
"{",
"if",
"(",
"$",
"this",
"->",
"cmd_starts_with",
"(",
"$",
"path",
")",
")",
"{",
"if",
"(",
"empty",
"(",
"$",
"real_when",
")",
"||",
"(",
"$",
"real_when",
"&&",
"$",
"real_when",
"===",
"$",
"when",
")",
")",
"{",
"$",
"this",
"->",
"run_command_and_exit",
"(",
")",
";",
"}",
"}",
"}",
"}"
] | Perform the early invocation of a command.
@param string $when Named execution hook | [
"Perform",
"the",
"early",
"invocation",
"of",
"a",
"command",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L64-L91 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.get_global_config_path | public function get_global_config_path() {
if ( getenv( 'WP_CLI_CONFIG_PATH' ) ) {
$config_path = getenv( 'WP_CLI_CONFIG_PATH' );
$this->global_config_path_debug = 'Using global config from WP_CLI_CONFIG_PATH env var: ' . $config_path;
} else {
$config_path = Utils\get_home_dir() . '/.wp-cli/config.yml';
$this->global_config_path_debug = 'Using default global config: ' . $config_path;
}
if ( is_readable( $config_path ) ) {
return $config_path;
}
$this->global_config_path_debug = 'No readable global config found';
return false;
} | php | public function get_global_config_path() {
if ( getenv( 'WP_CLI_CONFIG_PATH' ) ) {
$config_path = getenv( 'WP_CLI_CONFIG_PATH' );
$this->global_config_path_debug = 'Using global config from WP_CLI_CONFIG_PATH env var: ' . $config_path;
} else {
$config_path = Utils\get_home_dir() . '/.wp-cli/config.yml';
$this->global_config_path_debug = 'Using default global config: ' . $config_path;
}
if ( is_readable( $config_path ) ) {
return $config_path;
}
$this->global_config_path_debug = 'No readable global config found';
return false;
} | [
"public",
"function",
"get_global_config_path",
"(",
")",
"{",
"if",
"(",
"getenv",
"(",
"'WP_CLI_CONFIG_PATH'",
")",
")",
"{",
"$",
"config_path",
"=",
"getenv",
"(",
"'WP_CLI_CONFIG_PATH'",
")",
";",
"$",
"this",
"->",
"global_config_path_debug",
"=",
"'Using global config from WP_CLI_CONFIG_PATH env var: '",
".",
"$",
"config_path",
";",
"}",
"else",
"{",
"$",
"config_path",
"=",
"Utils",
"\\",
"get_home_dir",
"(",
")",
".",
"'/.wp-cli/config.yml'",
";",
"$",
"this",
"->",
"global_config_path_debug",
"=",
"'Using default global config: '",
".",
"$",
"config_path",
";",
"}",
"if",
"(",
"is_readable",
"(",
"$",
"config_path",
")",
")",
"{",
"return",
"$",
"config_path",
";",
"}",
"$",
"this",
"->",
"global_config_path_debug",
"=",
"'No readable global config found'",
";",
"return",
"false",
";",
"}"
] | Get the path to the global configuration YAML file.
@return string|false | [
"Get",
"the",
"path",
"to",
"the",
"global",
"configuration",
"YAML",
"file",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L98-L115 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.get_project_config_path | public function get_project_config_path() {
$config_files = array(
'wp-cli.local.yml',
'wp-cli.yml',
);
// Stop looking upward when we find we have emerged from a subdirectory
// installation into a parent installation
$project_config_path = Utils\find_file_upward(
$config_files,
getcwd(),
function ( $dir ) {
static $wp_load_count = 0;
$wp_load_path = $dir . DIRECTORY_SEPARATOR . 'wp-load.php';
if ( file_exists( $wp_load_path ) ) {
++ $wp_load_count;
}
return $wp_load_count > 1;
}
);
$this->project_config_path_debug = 'No project config found';
if ( ! empty( $project_config_path ) ) {
$this->project_config_path_debug = 'Using project config: ' . $project_config_path;
}
return $project_config_path;
} | php | public function get_project_config_path() {
$config_files = array(
'wp-cli.local.yml',
'wp-cli.yml',
);
// Stop looking upward when we find we have emerged from a subdirectory
// installation into a parent installation
$project_config_path = Utils\find_file_upward(
$config_files,
getcwd(),
function ( $dir ) {
static $wp_load_count = 0;
$wp_load_path = $dir . DIRECTORY_SEPARATOR . 'wp-load.php';
if ( file_exists( $wp_load_path ) ) {
++ $wp_load_count;
}
return $wp_load_count > 1;
}
);
$this->project_config_path_debug = 'No project config found';
if ( ! empty( $project_config_path ) ) {
$this->project_config_path_debug = 'Using project config: ' . $project_config_path;
}
return $project_config_path;
} | [
"public",
"function",
"get_project_config_path",
"(",
")",
"{",
"$",
"config_files",
"=",
"array",
"(",
"'wp-cli.local.yml'",
",",
"'wp-cli.yml'",
",",
")",
";",
"// Stop looking upward when we find we have emerged from a subdirectory",
"// installation into a parent installation",
"$",
"project_config_path",
"=",
"Utils",
"\\",
"find_file_upward",
"(",
"$",
"config_files",
",",
"getcwd",
"(",
")",
",",
"function",
"(",
"$",
"dir",
")",
"{",
"static",
"$",
"wp_load_count",
"=",
"0",
";",
"$",
"wp_load_path",
"=",
"$",
"dir",
".",
"DIRECTORY_SEPARATOR",
".",
"'wp-load.php'",
";",
"if",
"(",
"file_exists",
"(",
"$",
"wp_load_path",
")",
")",
"{",
"++",
"$",
"wp_load_count",
";",
"}",
"return",
"$",
"wp_load_count",
">",
"1",
";",
"}",
")",
";",
"$",
"this",
"->",
"project_config_path_debug",
"=",
"'No project config found'",
";",
"if",
"(",
"!",
"empty",
"(",
"$",
"project_config_path",
")",
")",
"{",
"$",
"this",
"->",
"project_config_path_debug",
"=",
"'Using project config: '",
".",
"$",
"project_config_path",
";",
"}",
"return",
"$",
"project_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 | [
"Get",
"the",
"path",
"to",
"the",
"project",
"-",
"specific",
"configuration",
"YAML",
"file",
".",
"wp",
"-",
"cli",
".",
"local",
".",
"yml",
"takes",
"priority",
"over",
"wp",
"-",
"cli",
".",
"yml",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L124-L152 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.get_packages_dir_path | public function get_packages_dir_path() {
if ( getenv( 'WP_CLI_PACKAGES_DIR' ) ) {
$packages_dir = Utils\trailingslashit( getenv( 'WP_CLI_PACKAGES_DIR' ) );
} else {
$packages_dir = Utils\get_home_dir() . '/.wp-cli/packages/';
}
return $packages_dir;
} | php | public function get_packages_dir_path() {
if ( getenv( 'WP_CLI_PACKAGES_DIR' ) ) {
$packages_dir = Utils\trailingslashit( getenv( 'WP_CLI_PACKAGES_DIR' ) );
} else {
$packages_dir = Utils\get_home_dir() . '/.wp-cli/packages/';
}
return $packages_dir;
} | [
"public",
"function",
"get_packages_dir_path",
"(",
")",
"{",
"if",
"(",
"getenv",
"(",
"'WP_CLI_PACKAGES_DIR'",
")",
")",
"{",
"$",
"packages_dir",
"=",
"Utils",
"\\",
"trailingslashit",
"(",
"getenv",
"(",
"'WP_CLI_PACKAGES_DIR'",
")",
")",
";",
"}",
"else",
"{",
"$",
"packages_dir",
"=",
"Utils",
"\\",
"get_home_dir",
"(",
")",
".",
"'/.wp-cli/packages/'",
";",
"}",
"return",
"$",
"packages_dir",
";",
"}"
] | Get the path to the packages directory
@return string | [
"Get",
"the",
"path",
"to",
"the",
"packages",
"directory"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L159-L166 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.extract_subdir_path | private static function extract_subdir_path( $index_path ) {
$index_code = file_get_contents( $index_path );
if ( ! preg_match( '|^\s*require\s*\(?\s*(.+?)/wp-blog-header\.php([\'"])|m', $index_code, $matches ) ) {
return false;
}
$wp_path_src = $matches[1] . $matches[2];
$wp_path_src = Utils\replace_path_consts( $wp_path_src, $index_path );
$wp_path = eval( "return $wp_path_src;" ); // phpcs:ignore Squiz.PHP.Eval.Discouraged
if ( ! Utils\is_path_absolute( $wp_path ) ) {
$wp_path = dirname( $index_path ) . "/$wp_path";
}
return $wp_path;
} | php | private static function extract_subdir_path( $index_path ) {
$index_code = file_get_contents( $index_path );
if ( ! preg_match( '|^\s*require\s*\(?\s*(.+?)/wp-blog-header\.php([\'"])|m', $index_code, $matches ) ) {
return false;
}
$wp_path_src = $matches[1] . $matches[2];
$wp_path_src = Utils\replace_path_consts( $wp_path_src, $index_path );
$wp_path = eval( "return $wp_path_src;" ); // phpcs:ignore Squiz.PHP.Eval.Discouraged
if ( ! Utils\is_path_absolute( $wp_path ) ) {
$wp_path = dirname( $index_path ) . "/$wp_path";
}
return $wp_path;
} | [
"private",
"static",
"function",
"extract_subdir_path",
"(",
"$",
"index_path",
")",
"{",
"$",
"index_code",
"=",
"file_get_contents",
"(",
"$",
"index_path",
")",
";",
"if",
"(",
"!",
"preg_match",
"(",
"'|^\\s*require\\s*\\(?\\s*(.+?)/wp-blog-header\\.php([\\'\"])|m'",
",",
"$",
"index_code",
",",
"$",
"matches",
")",
")",
"{",
"return",
"false",
";",
"}",
"$",
"wp_path_src",
"=",
"$",
"matches",
"[",
"1",
"]",
".",
"$",
"matches",
"[",
"2",
"]",
";",
"$",
"wp_path_src",
"=",
"Utils",
"\\",
"replace_path_consts",
"(",
"$",
"wp_path_src",
",",
"$",
"index_path",
")",
";",
"$",
"wp_path",
"=",
"eval",
"(",
"\"return $wp_path_src;\"",
")",
";",
"// phpcs:ignore Squiz.PHP.Eval.Discouraged",
"if",
"(",
"!",
"Utils",
"\\",
"is_path_absolute",
"(",
"$",
"wp_path",
")",
")",
"{",
"$",
"wp_path",
"=",
"dirname",
"(",
"$",
"index_path",
")",
".",
"\"/$wp_path\"",
";",
"}",
"return",
"$",
"wp_path",
";",
"}"
] | Attempts to find the path to the WP installation inside index.php
@param string $index_path
@return string|false | [
"Attempts",
"to",
"find",
"the",
"path",
"to",
"the",
"WP",
"installation",
"inside",
"index",
".",
"php"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L174-L191 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.find_wp_root | private function find_wp_root() {
if ( ! empty( $this->config['path'] ) ) {
$path = $this->config['path'];
if ( ! Utils\is_path_absolute( $path ) ) {
$path = getcwd() . '/' . $path;
}
return $path;
}
if ( $this->cmd_starts_with( array( 'core', 'download' ) ) ) {
return getcwd();
}
$dir = getcwd();
while ( is_readable( $dir ) ) {
if ( file_exists( "$dir/wp-load.php" ) ) {
return $dir;
}
if ( file_exists( "$dir/index.php" ) ) {
$path = self::extract_subdir_path( "$dir/index.php" );
if ( ! empty( $path ) ) {
return $path;
}
}
$parent_dir = dirname( $dir );
if ( empty( $parent_dir ) || $parent_dir === $dir ) {
break;
}
$dir = $parent_dir;
}
} | php | private function find_wp_root() {
if ( ! empty( $this->config['path'] ) ) {
$path = $this->config['path'];
if ( ! Utils\is_path_absolute( $path ) ) {
$path = getcwd() . '/' . $path;
}
return $path;
}
if ( $this->cmd_starts_with( array( 'core', 'download' ) ) ) {
return getcwd();
}
$dir = getcwd();
while ( is_readable( $dir ) ) {
if ( file_exists( "$dir/wp-load.php" ) ) {
return $dir;
}
if ( file_exists( "$dir/index.php" ) ) {
$path = self::extract_subdir_path( "$dir/index.php" );
if ( ! empty( $path ) ) {
return $path;
}
}
$parent_dir = dirname( $dir );
if ( empty( $parent_dir ) || $parent_dir === $dir ) {
break;
}
$dir = $parent_dir;
}
} | [
"private",
"function",
"find_wp_root",
"(",
")",
"{",
"if",
"(",
"!",
"empty",
"(",
"$",
"this",
"->",
"config",
"[",
"'path'",
"]",
")",
")",
"{",
"$",
"path",
"=",
"$",
"this",
"->",
"config",
"[",
"'path'",
"]",
";",
"if",
"(",
"!",
"Utils",
"\\",
"is_path_absolute",
"(",
"$",
"path",
")",
")",
"{",
"$",
"path",
"=",
"getcwd",
"(",
")",
".",
"'/'",
".",
"$",
"path",
";",
"}",
"return",
"$",
"path",
";",
"}",
"if",
"(",
"$",
"this",
"->",
"cmd_starts_with",
"(",
"array",
"(",
"'core'",
",",
"'download'",
")",
")",
")",
"{",
"return",
"getcwd",
"(",
")",
";",
"}",
"$",
"dir",
"=",
"getcwd",
"(",
")",
";",
"while",
"(",
"is_readable",
"(",
"$",
"dir",
")",
")",
"{",
"if",
"(",
"file_exists",
"(",
"\"$dir/wp-load.php\"",
")",
")",
"{",
"return",
"$",
"dir",
";",
"}",
"if",
"(",
"file_exists",
"(",
"\"$dir/index.php\"",
")",
")",
"{",
"$",
"path",
"=",
"self",
"::",
"extract_subdir_path",
"(",
"\"$dir/index.php\"",
")",
";",
"if",
"(",
"!",
"empty",
"(",
"$",
"path",
")",
")",
"{",
"return",
"$",
"path",
";",
"}",
"}",
"$",
"parent_dir",
"=",
"dirname",
"(",
"$",
"dir",
")",
";",
"if",
"(",
"empty",
"(",
"$",
"parent_dir",
")",
"||",
"$",
"parent_dir",
"===",
"$",
"dir",
")",
"{",
"break",
";",
"}",
"$",
"dir",
"=",
"$",
"parent_dir",
";",
"}",
"}"
] | Find the directory that contains the WordPress files.
Defaults to the current working dir.
@return string An absolute path | [
"Find",
"the",
"directory",
"that",
"contains",
"the",
"WordPress",
"files",
".",
"Defaults",
"to",
"the",
"current",
"working",
"dir",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L199-L233 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.set_wp_root | private static function set_wp_root( $path ) {
if ( ! defined( 'ABSPATH' ) ) {
// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedConstantFound -- Declaring a WP native constant.
define( 'ABSPATH', Utils\normalize_path( Utils\trailingslashit( $path ) ) );
} elseif ( ! is_null( $path ) ) {
WP_CLI::error_multi_line(
array(
'The --path parameter cannot be used when ABSPATH is already defined elsewhere',
'ABSPATH is defined as: "' . ABSPATH . '"',
)
);
}
WP_CLI::debug( 'ABSPATH defined: ' . ABSPATH, 'bootstrap' );
$_SERVER['DOCUMENT_ROOT'] = realpath( $path );
} | php | private static function set_wp_root( $path ) {
if ( ! defined( 'ABSPATH' ) ) {
// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedConstantFound -- Declaring a WP native constant.
define( 'ABSPATH', Utils\normalize_path( Utils\trailingslashit( $path ) ) );
} elseif ( ! is_null( $path ) ) {
WP_CLI::error_multi_line(
array(
'The --path parameter cannot be used when ABSPATH is already defined elsewhere',
'ABSPATH is defined as: "' . ABSPATH . '"',
)
);
}
WP_CLI::debug( 'ABSPATH defined: ' . ABSPATH, 'bootstrap' );
$_SERVER['DOCUMENT_ROOT'] = realpath( $path );
} | [
"private",
"static",
"function",
"set_wp_root",
"(",
"$",
"path",
")",
"{",
"if",
"(",
"!",
"defined",
"(",
"'ABSPATH'",
")",
")",
"{",
"// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedConstantFound -- Declaring a WP native constant.",
"define",
"(",
"'ABSPATH'",
",",
"Utils",
"\\",
"normalize_path",
"(",
"Utils",
"\\",
"trailingslashit",
"(",
"$",
"path",
")",
")",
")",
";",
"}",
"elseif",
"(",
"!",
"is_null",
"(",
"$",
"path",
")",
")",
"{",
"WP_CLI",
"::",
"error_multi_line",
"(",
"array",
"(",
"'The --path parameter cannot be used when ABSPATH is already defined elsewhere'",
",",
"'ABSPATH is defined as: \"'",
".",
"ABSPATH",
".",
"'\"'",
",",
")",
")",
";",
"}",
"WP_CLI",
"::",
"debug",
"(",
"'ABSPATH defined: '",
".",
"ABSPATH",
",",
"'bootstrap'",
")",
";",
"$",
"_SERVER",
"[",
"'DOCUMENT_ROOT'",
"]",
"=",
"realpath",
"(",
"$",
"path",
")",
";",
"}"
] | Set WordPress root as a given path.
@param string $path | [
"Set",
"WordPress",
"root",
"as",
"a",
"given",
"path",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L240-L255 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.guess_url | private static function guess_url( $assoc_args ) {
if ( isset( $assoc_args['blog'] ) ) {
$assoc_args['url'] = $assoc_args['blog'];
}
if ( isset( $assoc_args['url'] ) ) {
$url = $assoc_args['url'];
if ( true === $url ) {
WP_CLI::warning( 'The --url parameter expects a value.' );
}
}
if ( isset( $url ) ) {
return $url;
}
return false;
} | php | private static function guess_url( $assoc_args ) {
if ( isset( $assoc_args['blog'] ) ) {
$assoc_args['url'] = $assoc_args['blog'];
}
if ( isset( $assoc_args['url'] ) ) {
$url = $assoc_args['url'];
if ( true === $url ) {
WP_CLI::warning( 'The --url parameter expects a value.' );
}
}
if ( isset( $url ) ) {
return $url;
}
return false;
} | [
"private",
"static",
"function",
"guess_url",
"(",
"$",
"assoc_args",
")",
"{",
"if",
"(",
"isset",
"(",
"$",
"assoc_args",
"[",
"'blog'",
"]",
")",
")",
"{",
"$",
"assoc_args",
"[",
"'url'",
"]",
"=",
"$",
"assoc_args",
"[",
"'blog'",
"]",
";",
"}",
"if",
"(",
"isset",
"(",
"$",
"assoc_args",
"[",
"'url'",
"]",
")",
")",
"{",
"$",
"url",
"=",
"$",
"assoc_args",
"[",
"'url'",
"]",
";",
"if",
"(",
"true",
"===",
"$",
"url",
")",
"{",
"WP_CLI",
"::",
"warning",
"(",
"'The --url parameter expects a value.'",
")",
";",
"}",
"}",
"if",
"(",
"isset",
"(",
"$",
"url",
")",
")",
"{",
"return",
"$",
"url",
";",
"}",
"return",
"false",
";",
"}"
] | Guess which URL context WP-CLI has been invoked under.
@param array $assoc_args
@return string|false | [
"Guess",
"which",
"URL",
"context",
"WP",
"-",
"CLI",
"has",
"been",
"invoked",
"under",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L263-L280 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.find_command_to_run | public function find_command_to_run( $args ) {
$command = \WP_CLI::get_root_command();
WP_CLI::do_hook( 'find_command_to_run_pre' );
$cmd_path = array();
while ( ! empty( $args ) && $command->can_have_subcommands() ) {
$cmd_path[] = $args[0];
$full_name = implode( ' ', $cmd_path );
$subcommand = $command->find_subcommand( $args );
if ( ! $subcommand ) {
if ( count( $cmd_path ) > 1 ) {
$child = array_pop( $cmd_path );
$parent_name = implode( ' ', $cmd_path );
$suggestion = $this->get_subcommand_suggestion( $child, $command );
return sprintf(
"'%s' is not a registered subcommand of '%s'. See 'wp help %s' for available subcommands.%s",
$child,
$parent_name,
$parent_name,
! empty( $suggestion ) ? PHP_EOL . "Did you mean '{$suggestion}'?" : ''
);
}
$suggestion = $this->get_subcommand_suggestion( $full_name, $command );
return sprintf(
"'%s' is not a registered wp command. See 'wp help' for available commands.%s",
$full_name,
! empty( $suggestion ) ? PHP_EOL . "Did you mean '{$suggestion}'?" : ''
);
}
if ( $this->is_command_disabled( $subcommand ) ) {
return sprintf(
"The '%s' command has been disabled from the config file.",
$full_name
);
}
$command = $subcommand;
}
return array( $command, $args, $cmd_path );
} | php | public function find_command_to_run( $args ) {
$command = \WP_CLI::get_root_command();
WP_CLI::do_hook( 'find_command_to_run_pre' );
$cmd_path = array();
while ( ! empty( $args ) && $command->can_have_subcommands() ) {
$cmd_path[] = $args[0];
$full_name = implode( ' ', $cmd_path );
$subcommand = $command->find_subcommand( $args );
if ( ! $subcommand ) {
if ( count( $cmd_path ) > 1 ) {
$child = array_pop( $cmd_path );
$parent_name = implode( ' ', $cmd_path );
$suggestion = $this->get_subcommand_suggestion( $child, $command );
return sprintf(
"'%s' is not a registered subcommand of '%s'. See 'wp help %s' for available subcommands.%s",
$child,
$parent_name,
$parent_name,
! empty( $suggestion ) ? PHP_EOL . "Did you mean '{$suggestion}'?" : ''
);
}
$suggestion = $this->get_subcommand_suggestion( $full_name, $command );
return sprintf(
"'%s' is not a registered wp command. See 'wp help' for available commands.%s",
$full_name,
! empty( $suggestion ) ? PHP_EOL . "Did you mean '{$suggestion}'?" : ''
);
}
if ( $this->is_command_disabled( $subcommand ) ) {
return sprintf(
"The '%s' command has been disabled from the config file.",
$full_name
);
}
$command = $subcommand;
}
return array( $command, $args, $cmd_path );
} | [
"public",
"function",
"find_command_to_run",
"(",
"$",
"args",
")",
"{",
"$",
"command",
"=",
"\\",
"WP_CLI",
"::",
"get_root_command",
"(",
")",
";",
"WP_CLI",
"::",
"do_hook",
"(",
"'find_command_to_run_pre'",
")",
";",
"$",
"cmd_path",
"=",
"array",
"(",
")",
";",
"while",
"(",
"!",
"empty",
"(",
"$",
"args",
")",
"&&",
"$",
"command",
"->",
"can_have_subcommands",
"(",
")",
")",
"{",
"$",
"cmd_path",
"[",
"]",
"=",
"$",
"args",
"[",
"0",
"]",
";",
"$",
"full_name",
"=",
"implode",
"(",
"' '",
",",
"$",
"cmd_path",
")",
";",
"$",
"subcommand",
"=",
"$",
"command",
"->",
"find_subcommand",
"(",
"$",
"args",
")",
";",
"if",
"(",
"!",
"$",
"subcommand",
")",
"{",
"if",
"(",
"count",
"(",
"$",
"cmd_path",
")",
">",
"1",
")",
"{",
"$",
"child",
"=",
"array_pop",
"(",
"$",
"cmd_path",
")",
";",
"$",
"parent_name",
"=",
"implode",
"(",
"' '",
",",
"$",
"cmd_path",
")",
";",
"$",
"suggestion",
"=",
"$",
"this",
"->",
"get_subcommand_suggestion",
"(",
"$",
"child",
",",
"$",
"command",
")",
";",
"return",
"sprintf",
"(",
"\"'%s' is not a registered subcommand of '%s'. See 'wp help %s' for available subcommands.%s\"",
",",
"$",
"child",
",",
"$",
"parent_name",
",",
"$",
"parent_name",
",",
"!",
"empty",
"(",
"$",
"suggestion",
")",
"?",
"PHP_EOL",
".",
"\"Did you mean '{$suggestion}'?\"",
":",
"''",
")",
";",
"}",
"$",
"suggestion",
"=",
"$",
"this",
"->",
"get_subcommand_suggestion",
"(",
"$",
"full_name",
",",
"$",
"command",
")",
";",
"return",
"sprintf",
"(",
"\"'%s' is not a registered wp command. See 'wp help' for available commands.%s\"",
",",
"$",
"full_name",
",",
"!",
"empty",
"(",
"$",
"suggestion",
")",
"?",
"PHP_EOL",
".",
"\"Did you mean '{$suggestion}'?\"",
":",
"''",
")",
";",
"}",
"if",
"(",
"$",
"this",
"->",
"is_command_disabled",
"(",
"$",
"subcommand",
")",
")",
"{",
"return",
"sprintf",
"(",
"\"The '%s' command has been disabled from the config file.\"",
",",
"$",
"full_name",
")",
";",
"}",
"$",
"command",
"=",
"$",
"subcommand",
";",
"}",
"return",
"array",
"(",
"$",
"command",
",",
"$",
"args",
",",
"$",
"cmd_path",
")",
";",
"}"
] | Given positional arguments, find the command to execute.
@param array $args
@return array|string Command, args, and path on success; error message on failure | [
"Given",
"positional",
"arguments",
"find",
"the",
"command",
"to",
"execute",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L292-L339 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.run_command | public function run_command( $args, $assoc_args = array(), $options = array() ) {
WP_CLI::do_hook( 'before_run_command' );
if ( ! empty( $options['back_compat_conversions'] ) ) {
list( $args, $assoc_args ) = self::back_compat_conversions( $args, $assoc_args );
}
$r = $this->find_command_to_run( $args );
if ( is_string( $r ) ) {
WP_CLI::error( $r );
}
list( $command, $final_args, $cmd_path ) = $r;
$name = implode( ' ', $cmd_path );
$extra_args = array();
if ( isset( $this->extra_config[ $name ] ) ) {
$extra_args = $this->extra_config[ $name ];
}
WP_CLI::debug( 'Running command: ' . $name, 'bootstrap' );
try {
$command->invoke( $final_args, $assoc_args, $extra_args );
} catch ( WP_CLI\Iterators\Exception $e ) {
WP_CLI::error( $e->getMessage() );
}
} | php | public function run_command( $args, $assoc_args = array(), $options = array() ) {
WP_CLI::do_hook( 'before_run_command' );
if ( ! empty( $options['back_compat_conversions'] ) ) {
list( $args, $assoc_args ) = self::back_compat_conversions( $args, $assoc_args );
}
$r = $this->find_command_to_run( $args );
if ( is_string( $r ) ) {
WP_CLI::error( $r );
}
list( $command, $final_args, $cmd_path ) = $r;
$name = implode( ' ', $cmd_path );
$extra_args = array();
if ( isset( $this->extra_config[ $name ] ) ) {
$extra_args = $this->extra_config[ $name ];
}
WP_CLI::debug( 'Running command: ' . $name, 'bootstrap' );
try {
$command->invoke( $final_args, $assoc_args, $extra_args );
} catch ( WP_CLI\Iterators\Exception $e ) {
WP_CLI::error( $e->getMessage() );
}
} | [
"public",
"function",
"run_command",
"(",
"$",
"args",
",",
"$",
"assoc_args",
"=",
"array",
"(",
")",
",",
"$",
"options",
"=",
"array",
"(",
")",
")",
"{",
"WP_CLI",
"::",
"do_hook",
"(",
"'before_run_command'",
")",
";",
"if",
"(",
"!",
"empty",
"(",
"$",
"options",
"[",
"'back_compat_conversions'",
"]",
")",
")",
"{",
"list",
"(",
"$",
"args",
",",
"$",
"assoc_args",
")",
"=",
"self",
"::",
"back_compat_conversions",
"(",
"$",
"args",
",",
"$",
"assoc_args",
")",
";",
"}",
"$",
"r",
"=",
"$",
"this",
"->",
"find_command_to_run",
"(",
"$",
"args",
")",
";",
"if",
"(",
"is_string",
"(",
"$",
"r",
")",
")",
"{",
"WP_CLI",
"::",
"error",
"(",
"$",
"r",
")",
";",
"}",
"list",
"(",
"$",
"command",
",",
"$",
"final_args",
",",
"$",
"cmd_path",
")",
"=",
"$",
"r",
";",
"$",
"name",
"=",
"implode",
"(",
"' '",
",",
"$",
"cmd_path",
")",
";",
"$",
"extra_args",
"=",
"array",
"(",
")",
";",
"if",
"(",
"isset",
"(",
"$",
"this",
"->",
"extra_config",
"[",
"$",
"name",
"]",
")",
")",
"{",
"$",
"extra_args",
"=",
"$",
"this",
"->",
"extra_config",
"[",
"$",
"name",
"]",
";",
"}",
"WP_CLI",
"::",
"debug",
"(",
"'Running command: '",
".",
"$",
"name",
",",
"'bootstrap'",
")",
";",
"try",
"{",
"$",
"command",
"->",
"invoke",
"(",
"$",
"final_args",
",",
"$",
"assoc_args",
",",
"$",
"extra_args",
")",
";",
"}",
"catch",
"(",
"WP_CLI",
"\\",
"Iterators",
"\\",
"Exception",
"$",
"e",
")",
"{",
"WP_CLI",
"::",
"error",
"(",
"$",
"e",
"->",
"getMessage",
"(",
")",
")",
";",
"}",
"}"
] | 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. | [
"Find",
"the",
"WP",
"-",
"CLI",
"command",
"to",
"run",
"given",
"arguments",
"and",
"invoke",
"it",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L348-L375 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.show_synopsis_if_composite_command | public function show_synopsis_if_composite_command() {
$r = $this->find_command_to_run( $this->arguments );
if ( is_array( $r ) ) {
list( $command ) = $r;
if ( $command->can_have_subcommands() ) {
$command->show_usage();
exit;
}
}
} | php | public function show_synopsis_if_composite_command() {
$r = $this->find_command_to_run( $this->arguments );
if ( is_array( $r ) ) {
list( $command ) = $r;
if ( $command->can_have_subcommands() ) {
$command->show_usage();
exit;
}
}
} | [
"public",
"function",
"show_synopsis_if_composite_command",
"(",
")",
"{",
"$",
"r",
"=",
"$",
"this",
"->",
"find_command_to_run",
"(",
"$",
"this",
"->",
"arguments",
")",
";",
"if",
"(",
"is_array",
"(",
"$",
"r",
")",
")",
"{",
"list",
"(",
"$",
"command",
")",
"=",
"$",
"r",
";",
"if",
"(",
"$",
"command",
"->",
"can_have_subcommands",
"(",
")",
")",
"{",
"$",
"command",
"->",
"show_usage",
"(",
")",
";",
"exit",
";",
"}",
"}",
"}"
] | Show synopsis if the called command is a composite command | [
"Show",
"synopsis",
"if",
"the",
"called",
"command",
"is",
"a",
"composite",
"command"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L380-L390 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.generate_ssh_command | private function generate_ssh_command( $bits, $wp_command ) {
$escaped_command = '';
// Set default values.
foreach ( array( 'scheme', 'user', 'host', 'port', 'path' ) as $bit ) {
if ( ! isset( $bits[ $bit ] ) ) {
$bits[ $bit ] = null;
}
WP_CLI::debug( 'SSH ' . $bit . ': ' . $bits[ $bit ], 'bootstrap' );
}
$is_tty = function_exists( 'posix_isatty' ) && posix_isatty( STDOUT );
if ( 'docker' === $bits['scheme'] ) {
$command = 'docker exec %s%s%s sh -c %s';
$escaped_command = sprintf(
$command,
$bits['user'] ? '--user ' . escapeshellarg( $bits['user'] ) . ' ' : '',
$is_tty ? '-t ' : '',
escapeshellarg( $bits['host'] ),
escapeshellarg( $wp_command )
);
}
if ( 'docker-compose' === $bits['scheme'] ) {
$command = 'docker-compose exec %s%s%s sh -c %s';
$escaped_command = sprintf(
$command,
$bits['user'] ? '--user ' . escapeshellarg( $bits['user'] ) . ' ' : '',
$is_tty ? '' : '-T ',
escapeshellarg( $bits['host'] ),
escapeshellarg( $wp_command )
);
}
// Vagrant ssh-config.
if ( 'vagrant' === $bits['scheme'] ) {
$command = 'vagrant ssh -c %s %s';
$escaped_command = sprintf(
$command,
escapeshellarg( $wp_command ),
escapeshellarg( $bits['host'] )
);
}
// Default scheme is SSH.
if ( 'ssh' === $bits['scheme'] || null === $bits['scheme'] ) {
$command = 'ssh -q %s%s %s %s';
if ( $bits['user'] ) {
$bits['host'] = $bits['user'] . '@' . $bits['host'];
}
$escaped_command = sprintf(
$command,
$bits['port'] ? '-p ' . (int) $bits['port'] . ' ' : '',
escapeshellarg( $bits['host'] ),
$is_tty ? '-t' : '-T',
escapeshellarg( $wp_command )
);
}
WP_CLI::debug( 'Running SSH command: ' . $escaped_command, 'bootstrap' );
return $escaped_command;
} | php | private function generate_ssh_command( $bits, $wp_command ) {
$escaped_command = '';
// Set default values.
foreach ( array( 'scheme', 'user', 'host', 'port', 'path' ) as $bit ) {
if ( ! isset( $bits[ $bit ] ) ) {
$bits[ $bit ] = null;
}
WP_CLI::debug( 'SSH ' . $bit . ': ' . $bits[ $bit ], 'bootstrap' );
}
$is_tty = function_exists( 'posix_isatty' ) && posix_isatty( STDOUT );
if ( 'docker' === $bits['scheme'] ) {
$command = 'docker exec %s%s%s sh -c %s';
$escaped_command = sprintf(
$command,
$bits['user'] ? '--user ' . escapeshellarg( $bits['user'] ) . ' ' : '',
$is_tty ? '-t ' : '',
escapeshellarg( $bits['host'] ),
escapeshellarg( $wp_command )
);
}
if ( 'docker-compose' === $bits['scheme'] ) {
$command = 'docker-compose exec %s%s%s sh -c %s';
$escaped_command = sprintf(
$command,
$bits['user'] ? '--user ' . escapeshellarg( $bits['user'] ) . ' ' : '',
$is_tty ? '' : '-T ',
escapeshellarg( $bits['host'] ),
escapeshellarg( $wp_command )
);
}
// Vagrant ssh-config.
if ( 'vagrant' === $bits['scheme'] ) {
$command = 'vagrant ssh -c %s %s';
$escaped_command = sprintf(
$command,
escapeshellarg( $wp_command ),
escapeshellarg( $bits['host'] )
);
}
// Default scheme is SSH.
if ( 'ssh' === $bits['scheme'] || null === $bits['scheme'] ) {
$command = 'ssh -q %s%s %s %s';
if ( $bits['user'] ) {
$bits['host'] = $bits['user'] . '@' . $bits['host'];
}
$escaped_command = sprintf(
$command,
$bits['port'] ? '-p ' . (int) $bits['port'] . ' ' : '',
escapeshellarg( $bits['host'] ),
$is_tty ? '-t' : '-T',
escapeshellarg( $wp_command )
);
}
WP_CLI::debug( 'Running SSH command: ' . $escaped_command, 'bootstrap' );
return $escaped_command;
} | [
"private",
"function",
"generate_ssh_command",
"(",
"$",
"bits",
",",
"$",
"wp_command",
")",
"{",
"$",
"escaped_command",
"=",
"''",
";",
"// Set default values.",
"foreach",
"(",
"array",
"(",
"'scheme'",
",",
"'user'",
",",
"'host'",
",",
"'port'",
",",
"'path'",
")",
"as",
"$",
"bit",
")",
"{",
"if",
"(",
"!",
"isset",
"(",
"$",
"bits",
"[",
"$",
"bit",
"]",
")",
")",
"{",
"$",
"bits",
"[",
"$",
"bit",
"]",
"=",
"null",
";",
"}",
"WP_CLI",
"::",
"debug",
"(",
"'SSH '",
".",
"$",
"bit",
".",
"': '",
".",
"$",
"bits",
"[",
"$",
"bit",
"]",
",",
"'bootstrap'",
")",
";",
"}",
"$",
"is_tty",
"=",
"function_exists",
"(",
"'posix_isatty'",
")",
"&&",
"posix_isatty",
"(",
"STDOUT",
")",
";",
"if",
"(",
"'docker'",
"===",
"$",
"bits",
"[",
"'scheme'",
"]",
")",
"{",
"$",
"command",
"=",
"'docker exec %s%s%s sh -c %s'",
";",
"$",
"escaped_command",
"=",
"sprintf",
"(",
"$",
"command",
",",
"$",
"bits",
"[",
"'user'",
"]",
"?",
"'--user '",
".",
"escapeshellarg",
"(",
"$",
"bits",
"[",
"'user'",
"]",
")",
".",
"' '",
":",
"''",
",",
"$",
"is_tty",
"?",
"'-t '",
":",
"''",
",",
"escapeshellarg",
"(",
"$",
"bits",
"[",
"'host'",
"]",
")",
",",
"escapeshellarg",
"(",
"$",
"wp_command",
")",
")",
";",
"}",
"if",
"(",
"'docker-compose'",
"===",
"$",
"bits",
"[",
"'scheme'",
"]",
")",
"{",
"$",
"command",
"=",
"'docker-compose exec %s%s%s sh -c %s'",
";",
"$",
"escaped_command",
"=",
"sprintf",
"(",
"$",
"command",
",",
"$",
"bits",
"[",
"'user'",
"]",
"?",
"'--user '",
".",
"escapeshellarg",
"(",
"$",
"bits",
"[",
"'user'",
"]",
")",
".",
"' '",
":",
"''",
",",
"$",
"is_tty",
"?",
"''",
":",
"'-T '",
",",
"escapeshellarg",
"(",
"$",
"bits",
"[",
"'host'",
"]",
")",
",",
"escapeshellarg",
"(",
"$",
"wp_command",
")",
")",
";",
"}",
"// Vagrant ssh-config.",
"if",
"(",
"'vagrant'",
"===",
"$",
"bits",
"[",
"'scheme'",
"]",
")",
"{",
"$",
"command",
"=",
"'vagrant ssh -c %s %s'",
";",
"$",
"escaped_command",
"=",
"sprintf",
"(",
"$",
"command",
",",
"escapeshellarg",
"(",
"$",
"wp_command",
")",
",",
"escapeshellarg",
"(",
"$",
"bits",
"[",
"'host'",
"]",
")",
")",
";",
"}",
"// Default scheme is SSH.",
"if",
"(",
"'ssh'",
"===",
"$",
"bits",
"[",
"'scheme'",
"]",
"||",
"null",
"===",
"$",
"bits",
"[",
"'scheme'",
"]",
")",
"{",
"$",
"command",
"=",
"'ssh -q %s%s %s %s'",
";",
"if",
"(",
"$",
"bits",
"[",
"'user'",
"]",
")",
"{",
"$",
"bits",
"[",
"'host'",
"]",
"=",
"$",
"bits",
"[",
"'user'",
"]",
".",
"'@'",
".",
"$",
"bits",
"[",
"'host'",
"]",
";",
"}",
"$",
"escaped_command",
"=",
"sprintf",
"(",
"$",
"command",
",",
"$",
"bits",
"[",
"'port'",
"]",
"?",
"'-p '",
".",
"(",
"int",
")",
"$",
"bits",
"[",
"'port'",
"]",
".",
"' '",
":",
"''",
",",
"escapeshellarg",
"(",
"$",
"bits",
"[",
"'host'",
"]",
")",
",",
"$",
"is_tty",
"?",
"'-t'",
":",
"'-T'",
",",
"escapeshellarg",
"(",
"$",
"wp_command",
")",
")",
";",
"}",
"WP_CLI",
"::",
"debug",
"(",
"'Running SSH command: '",
".",
"$",
"escaped_command",
",",
"'bootstrap'",
")",
";",
"return",
"$",
"escaped_command",
";",
"}"
] | 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 | [
"Generate",
"a",
"shell",
"command",
"from",
"the",
"parsed",
"connection",
"string",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L486-L555 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.is_command_disabled | public function is_command_disabled( $command ) {
$path = implode( ' ', array_slice( \WP_CLI\Dispatcher\get_path( $command ), 1 ) );
return in_array( $path, $this->config['disabled_commands'], true );
} | php | public function is_command_disabled( $command ) {
$path = implode( ' ', array_slice( \WP_CLI\Dispatcher\get_path( $command ), 1 ) );
return in_array( $path, $this->config['disabled_commands'], true );
} | [
"public",
"function",
"is_command_disabled",
"(",
"$",
"command",
")",
"{",
"$",
"path",
"=",
"implode",
"(",
"' '",
",",
"array_slice",
"(",
"\\",
"WP_CLI",
"\\",
"Dispatcher",
"\\",
"get_path",
"(",
"$",
"command",
")",
",",
"1",
")",
")",
";",
"return",
"in_array",
"(",
"$",
"path",
",",
"$",
"this",
"->",
"config",
"[",
"'disabled_commands'",
"]",
",",
"true",
")",
";",
"}"
] | Check whether a given command is disabled by the config
@return bool | [
"Check",
"whether",
"a",
"given",
"command",
"is",
"disabled",
"by",
"the",
"config"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L562-L565 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.get_wp_config_code | public function get_wp_config_code() {
$wp_config_path = Utils\locate_wp_config();
$wp_config_code = explode( "\n", file_get_contents( $wp_config_path ) );
$found_wp_settings = false;
$lines_to_run = array();
foreach ( $wp_config_code as $line ) {
if ( preg_match( '/^\s*require.+wp-settings\.php/', $line ) ) {
$found_wp_settings = true;
continue;
}
$lines_to_run[] = $line;
}
if ( ! $found_wp_settings ) {
WP_CLI::error( 'Strange wp-config.php file: wp-settings.php is not loaded directly.' );
}
$source = implode( "\n", $lines_to_run );
$source = Utils\replace_path_consts( $source, $wp_config_path );
return preg_replace( '|^\s*\<\?php\s*|', '', $source );
} | php | public function get_wp_config_code() {
$wp_config_path = Utils\locate_wp_config();
$wp_config_code = explode( "\n", file_get_contents( $wp_config_path ) );
$found_wp_settings = false;
$lines_to_run = array();
foreach ( $wp_config_code as $line ) {
if ( preg_match( '/^\s*require.+wp-settings\.php/', $line ) ) {
$found_wp_settings = true;
continue;
}
$lines_to_run[] = $line;
}
if ( ! $found_wp_settings ) {
WP_CLI::error( 'Strange wp-config.php file: wp-settings.php is not loaded directly.' );
}
$source = implode( "\n", $lines_to_run );
$source = Utils\replace_path_consts( $source, $wp_config_path );
return preg_replace( '|^\s*\<\?php\s*|', '', $source );
} | [
"public",
"function",
"get_wp_config_code",
"(",
")",
"{",
"$",
"wp_config_path",
"=",
"Utils",
"\\",
"locate_wp_config",
"(",
")",
";",
"$",
"wp_config_code",
"=",
"explode",
"(",
"\"\\n\"",
",",
"file_get_contents",
"(",
"$",
"wp_config_path",
")",
")",
";",
"$",
"found_wp_settings",
"=",
"false",
";",
"$",
"lines_to_run",
"=",
"array",
"(",
")",
";",
"foreach",
"(",
"$",
"wp_config_code",
"as",
"$",
"line",
")",
"{",
"if",
"(",
"preg_match",
"(",
"'/^\\s*require.+wp-settings\\.php/'",
",",
"$",
"line",
")",
")",
"{",
"$",
"found_wp_settings",
"=",
"true",
";",
"continue",
";",
"}",
"$",
"lines_to_run",
"[",
"]",
"=",
"$",
"line",
";",
"}",
"if",
"(",
"!",
"$",
"found_wp_settings",
")",
"{",
"WP_CLI",
"::",
"error",
"(",
"'Strange wp-config.php file: wp-settings.php is not loaded directly.'",
")",
";",
"}",
"$",
"source",
"=",
"implode",
"(",
"\"\\n\"",
",",
"$",
"lines_to_run",
")",
";",
"$",
"source",
"=",
"Utils",
"\\",
"replace_path_consts",
"(",
"$",
"source",
",",
"$",
"wp_config_path",
")",
";",
"return",
"preg_replace",
"(",
"'|^\\s*\\<\\?php\\s*|'",
",",
"''",
",",
"$",
"source",
")",
";",
"}"
] | Returns wp-config.php code, skipping the loading of wp-settings.php
@return string | [
"Returns",
"wp",
"-",
"config",
".",
"php",
"code",
"skipping",
"the",
"loading",
"of",
"wp",
"-",
"settings",
".",
"php"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L572-L597 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.load_wordpress | public function load_wordpress() {
static $wp_cli_is_loaded;
// Globals not explicitly globalized in WordPress
global $site_id, $wpdb, $public, $current_site, $current_blog, $path, $shortcode_tags;
if ( ! empty( $wp_cli_is_loaded ) ) {
return;
}
$wp_cli_is_loaded = true;
WP_CLI::debug( 'Begin WordPress load', 'bootstrap' );
WP_CLI::do_hook( 'before_wp_load' );
$this->check_wp_version();
$wp_config_path = Utils\locate_wp_config();
if ( ! $wp_config_path ) {
WP_CLI::error(
"'wp-config.php' not found.\n" .
'Either create one manually or use `wp config create`.'
);
}
WP_CLI::debug( 'wp-config.php path: ' . $wp_config_path, 'bootstrap' );
WP_CLI::do_hook( 'before_wp_config_load' );
// Load wp-config.php code, in the global scope
$wp_cli_original_defined_vars = get_defined_vars();
eval( $this->get_wp_config_code() ); // phpcs:ignore Squiz.PHP.Eval.Discouraged
foreach ( get_defined_vars() as $key => $var ) {
if ( array_key_exists( $key, $wp_cli_original_defined_vars ) || 'wp_cli_original_defined_vars' === $key ) {
continue;
}
// phpcs:ignore PHPCompatibility.Variables.ForbiddenGlobalVariableVariable.NonBareVariableFound
global ${$key};
// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedVariableFound
${$key} = $var;
}
$this->maybe_update_url_from_domain_constant();
WP_CLI::do_hook( 'after_wp_config_load' );
$this->do_early_invoke( 'after_wp_config_load' );
// Prevent error notice from wp_guess_url() when core isn't installed
if ( $this->cmd_starts_with( array( 'core', 'is-installed' ) )
&& ! defined( 'COOKIEHASH' ) ) {
define( 'COOKIEHASH', md5( 'wp-cli' ) );
}
// Load WP-CLI utilities
require WP_CLI_ROOT . '/php/utils-wp.php';
// Set up WordPress bootstrap actions and filters
$this->setup_bootstrap_hooks();
// Load Core, mu-plugins, plugins, themes etc.
if ( Utils\wp_version_compare( '4.6-alpha-37575', '>=' ) ) {
if ( $this->cmd_starts_with( array( 'help' ) ) ) {
// Hack: define `WP_DEBUG` and `WP_DEBUG_DISPLAY` to get `wpdb::bail()` to `wp_die()`.
if ( ! defined( 'WP_DEBUG' ) ) {
define( 'WP_DEBUG', true );
}
if ( ! defined( 'WP_DEBUG_DISPLAY' ) ) {
define( 'WP_DEBUG_DISPLAY', true );
}
}
require ABSPATH . 'wp-settings.php';
} else {
require WP_CLI_ROOT . '/php/wp-settings-cli.php';
}
// Fix memory limit. See http://core.trac.wordpress.org/ticket/14889
// phpcs:ignore WordPress.PHP.IniSet.memory_limit_Blacklisted -- This is perfectly fine for CLI usage.
ini_set( 'memory_limit', -1 );
// Load all the admin APIs, for convenience
require ABSPATH . 'wp-admin/includes/admin.php';
add_filter(
'filesystem_method',
function() {
return 'direct';
},
99
);
// Re-enable PHP error reporting to stderr if testing.
if ( getenv( 'BEHAT_RUN' ) ) {
$this->enable_error_reporting();
}
WP_CLI::debug( 'Loaded WordPress', 'bootstrap' );
WP_CLI::do_hook( 'after_wp_load' );
} | php | public function load_wordpress() {
static $wp_cli_is_loaded;
// Globals not explicitly globalized in WordPress
global $site_id, $wpdb, $public, $current_site, $current_blog, $path, $shortcode_tags;
if ( ! empty( $wp_cli_is_loaded ) ) {
return;
}
$wp_cli_is_loaded = true;
WP_CLI::debug( 'Begin WordPress load', 'bootstrap' );
WP_CLI::do_hook( 'before_wp_load' );
$this->check_wp_version();
$wp_config_path = Utils\locate_wp_config();
if ( ! $wp_config_path ) {
WP_CLI::error(
"'wp-config.php' not found.\n" .
'Either create one manually or use `wp config create`.'
);
}
WP_CLI::debug( 'wp-config.php path: ' . $wp_config_path, 'bootstrap' );
WP_CLI::do_hook( 'before_wp_config_load' );
// Load wp-config.php code, in the global scope
$wp_cli_original_defined_vars = get_defined_vars();
eval( $this->get_wp_config_code() ); // phpcs:ignore Squiz.PHP.Eval.Discouraged
foreach ( get_defined_vars() as $key => $var ) {
if ( array_key_exists( $key, $wp_cli_original_defined_vars ) || 'wp_cli_original_defined_vars' === $key ) {
continue;
}
// phpcs:ignore PHPCompatibility.Variables.ForbiddenGlobalVariableVariable.NonBareVariableFound
global ${$key};
// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedVariableFound
${$key} = $var;
}
$this->maybe_update_url_from_domain_constant();
WP_CLI::do_hook( 'after_wp_config_load' );
$this->do_early_invoke( 'after_wp_config_load' );
// Prevent error notice from wp_guess_url() when core isn't installed
if ( $this->cmd_starts_with( array( 'core', 'is-installed' ) )
&& ! defined( 'COOKIEHASH' ) ) {
define( 'COOKIEHASH', md5( 'wp-cli' ) );
}
// Load WP-CLI utilities
require WP_CLI_ROOT . '/php/utils-wp.php';
// Set up WordPress bootstrap actions and filters
$this->setup_bootstrap_hooks();
// Load Core, mu-plugins, plugins, themes etc.
if ( Utils\wp_version_compare( '4.6-alpha-37575', '>=' ) ) {
if ( $this->cmd_starts_with( array( 'help' ) ) ) {
// Hack: define `WP_DEBUG` and `WP_DEBUG_DISPLAY` to get `wpdb::bail()` to `wp_die()`.
if ( ! defined( 'WP_DEBUG' ) ) {
define( 'WP_DEBUG', true );
}
if ( ! defined( 'WP_DEBUG_DISPLAY' ) ) {
define( 'WP_DEBUG_DISPLAY', true );
}
}
require ABSPATH . 'wp-settings.php';
} else {
require WP_CLI_ROOT . '/php/wp-settings-cli.php';
}
// Fix memory limit. See http://core.trac.wordpress.org/ticket/14889
// phpcs:ignore WordPress.PHP.IniSet.memory_limit_Blacklisted -- This is perfectly fine for CLI usage.
ini_set( 'memory_limit', -1 );
// Load all the admin APIs, for convenience
require ABSPATH . 'wp-admin/includes/admin.php';
add_filter(
'filesystem_method',
function() {
return 'direct';
},
99
);
// Re-enable PHP error reporting to stderr if testing.
if ( getenv( 'BEHAT_RUN' ) ) {
$this->enable_error_reporting();
}
WP_CLI::debug( 'Loaded WordPress', 'bootstrap' );
WP_CLI::do_hook( 'after_wp_load' );
} | [
"public",
"function",
"load_wordpress",
"(",
")",
"{",
"static",
"$",
"wp_cli_is_loaded",
";",
"// Globals not explicitly globalized in WordPress",
"global",
"$",
"site_id",
",",
"$",
"wpdb",
",",
"$",
"public",
",",
"$",
"current_site",
",",
"$",
"current_blog",
",",
"$",
"path",
",",
"$",
"shortcode_tags",
";",
"if",
"(",
"!",
"empty",
"(",
"$",
"wp_cli_is_loaded",
")",
")",
"{",
"return",
";",
"}",
"$",
"wp_cli_is_loaded",
"=",
"true",
";",
"WP_CLI",
"::",
"debug",
"(",
"'Begin WordPress load'",
",",
"'bootstrap'",
")",
";",
"WP_CLI",
"::",
"do_hook",
"(",
"'before_wp_load'",
")",
";",
"$",
"this",
"->",
"check_wp_version",
"(",
")",
";",
"$",
"wp_config_path",
"=",
"Utils",
"\\",
"locate_wp_config",
"(",
")",
";",
"if",
"(",
"!",
"$",
"wp_config_path",
")",
"{",
"WP_CLI",
"::",
"error",
"(",
"\"'wp-config.php' not found.\\n\"",
".",
"'Either create one manually or use `wp config create`.'",
")",
";",
"}",
"WP_CLI",
"::",
"debug",
"(",
"'wp-config.php path: '",
".",
"$",
"wp_config_path",
",",
"'bootstrap'",
")",
";",
"WP_CLI",
"::",
"do_hook",
"(",
"'before_wp_config_load'",
")",
";",
"// Load wp-config.php code, in the global scope",
"$",
"wp_cli_original_defined_vars",
"=",
"get_defined_vars",
"(",
")",
";",
"eval",
"(",
"$",
"this",
"->",
"get_wp_config_code",
"(",
")",
")",
";",
"// phpcs:ignore Squiz.PHP.Eval.Discouraged",
"foreach",
"(",
"get_defined_vars",
"(",
")",
"as",
"$",
"key",
"=>",
"$",
"var",
")",
"{",
"if",
"(",
"array_key_exists",
"(",
"$",
"key",
",",
"$",
"wp_cli_original_defined_vars",
")",
"||",
"'wp_cli_original_defined_vars'",
"===",
"$",
"key",
")",
"{",
"continue",
";",
"}",
"// phpcs:ignore PHPCompatibility.Variables.ForbiddenGlobalVariableVariable.NonBareVariableFound",
"global",
"$",
"{",
"$",
"key",
"}",
";",
"// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedVariableFound",
"$",
"{",
"$",
"key",
"}",
"=",
"$",
"var",
";",
"}",
"$",
"this",
"->",
"maybe_update_url_from_domain_constant",
"(",
")",
";",
"WP_CLI",
"::",
"do_hook",
"(",
"'after_wp_config_load'",
")",
";",
"$",
"this",
"->",
"do_early_invoke",
"(",
"'after_wp_config_load'",
")",
";",
"// Prevent error notice from wp_guess_url() when core isn't installed",
"if",
"(",
"$",
"this",
"->",
"cmd_starts_with",
"(",
"array",
"(",
"'core'",
",",
"'is-installed'",
")",
")",
"&&",
"!",
"defined",
"(",
"'COOKIEHASH'",
")",
")",
"{",
"define",
"(",
"'COOKIEHASH'",
",",
"md5",
"(",
"'wp-cli'",
")",
")",
";",
"}",
"// Load WP-CLI utilities",
"require",
"WP_CLI_ROOT",
".",
"'/php/utils-wp.php'",
";",
"// Set up WordPress bootstrap actions and filters",
"$",
"this",
"->",
"setup_bootstrap_hooks",
"(",
")",
";",
"// Load Core, mu-plugins, plugins, themes etc.",
"if",
"(",
"Utils",
"\\",
"wp_version_compare",
"(",
"'4.6-alpha-37575'",
",",
"'>='",
")",
")",
"{",
"if",
"(",
"$",
"this",
"->",
"cmd_starts_with",
"(",
"array",
"(",
"'help'",
")",
")",
")",
"{",
"// Hack: define `WP_DEBUG` and `WP_DEBUG_DISPLAY` to get `wpdb::bail()` to `wp_die()`.",
"if",
"(",
"!",
"defined",
"(",
"'WP_DEBUG'",
")",
")",
"{",
"define",
"(",
"'WP_DEBUG'",
",",
"true",
")",
";",
"}",
"if",
"(",
"!",
"defined",
"(",
"'WP_DEBUG_DISPLAY'",
")",
")",
"{",
"define",
"(",
"'WP_DEBUG_DISPLAY'",
",",
"true",
")",
";",
"}",
"}",
"require",
"ABSPATH",
".",
"'wp-settings.php'",
";",
"}",
"else",
"{",
"require",
"WP_CLI_ROOT",
".",
"'/php/wp-settings-cli.php'",
";",
"}",
"// Fix memory limit. See http://core.trac.wordpress.org/ticket/14889",
"// phpcs:ignore WordPress.PHP.IniSet.memory_limit_Blacklisted -- This is perfectly fine for CLI usage.",
"ini_set",
"(",
"'memory_limit'",
",",
"-",
"1",
")",
";",
"// Load all the admin APIs, for convenience",
"require",
"ABSPATH",
".",
"'wp-admin/includes/admin.php'",
";",
"add_filter",
"(",
"'filesystem_method'",
",",
"function",
"(",
")",
"{",
"return",
"'direct'",
";",
"}",
",",
"99",
")",
";",
"// Re-enable PHP error reporting to stderr if testing.",
"if",
"(",
"getenv",
"(",
"'BEHAT_RUN'",
")",
")",
"{",
"$",
"this",
"->",
"enable_error_reporting",
"(",
")",
";",
"}",
"WP_CLI",
"::",
"debug",
"(",
"'Loaded WordPress'",
",",
"'bootstrap'",
")",
";",
"WP_CLI",
"::",
"do_hook",
"(",
"'after_wp_load'",
")",
";",
"}"
] | Load WordPress, if it hasn't already been loaded | [
"Load",
"WordPress",
"if",
"it",
"hasn",
"t",
"already",
"been",
"loaded"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L1139-L1237 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.setup_skip_plugins_filters | private function setup_skip_plugins_filters() {
$wp_cli_filter_active_plugins = function( $plugins ) {
$skipped_plugins = WP_CLI::get_runner()->config['skip-plugins'];
if ( true === $skipped_plugins ) {
return array();
}
if ( ! is_array( $plugins ) ) {
return $plugins;
}
foreach ( $plugins as $a => $b ) {
// active_sitewide_plugins stores plugin name as the key.
if ( false !== strpos( current_filter(), 'active_sitewide_plugins' ) && Utils\is_plugin_skipped( $a ) ) {
unset( $plugins[ $a ] );
// active_plugins stores plugin name as the value.
} elseif ( false !== strpos( current_filter(), 'active_plugins' ) && Utils\is_plugin_skipped( $b ) ) {
unset( $plugins[ $a ] );
}
}
// Reindex because active_plugins expects a numeric index.
if ( false !== strpos( current_filter(), 'active_plugins' ) ) {
$plugins = array_values( $plugins );
}
return $plugins;
};
$hooks = array(
'pre_site_option_active_sitewide_plugins',
'site_option_active_sitewide_plugins',
'pre_option_active_plugins',
'option_active_plugins',
);
foreach ( $hooks as $hook ) {
WP_CLI::add_wp_hook( $hook, $wp_cli_filter_active_plugins, 999 );
}
WP_CLI::add_wp_hook(
'plugins_loaded',
function() use ( $hooks, $wp_cli_filter_active_plugins ) {
foreach ( $hooks as $hook ) {
remove_filter( $hook, $wp_cli_filter_active_plugins, 999 );
}
},
0
);
} | php | private function setup_skip_plugins_filters() {
$wp_cli_filter_active_plugins = function( $plugins ) {
$skipped_plugins = WP_CLI::get_runner()->config['skip-plugins'];
if ( true === $skipped_plugins ) {
return array();
}
if ( ! is_array( $plugins ) ) {
return $plugins;
}
foreach ( $plugins as $a => $b ) {
// active_sitewide_plugins stores plugin name as the key.
if ( false !== strpos( current_filter(), 'active_sitewide_plugins' ) && Utils\is_plugin_skipped( $a ) ) {
unset( $plugins[ $a ] );
// active_plugins stores plugin name as the value.
} elseif ( false !== strpos( current_filter(), 'active_plugins' ) && Utils\is_plugin_skipped( $b ) ) {
unset( $plugins[ $a ] );
}
}
// Reindex because active_plugins expects a numeric index.
if ( false !== strpos( current_filter(), 'active_plugins' ) ) {
$plugins = array_values( $plugins );
}
return $plugins;
};
$hooks = array(
'pre_site_option_active_sitewide_plugins',
'site_option_active_sitewide_plugins',
'pre_option_active_plugins',
'option_active_plugins',
);
foreach ( $hooks as $hook ) {
WP_CLI::add_wp_hook( $hook, $wp_cli_filter_active_plugins, 999 );
}
WP_CLI::add_wp_hook(
'plugins_loaded',
function() use ( $hooks, $wp_cli_filter_active_plugins ) {
foreach ( $hooks as $hook ) {
remove_filter( $hook, $wp_cli_filter_active_plugins, 999 );
}
},
0
);
} | [
"private",
"function",
"setup_skip_plugins_filters",
"(",
")",
"{",
"$",
"wp_cli_filter_active_plugins",
"=",
"function",
"(",
"$",
"plugins",
")",
"{",
"$",
"skipped_plugins",
"=",
"WP_CLI",
"::",
"get_runner",
"(",
")",
"->",
"config",
"[",
"'skip-plugins'",
"]",
";",
"if",
"(",
"true",
"===",
"$",
"skipped_plugins",
")",
"{",
"return",
"array",
"(",
")",
";",
"}",
"if",
"(",
"!",
"is_array",
"(",
"$",
"plugins",
")",
")",
"{",
"return",
"$",
"plugins",
";",
"}",
"foreach",
"(",
"$",
"plugins",
"as",
"$",
"a",
"=>",
"$",
"b",
")",
"{",
"// active_sitewide_plugins stores plugin name as the key.",
"if",
"(",
"false",
"!==",
"strpos",
"(",
"current_filter",
"(",
")",
",",
"'active_sitewide_plugins'",
")",
"&&",
"Utils",
"\\",
"is_plugin_skipped",
"(",
"$",
"a",
")",
")",
"{",
"unset",
"(",
"$",
"plugins",
"[",
"$",
"a",
"]",
")",
";",
"// active_plugins stores plugin name as the value.",
"}",
"elseif",
"(",
"false",
"!==",
"strpos",
"(",
"current_filter",
"(",
")",
",",
"'active_plugins'",
")",
"&&",
"Utils",
"\\",
"is_plugin_skipped",
"(",
"$",
"b",
")",
")",
"{",
"unset",
"(",
"$",
"plugins",
"[",
"$",
"a",
"]",
")",
";",
"}",
"}",
"// Reindex because active_plugins expects a numeric index.",
"if",
"(",
"false",
"!==",
"strpos",
"(",
"current_filter",
"(",
")",
",",
"'active_plugins'",
")",
")",
"{",
"$",
"plugins",
"=",
"array_values",
"(",
"$",
"plugins",
")",
";",
"}",
"return",
"$",
"plugins",
";",
"}",
";",
"$",
"hooks",
"=",
"array",
"(",
"'pre_site_option_active_sitewide_plugins'",
",",
"'site_option_active_sitewide_plugins'",
",",
"'pre_option_active_plugins'",
",",
"'option_active_plugins'",
",",
")",
";",
"foreach",
"(",
"$",
"hooks",
"as",
"$",
"hook",
")",
"{",
"WP_CLI",
"::",
"add_wp_hook",
"(",
"$",
"hook",
",",
"$",
"wp_cli_filter_active_plugins",
",",
"999",
")",
";",
"}",
"WP_CLI",
"::",
"add_wp_hook",
"(",
"'plugins_loaded'",
",",
"function",
"(",
")",
"use",
"(",
"$",
"hooks",
",",
"$",
"wp_cli_filter_active_plugins",
")",
"{",
"foreach",
"(",
"$",
"hooks",
"as",
"$",
"hook",
")",
"{",
"remove_filter",
"(",
"$",
"hook",
",",
"$",
"wp_cli_filter_active_plugins",
",",
"999",
")",
";",
"}",
"}",
",",
"0",
")",
";",
"}"
] | Set up the filters to skip the loaded plugins | [
"Set",
"up",
"the",
"filters",
"to",
"skip",
"the",
"loaded",
"plugins"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L1535-L1578 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.action_setup_theme_wp_cli_skip_themes | public function action_setup_theme_wp_cli_skip_themes() {
$wp_cli_filter_active_theme = function( $value ) {
$skipped_themes = WP_CLI::get_runner()->config['skip-themes'];
if ( true === $skipped_themes ) {
return '';
}
if ( ! is_array( $skipped_themes ) ) {
$skipped_themes = explode( ',', $skipped_themes );
}
$checked_value = $value;
// Always check against the stylesheet value
// This ensures a child theme can be skipped when template differs
if ( false !== stripos( current_filter(), 'option_template' ) ) {
$checked_value = get_option( 'stylesheet' );
}
if ( '' === $checked_value || in_array( $checked_value, $skipped_themes, true ) ) {
return '';
}
return $value;
};
$hooks = array(
'pre_option_template',
'option_template',
'pre_option_stylesheet',
'option_stylesheet',
);
foreach ( $hooks as $hook ) {
add_filter( $hook, $wp_cli_filter_active_theme, 999 );
}
// Clean up after the TEMPLATEPATH and STYLESHEETPATH constants are defined
WP_CLI::add_wp_hook(
'after_setup_theme',
function() use ( $hooks, $wp_cli_filter_active_theme ) {
foreach ( $hooks as $hook ) {
remove_filter( $hook, $wp_cli_filter_active_theme, 999 );
}
},
0
);
} | php | public function action_setup_theme_wp_cli_skip_themes() {
$wp_cli_filter_active_theme = function( $value ) {
$skipped_themes = WP_CLI::get_runner()->config['skip-themes'];
if ( true === $skipped_themes ) {
return '';
}
if ( ! is_array( $skipped_themes ) ) {
$skipped_themes = explode( ',', $skipped_themes );
}
$checked_value = $value;
// Always check against the stylesheet value
// This ensures a child theme can be skipped when template differs
if ( false !== stripos( current_filter(), 'option_template' ) ) {
$checked_value = get_option( 'stylesheet' );
}
if ( '' === $checked_value || in_array( $checked_value, $skipped_themes, true ) ) {
return '';
}
return $value;
};
$hooks = array(
'pre_option_template',
'option_template',
'pre_option_stylesheet',
'option_stylesheet',
);
foreach ( $hooks as $hook ) {
add_filter( $hook, $wp_cli_filter_active_theme, 999 );
}
// Clean up after the TEMPLATEPATH and STYLESHEETPATH constants are defined
WP_CLI::add_wp_hook(
'after_setup_theme',
function() use ( $hooks, $wp_cli_filter_active_theme ) {
foreach ( $hooks as $hook ) {
remove_filter( $hook, $wp_cli_filter_active_theme, 999 );
}
},
0
);
} | [
"public",
"function",
"action_setup_theme_wp_cli_skip_themes",
"(",
")",
"{",
"$",
"wp_cli_filter_active_theme",
"=",
"function",
"(",
"$",
"value",
")",
"{",
"$",
"skipped_themes",
"=",
"WP_CLI",
"::",
"get_runner",
"(",
")",
"->",
"config",
"[",
"'skip-themes'",
"]",
";",
"if",
"(",
"true",
"===",
"$",
"skipped_themes",
")",
"{",
"return",
"''",
";",
"}",
"if",
"(",
"!",
"is_array",
"(",
"$",
"skipped_themes",
")",
")",
"{",
"$",
"skipped_themes",
"=",
"explode",
"(",
"','",
",",
"$",
"skipped_themes",
")",
";",
"}",
"$",
"checked_value",
"=",
"$",
"value",
";",
"// Always check against the stylesheet value",
"// This ensures a child theme can be skipped when template differs",
"if",
"(",
"false",
"!==",
"stripos",
"(",
"current_filter",
"(",
")",
",",
"'option_template'",
")",
")",
"{",
"$",
"checked_value",
"=",
"get_option",
"(",
"'stylesheet'",
")",
";",
"}",
"if",
"(",
"''",
"===",
"$",
"checked_value",
"||",
"in_array",
"(",
"$",
"checked_value",
",",
"$",
"skipped_themes",
",",
"true",
")",
")",
"{",
"return",
"''",
";",
"}",
"return",
"$",
"value",
";",
"}",
";",
"$",
"hooks",
"=",
"array",
"(",
"'pre_option_template'",
",",
"'option_template'",
",",
"'pre_option_stylesheet'",
",",
"'option_stylesheet'",
",",
")",
";",
"foreach",
"(",
"$",
"hooks",
"as",
"$",
"hook",
")",
"{",
"add_filter",
"(",
"$",
"hook",
",",
"$",
"wp_cli_filter_active_theme",
",",
"999",
")",
";",
"}",
"// Clean up after the TEMPLATEPATH and STYLESHEETPATH constants are defined",
"WP_CLI",
"::",
"add_wp_hook",
"(",
"'after_setup_theme'",
",",
"function",
"(",
")",
"use",
"(",
"$",
"hooks",
",",
"$",
"wp_cli_filter_active_theme",
")",
"{",
"foreach",
"(",
"$",
"hooks",
"as",
"$",
"hook",
")",
"{",
"remove_filter",
"(",
"$",
"hook",
",",
"$",
"wp_cli_filter_active_theme",
",",
"999",
")",
";",
"}",
"}",
",",
"0",
")",
";",
"}"
] | Set up the filters to skip the loaded theme | [
"Set",
"up",
"the",
"filters",
"to",
"skip",
"the",
"loaded",
"theme"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L1583-L1624 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.auto_check_update | private function auto_check_update() {
// `wp cli update` only works with Phars at this time.
if ( ! Utils\inside_phar() ) {
return;
}
$existing_phar = realpath( $_SERVER['argv'][0] );
// Phar needs to be writable to be easily updateable.
if ( ! is_writable( $existing_phar ) || ! is_writable( dirname( $existing_phar ) ) ) {
return;
}
// Only check for update when a human is operating.
if ( ! function_exists( 'posix_isatty' ) || ! posix_isatty( STDOUT ) ) {
return;
}
// Allow hosts and other providers to disable automatic check update.
if ( getenv( 'WP_CLI_DISABLE_AUTO_CHECK_UPDATE' ) ) {
return;
}
// Permit configuration of number of days between checks.
$days_between_checks = getenv( 'WP_CLI_AUTO_CHECK_UPDATE_DAYS' );
if ( false === $days_between_checks ) {
$days_between_checks = 1;
}
$cache = WP_CLI::get_cache();
$cache_key = 'wp-cli-update-check';
// Bail early on the first check, so we don't always check on an unwritable cache.
if ( ! $cache->has( $cache_key ) ) {
$cache->write( $cache_key, time() );
return;
}
// Bail if last check is still within our update check time period.
$last_check = (int) $cache->read( $cache_key );
if ( ( time() - ( 24 * 60 * 60 * $days_between_checks ) ) < $last_check ) {
return;
}
// In case the operation fails, ensure the timestamp has been updated.
$cache->write( $cache_key, time() );
// Check whether any updates are available.
ob_start();
WP_CLI::run_command(
array( 'cli', 'check-update' ),
array(
'format' => 'count',
)
);
$count = ob_get_clean();
if ( ! $count ) {
return;
}
// Looks like an update is available, so let's prompt to update.
WP_CLI::run_command( array( 'cli', 'update' ) );
// If the Phar was replaced, we can't proceed with the original process.
exit;
} | php | private function auto_check_update() {
// `wp cli update` only works with Phars at this time.
if ( ! Utils\inside_phar() ) {
return;
}
$existing_phar = realpath( $_SERVER['argv'][0] );
// Phar needs to be writable to be easily updateable.
if ( ! is_writable( $existing_phar ) || ! is_writable( dirname( $existing_phar ) ) ) {
return;
}
// Only check for update when a human is operating.
if ( ! function_exists( 'posix_isatty' ) || ! posix_isatty( STDOUT ) ) {
return;
}
// Allow hosts and other providers to disable automatic check update.
if ( getenv( 'WP_CLI_DISABLE_AUTO_CHECK_UPDATE' ) ) {
return;
}
// Permit configuration of number of days between checks.
$days_between_checks = getenv( 'WP_CLI_AUTO_CHECK_UPDATE_DAYS' );
if ( false === $days_between_checks ) {
$days_between_checks = 1;
}
$cache = WP_CLI::get_cache();
$cache_key = 'wp-cli-update-check';
// Bail early on the first check, so we don't always check on an unwritable cache.
if ( ! $cache->has( $cache_key ) ) {
$cache->write( $cache_key, time() );
return;
}
// Bail if last check is still within our update check time period.
$last_check = (int) $cache->read( $cache_key );
if ( ( time() - ( 24 * 60 * 60 * $days_between_checks ) ) < $last_check ) {
return;
}
// In case the operation fails, ensure the timestamp has been updated.
$cache->write( $cache_key, time() );
// Check whether any updates are available.
ob_start();
WP_CLI::run_command(
array( 'cli', 'check-update' ),
array(
'format' => 'count',
)
);
$count = ob_get_clean();
if ( ! $count ) {
return;
}
// Looks like an update is available, so let's prompt to update.
WP_CLI::run_command( array( 'cli', 'update' ) );
// If the Phar was replaced, we can't proceed with the original process.
exit;
} | [
"private",
"function",
"auto_check_update",
"(",
")",
"{",
"// `wp cli update` only works with Phars at this time.",
"if",
"(",
"!",
"Utils",
"\\",
"inside_phar",
"(",
")",
")",
"{",
"return",
";",
"}",
"$",
"existing_phar",
"=",
"realpath",
"(",
"$",
"_SERVER",
"[",
"'argv'",
"]",
"[",
"0",
"]",
")",
";",
"// Phar needs to be writable to be easily updateable.",
"if",
"(",
"!",
"is_writable",
"(",
"$",
"existing_phar",
")",
"||",
"!",
"is_writable",
"(",
"dirname",
"(",
"$",
"existing_phar",
")",
")",
")",
"{",
"return",
";",
"}",
"// Only check for update when a human is operating.",
"if",
"(",
"!",
"function_exists",
"(",
"'posix_isatty'",
")",
"||",
"!",
"posix_isatty",
"(",
"STDOUT",
")",
")",
"{",
"return",
";",
"}",
"// Allow hosts and other providers to disable automatic check update.",
"if",
"(",
"getenv",
"(",
"'WP_CLI_DISABLE_AUTO_CHECK_UPDATE'",
")",
")",
"{",
"return",
";",
"}",
"// Permit configuration of number of days between checks.",
"$",
"days_between_checks",
"=",
"getenv",
"(",
"'WP_CLI_AUTO_CHECK_UPDATE_DAYS'",
")",
";",
"if",
"(",
"false",
"===",
"$",
"days_between_checks",
")",
"{",
"$",
"days_between_checks",
"=",
"1",
";",
"}",
"$",
"cache",
"=",
"WP_CLI",
"::",
"get_cache",
"(",
")",
";",
"$",
"cache_key",
"=",
"'wp-cli-update-check'",
";",
"// Bail early on the first check, so we don't always check on an unwritable cache.",
"if",
"(",
"!",
"$",
"cache",
"->",
"has",
"(",
"$",
"cache_key",
")",
")",
"{",
"$",
"cache",
"->",
"write",
"(",
"$",
"cache_key",
",",
"time",
"(",
")",
")",
";",
"return",
";",
"}",
"// Bail if last check is still within our update check time period.",
"$",
"last_check",
"=",
"(",
"int",
")",
"$",
"cache",
"->",
"read",
"(",
"$",
"cache_key",
")",
";",
"if",
"(",
"(",
"time",
"(",
")",
"-",
"(",
"24",
"*",
"60",
"*",
"60",
"*",
"$",
"days_between_checks",
")",
")",
"<",
"$",
"last_check",
")",
"{",
"return",
";",
"}",
"// In case the operation fails, ensure the timestamp has been updated.",
"$",
"cache",
"->",
"write",
"(",
"$",
"cache_key",
",",
"time",
"(",
")",
")",
";",
"// Check whether any updates are available.",
"ob_start",
"(",
")",
";",
"WP_CLI",
"::",
"run_command",
"(",
"array",
"(",
"'cli'",
",",
"'check-update'",
")",
",",
"array",
"(",
"'format'",
"=>",
"'count'",
",",
")",
")",
";",
"$",
"count",
"=",
"ob_get_clean",
"(",
")",
";",
"if",
"(",
"!",
"$",
"count",
")",
"{",
"return",
";",
"}",
"// Looks like an update is available, so let's prompt to update.",
"WP_CLI",
"::",
"run_command",
"(",
"array",
"(",
"'cli'",
",",
"'update'",
")",
")",
";",
"// If the Phar was replaced, we can't proceed with the original process.",
"exit",
";",
"}"
] | Check whether there's a WP-CLI update available, and suggest update if so. | [
"Check",
"whether",
"there",
"s",
"a",
"WP",
"-",
"CLI",
"update",
"available",
"and",
"suggest",
"update",
"if",
"so",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L1660-L1723 | train |
wp-cli/wp-cli | php/WP_CLI/Runner.php | Runner.enumerate_commands | private function enumerate_commands( CompositeCommand $command, array &$list, $parent = '' ) {
foreach ( $command->get_subcommands() as $subcommand ) {
/** @var CompositeCommand $subcommand */
$command_string = empty( $parent )
? $subcommand->get_name()
: "{$parent} {$subcommand->get_name()}";
$list[] = $command_string;
$this->enumerate_commands( $subcommand, $list, $command_string );
}
} | php | private function enumerate_commands( CompositeCommand $command, array &$list, $parent = '' ) {
foreach ( $command->get_subcommands() as $subcommand ) {
/** @var CompositeCommand $subcommand */
$command_string = empty( $parent )
? $subcommand->get_name()
: "{$parent} {$subcommand->get_name()}";
$list[] = $command_string;
$this->enumerate_commands( $subcommand, $list, $command_string );
}
} | [
"private",
"function",
"enumerate_commands",
"(",
"CompositeCommand",
"$",
"command",
",",
"array",
"&",
"$",
"list",
",",
"$",
"parent",
"=",
"''",
")",
"{",
"foreach",
"(",
"$",
"command",
"->",
"get_subcommands",
"(",
")",
"as",
"$",
"subcommand",
")",
"{",
"/** @var CompositeCommand $subcommand */",
"$",
"command_string",
"=",
"empty",
"(",
"$",
"parent",
")",
"?",
"$",
"subcommand",
"->",
"get_name",
"(",
")",
":",
"\"{$parent} {$subcommand->get_name()}\"",
";",
"$",
"list",
"[",
"]",
"=",
"$",
"command_string",
";",
"$",
"this",
"->",
"enumerate_commands",
"(",
"$",
"subcommand",
",",
"$",
"list",
",",
"$",
"command_string",
")",
";",
"}",
"}"
] | 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. | [
"Recursive",
"method",
"to",
"enumerate",
"all",
"known",
"commands",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Runner.php#L1750-L1761 | train |
wp-cli/wp-cli | php/WP_CLI/Extractor.php | Extractor.extract | public static function extract( $tarball_or_zip, $dest ) {
if ( preg_match( '/\.zip$/', $tarball_or_zip ) ) {
return self::extract_zip( $tarball_or_zip, $dest );
}
if ( preg_match( '/\.tar\.gz$/', $tarball_or_zip ) ) {
return self::extract_tarball( $tarball_or_zip, $dest );
}
throw new \Exception( "Extraction only supported for '.zip' and '.tar.gz' file types." );
} | php | public static function extract( $tarball_or_zip, $dest ) {
if ( preg_match( '/\.zip$/', $tarball_or_zip ) ) {
return self::extract_zip( $tarball_or_zip, $dest );
}
if ( preg_match( '/\.tar\.gz$/', $tarball_or_zip ) ) {
return self::extract_tarball( $tarball_or_zip, $dest );
}
throw new \Exception( "Extraction only supported for '.zip' and '.tar.gz' file types." );
} | [
"public",
"static",
"function",
"extract",
"(",
"$",
"tarball_or_zip",
",",
"$",
"dest",
")",
"{",
"if",
"(",
"preg_match",
"(",
"'/\\.zip$/'",
",",
"$",
"tarball_or_zip",
")",
")",
"{",
"return",
"self",
"::",
"extract_zip",
"(",
"$",
"tarball_or_zip",
",",
"$",
"dest",
")",
";",
"}",
"if",
"(",
"preg_match",
"(",
"'/\\.tar\\.gz$/'",
",",
"$",
"tarball_or_zip",
")",
")",
"{",
"return",
"self",
"::",
"extract_tarball",
"(",
"$",
"tarball_or_zip",
",",
"$",
"dest",
")",
";",
"}",
"throw",
"new",
"\\",
"Exception",
"(",
"\"Extraction only supported for '.zip' and '.tar.gz' file types.\"",
")",
";",
"}"
] | Extract the archive file to a specific destination.
@param string $dest | [
"Extract",
"the",
"archive",
"file",
"to",
"a",
"specific",
"destination",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Extractor.php#L23-L32 | train |
wp-cli/wp-cli | php/WP_CLI/Extractor.php | Extractor.extract_zip | private static function extract_zip( $zipfile, $dest ) {
if ( ! class_exists( 'ZipArchive' ) ) {
throw new \Exception( 'Extracting a zip file requires ZipArchive.' );
}
$zip = new ZipArchive();
$res = $zip->open( $zipfile );
if ( true === $res ) {
$tempdir = implode(
DIRECTORY_SEPARATOR,
array(
dirname( $zipfile ),
Utils\basename( $zipfile, '.zip' ),
$zip->getNameIndex( 0 ),
)
);
$zip->extractTo( dirname( $tempdir ) );
$zip->close();
self::copy_overwrite_files( $tempdir, $dest );
self::rmdir( dirname( $tempdir ) );
} else {
throw new \Exception( sprintf( "ZipArchive failed to unzip '%s': %s.", $zipfile, self::zip_error_msg( $res ) ) );
}
} | php | private static function extract_zip( $zipfile, $dest ) {
if ( ! class_exists( 'ZipArchive' ) ) {
throw new \Exception( 'Extracting a zip file requires ZipArchive.' );
}
$zip = new ZipArchive();
$res = $zip->open( $zipfile );
if ( true === $res ) {
$tempdir = implode(
DIRECTORY_SEPARATOR,
array(
dirname( $zipfile ),
Utils\basename( $zipfile, '.zip' ),
$zip->getNameIndex( 0 ),
)
);
$zip->extractTo( dirname( $tempdir ) );
$zip->close();
self::copy_overwrite_files( $tempdir, $dest );
self::rmdir( dirname( $tempdir ) );
} else {
throw new \Exception( sprintf( "ZipArchive failed to unzip '%s': %s.", $zipfile, self::zip_error_msg( $res ) ) );
}
} | [
"private",
"static",
"function",
"extract_zip",
"(",
"$",
"zipfile",
",",
"$",
"dest",
")",
"{",
"if",
"(",
"!",
"class_exists",
"(",
"'ZipArchive'",
")",
")",
"{",
"throw",
"new",
"\\",
"Exception",
"(",
"'Extracting a zip file requires ZipArchive.'",
")",
";",
"}",
"$",
"zip",
"=",
"new",
"ZipArchive",
"(",
")",
";",
"$",
"res",
"=",
"$",
"zip",
"->",
"open",
"(",
"$",
"zipfile",
")",
";",
"if",
"(",
"true",
"===",
"$",
"res",
")",
"{",
"$",
"tempdir",
"=",
"implode",
"(",
"DIRECTORY_SEPARATOR",
",",
"array",
"(",
"dirname",
"(",
"$",
"zipfile",
")",
",",
"Utils",
"\\",
"basename",
"(",
"$",
"zipfile",
",",
"'.zip'",
")",
",",
"$",
"zip",
"->",
"getNameIndex",
"(",
"0",
")",
",",
")",
")",
";",
"$",
"zip",
"->",
"extractTo",
"(",
"dirname",
"(",
"$",
"tempdir",
")",
")",
";",
"$",
"zip",
"->",
"close",
"(",
")",
";",
"self",
"::",
"copy_overwrite_files",
"(",
"$",
"tempdir",
",",
"$",
"dest",
")",
";",
"self",
"::",
"rmdir",
"(",
"dirname",
"(",
"$",
"tempdir",
")",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"\\",
"Exception",
"(",
"sprintf",
"(",
"\"ZipArchive failed to unzip '%s': %s.\"",
",",
"$",
"zipfile",
",",
"self",
"::",
"zip_error_msg",
"(",
"$",
"res",
")",
")",
")",
";",
"}",
"}"
] | Extract a ZIP file to a specific destination.
@param string $zipfile
@param string $dest | [
"Extract",
"a",
"ZIP",
"file",
"to",
"a",
"specific",
"destination",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Extractor.php#L40-L64 | train |
wp-cli/wp-cli | php/WP_CLI/Extractor.php | Extractor.extract_tarball | private static function extract_tarball( $tarball, $dest ) {
if ( class_exists( 'PharData' ) ) {
try {
$phar = new PharData( $tarball );
$tempdir = implode(
DIRECTORY_SEPARATOR,
array(
dirname( $tarball ),
Utils\basename( $tarball, '.tar.gz' ),
$phar->getFilename(),
)
);
$phar->extractTo( dirname( $tempdir ), null, true );
self::copy_overwrite_files( $tempdir, $dest );
self::rmdir( dirname( $tempdir ) );
return;
} catch ( \Exception $e ) {
WP_CLI::warning( "PharData failed, falling back to 'tar xz' (" . $e->getMessage() . ')' );
// Fall through to trying `tar xz` below
}
}
// Note: directory must exist for tar --directory to work.
$cmd = Utils\esc_cmd( 'tar xz --strip-components=1 --directory=%s -f %s', $dest, $tarball );
$process_run = WP_CLI::launch( $cmd, false /*exit_on_error*/, true /*return_detailed*/ );
if ( 0 !== $process_run->return_code ) {
throw new \Exception( sprintf( 'Failed to execute `%s`: %s.', $cmd, self::tar_error_msg( $process_run ) ) );
}
} | php | private static function extract_tarball( $tarball, $dest ) {
if ( class_exists( 'PharData' ) ) {
try {
$phar = new PharData( $tarball );
$tempdir = implode(
DIRECTORY_SEPARATOR,
array(
dirname( $tarball ),
Utils\basename( $tarball, '.tar.gz' ),
$phar->getFilename(),
)
);
$phar->extractTo( dirname( $tempdir ), null, true );
self::copy_overwrite_files( $tempdir, $dest );
self::rmdir( dirname( $tempdir ) );
return;
} catch ( \Exception $e ) {
WP_CLI::warning( "PharData failed, falling back to 'tar xz' (" . $e->getMessage() . ')' );
// Fall through to trying `tar xz` below
}
}
// Note: directory must exist for tar --directory to work.
$cmd = Utils\esc_cmd( 'tar xz --strip-components=1 --directory=%s -f %s', $dest, $tarball );
$process_run = WP_CLI::launch( $cmd, false /*exit_on_error*/, true /*return_detailed*/ );
if ( 0 !== $process_run->return_code ) {
throw new \Exception( sprintf( 'Failed to execute `%s`: %s.', $cmd, self::tar_error_msg( $process_run ) ) );
}
} | [
"private",
"static",
"function",
"extract_tarball",
"(",
"$",
"tarball",
",",
"$",
"dest",
")",
"{",
"if",
"(",
"class_exists",
"(",
"'PharData'",
")",
")",
"{",
"try",
"{",
"$",
"phar",
"=",
"new",
"PharData",
"(",
"$",
"tarball",
")",
";",
"$",
"tempdir",
"=",
"implode",
"(",
"DIRECTORY_SEPARATOR",
",",
"array",
"(",
"dirname",
"(",
"$",
"tarball",
")",
",",
"Utils",
"\\",
"basename",
"(",
"$",
"tarball",
",",
"'.tar.gz'",
")",
",",
"$",
"phar",
"->",
"getFilename",
"(",
")",
",",
")",
")",
";",
"$",
"phar",
"->",
"extractTo",
"(",
"dirname",
"(",
"$",
"tempdir",
")",
",",
"null",
",",
"true",
")",
";",
"self",
"::",
"copy_overwrite_files",
"(",
"$",
"tempdir",
",",
"$",
"dest",
")",
";",
"self",
"::",
"rmdir",
"(",
"dirname",
"(",
"$",
"tempdir",
")",
")",
";",
"return",
";",
"}",
"catch",
"(",
"\\",
"Exception",
"$",
"e",
")",
"{",
"WP_CLI",
"::",
"warning",
"(",
"\"PharData failed, falling back to 'tar xz' (\"",
".",
"$",
"e",
"->",
"getMessage",
"(",
")",
".",
"')'",
")",
";",
"// Fall through to trying `tar xz` below",
"}",
"}",
"// Note: directory must exist for tar --directory to work.",
"$",
"cmd",
"=",
"Utils",
"\\",
"esc_cmd",
"(",
"'tar xz --strip-components=1 --directory=%s -f %s'",
",",
"$",
"dest",
",",
"$",
"tarball",
")",
";",
"$",
"process_run",
"=",
"WP_CLI",
"::",
"launch",
"(",
"$",
"cmd",
",",
"false",
"/*exit_on_error*/",
",",
"true",
"/*return_detailed*/",
")",
";",
"if",
"(",
"0",
"!==",
"$",
"process_run",
"->",
"return_code",
")",
"{",
"throw",
"new",
"\\",
"Exception",
"(",
"sprintf",
"(",
"'Failed to execute `%s`: %s.'",
",",
"$",
"cmd",
",",
"self",
"::",
"tar_error_msg",
"(",
"$",
"process_run",
")",
")",
")",
";",
"}",
"}"
] | Extract a tarball to a specific destination.
@param string $tarball
@param string $dest | [
"Extract",
"a",
"tarball",
"to",
"a",
"specific",
"destination",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Extractor.php#L72-L103 | train |
wp-cli/wp-cli | php/WP_CLI/Extractor.php | Extractor.copy_overwrite_files | public static function copy_overwrite_files( $source, $dest ) {
$iterator = new RecursiveIteratorIterator(
new RecursiveDirectoryIterator( $source, RecursiveDirectoryIterator::SKIP_DOTS ),
RecursiveIteratorIterator::SELF_FIRST
);
$error = 0;
if ( ! is_dir( $dest ) ) {
mkdir( $dest, 0777, true );
}
foreach ( $iterator as $item ) {
$dest_path = $dest . DIRECTORY_SEPARATOR . $iterator->getSubPathName();
if ( $item->isDir() ) {
if ( ! is_dir( $dest_path ) ) {
mkdir( $dest_path );
}
} else {
if ( file_exists( $dest_path ) && is_writable( $dest_path ) ) {
copy( $item, $dest_path );
} elseif ( ! file_exists( $dest_path ) ) {
copy( $item, $dest_path );
} else {
$error = 1;
WP_CLI::warning( "Unable to copy '" . $iterator->getSubPathName() . "' to current directory." );
}
}
}
if ( $error ) {
throw new \Exception( 'There was an error overwriting existing files.' );
}
} | php | public static function copy_overwrite_files( $source, $dest ) {
$iterator = new RecursiveIteratorIterator(
new RecursiveDirectoryIterator( $source, RecursiveDirectoryIterator::SKIP_DOTS ),
RecursiveIteratorIterator::SELF_FIRST
);
$error = 0;
if ( ! is_dir( $dest ) ) {
mkdir( $dest, 0777, true );
}
foreach ( $iterator as $item ) {
$dest_path = $dest . DIRECTORY_SEPARATOR . $iterator->getSubPathName();
if ( $item->isDir() ) {
if ( ! is_dir( $dest_path ) ) {
mkdir( $dest_path );
}
} else {
if ( file_exists( $dest_path ) && is_writable( $dest_path ) ) {
copy( $item, $dest_path );
} elseif ( ! file_exists( $dest_path ) ) {
copy( $item, $dest_path );
} else {
$error = 1;
WP_CLI::warning( "Unable to copy '" . $iterator->getSubPathName() . "' to current directory." );
}
}
}
if ( $error ) {
throw new \Exception( 'There was an error overwriting existing files.' );
}
} | [
"public",
"static",
"function",
"copy_overwrite_files",
"(",
"$",
"source",
",",
"$",
"dest",
")",
"{",
"$",
"iterator",
"=",
"new",
"RecursiveIteratorIterator",
"(",
"new",
"RecursiveDirectoryIterator",
"(",
"$",
"source",
",",
"RecursiveDirectoryIterator",
"::",
"SKIP_DOTS",
")",
",",
"RecursiveIteratorIterator",
"::",
"SELF_FIRST",
")",
";",
"$",
"error",
"=",
"0",
";",
"if",
"(",
"!",
"is_dir",
"(",
"$",
"dest",
")",
")",
"{",
"mkdir",
"(",
"$",
"dest",
",",
"0777",
",",
"true",
")",
";",
"}",
"foreach",
"(",
"$",
"iterator",
"as",
"$",
"item",
")",
"{",
"$",
"dest_path",
"=",
"$",
"dest",
".",
"DIRECTORY_SEPARATOR",
".",
"$",
"iterator",
"->",
"getSubPathName",
"(",
")",
";",
"if",
"(",
"$",
"item",
"->",
"isDir",
"(",
")",
")",
"{",
"if",
"(",
"!",
"is_dir",
"(",
"$",
"dest_path",
")",
")",
"{",
"mkdir",
"(",
"$",
"dest_path",
")",
";",
"}",
"}",
"else",
"{",
"if",
"(",
"file_exists",
"(",
"$",
"dest_path",
")",
"&&",
"is_writable",
"(",
"$",
"dest_path",
")",
")",
"{",
"copy",
"(",
"$",
"item",
",",
"$",
"dest_path",
")",
";",
"}",
"elseif",
"(",
"!",
"file_exists",
"(",
"$",
"dest_path",
")",
")",
"{",
"copy",
"(",
"$",
"item",
",",
"$",
"dest_path",
")",
";",
"}",
"else",
"{",
"$",
"error",
"=",
"1",
";",
"WP_CLI",
"::",
"warning",
"(",
"\"Unable to copy '\"",
".",
"$",
"iterator",
"->",
"getSubPathName",
"(",
")",
".",
"\"' to current directory.\"",
")",
";",
"}",
"}",
"}",
"if",
"(",
"$",
"error",
")",
"{",
"throw",
"new",
"\\",
"Exception",
"(",
"'There was an error overwriting existing files.'",
")",
";",
"}",
"}"
] | Copy files from source directory to destination directory. Source directory must exist.
@param string $source
@param string $dest | [
"Copy",
"files",
"from",
"source",
"directory",
"to",
"destination",
"directory",
".",
"Source",
"directory",
"must",
"exist",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Extractor.php#L111-L146 | train |
wp-cli/wp-cli | php/WP_CLI/Extractor.php | Extractor.rmdir | public static function rmdir( $dir ) {
$files = new RecursiveIteratorIterator(
new RecursiveDirectoryIterator( $dir, RecursiveDirectoryIterator::SKIP_DOTS ),
RecursiveIteratorIterator::CHILD_FIRST
);
foreach ( $files as $fileinfo ) {
$todo = $fileinfo->isDir() ? 'rmdir' : 'unlink';
$todo( $fileinfo->getRealPath() );
}
rmdir( $dir );
} | php | public static function rmdir( $dir ) {
$files = new RecursiveIteratorIterator(
new RecursiveDirectoryIterator( $dir, RecursiveDirectoryIterator::SKIP_DOTS ),
RecursiveIteratorIterator::CHILD_FIRST
);
foreach ( $files as $fileinfo ) {
$todo = $fileinfo->isDir() ? 'rmdir' : 'unlink';
$todo( $fileinfo->getRealPath() );
}
rmdir( $dir );
} | [
"public",
"static",
"function",
"rmdir",
"(",
"$",
"dir",
")",
"{",
"$",
"files",
"=",
"new",
"RecursiveIteratorIterator",
"(",
"new",
"RecursiveDirectoryIterator",
"(",
"$",
"dir",
",",
"RecursiveDirectoryIterator",
"::",
"SKIP_DOTS",
")",
",",
"RecursiveIteratorIterator",
"::",
"CHILD_FIRST",
")",
";",
"foreach",
"(",
"$",
"files",
"as",
"$",
"fileinfo",
")",
"{",
"$",
"todo",
"=",
"$",
"fileinfo",
"->",
"isDir",
"(",
")",
"?",
"'rmdir'",
":",
"'unlink'",
";",
"$",
"todo",
"(",
"$",
"fileinfo",
"->",
"getRealPath",
"(",
")",
")",
";",
"}",
"rmdir",
"(",
"$",
"dir",
")",
";",
"}"
] | Delete all files and directories recursively from directory. Directory must exist.
@param string $dir | [
"Delete",
"all",
"files",
"and",
"directories",
"recursively",
"from",
"directory",
".",
"Directory",
"must",
"exist",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Extractor.php#L153-L164 | train |
wp-cli/wp-cli | php/WP_CLI/Extractor.php | Extractor.zip_error_msg | public static function zip_error_msg( $error_code ) {
// From https://github.com/php/php-src/blob/php-5.3.0/ext/zip/php_zip.c#L2623-L2646
static $zip_err_msgs = array(
ZipArchive::ER_OK => 'No error',
ZipArchive::ER_MULTIDISK => 'Multi-disk zip archives not supported',
ZipArchive::ER_RENAME => 'Renaming temporary file failed',
ZipArchive::ER_CLOSE => 'Closing zip archive failed',
ZipArchive::ER_SEEK => 'Seek error',
ZipArchive::ER_READ => 'Read error',
ZipArchive::ER_WRITE => 'Write error',
ZipArchive::ER_CRC => 'CRC error',
ZipArchive::ER_ZIPCLOSED => 'Containing zip archive was closed',
ZipArchive::ER_NOENT => 'No such file',
ZipArchive::ER_EXISTS => 'File already exists',
ZipArchive::ER_OPEN => 'Can\'t open file',
ZipArchive::ER_TMPOPEN => 'Failure to create temporary file',
ZipArchive::ER_ZLIB => 'Zlib error',
ZipArchive::ER_MEMORY => 'Malloc failure',
ZipArchive::ER_CHANGED => 'Entry has been changed',
ZipArchive::ER_COMPNOTSUPP => 'Compression method not supported',
ZipArchive::ER_EOF => 'Premature EOF',
ZipArchive::ER_INVAL => 'Invalid argument',
ZipArchive::ER_NOZIP => 'Not a zip archive',
ZipArchive::ER_INTERNAL => 'Internal error',
ZipArchive::ER_INCONS => 'Zip archive inconsistent',
ZipArchive::ER_REMOVE => 'Can\'t remove file',
ZipArchive::ER_DELETED => 'Entry has been deleted',
);
if ( isset( $zip_err_msgs[ $error_code ] ) ) {
return sprintf( '%s (%d)', $zip_err_msgs[ $error_code ], $error_code );
}
return $error_code;
} | php | public static function zip_error_msg( $error_code ) {
// From https://github.com/php/php-src/blob/php-5.3.0/ext/zip/php_zip.c#L2623-L2646
static $zip_err_msgs = array(
ZipArchive::ER_OK => 'No error',
ZipArchive::ER_MULTIDISK => 'Multi-disk zip archives not supported',
ZipArchive::ER_RENAME => 'Renaming temporary file failed',
ZipArchive::ER_CLOSE => 'Closing zip archive failed',
ZipArchive::ER_SEEK => 'Seek error',
ZipArchive::ER_READ => 'Read error',
ZipArchive::ER_WRITE => 'Write error',
ZipArchive::ER_CRC => 'CRC error',
ZipArchive::ER_ZIPCLOSED => 'Containing zip archive was closed',
ZipArchive::ER_NOENT => 'No such file',
ZipArchive::ER_EXISTS => 'File already exists',
ZipArchive::ER_OPEN => 'Can\'t open file',
ZipArchive::ER_TMPOPEN => 'Failure to create temporary file',
ZipArchive::ER_ZLIB => 'Zlib error',
ZipArchive::ER_MEMORY => 'Malloc failure',
ZipArchive::ER_CHANGED => 'Entry has been changed',
ZipArchive::ER_COMPNOTSUPP => 'Compression method not supported',
ZipArchive::ER_EOF => 'Premature EOF',
ZipArchive::ER_INVAL => 'Invalid argument',
ZipArchive::ER_NOZIP => 'Not a zip archive',
ZipArchive::ER_INTERNAL => 'Internal error',
ZipArchive::ER_INCONS => 'Zip archive inconsistent',
ZipArchive::ER_REMOVE => 'Can\'t remove file',
ZipArchive::ER_DELETED => 'Entry has been deleted',
);
if ( isset( $zip_err_msgs[ $error_code ] ) ) {
return sprintf( '%s (%d)', $zip_err_msgs[ $error_code ], $error_code );
}
return $error_code;
} | [
"public",
"static",
"function",
"zip_error_msg",
"(",
"$",
"error_code",
")",
"{",
"// From https://github.com/php/php-src/blob/php-5.3.0/ext/zip/php_zip.c#L2623-L2646",
"static",
"$",
"zip_err_msgs",
"=",
"array",
"(",
"ZipArchive",
"::",
"ER_OK",
"=>",
"'No error'",
",",
"ZipArchive",
"::",
"ER_MULTIDISK",
"=>",
"'Multi-disk zip archives not supported'",
",",
"ZipArchive",
"::",
"ER_RENAME",
"=>",
"'Renaming temporary file failed'",
",",
"ZipArchive",
"::",
"ER_CLOSE",
"=>",
"'Closing zip archive failed'",
",",
"ZipArchive",
"::",
"ER_SEEK",
"=>",
"'Seek error'",
",",
"ZipArchive",
"::",
"ER_READ",
"=>",
"'Read error'",
",",
"ZipArchive",
"::",
"ER_WRITE",
"=>",
"'Write error'",
",",
"ZipArchive",
"::",
"ER_CRC",
"=>",
"'CRC error'",
",",
"ZipArchive",
"::",
"ER_ZIPCLOSED",
"=>",
"'Containing zip archive was closed'",
",",
"ZipArchive",
"::",
"ER_NOENT",
"=>",
"'No such file'",
",",
"ZipArchive",
"::",
"ER_EXISTS",
"=>",
"'File already exists'",
",",
"ZipArchive",
"::",
"ER_OPEN",
"=>",
"'Can\\'t open file'",
",",
"ZipArchive",
"::",
"ER_TMPOPEN",
"=>",
"'Failure to create temporary file'",
",",
"ZipArchive",
"::",
"ER_ZLIB",
"=>",
"'Zlib error'",
",",
"ZipArchive",
"::",
"ER_MEMORY",
"=>",
"'Malloc failure'",
",",
"ZipArchive",
"::",
"ER_CHANGED",
"=>",
"'Entry has been changed'",
",",
"ZipArchive",
"::",
"ER_COMPNOTSUPP",
"=>",
"'Compression method not supported'",
",",
"ZipArchive",
"::",
"ER_EOF",
"=>",
"'Premature EOF'",
",",
"ZipArchive",
"::",
"ER_INVAL",
"=>",
"'Invalid argument'",
",",
"ZipArchive",
"::",
"ER_NOZIP",
"=>",
"'Not a zip archive'",
",",
"ZipArchive",
"::",
"ER_INTERNAL",
"=>",
"'Internal error'",
",",
"ZipArchive",
"::",
"ER_INCONS",
"=>",
"'Zip archive inconsistent'",
",",
"ZipArchive",
"::",
"ER_REMOVE",
"=>",
"'Can\\'t remove file'",
",",
"ZipArchive",
"::",
"ER_DELETED",
"=>",
"'Entry has been deleted'",
",",
")",
";",
"if",
"(",
"isset",
"(",
"$",
"zip_err_msgs",
"[",
"$",
"error_code",
"]",
")",
")",
"{",
"return",
"sprintf",
"(",
"'%s (%d)'",
",",
"$",
"zip_err_msgs",
"[",
"$",
"error_code",
"]",
",",
"$",
"error_code",
")",
";",
"}",
"return",
"$",
"error_code",
";",
"}"
] | 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. | [
"Return",
"formatted",
"ZipArchive",
"error",
"message",
"from",
"error",
"code",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Extractor.php#L173-L206 | train |
wp-cli/wp-cli | php/WP_CLI/Extractor.php | Extractor.tar_error_msg | public static function tar_error_msg( $process_run ) {
$stderr = trim( $process_run->stderr );
$nl_pos = strpos( $stderr, "\n" );
if ( false !== $nl_pos ) {
$stderr = trim( substr( $stderr, 0, $nl_pos ) );
}
if ( $stderr ) {
return sprintf( '%s (%d)', $stderr, $process_run->return_code );
}
return $process_run->return_code;
} | php | public static function tar_error_msg( $process_run ) {
$stderr = trim( $process_run->stderr );
$nl_pos = strpos( $stderr, "\n" );
if ( false !== $nl_pos ) {
$stderr = trim( substr( $stderr, 0, $nl_pos ) );
}
if ( $stderr ) {
return sprintf( '%s (%d)', $stderr, $process_run->return_code );
}
return $process_run->return_code;
} | [
"public",
"static",
"function",
"tar_error_msg",
"(",
"$",
"process_run",
")",
"{",
"$",
"stderr",
"=",
"trim",
"(",
"$",
"process_run",
"->",
"stderr",
")",
";",
"$",
"nl_pos",
"=",
"strpos",
"(",
"$",
"stderr",
",",
"\"\\n\"",
")",
";",
"if",
"(",
"false",
"!==",
"$",
"nl_pos",
")",
"{",
"$",
"stderr",
"=",
"trim",
"(",
"substr",
"(",
"$",
"stderr",
",",
"0",
",",
"$",
"nl_pos",
")",
")",
";",
"}",
"if",
"(",
"$",
"stderr",
")",
"{",
"return",
"sprintf",
"(",
"'%s (%d)'",
",",
"$",
"stderr",
",",
"$",
"process_run",
"->",
"return_code",
")",
";",
"}",
"return",
"$",
"process_run",
"->",
"return_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. | [
"Return",
"formatted",
"error",
"message",
"from",
"ProcessRun",
"of",
"tar",
"command",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Extractor.php#L215-L225 | train |
wp-cli/wp-cli | php/WP_CLI/Loggers/Base.php | Base._line | protected function _line( $message, $label, $color, $handle = STDOUT ) { // phpcs:ignore PSR2.Methods.MethodDeclaration.Underscore -- Used in third party extensions.
if ( class_exists( 'cli\Colors' ) ) {
$label = \cli\Colors::colorize( "$color$label:%n", $this->in_color );
} else {
$label = "$label:";
}
$this->write( $handle, "$label $message\n" );
} | php | protected function _line( $message, $label, $color, $handle = STDOUT ) { // phpcs:ignore PSR2.Methods.MethodDeclaration.Underscore -- Used in third party extensions.
if ( class_exists( 'cli\Colors' ) ) {
$label = \cli\Colors::colorize( "$color$label:%n", $this->in_color );
} else {
$label = "$label:";
}
$this->write( $handle, "$label $message\n" );
} | [
"protected",
"function",
"_line",
"(",
"$",
"message",
",",
"$",
"label",
",",
"$",
"color",
",",
"$",
"handle",
"=",
"STDOUT",
")",
"{",
"// phpcs:ignore PSR2.Methods.MethodDeclaration.Underscore -- Used in third party extensions.",
"if",
"(",
"class_exists",
"(",
"'cli\\Colors'",
")",
")",
"{",
"$",
"label",
"=",
"\\",
"cli",
"\\",
"Colors",
"::",
"colorize",
"(",
"\"$color$label:%n\"",
",",
"$",
"this",
"->",
"in_color",
")",
";",
"}",
"else",
"{",
"$",
"label",
"=",
"\"$label:\"",
";",
"}",
"$",
"this",
"->",
"write",
"(",
"$",
"handle",
",",
"\"$label $message\\n\"",
")",
";",
"}"
] | 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. | [
"Output",
"one",
"line",
"of",
"message",
"to",
"a",
"resource",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Loggers/Base.php#L75-L82 | train |
wp-cli/wp-cli | php/WP_CLI/Bootstrap/InitializeLogger.php | InitializeLogger.declare_loggers | private function declare_loggers() {
$logger_dir = WP_CLI_ROOT . '/php/WP_CLI/Loggers';
$iterator = new \DirectoryIterator( $logger_dir );
// Make sure the base class is declared first.
include_once "$logger_dir/Base.php";
foreach ( $iterator as $filename ) {
if ( '.php' !== substr( $filename, - 4 ) ) {
continue;
}
include_once "$logger_dir/$filename";
}
} | php | private function declare_loggers() {
$logger_dir = WP_CLI_ROOT . '/php/WP_CLI/Loggers';
$iterator = new \DirectoryIterator( $logger_dir );
// Make sure the base class is declared first.
include_once "$logger_dir/Base.php";
foreach ( $iterator as $filename ) {
if ( '.php' !== substr( $filename, - 4 ) ) {
continue;
}
include_once "$logger_dir/$filename";
}
} | [
"private",
"function",
"declare_loggers",
"(",
")",
"{",
"$",
"logger_dir",
"=",
"WP_CLI_ROOT",
".",
"'/php/WP_CLI/Loggers'",
";",
"$",
"iterator",
"=",
"new",
"\\",
"DirectoryIterator",
"(",
"$",
"logger_dir",
")",
";",
"// Make sure the base class is declared first.",
"include_once",
"\"$logger_dir/Base.php\"",
";",
"foreach",
"(",
"$",
"iterator",
"as",
"$",
"filename",
")",
"{",
"if",
"(",
"'.php'",
"!==",
"substr",
"(",
"$",
"filename",
",",
"-",
"4",
")",
")",
"{",
"continue",
";",
"}",
"include_once",
"\"$logger_dir/$filename\"",
";",
"}",
"}"
] | Load the class declarations for the loggers. | [
"Load",
"the",
"class",
"declarations",
"for",
"the",
"loggers",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Bootstrap/InitializeLogger.php#L32-L46 | train |
wp-cli/wp-cli | php/commands/src/CLI_Cache_Command.php | CLI_Cache_Command.cache_clear | public function cache_clear() {
$cache = WP_CLI::get_cache();
if ( ! $cache->is_enabled() ) {
WP_CLI::error( 'Cache directory does not exist.' );
}
$cache->clear();
WP_CLI::success( 'Cache cleared.' );
} | php | public function cache_clear() {
$cache = WP_CLI::get_cache();
if ( ! $cache->is_enabled() ) {
WP_CLI::error( 'Cache directory does not exist.' );
}
$cache->clear();
WP_CLI::success( 'Cache cleared.' );
} | [
"public",
"function",
"cache_clear",
"(",
")",
"{",
"$",
"cache",
"=",
"WP_CLI",
"::",
"get_cache",
"(",
")",
";",
"if",
"(",
"!",
"$",
"cache",
"->",
"is_enabled",
"(",
")",
")",
"{",
"WP_CLI",
"::",
"error",
"(",
"'Cache directory does not exist.'",
")",
";",
"}",
"$",
"cache",
"->",
"clear",
"(",
")",
";",
"WP_CLI",
"::",
"success",
"(",
"'Cache cleared.'",
")",
";",
"}"
] | Clear the internal cache.
## EXAMPLES
$ wp cli cache clear
Success: Cache cleared.
@subcommand clear | [
"Clear",
"the",
"internal",
"cache",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/CLI_Cache_Command.php#L30-L40 | train |
wp-cli/wp-cli | php/commands/src/CLI_Cache_Command.php | CLI_Cache_Command.cache_prune | public function cache_prune() {
$cache = WP_CLI::get_cache();
if ( ! $cache->is_enabled() ) {
WP_CLI::error( 'Cache directory does not exist.' );
}
$cache->prune();
WP_CLI::success( 'Cache pruned.' );
} | php | public function cache_prune() {
$cache = WP_CLI::get_cache();
if ( ! $cache->is_enabled() ) {
WP_CLI::error( 'Cache directory does not exist.' );
}
$cache->prune();
WP_CLI::success( 'Cache pruned.' );
} | [
"public",
"function",
"cache_prune",
"(",
")",
"{",
"$",
"cache",
"=",
"WP_CLI",
"::",
"get_cache",
"(",
")",
";",
"if",
"(",
"!",
"$",
"cache",
"->",
"is_enabled",
"(",
")",
")",
"{",
"WP_CLI",
"::",
"error",
"(",
"'Cache directory does not exist.'",
")",
";",
"}",
"$",
"cache",
"->",
"prune",
"(",
")",
";",
"WP_CLI",
"::",
"success",
"(",
"'Cache pruned.'",
")",
";",
"}"
] | 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 | [
"Prune",
"the",
"internal",
"cache",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/CLI_Cache_Command.php#L54-L64 | train |
wp-cli/wp-cli | php/WP_CLI/Dispatcher/RootCommand.php | RootCommand.find_subcommand | public function find_subcommand( &$args ) {
$command = array_shift( $args );
Utils\load_command( $command );
if ( ! isset( $this->subcommands[ $command ] ) ) {
return false;
}
return $this->subcommands[ $command ];
} | php | public function find_subcommand( &$args ) {
$command = array_shift( $args );
Utils\load_command( $command );
if ( ! isset( $this->subcommands[ $command ] ) ) {
return false;
}
return $this->subcommands[ $command ];
} | [
"public",
"function",
"find_subcommand",
"(",
"&",
"$",
"args",
")",
"{",
"$",
"command",
"=",
"array_shift",
"(",
"$",
"args",
")",
";",
"Utils",
"\\",
"load_command",
"(",
"$",
"command",
")",
";",
"if",
"(",
"!",
"isset",
"(",
"$",
"this",
"->",
"subcommands",
"[",
"$",
"command",
"]",
")",
")",
"{",
"return",
"false",
";",
"}",
"return",
"$",
"this",
"->",
"subcommands",
"[",
"$",
"command",
"]",
";",
"}"
] | Find a subcommand registered on the root
command.
@param array $args
@return \WP_CLI\Dispatcher\Subcommand|false | [
"Find",
"a",
"subcommand",
"registered",
"on",
"the",
"root",
"command",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Dispatcher/RootCommand.php#L38-L48 | train |
wp-cli/wp-cli | php/WP_CLI/Dispatcher/CommandFactory.php | CommandFactory.create_subcommand | private static function create_subcommand( $parent, $name, $callable, $reflection ) {
$doc_comment = self::get_doc_comment( $reflection );
$docparser = new \WP_CLI\DocParser( $doc_comment );
if ( is_array( $callable ) ) {
if ( ! $name ) {
$name = $docparser->get_tag( 'subcommand' );
}
if ( ! $name ) {
$name = $reflection->name;
}
}
if ( ! $doc_comment ) {
\WP_CLI::debug( null === $doc_comment ? "Failed to get doc comment for {$name}." : "No doc comment for {$name}.", 'commandfactory' );
}
$when_invoked = function ( $args, $assoc_args ) use ( $callable ) {
if ( is_array( $callable ) ) {
$callable[0] = is_object( $callable[0] ) ? $callable[0] : new $callable[0]();
call_user_func( array( $callable[0], $callable[1] ), $args, $assoc_args );
} else {
call_user_func( $callable, $args, $assoc_args );
}
};
return new Subcommand( $parent, $name, $docparser, $when_invoked );
} | php | private static function create_subcommand( $parent, $name, $callable, $reflection ) {
$doc_comment = self::get_doc_comment( $reflection );
$docparser = new \WP_CLI\DocParser( $doc_comment );
if ( is_array( $callable ) ) {
if ( ! $name ) {
$name = $docparser->get_tag( 'subcommand' );
}
if ( ! $name ) {
$name = $reflection->name;
}
}
if ( ! $doc_comment ) {
\WP_CLI::debug( null === $doc_comment ? "Failed to get doc comment for {$name}." : "No doc comment for {$name}.", 'commandfactory' );
}
$when_invoked = function ( $args, $assoc_args ) use ( $callable ) {
if ( is_array( $callable ) ) {
$callable[0] = is_object( $callable[0] ) ? $callable[0] : new $callable[0]();
call_user_func( array( $callable[0], $callable[1] ), $args, $assoc_args );
} else {
call_user_func( $callable, $args, $assoc_args );
}
};
return new Subcommand( $parent, $name, $docparser, $when_invoked );
} | [
"private",
"static",
"function",
"create_subcommand",
"(",
"$",
"parent",
",",
"$",
"name",
",",
"$",
"callable",
",",
"$",
"reflection",
")",
"{",
"$",
"doc_comment",
"=",
"self",
"::",
"get_doc_comment",
"(",
"$",
"reflection",
")",
";",
"$",
"docparser",
"=",
"new",
"\\",
"WP_CLI",
"\\",
"DocParser",
"(",
"$",
"doc_comment",
")",
";",
"if",
"(",
"is_array",
"(",
"$",
"callable",
")",
")",
"{",
"if",
"(",
"!",
"$",
"name",
")",
"{",
"$",
"name",
"=",
"$",
"docparser",
"->",
"get_tag",
"(",
"'subcommand'",
")",
";",
"}",
"if",
"(",
"!",
"$",
"name",
")",
"{",
"$",
"name",
"=",
"$",
"reflection",
"->",
"name",
";",
"}",
"}",
"if",
"(",
"!",
"$",
"doc_comment",
")",
"{",
"\\",
"WP_CLI",
"::",
"debug",
"(",
"null",
"===",
"$",
"doc_comment",
"?",
"\"Failed to get doc comment for {$name}.\"",
":",
"\"No doc comment for {$name}.\"",
",",
"'commandfactory'",
")",
";",
"}",
"$",
"when_invoked",
"=",
"function",
"(",
"$",
"args",
",",
"$",
"assoc_args",
")",
"use",
"(",
"$",
"callable",
")",
"{",
"if",
"(",
"is_array",
"(",
"$",
"callable",
")",
")",
"{",
"$",
"callable",
"[",
"0",
"]",
"=",
"is_object",
"(",
"$",
"callable",
"[",
"0",
"]",
")",
"?",
"$",
"callable",
"[",
"0",
"]",
":",
"new",
"$",
"callable",
"[",
"0",
"]",
"(",
")",
";",
"call_user_func",
"(",
"array",
"(",
"$",
"callable",
"[",
"0",
"]",
",",
"$",
"callable",
"[",
"1",
"]",
")",
",",
"$",
"args",
",",
"$",
"assoc_args",
")",
";",
"}",
"else",
"{",
"call_user_func",
"(",
"$",
"callable",
",",
"$",
"args",
",",
"$",
"assoc_args",
")",
";",
"}",
"}",
";",
"return",
"new",
"Subcommand",
"(",
"$",
"parent",
",",
"$",
"name",
",",
"$",
"docparser",
",",
"$",
"when_invoked",
")",
";",
"}"
] | 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. | [
"Create",
"a",
"new",
"Subcommand",
"instance",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Dispatcher/CommandFactory.php#L78-L105 | train |
wp-cli/wp-cli | php/WP_CLI/Dispatcher/CommandFactory.php | CommandFactory.create_composite_command | private static function create_composite_command( $parent, $name, $callable ) {
$reflection = new ReflectionClass( $callable );
$doc_comment = self::get_doc_comment( $reflection );
if ( ! $doc_comment ) {
\WP_CLI::debug( null === $doc_comment ? "Failed to get doc comment for {$name}." : "No doc comment for {$name}.", 'commandfactory' );
}
$docparser = new \WP_CLI\DocParser( $doc_comment );
$container = new CompositeCommand( $parent, $name, $docparser );
foreach ( $reflection->getMethods() as $method ) {
if ( ! self::is_good_method( $method ) ) {
continue;
}
$class = is_object( $callable ) ? $callable : $reflection->name;
$subcommand = self::create_subcommand( $container, false, array( $class, $method->name ), $method );
$subcommand_name = $subcommand->get_name();
$container->add_subcommand( $subcommand_name, $subcommand );
}
return $container;
} | php | private static function create_composite_command( $parent, $name, $callable ) {
$reflection = new ReflectionClass( $callable );
$doc_comment = self::get_doc_comment( $reflection );
if ( ! $doc_comment ) {
\WP_CLI::debug( null === $doc_comment ? "Failed to get doc comment for {$name}." : "No doc comment for {$name}.", 'commandfactory' );
}
$docparser = new \WP_CLI\DocParser( $doc_comment );
$container = new CompositeCommand( $parent, $name, $docparser );
foreach ( $reflection->getMethods() as $method ) {
if ( ! self::is_good_method( $method ) ) {
continue;
}
$class = is_object( $callable ) ? $callable : $reflection->name;
$subcommand = self::create_subcommand( $container, false, array( $class, $method->name ), $method );
$subcommand_name = $subcommand->get_name();
$container->add_subcommand( $subcommand_name, $subcommand );
}
return $container;
} | [
"private",
"static",
"function",
"create_composite_command",
"(",
"$",
"parent",
",",
"$",
"name",
",",
"$",
"callable",
")",
"{",
"$",
"reflection",
"=",
"new",
"ReflectionClass",
"(",
"$",
"callable",
")",
";",
"$",
"doc_comment",
"=",
"self",
"::",
"get_doc_comment",
"(",
"$",
"reflection",
")",
";",
"if",
"(",
"!",
"$",
"doc_comment",
")",
"{",
"\\",
"WP_CLI",
"::",
"debug",
"(",
"null",
"===",
"$",
"doc_comment",
"?",
"\"Failed to get doc comment for {$name}.\"",
":",
"\"No doc comment for {$name}.\"",
",",
"'commandfactory'",
")",
";",
"}",
"$",
"docparser",
"=",
"new",
"\\",
"WP_CLI",
"\\",
"DocParser",
"(",
"$",
"doc_comment",
")",
";",
"$",
"container",
"=",
"new",
"CompositeCommand",
"(",
"$",
"parent",
",",
"$",
"name",
",",
"$",
"docparser",
")",
";",
"foreach",
"(",
"$",
"reflection",
"->",
"getMethods",
"(",
")",
"as",
"$",
"method",
")",
"{",
"if",
"(",
"!",
"self",
"::",
"is_good_method",
"(",
"$",
"method",
")",
")",
"{",
"continue",
";",
"}",
"$",
"class",
"=",
"is_object",
"(",
"$",
"callable",
")",
"?",
"$",
"callable",
":",
"$",
"reflection",
"->",
"name",
";",
"$",
"subcommand",
"=",
"self",
"::",
"create_subcommand",
"(",
"$",
"container",
",",
"false",
",",
"array",
"(",
"$",
"class",
",",
"$",
"method",
"->",
"name",
")",
",",
"$",
"method",
")",
";",
"$",
"subcommand_name",
"=",
"$",
"subcommand",
"->",
"get_name",
"(",
")",
";",
"$",
"container",
"->",
"add_subcommand",
"(",
"$",
"subcommand_name",
",",
"$",
"subcommand",
")",
";",
"}",
"return",
"$",
"container",
";",
"}"
] | 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 | [
"Create",
"a",
"new",
"Composite",
"command",
"instance",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Dispatcher/CommandFactory.php#L114-L138 | train |
wp-cli/wp-cli | php/WP_CLI/Dispatcher/CommandFactory.php | CommandFactory.create_namespace | private static function create_namespace( $parent, $name, $callable ) {
$reflection = new ReflectionClass( $callable );
$doc_comment = self::get_doc_comment( $reflection );
if ( ! $doc_comment ) {
\WP_CLI::debug( null === $doc_comment ? "Failed to get doc comment for {$name}." : "No doc comment for {$name}.", 'commandfactory' );
}
$docparser = new \WP_CLI\DocParser( $doc_comment );
return new CommandNamespace( $parent, $name, $docparser );
} | php | private static function create_namespace( $parent, $name, $callable ) {
$reflection = new ReflectionClass( $callable );
$doc_comment = self::get_doc_comment( $reflection );
if ( ! $doc_comment ) {
\WP_CLI::debug( null === $doc_comment ? "Failed to get doc comment for {$name}." : "No doc comment for {$name}.", 'commandfactory' );
}
$docparser = new \WP_CLI\DocParser( $doc_comment );
return new CommandNamespace( $parent, $name, $docparser );
} | [
"private",
"static",
"function",
"create_namespace",
"(",
"$",
"parent",
",",
"$",
"name",
",",
"$",
"callable",
")",
"{",
"$",
"reflection",
"=",
"new",
"ReflectionClass",
"(",
"$",
"callable",
")",
";",
"$",
"doc_comment",
"=",
"self",
"::",
"get_doc_comment",
"(",
"$",
"reflection",
")",
";",
"if",
"(",
"!",
"$",
"doc_comment",
")",
"{",
"\\",
"WP_CLI",
"::",
"debug",
"(",
"null",
"===",
"$",
"doc_comment",
"?",
"\"Failed to get doc comment for {$name}.\"",
":",
"\"No doc comment for {$name}.\"",
",",
"'commandfactory'",
")",
";",
"}",
"$",
"docparser",
"=",
"new",
"\\",
"WP_CLI",
"\\",
"DocParser",
"(",
"$",
"doc_comment",
")",
";",
"return",
"new",
"CommandNamespace",
"(",
"$",
"parent",
",",
"$",
"name",
",",
"$",
"docparser",
")",
";",
"}"
] | 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 | [
"Create",
"a",
"new",
"command",
"namespace",
"instance",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Dispatcher/CommandFactory.php#L147-L156 | train |
wp-cli/wp-cli | php/WP_CLI/Dispatcher/CommandFactory.php | CommandFactory.get_doc_comment | private static function get_doc_comment( $reflection ) {
$doc_comment = $reflection->getDocComment();
if ( false !== $doc_comment || ! ( ini_get( 'opcache.enable_cli' ) && ! ini_get( 'opcache.save_comments' ) ) ) {
// Either have doc comment, or no doc comment and save comments enabled - standard situation.
if ( ! getenv( 'WP_CLI_TEST_GET_DOC_COMMENT' ) ) {
return $doc_comment;
}
}
$filename = $reflection->getFileName();
if ( isset( self::$file_contents[ $filename ] ) ) {
$contents = self::$file_contents[ $filename ];
} elseif ( is_readable( $filename ) ) {
$contents = file_get_contents( $filename );
if ( is_string( $contents ) && '' !== $contents ) {
$contents = explode( "\n", $contents );
self::$file_contents[ $filename ] = $contents;
}
}
if ( ! empty( $contents ) ) {
return self::extract_last_doc_comment( implode( "\n", array_slice( $contents, 0, $reflection->getStartLine() ) ) );
}
\WP_CLI::debug( "Could not read contents for filename '{$filename}'.", 'commandfactory' );
return null;
} | php | private static function get_doc_comment( $reflection ) {
$doc_comment = $reflection->getDocComment();
if ( false !== $doc_comment || ! ( ini_get( 'opcache.enable_cli' ) && ! ini_get( 'opcache.save_comments' ) ) ) {
// Either have doc comment, or no doc comment and save comments enabled - standard situation.
if ( ! getenv( 'WP_CLI_TEST_GET_DOC_COMMENT' ) ) {
return $doc_comment;
}
}
$filename = $reflection->getFileName();
if ( isset( self::$file_contents[ $filename ] ) ) {
$contents = self::$file_contents[ $filename ];
} elseif ( is_readable( $filename ) ) {
$contents = file_get_contents( $filename );
if ( is_string( $contents ) && '' !== $contents ) {
$contents = explode( "\n", $contents );
self::$file_contents[ $filename ] = $contents;
}
}
if ( ! empty( $contents ) ) {
return self::extract_last_doc_comment( implode( "\n", array_slice( $contents, 0, $reflection->getStartLine() ) ) );
}
\WP_CLI::debug( "Could not read contents for filename '{$filename}'.", 'commandfactory' );
return null;
} | [
"private",
"static",
"function",
"get_doc_comment",
"(",
"$",
"reflection",
")",
"{",
"$",
"doc_comment",
"=",
"$",
"reflection",
"->",
"getDocComment",
"(",
")",
";",
"if",
"(",
"false",
"!==",
"$",
"doc_comment",
"||",
"!",
"(",
"ini_get",
"(",
"'opcache.enable_cli'",
")",
"&&",
"!",
"ini_get",
"(",
"'opcache.save_comments'",
")",
")",
")",
"{",
"// Either have doc comment, or no doc comment and save comments enabled - standard situation.",
"if",
"(",
"!",
"getenv",
"(",
"'WP_CLI_TEST_GET_DOC_COMMENT'",
")",
")",
"{",
"return",
"$",
"doc_comment",
";",
"}",
"}",
"$",
"filename",
"=",
"$",
"reflection",
"->",
"getFileName",
"(",
")",
";",
"if",
"(",
"isset",
"(",
"self",
"::",
"$",
"file_contents",
"[",
"$",
"filename",
"]",
")",
")",
"{",
"$",
"contents",
"=",
"self",
"::",
"$",
"file_contents",
"[",
"$",
"filename",
"]",
";",
"}",
"elseif",
"(",
"is_readable",
"(",
"$",
"filename",
")",
")",
"{",
"$",
"contents",
"=",
"file_get_contents",
"(",
"$",
"filename",
")",
";",
"if",
"(",
"is_string",
"(",
"$",
"contents",
")",
"&&",
"''",
"!==",
"$",
"contents",
")",
"{",
"$",
"contents",
"=",
"explode",
"(",
"\"\\n\"",
",",
"$",
"contents",
")",
";",
"self",
"::",
"$",
"file_contents",
"[",
"$",
"filename",
"]",
"=",
"$",
"contents",
";",
"}",
"}",
"if",
"(",
"!",
"empty",
"(",
"$",
"contents",
")",
")",
"{",
"return",
"self",
"::",
"extract_last_doc_comment",
"(",
"implode",
"(",
"\"\\n\"",
",",
"array_slice",
"(",
"$",
"contents",
",",
"0",
",",
"$",
"reflection",
"->",
"getStartLine",
"(",
")",
")",
")",
")",
";",
"}",
"\\",
"WP_CLI",
"::",
"debug",
"(",
"\"Could not read contents for filename '{$filename}'.\"",
",",
"'commandfactory'",
")",
";",
"return",
"null",
";",
"}"
] | 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. | [
"Gets",
"the",
"document",
"comment",
".",
"Caters",
"for",
"PHP",
"directive",
"opcache",
".",
"save",
"comments",
"being",
"disabled",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Dispatcher/CommandFactory.php#L174-L202 | train |
wp-cli/wp-cli | php/WP_CLI/Formatter.php | Formatter.display_item | public function display_item( $item, $ascii_pre_colorized = false ) {
if ( isset( $this->args['field'] ) ) {
$item = (object) $item;
$key = $this->find_item_key( $item, $this->args['field'] );
$value = $item->$key;
if ( in_array( $this->args['format'], array( 'table', 'csv' ), true ) && ( is_object( $value ) || is_array( $value ) ) ) {
$value = json_encode( $value );
}
\WP_CLI::print_value(
$value,
array(
'format' => $this->args['format'],
)
);
} else {
$this->show_multiple_fields( $item, $this->args['format'], $ascii_pre_colorized );
}
} | php | public function display_item( $item, $ascii_pre_colorized = false ) {
if ( isset( $this->args['field'] ) ) {
$item = (object) $item;
$key = $this->find_item_key( $item, $this->args['field'] );
$value = $item->$key;
if ( in_array( $this->args['format'], array( 'table', 'csv' ), true ) && ( is_object( $value ) || is_array( $value ) ) ) {
$value = json_encode( $value );
}
\WP_CLI::print_value(
$value,
array(
'format' => $this->args['format'],
)
);
} else {
$this->show_multiple_fields( $item, $this->args['format'], $ascii_pre_colorized );
}
} | [
"public",
"function",
"display_item",
"(",
"$",
"item",
",",
"$",
"ascii_pre_colorized",
"=",
"false",
")",
"{",
"if",
"(",
"isset",
"(",
"$",
"this",
"->",
"args",
"[",
"'field'",
"]",
")",
")",
"{",
"$",
"item",
"=",
"(",
"object",
")",
"$",
"item",
";",
"$",
"key",
"=",
"$",
"this",
"->",
"find_item_key",
"(",
"$",
"item",
",",
"$",
"this",
"->",
"args",
"[",
"'field'",
"]",
")",
";",
"$",
"value",
"=",
"$",
"item",
"->",
"$",
"key",
";",
"if",
"(",
"in_array",
"(",
"$",
"this",
"->",
"args",
"[",
"'format'",
"]",
",",
"array",
"(",
"'table'",
",",
"'csv'",
")",
",",
"true",
")",
"&&",
"(",
"is_object",
"(",
"$",
"value",
")",
"||",
"is_array",
"(",
"$",
"value",
")",
")",
")",
"{",
"$",
"value",
"=",
"json_encode",
"(",
"$",
"value",
")",
";",
"}",
"\\",
"WP_CLI",
"::",
"print_value",
"(",
"$",
"value",
",",
"array",
"(",
"'format'",
"=>",
"$",
"this",
"->",
"args",
"[",
"'format'",
"]",
",",
")",
")",
";",
"}",
"else",
"{",
"$",
"this",
"->",
"show_multiple_fields",
"(",
"$",
"item",
",",
"$",
"this",
"->",
"args",
"[",
"'format'",
"]",
",",
"$",
"ascii_pre_colorized",
")",
";",
"}",
"}"
] | 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. | [
"Display",
"a",
"single",
"item",
"according",
"to",
"the",
"output",
"arguments",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Formatter.php#L100-L117 | train |
wp-cli/wp-cli | php/WP_CLI/Formatter.php | Formatter.format | private function format( $items, $ascii_pre_colorized = false ) {
$fields = $this->args['fields'];
switch ( $this->args['format'] ) {
case 'count':
if ( ! is_array( $items ) ) {
$items = iterator_to_array( $items );
}
echo count( $items );
break;
case 'ids':
if ( ! is_array( $items ) ) {
$items = iterator_to_array( $items );
}
echo implode( ' ', $items );
break;
case 'table':
self::show_table( $items, $fields, $ascii_pre_colorized );
break;
case 'csv':
\WP_CLI\Utils\write_csv( STDOUT, $items, $fields );
break;
case 'json':
case 'yaml':
$out = array();
foreach ( $items as $item ) {
$out[] = \WP_CLI\Utils\pick_fields( $item, $fields );
}
if ( 'json' === $this->args['format'] ) {
if ( defined( 'JSON_PARTIAL_OUTPUT_ON_ERROR' ) ) {
// phpcs:ignore PHPCompatibility.Constants.NewConstants.json_partial_output_on_errorFound
echo json_encode( $out, JSON_PARTIAL_OUTPUT_ON_ERROR );
} else {
echo json_encode( $out );
}
} elseif ( 'yaml' === $this->args['format'] ) {
echo Spyc::YAMLDump( $out, 2, 0 );
}
break;
default:
\WP_CLI::error( 'Invalid format: ' . $this->args['format'] );
}
} | php | private function format( $items, $ascii_pre_colorized = false ) {
$fields = $this->args['fields'];
switch ( $this->args['format'] ) {
case 'count':
if ( ! is_array( $items ) ) {
$items = iterator_to_array( $items );
}
echo count( $items );
break;
case 'ids':
if ( ! is_array( $items ) ) {
$items = iterator_to_array( $items );
}
echo implode( ' ', $items );
break;
case 'table':
self::show_table( $items, $fields, $ascii_pre_colorized );
break;
case 'csv':
\WP_CLI\Utils\write_csv( STDOUT, $items, $fields );
break;
case 'json':
case 'yaml':
$out = array();
foreach ( $items as $item ) {
$out[] = \WP_CLI\Utils\pick_fields( $item, $fields );
}
if ( 'json' === $this->args['format'] ) {
if ( defined( 'JSON_PARTIAL_OUTPUT_ON_ERROR' ) ) {
// phpcs:ignore PHPCompatibility.Constants.NewConstants.json_partial_output_on_errorFound
echo json_encode( $out, JSON_PARTIAL_OUTPUT_ON_ERROR );
} else {
echo json_encode( $out );
}
} elseif ( 'yaml' === $this->args['format'] ) {
echo Spyc::YAMLDump( $out, 2, 0 );
}
break;
default:
\WP_CLI::error( 'Invalid format: ' . $this->args['format'] );
}
} | [
"private",
"function",
"format",
"(",
"$",
"items",
",",
"$",
"ascii_pre_colorized",
"=",
"false",
")",
"{",
"$",
"fields",
"=",
"$",
"this",
"->",
"args",
"[",
"'fields'",
"]",
";",
"switch",
"(",
"$",
"this",
"->",
"args",
"[",
"'format'",
"]",
")",
"{",
"case",
"'count'",
":",
"if",
"(",
"!",
"is_array",
"(",
"$",
"items",
")",
")",
"{",
"$",
"items",
"=",
"iterator_to_array",
"(",
"$",
"items",
")",
";",
"}",
"echo",
"count",
"(",
"$",
"items",
")",
";",
"break",
";",
"case",
"'ids'",
":",
"if",
"(",
"!",
"is_array",
"(",
"$",
"items",
")",
")",
"{",
"$",
"items",
"=",
"iterator_to_array",
"(",
"$",
"items",
")",
";",
"}",
"echo",
"implode",
"(",
"' '",
",",
"$",
"items",
")",
";",
"break",
";",
"case",
"'table'",
":",
"self",
"::",
"show_table",
"(",
"$",
"items",
",",
"$",
"fields",
",",
"$",
"ascii_pre_colorized",
")",
";",
"break",
";",
"case",
"'csv'",
":",
"\\",
"WP_CLI",
"\\",
"Utils",
"\\",
"write_csv",
"(",
"STDOUT",
",",
"$",
"items",
",",
"$",
"fields",
")",
";",
"break",
";",
"case",
"'json'",
":",
"case",
"'yaml'",
":",
"$",
"out",
"=",
"array",
"(",
")",
";",
"foreach",
"(",
"$",
"items",
"as",
"$",
"item",
")",
"{",
"$",
"out",
"[",
"]",
"=",
"\\",
"WP_CLI",
"\\",
"Utils",
"\\",
"pick_fields",
"(",
"$",
"item",
",",
"$",
"fields",
")",
";",
"}",
"if",
"(",
"'json'",
"===",
"$",
"this",
"->",
"args",
"[",
"'format'",
"]",
")",
"{",
"if",
"(",
"defined",
"(",
"'JSON_PARTIAL_OUTPUT_ON_ERROR'",
")",
")",
"{",
"// phpcs:ignore PHPCompatibility.Constants.NewConstants.json_partial_output_on_errorFound",
"echo",
"json_encode",
"(",
"$",
"out",
",",
"JSON_PARTIAL_OUTPUT_ON_ERROR",
")",
";",
"}",
"else",
"{",
"echo",
"json_encode",
"(",
"$",
"out",
")",
";",
"}",
"}",
"elseif",
"(",
"'yaml'",
"===",
"$",
"this",
"->",
"args",
"[",
"'format'",
"]",
")",
"{",
"echo",
"Spyc",
"::",
"YAMLDump",
"(",
"$",
"out",
",",
"2",
",",
"0",
")",
";",
"}",
"break",
";",
"default",
":",
"\\",
"WP_CLI",
"::",
"error",
"(",
"'Invalid format: '",
".",
"$",
"this",
"->",
"args",
"[",
"'format'",
"]",
")",
";",
"}",
"}"
] | 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. | [
"Format",
"items",
"according",
"to",
"arguments",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Formatter.php#L125-L173 | train |
wp-cli/wp-cli | php/WP_CLI/Formatter.php | Formatter.show_single_field | private function show_single_field( $items, $field ) {
$key = null;
$values = array();
foreach ( $items as $item ) {
$item = (object) $item;
if ( null === $key ) {
$key = $this->find_item_key( $item, $field );
}
if ( 'json' === $this->args['format'] ) {
$values[] = $item->$key;
} else {
\WP_CLI::print_value(
$item->$key,
array(
'format' => $this->args['format'],
)
);
}
}
if ( 'json' === $this->args['format'] ) {
echo json_encode( $values );
}
} | php | private function show_single_field( $items, $field ) {
$key = null;
$values = array();
foreach ( $items as $item ) {
$item = (object) $item;
if ( null === $key ) {
$key = $this->find_item_key( $item, $field );
}
if ( 'json' === $this->args['format'] ) {
$values[] = $item->$key;
} else {
\WP_CLI::print_value(
$item->$key,
array(
'format' => $this->args['format'],
)
);
}
}
if ( 'json' === $this->args['format'] ) {
echo json_encode( $values );
}
} | [
"private",
"function",
"show_single_field",
"(",
"$",
"items",
",",
"$",
"field",
")",
"{",
"$",
"key",
"=",
"null",
";",
"$",
"values",
"=",
"array",
"(",
")",
";",
"foreach",
"(",
"$",
"items",
"as",
"$",
"item",
")",
"{",
"$",
"item",
"=",
"(",
"object",
")",
"$",
"item",
";",
"if",
"(",
"null",
"===",
"$",
"key",
")",
"{",
"$",
"key",
"=",
"$",
"this",
"->",
"find_item_key",
"(",
"$",
"item",
",",
"$",
"field",
")",
";",
"}",
"if",
"(",
"'json'",
"===",
"$",
"this",
"->",
"args",
"[",
"'format'",
"]",
")",
"{",
"$",
"values",
"[",
"]",
"=",
"$",
"item",
"->",
"$",
"key",
";",
"}",
"else",
"{",
"\\",
"WP_CLI",
"::",
"print_value",
"(",
"$",
"item",
"->",
"$",
"key",
",",
"array",
"(",
"'format'",
"=>",
"$",
"this",
"->",
"args",
"[",
"'format'",
"]",
",",
")",
")",
";",
"}",
"}",
"if",
"(",
"'json'",
"===",
"$",
"this",
"->",
"args",
"[",
"'format'",
"]",
")",
"{",
"echo",
"json_encode",
"(",
"$",
"values",
")",
";",
"}",
"}"
] | Show a single field from a list of items.
@param array Array of objects to show fields from
@param string The field to show | [
"Show",
"a",
"single",
"field",
"from",
"a",
"list",
"of",
"items",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Formatter.php#L181-L207 | train |
wp-cli/wp-cli | php/WP_CLI/Formatter.php | Formatter.show_multiple_fields | private function show_multiple_fields( $data, $format, $ascii_pre_colorized = false ) {
$true_fields = array();
foreach ( $this->args['fields'] as $field ) {
$true_fields[] = $this->find_item_key( $data, $field );
}
foreach ( $data as $key => $value ) {
if ( ! in_array( $key, $true_fields, true ) ) {
if ( is_array( $data ) ) {
unset( $data[ $key ] );
} elseif ( is_object( $data ) ) {
unset( $data->$key );
}
}
}
switch ( $format ) {
case 'table':
case 'csv':
$rows = $this->assoc_array_to_rows( $data );
$fields = array( 'Field', 'Value' );
if ( 'table' === $format ) {
self::show_table( $rows, $fields, $ascii_pre_colorized );
} elseif ( 'csv' === $format ) {
\WP_CLI\Utils\write_csv( STDOUT, $rows, $fields );
}
break;
case 'yaml':
case 'json':
\WP_CLI::print_value(
$data,
array(
'format' => $format,
)
);
break;
default:
\WP_CLI::error( 'Invalid format: ' . $format );
break;
}
} | php | private function show_multiple_fields( $data, $format, $ascii_pre_colorized = false ) {
$true_fields = array();
foreach ( $this->args['fields'] as $field ) {
$true_fields[] = $this->find_item_key( $data, $field );
}
foreach ( $data as $key => $value ) {
if ( ! in_array( $key, $true_fields, true ) ) {
if ( is_array( $data ) ) {
unset( $data[ $key ] );
} elseif ( is_object( $data ) ) {
unset( $data->$key );
}
}
}
switch ( $format ) {
case 'table':
case 'csv':
$rows = $this->assoc_array_to_rows( $data );
$fields = array( 'Field', 'Value' );
if ( 'table' === $format ) {
self::show_table( $rows, $fields, $ascii_pre_colorized );
} elseif ( 'csv' === $format ) {
\WP_CLI\Utils\write_csv( STDOUT, $rows, $fields );
}
break;
case 'yaml':
case 'json':
\WP_CLI::print_value(
$data,
array(
'format' => $format,
)
);
break;
default:
\WP_CLI::error( 'Invalid format: ' . $format );
break;
}
} | [
"private",
"function",
"show_multiple_fields",
"(",
"$",
"data",
",",
"$",
"format",
",",
"$",
"ascii_pre_colorized",
"=",
"false",
")",
"{",
"$",
"true_fields",
"=",
"array",
"(",
")",
";",
"foreach",
"(",
"$",
"this",
"->",
"args",
"[",
"'fields'",
"]",
"as",
"$",
"field",
")",
"{",
"$",
"true_fields",
"[",
"]",
"=",
"$",
"this",
"->",
"find_item_key",
"(",
"$",
"data",
",",
"$",
"field",
")",
";",
"}",
"foreach",
"(",
"$",
"data",
"as",
"$",
"key",
"=>",
"$",
"value",
")",
"{",
"if",
"(",
"!",
"in_array",
"(",
"$",
"key",
",",
"$",
"true_fields",
",",
"true",
")",
")",
"{",
"if",
"(",
"is_array",
"(",
"$",
"data",
")",
")",
"{",
"unset",
"(",
"$",
"data",
"[",
"$",
"key",
"]",
")",
";",
"}",
"elseif",
"(",
"is_object",
"(",
"$",
"data",
")",
")",
"{",
"unset",
"(",
"$",
"data",
"->",
"$",
"key",
")",
";",
"}",
"}",
"}",
"switch",
"(",
"$",
"format",
")",
"{",
"case",
"'table'",
":",
"case",
"'csv'",
":",
"$",
"rows",
"=",
"$",
"this",
"->",
"assoc_array_to_rows",
"(",
"$",
"data",
")",
";",
"$",
"fields",
"=",
"array",
"(",
"'Field'",
",",
"'Value'",
")",
";",
"if",
"(",
"'table'",
"===",
"$",
"format",
")",
"{",
"self",
"::",
"show_table",
"(",
"$",
"rows",
",",
"$",
"fields",
",",
"$",
"ascii_pre_colorized",
")",
";",
"}",
"elseif",
"(",
"'csv'",
"===",
"$",
"format",
")",
"{",
"\\",
"WP_CLI",
"\\",
"Utils",
"\\",
"write_csv",
"(",
"STDOUT",
",",
"$",
"rows",
",",
"$",
"fields",
")",
";",
"}",
"break",
";",
"case",
"'yaml'",
":",
"case",
"'json'",
":",
"\\",
"WP_CLI",
"::",
"print_value",
"(",
"$",
"data",
",",
"array",
"(",
"'format'",
"=>",
"$",
"format",
",",
")",
")",
";",
"break",
";",
"default",
":",
"\\",
"WP_CLI",
"::",
"error",
"(",
"'Invalid format: '",
".",
"$",
"format",
")",
";",
"break",
";",
"}",
"}"
] | 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. | [
"Show",
"multiple",
"fields",
"of",
"an",
"object",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Formatter.php#L239-L285 | train |
wp-cli/wp-cli | php/WP_CLI/Formatter.php | Formatter.assoc_array_to_rows | private function assoc_array_to_rows( $fields ) {
$rows = array();
foreach ( $fields as $field => $value ) {
if ( ! is_string( $value ) ) {
$value = json_encode( $value );
}
$rows[] = (object) array(
'Field' => $field,
'Value' => $value,
);
}
return $rows;
} | php | private function assoc_array_to_rows( $fields ) {
$rows = array();
foreach ( $fields as $field => $value ) {
if ( ! is_string( $value ) ) {
$value = json_encode( $value );
}
$rows[] = (object) array(
'Field' => $field,
'Value' => $value,
);
}
return $rows;
} | [
"private",
"function",
"assoc_array_to_rows",
"(",
"$",
"fields",
")",
"{",
"$",
"rows",
"=",
"array",
"(",
")",
";",
"foreach",
"(",
"$",
"fields",
"as",
"$",
"field",
"=>",
"$",
"value",
")",
"{",
"if",
"(",
"!",
"is_string",
"(",
"$",
"value",
")",
")",
"{",
"$",
"value",
"=",
"json_encode",
"(",
"$",
"value",
")",
";",
"}",
"$",
"rows",
"[",
"]",
"=",
"(",
"object",
")",
"array",
"(",
"'Field'",
"=>",
"$",
"field",
",",
"'Value'",
"=>",
"$",
"value",
",",
")",
";",
"}",
"return",
"$",
"rows",
";",
"}"
] | Format an associative array as a table.
@param array $fields Fields and values to format
@return array $rows | [
"Format",
"an",
"associative",
"array",
"as",
"a",
"table",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Formatter.php#L324-L340 | train |
wp-cli/wp-cli | php/WP_CLI/Formatter.php | Formatter.transform_item_values_to_json | public function transform_item_values_to_json( $item ) {
foreach ( $this->args['fields'] as $field ) {
$true_field = $this->find_item_key( $item, $field );
$value = is_object( $item ) ? $item->$true_field : $item[ $true_field ];
if ( is_array( $value ) || is_object( $value ) ) {
if ( is_object( $item ) ) {
$item->$true_field = json_encode( $value );
} elseif ( is_array( $item ) ) {
$item[ $true_field ] = json_encode( $value );
}
}
}
return $item;
} | php | public function transform_item_values_to_json( $item ) {
foreach ( $this->args['fields'] as $field ) {
$true_field = $this->find_item_key( $item, $field );
$value = is_object( $item ) ? $item->$true_field : $item[ $true_field ];
if ( is_array( $value ) || is_object( $value ) ) {
if ( is_object( $item ) ) {
$item->$true_field = json_encode( $value );
} elseif ( is_array( $item ) ) {
$item[ $true_field ] = json_encode( $value );
}
}
}
return $item;
} | [
"public",
"function",
"transform_item_values_to_json",
"(",
"$",
"item",
")",
"{",
"foreach",
"(",
"$",
"this",
"->",
"args",
"[",
"'fields'",
"]",
"as",
"$",
"field",
")",
"{",
"$",
"true_field",
"=",
"$",
"this",
"->",
"find_item_key",
"(",
"$",
"item",
",",
"$",
"field",
")",
";",
"$",
"value",
"=",
"is_object",
"(",
"$",
"item",
")",
"?",
"$",
"item",
"->",
"$",
"true_field",
":",
"$",
"item",
"[",
"$",
"true_field",
"]",
";",
"if",
"(",
"is_array",
"(",
"$",
"value",
")",
"||",
"is_object",
"(",
"$",
"value",
")",
")",
"{",
"if",
"(",
"is_object",
"(",
"$",
"item",
")",
")",
"{",
"$",
"item",
"->",
"$",
"true_field",
"=",
"json_encode",
"(",
"$",
"value",
")",
";",
"}",
"elseif",
"(",
"is_array",
"(",
"$",
"item",
")",
")",
"{",
"$",
"item",
"[",
"$",
"true_field",
"]",
"=",
"json_encode",
"(",
"$",
"value",
")",
";",
"}",
"}",
"}",
"return",
"$",
"item",
";",
"}"
] | Transforms objects and arrays to JSON as necessary
@param mixed $item
@return mixed | [
"Transforms",
"objects",
"and",
"arrays",
"to",
"JSON",
"as",
"necessary"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Formatter.php#L348-L361 | train |
wp-cli/wp-cli | php/commands/src/Help_Command.php | Help_Command.parse_reference_links | private static function parse_reference_links( $longdesc ) {
$description = '';
foreach ( explode( "\n", $longdesc ) as $line ) {
if ( 0 === strpos( $line, '#' ) ) {
break;
}
$description .= $line . "\n";
}
// Fires if it has description text at the head of `$longdesc`.
if ( $description ) {
$links = array(); // An array of URLs from the description.
$pattern = '/\[.+?\]\((https?:\/\/.+?)\)/';
$newdesc = preg_replace_callback(
$pattern,
function( $matches ) use ( &$links ) {
static $count = 0;
$count++;
$links[] = $matches[1];
return str_replace( '(' . $matches[1] . ')', '[' . $count . ']', $matches[0] );
},
$description
);
$footnote = '';
$link_count = count( $links );
for ( $i = 0; $i < $link_count; $i++ ) {
$n = $i + 1;
$footnote .= '[' . $n . '] ' . $links[ $i ] . "\n";
}
if ( $footnote ) {
$newdesc = trim( $newdesc ) . "\n\n---\n" . $footnote;
$longdesc = str_replace( trim( $description ), trim( $newdesc ), $longdesc );
}
}
return $longdesc;
} | php | private static function parse_reference_links( $longdesc ) {
$description = '';
foreach ( explode( "\n", $longdesc ) as $line ) {
if ( 0 === strpos( $line, '#' ) ) {
break;
}
$description .= $line . "\n";
}
// Fires if it has description text at the head of `$longdesc`.
if ( $description ) {
$links = array(); // An array of URLs from the description.
$pattern = '/\[.+?\]\((https?:\/\/.+?)\)/';
$newdesc = preg_replace_callback(
$pattern,
function( $matches ) use ( &$links ) {
static $count = 0;
$count++;
$links[] = $matches[1];
return str_replace( '(' . $matches[1] . ')', '[' . $count . ']', $matches[0] );
},
$description
);
$footnote = '';
$link_count = count( $links );
for ( $i = 0; $i < $link_count; $i++ ) {
$n = $i + 1;
$footnote .= '[' . $n . '] ' . $links[ $i ] . "\n";
}
if ( $footnote ) {
$newdesc = trim( $newdesc ) . "\n\n---\n" . $footnote;
$longdesc = str_replace( trim( $description ), trim( $newdesc ), $longdesc );
}
}
return $longdesc;
} | [
"private",
"static",
"function",
"parse_reference_links",
"(",
"$",
"longdesc",
")",
"{",
"$",
"description",
"=",
"''",
";",
"foreach",
"(",
"explode",
"(",
"\"\\n\"",
",",
"$",
"longdesc",
")",
"as",
"$",
"line",
")",
"{",
"if",
"(",
"0",
"===",
"strpos",
"(",
"$",
"line",
",",
"'#'",
")",
")",
"{",
"break",
";",
"}",
"$",
"description",
".=",
"$",
"line",
".",
"\"\\n\"",
";",
"}",
"// Fires if it has description text at the head of `$longdesc`.",
"if",
"(",
"$",
"description",
")",
"{",
"$",
"links",
"=",
"array",
"(",
")",
";",
"// An array of URLs from the description.",
"$",
"pattern",
"=",
"'/\\[.+?\\]\\((https?:\\/\\/.+?)\\)/'",
";",
"$",
"newdesc",
"=",
"preg_replace_callback",
"(",
"$",
"pattern",
",",
"function",
"(",
"$",
"matches",
")",
"use",
"(",
"&",
"$",
"links",
")",
"{",
"static",
"$",
"count",
"=",
"0",
";",
"$",
"count",
"++",
";",
"$",
"links",
"[",
"]",
"=",
"$",
"matches",
"[",
"1",
"]",
";",
"return",
"str_replace",
"(",
"'('",
".",
"$",
"matches",
"[",
"1",
"]",
".",
"')'",
",",
"'['",
".",
"$",
"count",
".",
"']'",
",",
"$",
"matches",
"[",
"0",
"]",
")",
";",
"}",
",",
"$",
"description",
")",
";",
"$",
"footnote",
"=",
"''",
";",
"$",
"link_count",
"=",
"count",
"(",
"$",
"links",
")",
";",
"for",
"(",
"$",
"i",
"=",
"0",
";",
"$",
"i",
"<",
"$",
"link_count",
";",
"$",
"i",
"++",
")",
"{",
"$",
"n",
"=",
"$",
"i",
"+",
"1",
";",
"$",
"footnote",
".=",
"'['",
".",
"$",
"n",
".",
"'] '",
".",
"$",
"links",
"[",
"$",
"i",
"]",
".",
"\"\\n\"",
";",
"}",
"if",
"(",
"$",
"footnote",
")",
"{",
"$",
"newdesc",
"=",
"trim",
"(",
"$",
"newdesc",
")",
".",
"\"\\n\\n---\\n\"",
".",
"$",
"footnote",
";",
"$",
"longdesc",
"=",
"str_replace",
"(",
"trim",
"(",
"$",
"description",
")",
",",
"trim",
"(",
"$",
"newdesc",
")",
",",
"$",
"longdesc",
")",
";",
"}",
"}",
"return",
"$",
"longdesc",
";",
"}"
] | Parse reference links from longdescription.
@param string $longdesc The longdescription from the `$command->get_longdesc()`.
@return string The longdescription which has links as footnote. | [
"Parse",
"reference",
"links",
"from",
"longdescription",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/Help_Command.php#L206-L244 | train |
wp-cli/wp-cli | php/WP_CLI/Dispatcher/CompositeCommand.php | CompositeCommand.show_usage | public function show_usage() {
$methods = $this->get_subcommands();
$i = 0;
foreach ( $methods as $name => $subcommand ) {
$prefix = ( 0 === $i ) ? 'usage: ' : ' or: ';
$i++;
if ( \WP_CLI::get_runner()->is_command_disabled( $subcommand ) ) {
continue;
}
\WP_CLI::line( $subcommand->get_usage( $prefix ) );
}
$cmd_name = implode( ' ', array_slice( get_path( $this ), 1 ) );
\WP_CLI::line();
\WP_CLI::line( "See 'wp help $cmd_name <command>' for more information on a specific command." );
} | php | public function show_usage() {
$methods = $this->get_subcommands();
$i = 0;
foreach ( $methods as $name => $subcommand ) {
$prefix = ( 0 === $i ) ? 'usage: ' : ' or: ';
$i++;
if ( \WP_CLI::get_runner()->is_command_disabled( $subcommand ) ) {
continue;
}
\WP_CLI::line( $subcommand->get_usage( $prefix ) );
}
$cmd_name = implode( ' ', array_slice( get_path( $this ), 1 ) );
\WP_CLI::line();
\WP_CLI::line( "See 'wp help $cmd_name <command>' for more information on a specific command." );
} | [
"public",
"function",
"show_usage",
"(",
")",
"{",
"$",
"methods",
"=",
"$",
"this",
"->",
"get_subcommands",
"(",
")",
";",
"$",
"i",
"=",
"0",
";",
"foreach",
"(",
"$",
"methods",
"as",
"$",
"name",
"=>",
"$",
"subcommand",
")",
"{",
"$",
"prefix",
"=",
"(",
"0",
"===",
"$",
"i",
")",
"?",
"'usage: '",
":",
"' or: '",
";",
"$",
"i",
"++",
";",
"if",
"(",
"\\",
"WP_CLI",
"::",
"get_runner",
"(",
")",
"->",
"is_command_disabled",
"(",
"$",
"subcommand",
")",
")",
"{",
"continue",
";",
"}",
"\\",
"WP_CLI",
"::",
"line",
"(",
"$",
"subcommand",
"->",
"get_usage",
"(",
"$",
"prefix",
")",
")",
";",
"}",
"$",
"cmd_name",
"=",
"implode",
"(",
"' '",
",",
"array_slice",
"(",
"get_path",
"(",
"$",
"this",
")",
",",
"1",
")",
")",
";",
"\\",
"WP_CLI",
"::",
"line",
"(",
")",
";",
"\\",
"WP_CLI",
"::",
"line",
"(",
"\"See 'wp help $cmd_name <command>' for more information on a specific command.\"",
")",
";",
"}"
] | Show the usage for all subcommands contained
by the composite command. | [
"Show",
"the",
"usage",
"for",
"all",
"subcommands",
"contained",
"by",
"the",
"composite",
"command",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Dispatcher/CompositeCommand.php#L176-L196 | train |
wp-cli/wp-cli | php/WP_CLI/Dispatcher/CompositeCommand.php | CompositeCommand.find_subcommand | public function find_subcommand( &$args ) {
$name = array_shift( $args );
$subcommands = $this->get_subcommands();
if ( ! isset( $subcommands[ $name ] ) ) {
$aliases = self::get_aliases( $subcommands );
if ( isset( $aliases[ $name ] ) ) {
$name = $aliases[ $name ];
}
}
if ( ! isset( $subcommands[ $name ] ) ) {
return false;
}
return $subcommands[ $name ];
} | php | public function find_subcommand( &$args ) {
$name = array_shift( $args );
$subcommands = $this->get_subcommands();
if ( ! isset( $subcommands[ $name ] ) ) {
$aliases = self::get_aliases( $subcommands );
if ( isset( $aliases[ $name ] ) ) {
$name = $aliases[ $name ];
}
}
if ( ! isset( $subcommands[ $name ] ) ) {
return false;
}
return $subcommands[ $name ];
} | [
"public",
"function",
"find_subcommand",
"(",
"&",
"$",
"args",
")",
"{",
"$",
"name",
"=",
"array_shift",
"(",
"$",
"args",
")",
";",
"$",
"subcommands",
"=",
"$",
"this",
"->",
"get_subcommands",
"(",
")",
";",
"if",
"(",
"!",
"isset",
"(",
"$",
"subcommands",
"[",
"$",
"name",
"]",
")",
")",
"{",
"$",
"aliases",
"=",
"self",
"::",
"get_aliases",
"(",
"$",
"subcommands",
")",
";",
"if",
"(",
"isset",
"(",
"$",
"aliases",
"[",
"$",
"name",
"]",
")",
")",
"{",
"$",
"name",
"=",
"$",
"aliases",
"[",
"$",
"name",
"]",
";",
"}",
"}",
"if",
"(",
"!",
"isset",
"(",
"$",
"subcommands",
"[",
"$",
"name",
"]",
")",
")",
"{",
"return",
"false",
";",
"}",
"return",
"$",
"subcommands",
"[",
"$",
"name",
"]",
";",
"}"
] | Given supplied arguments, find a contained
subcommand
@param array $args
@return \WP_CLI\Dispatcher\Subcommand|false | [
"Given",
"supplied",
"arguments",
"find",
"a",
"contained",
"subcommand"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Dispatcher/CompositeCommand.php#L217-L235 | train |
wp-cli/wp-cli | php/WP_CLI/Dispatcher/CompositeCommand.php | CompositeCommand.get_aliases | private static function get_aliases( $subcommands ) {
$aliases = array();
foreach ( $subcommands as $name => $subcommand ) {
$alias = $subcommand->get_alias();
if ( $alias ) {
$aliases[ $alias ] = $name;
}
}
return $aliases;
} | php | private static function get_aliases( $subcommands ) {
$aliases = array();
foreach ( $subcommands as $name => $subcommand ) {
$alias = $subcommand->get_alias();
if ( $alias ) {
$aliases[ $alias ] = $name;
}
}
return $aliases;
} | [
"private",
"static",
"function",
"get_aliases",
"(",
"$",
"subcommands",
")",
"{",
"$",
"aliases",
"=",
"array",
"(",
")",
";",
"foreach",
"(",
"$",
"subcommands",
"as",
"$",
"name",
"=>",
"$",
"subcommand",
")",
"{",
"$",
"alias",
"=",
"$",
"subcommand",
"->",
"get_alias",
"(",
")",
";",
"if",
"(",
"$",
"alias",
")",
"{",
"$",
"aliases",
"[",
"$",
"alias",
"]",
"=",
"$",
"name",
";",
"}",
"}",
"return",
"$",
"aliases",
";",
"}"
] | Get any registered aliases for this composite command's
subcommands.
@param array $subcommands
@return array | [
"Get",
"any",
"registered",
"aliases",
"for",
"this",
"composite",
"command",
"s",
"subcommands",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Dispatcher/CompositeCommand.php#L244-L255 | train |
wp-cli/wp-cli | php/commands/src/CLI_Command.php | CLI_Command.info | public function info( $_, $assoc_args ) {
$php_bin = Utils\get_php_binary();
// php_uname() $mode argument was only added with PHP 7.0+. Fall back to
// entire string for older versions.
$system_os = PHP_MAJOR_VERSION < 7
? php_uname()
: sprintf(
'%s %s %s %s',
php_uname( 's' ),
php_uname( 'r' ),
php_uname( 'v' ),
php_uname( 'm' )
);
$shell = getenv( 'SHELL' );
if ( ! $shell && Utils\is_windows() ) {
$shell = getenv( 'ComSpec' );
}
$runner = WP_CLI::get_runner();
$packages_dir = $runner->get_packages_dir_path();
if ( ! is_dir( $packages_dir ) ) {
$packages_dir = null;
}
if ( \WP_CLI\Utils\get_flag_value( $assoc_args, 'format' ) === 'json' ) {
$info = array(
'php_binary_path' => $php_bin,
'global_config_path' => $runner->global_config_path,
'project_config_path' => $runner->project_config_path,
'wp_cli_dir_path' => WP_CLI_ROOT,
'wp_cli_packages_dir_path' => $packages_dir,
'wp_cli_version' => WP_CLI_VERSION,
'system_os' => $system_os,
'shell' => $shell,
);
WP_CLI::line( json_encode( $info ) );
} else {
WP_CLI::line( "OS:\t" . $system_os );
WP_CLI::line( "Shell:\t" . $shell );
WP_CLI::line( "PHP binary:\t" . $php_bin );
WP_CLI::line( "PHP version:\t" . PHP_VERSION );
WP_CLI::line( "php.ini used:\t" . get_cfg_var( 'cfg_file_path' ) );
WP_CLI::line( "WP-CLI root dir:\t" . WP_CLI_ROOT );
WP_CLI::line( "WP-CLI vendor dir:\t" . WP_CLI_VENDOR_DIR );
WP_CLI::line( "WP_CLI phar path:\t" . ( defined( 'WP_CLI_PHAR_PATH' ) ? WP_CLI_PHAR_PATH : '' ) );
WP_CLI::line( "WP-CLI packages dir:\t" . $packages_dir );
WP_CLI::line( "WP-CLI global config:\t" . $runner->global_config_path );
WP_CLI::line( "WP-CLI project config:\t" . $runner->project_config_path );
WP_CLI::line( "WP-CLI version:\t" . WP_CLI_VERSION );
}
} | php | public function info( $_, $assoc_args ) {
$php_bin = Utils\get_php_binary();
// php_uname() $mode argument was only added with PHP 7.0+. Fall back to
// entire string for older versions.
$system_os = PHP_MAJOR_VERSION < 7
? php_uname()
: sprintf(
'%s %s %s %s',
php_uname( 's' ),
php_uname( 'r' ),
php_uname( 'v' ),
php_uname( 'm' )
);
$shell = getenv( 'SHELL' );
if ( ! $shell && Utils\is_windows() ) {
$shell = getenv( 'ComSpec' );
}
$runner = WP_CLI::get_runner();
$packages_dir = $runner->get_packages_dir_path();
if ( ! is_dir( $packages_dir ) ) {
$packages_dir = null;
}
if ( \WP_CLI\Utils\get_flag_value( $assoc_args, 'format' ) === 'json' ) {
$info = array(
'php_binary_path' => $php_bin,
'global_config_path' => $runner->global_config_path,
'project_config_path' => $runner->project_config_path,
'wp_cli_dir_path' => WP_CLI_ROOT,
'wp_cli_packages_dir_path' => $packages_dir,
'wp_cli_version' => WP_CLI_VERSION,
'system_os' => $system_os,
'shell' => $shell,
);
WP_CLI::line( json_encode( $info ) );
} else {
WP_CLI::line( "OS:\t" . $system_os );
WP_CLI::line( "Shell:\t" . $shell );
WP_CLI::line( "PHP binary:\t" . $php_bin );
WP_CLI::line( "PHP version:\t" . PHP_VERSION );
WP_CLI::line( "php.ini used:\t" . get_cfg_var( 'cfg_file_path' ) );
WP_CLI::line( "WP-CLI root dir:\t" . WP_CLI_ROOT );
WP_CLI::line( "WP-CLI vendor dir:\t" . WP_CLI_VENDOR_DIR );
WP_CLI::line( "WP_CLI phar path:\t" . ( defined( 'WP_CLI_PHAR_PATH' ) ? WP_CLI_PHAR_PATH : '' ) );
WP_CLI::line( "WP-CLI packages dir:\t" . $packages_dir );
WP_CLI::line( "WP-CLI global config:\t" . $runner->global_config_path );
WP_CLI::line( "WP-CLI project config:\t" . $runner->project_config_path );
WP_CLI::line( "WP-CLI version:\t" . WP_CLI_VERSION );
}
} | [
"public",
"function",
"info",
"(",
"$",
"_",
",",
"$",
"assoc_args",
")",
"{",
"$",
"php_bin",
"=",
"Utils",
"\\",
"get_php_binary",
"(",
")",
";",
"// php_uname() $mode argument was only added with PHP 7.0+. Fall back to",
"// entire string for older versions.",
"$",
"system_os",
"=",
"PHP_MAJOR_VERSION",
"<",
"7",
"?",
"php_uname",
"(",
")",
":",
"sprintf",
"(",
"'%s %s %s %s'",
",",
"php_uname",
"(",
"'s'",
")",
",",
"php_uname",
"(",
"'r'",
")",
",",
"php_uname",
"(",
"'v'",
")",
",",
"php_uname",
"(",
"'m'",
")",
")",
";",
"$",
"shell",
"=",
"getenv",
"(",
"'SHELL'",
")",
";",
"if",
"(",
"!",
"$",
"shell",
"&&",
"Utils",
"\\",
"is_windows",
"(",
")",
")",
"{",
"$",
"shell",
"=",
"getenv",
"(",
"'ComSpec'",
")",
";",
"}",
"$",
"runner",
"=",
"WP_CLI",
"::",
"get_runner",
"(",
")",
";",
"$",
"packages_dir",
"=",
"$",
"runner",
"->",
"get_packages_dir_path",
"(",
")",
";",
"if",
"(",
"!",
"is_dir",
"(",
"$",
"packages_dir",
")",
")",
"{",
"$",
"packages_dir",
"=",
"null",
";",
"}",
"if",
"(",
"\\",
"WP_CLI",
"\\",
"Utils",
"\\",
"get_flag_value",
"(",
"$",
"assoc_args",
",",
"'format'",
")",
"===",
"'json'",
")",
"{",
"$",
"info",
"=",
"array",
"(",
"'php_binary_path'",
"=>",
"$",
"php_bin",
",",
"'global_config_path'",
"=>",
"$",
"runner",
"->",
"global_config_path",
",",
"'project_config_path'",
"=>",
"$",
"runner",
"->",
"project_config_path",
",",
"'wp_cli_dir_path'",
"=>",
"WP_CLI_ROOT",
",",
"'wp_cli_packages_dir_path'",
"=>",
"$",
"packages_dir",
",",
"'wp_cli_version'",
"=>",
"WP_CLI_VERSION",
",",
"'system_os'",
"=>",
"$",
"system_os",
",",
"'shell'",
"=>",
"$",
"shell",
",",
")",
";",
"WP_CLI",
"::",
"line",
"(",
"json_encode",
"(",
"$",
"info",
")",
")",
";",
"}",
"else",
"{",
"WP_CLI",
"::",
"line",
"(",
"\"OS:\\t\"",
".",
"$",
"system_os",
")",
";",
"WP_CLI",
"::",
"line",
"(",
"\"Shell:\\t\"",
".",
"$",
"shell",
")",
";",
"WP_CLI",
"::",
"line",
"(",
"\"PHP binary:\\t\"",
".",
"$",
"php_bin",
")",
";",
"WP_CLI",
"::",
"line",
"(",
"\"PHP version:\\t\"",
".",
"PHP_VERSION",
")",
";",
"WP_CLI",
"::",
"line",
"(",
"\"php.ini used:\\t\"",
".",
"get_cfg_var",
"(",
"'cfg_file_path'",
")",
")",
";",
"WP_CLI",
"::",
"line",
"(",
"\"WP-CLI root dir:\\t\"",
".",
"WP_CLI_ROOT",
")",
";",
"WP_CLI",
"::",
"line",
"(",
"\"WP-CLI vendor dir:\\t\"",
".",
"WP_CLI_VENDOR_DIR",
")",
";",
"WP_CLI",
"::",
"line",
"(",
"\"WP_CLI phar path:\\t\"",
".",
"(",
"defined",
"(",
"'WP_CLI_PHAR_PATH'",
")",
"?",
"WP_CLI_PHAR_PATH",
":",
"''",
")",
")",
";",
"WP_CLI",
"::",
"line",
"(",
"\"WP-CLI packages dir:\\t\"",
".",
"$",
"packages_dir",
")",
";",
"WP_CLI",
"::",
"line",
"(",
"\"WP-CLI global config:\\t\"",
".",
"$",
"runner",
"->",
"global_config_path",
")",
";",
"WP_CLI",
"::",
"line",
"(",
"\"WP-CLI project config:\\t\"",
".",
"$",
"runner",
"->",
"project_config_path",
")",
";",
"WP_CLI",
"::",
"line",
"(",
"\"WP-CLI version:\\t\"",
".",
"WP_CLI_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 | [
"Print",
"various",
"details",
"about",
"the",
"WP",
"-",
"CLI",
"environment",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/CLI_Command.php#L109-L162 | train |
wp-cli/wp-cli | php/commands/src/CLI_Command.php | CLI_Command.check_update | public function check_update( $_, $assoc_args ) {
$updates = $this->get_updates( $assoc_args );
if ( $updates ) {
$formatter = new \WP_CLI\Formatter(
$assoc_args,
array( 'version', 'update_type', 'package_url' )
);
$formatter->display_items( $updates );
} elseif ( empty( $assoc_args['format'] ) || 'table' === $assoc_args['format'] ) {
$update_type = $this->get_update_type_str( $assoc_args );
WP_CLI::success( "WP-CLI is at the latest{$update_type}version." );
}
} | php | public function check_update( $_, $assoc_args ) {
$updates = $this->get_updates( $assoc_args );
if ( $updates ) {
$formatter = new \WP_CLI\Formatter(
$assoc_args,
array( 'version', 'update_type', 'package_url' )
);
$formatter->display_items( $updates );
} elseif ( empty( $assoc_args['format'] ) || 'table' === $assoc_args['format'] ) {
$update_type = $this->get_update_type_str( $assoc_args );
WP_CLI::success( "WP-CLI is at the latest{$update_type}version." );
}
} | [
"public",
"function",
"check_update",
"(",
"$",
"_",
",",
"$",
"assoc_args",
")",
"{",
"$",
"updates",
"=",
"$",
"this",
"->",
"get_updates",
"(",
"$",
"assoc_args",
")",
";",
"if",
"(",
"$",
"updates",
")",
"{",
"$",
"formatter",
"=",
"new",
"\\",
"WP_CLI",
"\\",
"Formatter",
"(",
"$",
"assoc_args",
",",
"array",
"(",
"'version'",
",",
"'update_type'",
",",
"'package_url'",
")",
")",
";",
"$",
"formatter",
"->",
"display_items",
"(",
"$",
"updates",
")",
";",
"}",
"elseif",
"(",
"empty",
"(",
"$",
"assoc_args",
"[",
"'format'",
"]",
")",
"||",
"'table'",
"===",
"$",
"assoc_args",
"[",
"'format'",
"]",
")",
"{",
"$",
"update_type",
"=",
"$",
"this",
"->",
"get_update_type_str",
"(",
"$",
"assoc_args",
")",
";",
"WP_CLI",
"::",
"success",
"(",
"\"WP-CLI is at the latest{$update_type}version.\"",
")",
";",
"}",
"}"
] | 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 | [
"Check",
"to",
"see",
"if",
"there",
"is",
"a",
"newer",
"version",
"of",
"WP",
"-",
"CLI",
"available",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/CLI_Command.php#L215-L228 | train |
wp-cli/wp-cli | php/commands/src/CLI_Command.php | CLI_Command.param_dump | public function param_dump( $_, $assoc_args ) {
$spec = \WP_CLI::get_configurator()->get_spec();
if ( \WP_CLI\Utils\get_flag_value( $assoc_args, 'with-values' ) ) {
$config = \WP_CLI::get_configurator()->to_array();
// Copy current config values to $spec
foreach ( $spec as $key => $value ) {
$current = null;
if ( isset( $config[0][ $key ] ) ) {
$current = $config[0][ $key ];
}
$spec[ $key ]['current'] = $current;
}
}
if ( 'var_export' === \WP_CLI\Utils\get_flag_value( $assoc_args, 'format' ) ) {
var_export( $spec );
} else {
echo json_encode( $spec );
}
} | php | public function param_dump( $_, $assoc_args ) {
$spec = \WP_CLI::get_configurator()->get_spec();
if ( \WP_CLI\Utils\get_flag_value( $assoc_args, 'with-values' ) ) {
$config = \WP_CLI::get_configurator()->to_array();
// Copy current config values to $spec
foreach ( $spec as $key => $value ) {
$current = null;
if ( isset( $config[0][ $key ] ) ) {
$current = $config[0][ $key ];
}
$spec[ $key ]['current'] = $current;
}
}
if ( 'var_export' === \WP_CLI\Utils\get_flag_value( $assoc_args, 'format' ) ) {
var_export( $spec );
} else {
echo json_encode( $spec );
}
} | [
"public",
"function",
"param_dump",
"(",
"$",
"_",
",",
"$",
"assoc_args",
")",
"{",
"$",
"spec",
"=",
"\\",
"WP_CLI",
"::",
"get_configurator",
"(",
")",
"->",
"get_spec",
"(",
")",
";",
"if",
"(",
"\\",
"WP_CLI",
"\\",
"Utils",
"\\",
"get_flag_value",
"(",
"$",
"assoc_args",
",",
"'with-values'",
")",
")",
"{",
"$",
"config",
"=",
"\\",
"WP_CLI",
"::",
"get_configurator",
"(",
")",
"->",
"to_array",
"(",
")",
";",
"// Copy current config values to $spec",
"foreach",
"(",
"$",
"spec",
"as",
"$",
"key",
"=>",
"$",
"value",
")",
"{",
"$",
"current",
"=",
"null",
";",
"if",
"(",
"isset",
"(",
"$",
"config",
"[",
"0",
"]",
"[",
"$",
"key",
"]",
")",
")",
"{",
"$",
"current",
"=",
"$",
"config",
"[",
"0",
"]",
"[",
"$",
"key",
"]",
";",
"}",
"$",
"spec",
"[",
"$",
"key",
"]",
"[",
"'current'",
"]",
"=",
"$",
"current",
";",
"}",
"}",
"if",
"(",
"'var_export'",
"===",
"\\",
"WP_CLI",
"\\",
"Utils",
"\\",
"get_flag_value",
"(",
"$",
"assoc_args",
",",
"'format'",
")",
")",
"{",
"var_export",
"(",
"$",
"spec",
")",
";",
"}",
"else",
"{",
"echo",
"json_encode",
"(",
"$",
"spec",
")",
";",
"}",
"}"
] | 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 | [
"Dump",
"the",
"list",
"of",
"global",
"parameters",
"as",
"JSON",
"or",
"in",
"var_export",
"format",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/CLI_Command.php#L498-L518 | train |
wp-cli/wp-cli | php/commands/src/CLI_Command.php | CLI_Command.completions | public function completions( $_, $assoc_args ) {
$line = substr( $assoc_args['line'], 0, $assoc_args['point'] );
$compl = new \WP_CLI\Completions( $line );
$compl->render();
} | php | public function completions( $_, $assoc_args ) {
$line = substr( $assoc_args['line'], 0, $assoc_args['point'] );
$compl = new \WP_CLI\Completions( $line );
$compl->render();
} | [
"public",
"function",
"completions",
"(",
"$",
"_",
",",
"$",
"assoc_args",
")",
"{",
"$",
"line",
"=",
"substr",
"(",
"$",
"assoc_args",
"[",
"'line'",
"]",
",",
"0",
",",
"$",
"assoc_args",
"[",
"'point'",
"]",
")",
";",
"$",
"compl",
"=",
"new",
"\\",
"WP_CLI",
"\\",
"Completions",
"(",
"$",
"line",
")",
";",
"$",
"compl",
"->",
"render",
"(",
")",
";",
"}"
] | 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 | [
"Generate",
"tab",
"completion",
"strings",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/CLI_Command.php#L553-L557 | train |
wp-cli/wp-cli | php/commands/src/CLI_Command.php | CLI_Command.get_update_type_str | private function get_update_type_str( $assoc_args ) {
$update_type = ' ';
foreach ( array( 'major', 'minor', 'patch' ) as $type ) {
if ( true === \WP_CLI\Utils\get_flag_value( $assoc_args, $type ) ) {
$update_type = ' ' . $type . ' ';
break;
}
}
return $update_type;
} | php | private function get_update_type_str( $assoc_args ) {
$update_type = ' ';
foreach ( array( 'major', 'minor', 'patch' ) as $type ) {
if ( true === \WP_CLI\Utils\get_flag_value( $assoc_args, $type ) ) {
$update_type = ' ' . $type . ' ';
break;
}
}
return $update_type;
} | [
"private",
"function",
"get_update_type_str",
"(",
"$",
"assoc_args",
")",
"{",
"$",
"update_type",
"=",
"' '",
";",
"foreach",
"(",
"array",
"(",
"'major'",
",",
"'minor'",
",",
"'patch'",
")",
"as",
"$",
"type",
")",
"{",
"if",
"(",
"true",
"===",
"\\",
"WP_CLI",
"\\",
"Utils",
"\\",
"get_flag_value",
"(",
"$",
"assoc_args",
",",
"$",
"type",
")",
")",
"{",
"$",
"update_type",
"=",
"' '",
".",
"$",
"type",
".",
"' '",
";",
"break",
";",
"}",
"}",
"return",
"$",
"update_type",
";",
"}"
] | Get a string representing the type of update being checked for. | [
"Get",
"a",
"string",
"representing",
"the",
"type",
"of",
"update",
"being",
"checked",
"for",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/CLI_Command.php#L562-L571 | train |
wp-cli/wp-cli | php/commands/src/CLI_Command.php | CLI_Command.has_command | public function has_command( $_, $assoc_args ) {
// If command is input as a string, then explode it into array.
$command = explode( ' ', implode( ' ', $_ ) );
WP_CLI::halt( is_array( WP_CLI::get_runner()->find_command_to_run( $command ) ) ? 0 : 1 );
} | php | public function has_command( $_, $assoc_args ) {
// If command is input as a string, then explode it into array.
$command = explode( ' ', implode( ' ', $_ ) );
WP_CLI::halt( is_array( WP_CLI::get_runner()->find_command_to_run( $command ) ) ? 0 : 1 );
} | [
"public",
"function",
"has_command",
"(",
"$",
"_",
",",
"$",
"assoc_args",
")",
"{",
"// If command is input as a string, then explode it into array.",
"$",
"command",
"=",
"explode",
"(",
"' '",
",",
"implode",
"(",
"' '",
",",
"$",
"_",
")",
")",
";",
"WP_CLI",
"::",
"halt",
"(",
"is_array",
"(",
"WP_CLI",
"::",
"get_runner",
"(",
")",
"->",
"find_command_to_run",
"(",
"$",
"command",
")",
")",
"?",
"0",
":",
"1",
")",
";",
"}"
] | 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 | [
"Detects",
"if",
"a",
"command",
"exists"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/CLI_Command.php#L600-L606 | train |
wp-cli/wp-cli | php/commands/src/CLI_Alias_Command.php | CLI_Alias_Command.get | public function get( $args, $assoc_args ) {
list( $alias ) = $args;
$aliases = WP_CLI::get_runner()->aliases;
if ( empty( $aliases[ $alias ] ) ) {
WP_CLI::error( "No alias found with key '{$alias}'." );
}
foreach ( $aliases[ $alias ] as $key => $value ) {
WP_CLI::log( "{$key}: {$value}" );
}
} | php | public function get( $args, $assoc_args ) {
list( $alias ) = $args;
$aliases = WP_CLI::get_runner()->aliases;
if ( empty( $aliases[ $alias ] ) ) {
WP_CLI::error( "No alias found with key '{$alias}'." );
}
foreach ( $aliases[ $alias ] as $key => $value ) {
WP_CLI::log( "{$key}: {$value}" );
}
} | [
"public",
"function",
"get",
"(",
"$",
"args",
",",
"$",
"assoc_args",
")",
"{",
"list",
"(",
"$",
"alias",
")",
"=",
"$",
"args",
";",
"$",
"aliases",
"=",
"WP_CLI",
"::",
"get_runner",
"(",
")",
"->",
"aliases",
";",
"if",
"(",
"empty",
"(",
"$",
"aliases",
"[",
"$",
"alias",
"]",
")",
")",
"{",
"WP_CLI",
"::",
"error",
"(",
"\"No alias found with key '{$alias}'.\"",
")",
";",
"}",
"foreach",
"(",
"$",
"aliases",
"[",
"$",
"alias",
"]",
"as",
"$",
"key",
"=>",
"$",
"value",
")",
"{",
"WP_CLI",
"::",
"log",
"(",
"\"{$key}: {$value}\"",
")",
";",
"}",
"}"
] | 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/ | [
"Gets",
"the",
"value",
"for",
"an",
"alias",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/CLI_Alias_Command.php#L97-L109 | train |
wp-cli/wp-cli | php/commands/src/CLI_Alias_Command.php | CLI_Alias_Command.delete | public function delete( $args, $assoc_args ) {
list( $alias ) = $args;
$config = ( ! empty( $assoc_args['config'] ) ? $assoc_args['config'] : '' );
list( $config_path, $aliases ) = $this->get_aliases_data( $config, $alias );
$this->validate_config_file( $config_path );
if ( empty( $aliases[ $alias ] ) ) {
WP_CLI::error( "No alias found with key '{$alias}'." );
}
unset( $aliases[ $alias ] );
$this->process_aliases( $aliases, $alias, $config_path, 'Deleted' );
} | php | public function delete( $args, $assoc_args ) {
list( $alias ) = $args;
$config = ( ! empty( $assoc_args['config'] ) ? $assoc_args['config'] : '' );
list( $config_path, $aliases ) = $this->get_aliases_data( $config, $alias );
$this->validate_config_file( $config_path );
if ( empty( $aliases[ $alias ] ) ) {
WP_CLI::error( "No alias found with key '{$alias}'." );
}
unset( $aliases[ $alias ] );
$this->process_aliases( $aliases, $alias, $config_path, 'Deleted' );
} | [
"public",
"function",
"delete",
"(",
"$",
"args",
",",
"$",
"assoc_args",
")",
"{",
"list",
"(",
"$",
"alias",
")",
"=",
"$",
"args",
";",
"$",
"config",
"=",
"(",
"!",
"empty",
"(",
"$",
"assoc_args",
"[",
"'config'",
"]",
")",
"?",
"$",
"assoc_args",
"[",
"'config'",
"]",
":",
"''",
")",
";",
"list",
"(",
"$",
"config_path",
",",
"$",
"aliases",
")",
"=",
"$",
"this",
"->",
"get_aliases_data",
"(",
"$",
"config",
",",
"$",
"alias",
")",
";",
"$",
"this",
"->",
"validate_config_file",
"(",
"$",
"config_path",
")",
";",
"if",
"(",
"empty",
"(",
"$",
"aliases",
"[",
"$",
"alias",
"]",
")",
")",
"{",
"WP_CLI",
"::",
"error",
"(",
"\"No alias found with key '{$alias}'.\"",
")",
";",
"}",
"unset",
"(",
"$",
"aliases",
"[",
"$",
"alias",
"]",
")",
";",
"$",
"this",
"->",
"process_aliases",
"(",
"$",
"aliases",
",",
"$",
"alias",
",",
"$",
"config_path",
",",
"'Deleted'",
")",
";",
"}"
] | 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. | [
"Deletes",
"an",
"alias",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/CLI_Alias_Command.php#L212-L229 | train |
wp-cli/wp-cli | php/commands/src/CLI_Alias_Command.php | CLI_Alias_Command.get_aliases_data | private function get_aliases_data( $config, $alias ) {
$global_config_path = WP_CLI::get_runner()->get_global_config_path();
$global_aliases = Spyc::YAMLLoad( $global_config_path );
$project_config_path = WP_CLI::get_runner()->get_project_config_path();
$project_aliases = Spyc::YAMLLoad( $project_config_path );
if ( 'global' === $config ) {
$config_path = $global_config_path;
$aliases = $global_aliases;
} elseif ( 'project' === $config ) {
$config_path = $project_config_path;
$aliases = $project_aliases;
} else {
$is_global_alias = array_key_exists( $alias, $global_aliases );
$is_project_alias = array_key_exists( $alias, $project_aliases );
if ( $is_global_alias && $is_project_alias ) {
WP_CLI::error( "Key '{$alias}' found in more than one path. Please pass --config param." );
} elseif ( $is_global_alias ) {
$config_path = $global_config_path;
$aliases = $global_aliases;
} else {
$config_path = $project_config_path;
$aliases = $project_aliases;
}
}
return array( $config_path, $aliases );
} | php | private function get_aliases_data( $config, $alias ) {
$global_config_path = WP_CLI::get_runner()->get_global_config_path();
$global_aliases = Spyc::YAMLLoad( $global_config_path );
$project_config_path = WP_CLI::get_runner()->get_project_config_path();
$project_aliases = Spyc::YAMLLoad( $project_config_path );
if ( 'global' === $config ) {
$config_path = $global_config_path;
$aliases = $global_aliases;
} elseif ( 'project' === $config ) {
$config_path = $project_config_path;
$aliases = $project_aliases;
} else {
$is_global_alias = array_key_exists( $alias, $global_aliases );
$is_project_alias = array_key_exists( $alias, $project_aliases );
if ( $is_global_alias && $is_project_alias ) {
WP_CLI::error( "Key '{$alias}' found in more than one path. Please pass --config param." );
} elseif ( $is_global_alias ) {
$config_path = $global_config_path;
$aliases = $global_aliases;
} else {
$config_path = $project_config_path;
$aliases = $project_aliases;
}
}
return array( $config_path, $aliases );
} | [
"private",
"function",
"get_aliases_data",
"(",
"$",
"config",
",",
"$",
"alias",
")",
"{",
"$",
"global_config_path",
"=",
"WP_CLI",
"::",
"get_runner",
"(",
")",
"->",
"get_global_config_path",
"(",
")",
";",
"$",
"global_aliases",
"=",
"Spyc",
"::",
"YAMLLoad",
"(",
"$",
"global_config_path",
")",
";",
"$",
"project_config_path",
"=",
"WP_CLI",
"::",
"get_runner",
"(",
")",
"->",
"get_project_config_path",
"(",
")",
";",
"$",
"project_aliases",
"=",
"Spyc",
"::",
"YAMLLoad",
"(",
"$",
"project_config_path",
")",
";",
"if",
"(",
"'global'",
"===",
"$",
"config",
")",
"{",
"$",
"config_path",
"=",
"$",
"global_config_path",
";",
"$",
"aliases",
"=",
"$",
"global_aliases",
";",
"}",
"elseif",
"(",
"'project'",
"===",
"$",
"config",
")",
"{",
"$",
"config_path",
"=",
"$",
"project_config_path",
";",
"$",
"aliases",
"=",
"$",
"project_aliases",
";",
"}",
"else",
"{",
"$",
"is_global_alias",
"=",
"array_key_exists",
"(",
"$",
"alias",
",",
"$",
"global_aliases",
")",
";",
"$",
"is_project_alias",
"=",
"array_key_exists",
"(",
"$",
"alias",
",",
"$",
"project_aliases",
")",
";",
"if",
"(",
"$",
"is_global_alias",
"&&",
"$",
"is_project_alias",
")",
"{",
"WP_CLI",
"::",
"error",
"(",
"\"Key '{$alias}' found in more than one path. Please pass --config param.\"",
")",
";",
"}",
"elseif",
"(",
"$",
"is_global_alias",
")",
"{",
"$",
"config_path",
"=",
"$",
"global_config_path",
";",
"$",
"aliases",
"=",
"$",
"global_aliases",
";",
"}",
"else",
"{",
"$",
"config_path",
"=",
"$",
"project_config_path",
";",
"$",
"aliases",
"=",
"$",
"project_aliases",
";",
"}",
"}",
"return",
"array",
"(",
"$",
"config_path",
",",
"$",
"aliases",
")",
";",
"}"
] | 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. | [
"Get",
"config",
"path",
"and",
"aliases",
"data",
"based",
"on",
"config",
"type",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/CLI_Alias_Command.php#L308-L340 | train |
wp-cli/wp-cli | php/commands/src/CLI_Alias_Command.php | CLI_Alias_Command.build_aliases | private function build_aliases( $aliases, $alias, $assoc_args, $is_grouping, $grouping = '', $is_update = false ) {
if ( $is_grouping ) {
$valid_assoc_args = array( 'config', 'grouping' );
$invalid_args = array_diff( array_keys( $assoc_args ), $valid_assoc_args );
// Check for invalid args.
if ( ! empty( $invalid_args ) ) {
$args_info = implode( ',', $invalid_args );
WP_CLI::error( "--grouping argument works alone. Found invalid arg(s) '$args_info'." );
}
}
if ( $is_update ) {
$this->validate_alias_type( $aliases, $alias, $assoc_args, $grouping );
}
if ( ! $is_grouping ) {
foreach ( $assoc_args as $key => $value ) {
if ( strpos( $key, 'set-' ) !== false ) {
$alias_key_info = explode( '-', $key );
$alias_key = empty( $alias_key_info[1] ) ? '' : $alias_key_info[1];
if ( ! empty( $alias_key ) && ! empty( $value ) ) {
$aliases[ $alias ][ $alias_key ] = $value;
}
}
}
} else {
if ( ! empty( $grouping ) ) {
$group_alias_list = explode( ',', $grouping );
$group_alias = array_map(
function ( $current_alias ) {
return '@' . ltrim( $current_alias, '@' );
},
$group_alias_list
);
$aliases[ $alias ] = $group_alias;
}
}
return $aliases;
} | php | private function build_aliases( $aliases, $alias, $assoc_args, $is_grouping, $grouping = '', $is_update = false ) {
if ( $is_grouping ) {
$valid_assoc_args = array( 'config', 'grouping' );
$invalid_args = array_diff( array_keys( $assoc_args ), $valid_assoc_args );
// Check for invalid args.
if ( ! empty( $invalid_args ) ) {
$args_info = implode( ',', $invalid_args );
WP_CLI::error( "--grouping argument works alone. Found invalid arg(s) '$args_info'." );
}
}
if ( $is_update ) {
$this->validate_alias_type( $aliases, $alias, $assoc_args, $grouping );
}
if ( ! $is_grouping ) {
foreach ( $assoc_args as $key => $value ) {
if ( strpos( $key, 'set-' ) !== false ) {
$alias_key_info = explode( '-', $key );
$alias_key = empty( $alias_key_info[1] ) ? '' : $alias_key_info[1];
if ( ! empty( $alias_key ) && ! empty( $value ) ) {
$aliases[ $alias ][ $alias_key ] = $value;
}
}
}
} else {
if ( ! empty( $grouping ) ) {
$group_alias_list = explode( ',', $grouping );
$group_alias = array_map(
function ( $current_alias ) {
return '@' . ltrim( $current_alias, '@' );
},
$group_alias_list
);
$aliases[ $alias ] = $group_alias;
}
}
return $aliases;
} | [
"private",
"function",
"build_aliases",
"(",
"$",
"aliases",
",",
"$",
"alias",
",",
"$",
"assoc_args",
",",
"$",
"is_grouping",
",",
"$",
"grouping",
"=",
"''",
",",
"$",
"is_update",
"=",
"false",
")",
"{",
"if",
"(",
"$",
"is_grouping",
")",
"{",
"$",
"valid_assoc_args",
"=",
"array",
"(",
"'config'",
",",
"'grouping'",
")",
";",
"$",
"invalid_args",
"=",
"array_diff",
"(",
"array_keys",
"(",
"$",
"assoc_args",
")",
",",
"$",
"valid_assoc_args",
")",
";",
"// Check for invalid args.",
"if",
"(",
"!",
"empty",
"(",
"$",
"invalid_args",
")",
")",
"{",
"$",
"args_info",
"=",
"implode",
"(",
"','",
",",
"$",
"invalid_args",
")",
";",
"WP_CLI",
"::",
"error",
"(",
"\"--grouping argument works alone. Found invalid arg(s) '$args_info'.\"",
")",
";",
"}",
"}",
"if",
"(",
"$",
"is_update",
")",
"{",
"$",
"this",
"->",
"validate_alias_type",
"(",
"$",
"aliases",
",",
"$",
"alias",
",",
"$",
"assoc_args",
",",
"$",
"grouping",
")",
";",
"}",
"if",
"(",
"!",
"$",
"is_grouping",
")",
"{",
"foreach",
"(",
"$",
"assoc_args",
"as",
"$",
"key",
"=>",
"$",
"value",
")",
"{",
"if",
"(",
"strpos",
"(",
"$",
"key",
",",
"'set-'",
")",
"!==",
"false",
")",
"{",
"$",
"alias_key_info",
"=",
"explode",
"(",
"'-'",
",",
"$",
"key",
")",
";",
"$",
"alias_key",
"=",
"empty",
"(",
"$",
"alias_key_info",
"[",
"1",
"]",
")",
"?",
"''",
":",
"$",
"alias_key_info",
"[",
"1",
"]",
";",
"if",
"(",
"!",
"empty",
"(",
"$",
"alias_key",
")",
"&&",
"!",
"empty",
"(",
"$",
"value",
")",
")",
"{",
"$",
"aliases",
"[",
"$",
"alias",
"]",
"[",
"$",
"alias_key",
"]",
"=",
"$",
"value",
";",
"}",
"}",
"}",
"}",
"else",
"{",
"if",
"(",
"!",
"empty",
"(",
"$",
"grouping",
")",
")",
"{",
"$",
"group_alias_list",
"=",
"explode",
"(",
"','",
",",
"$",
"grouping",
")",
";",
"$",
"group_alias",
"=",
"array_map",
"(",
"function",
"(",
"$",
"current_alias",
")",
"{",
"return",
"'@'",
".",
"ltrim",
"(",
"$",
"current_alias",
",",
"'@'",
")",
";",
"}",
",",
"$",
"group_alias_list",
")",
";",
"$",
"aliases",
"[",
"$",
"alias",
"]",
"=",
"$",
"group_alias",
";",
"}",
"}",
"return",
"$",
"aliases",
";",
"}"
] | 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 | [
"Return",
"aliases",
"array",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/CLI_Alias_Command.php#L367-L409 | train |
wp-cli/wp-cli | php/commands/src/CLI_Alias_Command.php | CLI_Alias_Command.validate_input | private function validate_input( $assoc_args, $grouping ) {
// Check if valid arguments were passed.
$arg_match = preg_grep( '/^set-(\w+)/i', array_keys( $assoc_args ) );
// Verify passed-arguments.
if ( empty( $grouping ) && empty( $arg_match ) ) {
WP_CLI::error( 'No valid arguments passed.' );
}
// Check whether passed arguments contain value or not.
$assoc_arg_values = array_filter( array_intersect_key( $assoc_args, array_flip( $arg_match ) ) );
if ( empty( $grouping ) && empty( $assoc_arg_values ) ) {
WP_CLI::error( 'No value passed to arguments.' );
}
} | php | private function validate_input( $assoc_args, $grouping ) {
// Check if valid arguments were passed.
$arg_match = preg_grep( '/^set-(\w+)/i', array_keys( $assoc_args ) );
// Verify passed-arguments.
if ( empty( $grouping ) && empty( $arg_match ) ) {
WP_CLI::error( 'No valid arguments passed.' );
}
// Check whether passed arguments contain value or not.
$assoc_arg_values = array_filter( array_intersect_key( $assoc_args, array_flip( $arg_match ) ) );
if ( empty( $grouping ) && empty( $assoc_arg_values ) ) {
WP_CLI::error( 'No value passed to arguments.' );
}
} | [
"private",
"function",
"validate_input",
"(",
"$",
"assoc_args",
",",
"$",
"grouping",
")",
"{",
"// Check if valid arguments were passed.",
"$",
"arg_match",
"=",
"preg_grep",
"(",
"'/^set-(\\w+)/i'",
",",
"array_keys",
"(",
"$",
"assoc_args",
")",
")",
";",
"// Verify passed-arguments.",
"if",
"(",
"empty",
"(",
"$",
"grouping",
")",
"&&",
"empty",
"(",
"$",
"arg_match",
")",
")",
"{",
"WP_CLI",
"::",
"error",
"(",
"'No valid arguments passed.'",
")",
";",
"}",
"// Check whether passed arguments contain value or not.",
"$",
"assoc_arg_values",
"=",
"array_filter",
"(",
"array_intersect_key",
"(",
"$",
"assoc_args",
",",
"array_flip",
"(",
"$",
"arg_match",
")",
")",
")",
";",
"if",
"(",
"empty",
"(",
"$",
"grouping",
")",
"&&",
"empty",
"(",
"$",
"assoc_arg_values",
")",
")",
"{",
"WP_CLI",
"::",
"error",
"(",
"'No value passed to arguments.'",
")",
";",
"}",
"}"
] | Validate input of passed arguments.
@param array $assoc_args Arguments array.
@param string $grouping Grouping argument value.
@throws WP_CLI\ExitException | [
"Validate",
"input",
"of",
"passed",
"arguments",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/CLI_Alias_Command.php#L419-L434 | train |
wp-cli/wp-cli | php/commands/src/CLI_Alias_Command.php | CLI_Alias_Command.validate_alias_type | private function validate_alias_type( $aliases, $alias, $assoc_args, $grouping ) {
$alias_data = $aliases[ $alias ];
$group_aliases_match = preg_grep( '/^@(\w+)/i', $alias_data );
$arg_match = preg_grep( '/^set-(\w+)/i', array_keys( $assoc_args ) );
if ( ! empty( $group_aliases_match ) && ! empty( $arg_match ) ) {
WP_CLI::error( 'Trying to update group alias with invalid arguments.' );
} elseif ( empty( $group_aliases_match ) && ! empty( $grouping ) ) {
WP_CLI::error( 'Trying to update simple alias with invalid --grouping argument.' );
}
} | php | private function validate_alias_type( $aliases, $alias, $assoc_args, $grouping ) {
$alias_data = $aliases[ $alias ];
$group_aliases_match = preg_grep( '/^@(\w+)/i', $alias_data );
$arg_match = preg_grep( '/^set-(\w+)/i', array_keys( $assoc_args ) );
if ( ! empty( $group_aliases_match ) && ! empty( $arg_match ) ) {
WP_CLI::error( 'Trying to update group alias with invalid arguments.' );
} elseif ( empty( $group_aliases_match ) && ! empty( $grouping ) ) {
WP_CLI::error( 'Trying to update simple alias with invalid --grouping argument.' );
}
} | [
"private",
"function",
"validate_alias_type",
"(",
"$",
"aliases",
",",
"$",
"alias",
",",
"$",
"assoc_args",
",",
"$",
"grouping",
")",
"{",
"$",
"alias_data",
"=",
"$",
"aliases",
"[",
"$",
"alias",
"]",
";",
"$",
"group_aliases_match",
"=",
"preg_grep",
"(",
"'/^@(\\w+)/i'",
",",
"$",
"alias_data",
")",
";",
"$",
"arg_match",
"=",
"preg_grep",
"(",
"'/^set-(\\w+)/i'",
",",
"array_keys",
"(",
"$",
"assoc_args",
")",
")",
";",
"if",
"(",
"!",
"empty",
"(",
"$",
"group_aliases_match",
")",
"&&",
"!",
"empty",
"(",
"$",
"arg_match",
")",
")",
"{",
"WP_CLI",
"::",
"error",
"(",
"'Trying to update group alias with invalid arguments.'",
")",
";",
"}",
"elseif",
"(",
"empty",
"(",
"$",
"group_aliases_match",
")",
"&&",
"!",
"empty",
"(",
"$",
"grouping",
")",
")",
"{",
"WP_CLI",
"::",
"error",
"(",
"'Trying to update simple alias with invalid --grouping argument.'",
")",
";",
"}",
"}"
] | 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 | [
"Validate",
"alias",
"type",
"before",
"update",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/CLI_Alias_Command.php#L446-L458 | train |
wp-cli/wp-cli | php/commands/src/CLI_Alias_Command.php | CLI_Alias_Command.process_aliases | private function process_aliases( $aliases, $alias, $config_path, $operation = '' ) {
// Convert data to YAML string.
$yaml_data = Spyc::YAMLDump( $aliases );
// Add data in config file.
if ( file_put_contents( $config_path, $yaml_data ) ) {
WP_CLI::success( "$operation '{$alias}' alias." );
}
} | php | private function process_aliases( $aliases, $alias, $config_path, $operation = '' ) {
// Convert data to YAML string.
$yaml_data = Spyc::YAMLDump( $aliases );
// Add data in config file.
if ( file_put_contents( $config_path, $yaml_data ) ) {
WP_CLI::success( "$operation '{$alias}' alias." );
}
} | [
"private",
"function",
"process_aliases",
"(",
"$",
"aliases",
",",
"$",
"alias",
",",
"$",
"config_path",
",",
"$",
"operation",
"=",
"''",
")",
"{",
"// Convert data to YAML string.",
"$",
"yaml_data",
"=",
"Spyc",
"::",
"YAMLDump",
"(",
"$",
"aliases",
")",
";",
"// Add data in config file.",
"if",
"(",
"file_put_contents",
"(",
"$",
"config_path",
",",
"$",
"yaml_data",
")",
")",
"{",
"WP_CLI",
"::",
"success",
"(",
"\"$operation '{$alias}' alias.\"",
")",
";",
"}",
"}"
] | 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. | [
"Save",
"aliases",
"data",
"to",
"config",
"file",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/commands/src/CLI_Alias_Command.php#L468-L476 | train |
wp-cli/wp-cli | php/WP_CLI/DocParser.php | DocParser.remove_decorations | private static function remove_decorations( $comment ) {
$comment = preg_replace( '|^/\*\*[\r\n]+|', '', $comment );
$comment = preg_replace( '|\n[\t ]*\*/$|', '', $comment );
$comment = preg_replace( '|^[\t ]*\* ?|m', '', $comment );
return $comment;
} | php | private static function remove_decorations( $comment ) {
$comment = preg_replace( '|^/\*\*[\r\n]+|', '', $comment );
$comment = preg_replace( '|\n[\t ]*\*/$|', '', $comment );
$comment = preg_replace( '|^[\t ]*\* ?|m', '', $comment );
return $comment;
} | [
"private",
"static",
"function",
"remove_decorations",
"(",
"$",
"comment",
")",
"{",
"$",
"comment",
"=",
"preg_replace",
"(",
"'|^/\\*\\*[\\r\\n]+|'",
",",
"''",
",",
"$",
"comment",
")",
";",
"$",
"comment",
"=",
"preg_replace",
"(",
"'|\\n[\\t ]*\\*/$|'",
",",
"''",
",",
"$",
"comment",
")",
";",
"$",
"comment",
"=",
"preg_replace",
"(",
"'|^[\\t ]*\\* ?|m'",
",",
"''",
",",
"$",
"comment",
")",
";",
"return",
"$",
"comment",
";",
"}"
] | Remove unused cruft from PHPdoc comment.
@param string $comment PHPdoc comment.
@return string | [
"Remove",
"unused",
"cruft",
"from",
"PHPdoc",
"comment",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/DocParser.php#L33-L39 | train |
wp-cli/wp-cli | php/WP_CLI/DocParser.php | DocParser.get_longdesc | public function get_longdesc() {
$shortdesc = $this->get_shortdesc();
if ( ! $shortdesc ) {
return '';
}
$longdesc = substr( $this->doc_comment, strlen( $shortdesc ) );
$lines = array();
foreach ( explode( "\n", $longdesc ) as $line ) {
if ( 0 === strpos( $line, '@' ) ) {
break;
}
$lines[] = $line;
}
$longdesc = trim( implode( $lines, "\n" ) );
return $longdesc;
} | php | public function get_longdesc() {
$shortdesc = $this->get_shortdesc();
if ( ! $shortdesc ) {
return '';
}
$longdesc = substr( $this->doc_comment, strlen( $shortdesc ) );
$lines = array();
foreach ( explode( "\n", $longdesc ) as $line ) {
if ( 0 === strpos( $line, '@' ) ) {
break;
}
$lines[] = $line;
}
$longdesc = trim( implode( $lines, "\n" ) );
return $longdesc;
} | [
"public",
"function",
"get_longdesc",
"(",
")",
"{",
"$",
"shortdesc",
"=",
"$",
"this",
"->",
"get_shortdesc",
"(",
")",
";",
"if",
"(",
"!",
"$",
"shortdesc",
")",
"{",
"return",
"''",
";",
"}",
"$",
"longdesc",
"=",
"substr",
"(",
"$",
"this",
"->",
"doc_comment",
",",
"strlen",
"(",
"$",
"shortdesc",
")",
")",
";",
"$",
"lines",
"=",
"array",
"(",
")",
";",
"foreach",
"(",
"explode",
"(",
"\"\\n\"",
",",
"$",
"longdesc",
")",
"as",
"$",
"line",
")",
"{",
"if",
"(",
"0",
"===",
"strpos",
"(",
"$",
"line",
",",
"'@'",
")",
")",
"{",
"break",
";",
"}",
"$",
"lines",
"[",
"]",
"=",
"$",
"line",
";",
"}",
"$",
"longdesc",
"=",
"trim",
"(",
"implode",
"(",
"$",
"lines",
",",
"\"\\n\"",
")",
")",
";",
"return",
"$",
"longdesc",
";",
"}"
] | Get the command's full description
@return string | [
"Get",
"the",
"command",
"s",
"full",
"description"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/DocParser.php#L59-L78 | train |
wp-cli/wp-cli | php/WP_CLI/DocParser.php | DocParser.get_arg_or_param_args | private function get_arg_or_param_args( $regex ) {
$bits = explode( "\n", $this->doc_comment );
$within_arg = false;
$within_doc = false;
$document = array();
foreach ( $bits as $bit ) {
if ( preg_match( $regex, $bit ) ) {
$within_arg = true;
}
if ( $within_arg && $within_doc && '---' === $bit ) {
$within_doc = false;
}
if ( $within_arg && ! $within_doc && '---' === $bit ) {
$within_doc = true;
}
if ( $within_doc ) {
$document[] = $bit;
}
if ( $within_arg && '' === $bit ) {
$within_arg = false;
break;
}
}
if ( $document ) {
return Spyc::YAMLLoadString( implode( "\n", $document ) );
}
return null;
} | php | private function get_arg_or_param_args( $regex ) {
$bits = explode( "\n", $this->doc_comment );
$within_arg = false;
$within_doc = false;
$document = array();
foreach ( $bits as $bit ) {
if ( preg_match( $regex, $bit ) ) {
$within_arg = true;
}
if ( $within_arg && $within_doc && '---' === $bit ) {
$within_doc = false;
}
if ( $within_arg && ! $within_doc && '---' === $bit ) {
$within_doc = true;
}
if ( $within_doc ) {
$document[] = $bit;
}
if ( $within_arg && '' === $bit ) {
$within_arg = false;
break;
}
}
if ( $document ) {
return Spyc::YAMLLoadString( implode( "\n", $document ) );
}
return null;
} | [
"private",
"function",
"get_arg_or_param_args",
"(",
"$",
"regex",
")",
"{",
"$",
"bits",
"=",
"explode",
"(",
"\"\\n\"",
",",
"$",
"this",
"->",
"doc_comment",
")",
";",
"$",
"within_arg",
"=",
"false",
";",
"$",
"within_doc",
"=",
"false",
";",
"$",
"document",
"=",
"array",
"(",
")",
";",
"foreach",
"(",
"$",
"bits",
"as",
"$",
"bit",
")",
"{",
"if",
"(",
"preg_match",
"(",
"$",
"regex",
",",
"$",
"bit",
")",
")",
"{",
"$",
"within_arg",
"=",
"true",
";",
"}",
"if",
"(",
"$",
"within_arg",
"&&",
"$",
"within_doc",
"&&",
"'---'",
"===",
"$",
"bit",
")",
"{",
"$",
"within_doc",
"=",
"false",
";",
"}",
"if",
"(",
"$",
"within_arg",
"&&",
"!",
"$",
"within_doc",
"&&",
"'---'",
"===",
"$",
"bit",
")",
"{",
"$",
"within_doc",
"=",
"true",
";",
"}",
"if",
"(",
"$",
"within_doc",
")",
"{",
"$",
"document",
"[",
"]",
"=",
"$",
"bit",
";",
"}",
"if",
"(",
"$",
"within_arg",
"&&",
"''",
"===",
"$",
"bit",
")",
"{",
"$",
"within_arg",
"=",
"false",
";",
"break",
";",
"}",
"}",
"if",
"(",
"$",
"document",
")",
"{",
"return",
"Spyc",
"::",
"YAMLLoadString",
"(",
"implode",
"(",
"\"\\n\"",
",",
"$",
"document",
")",
")",
";",
"}",
"return",
"null",
";",
"}"
] | Get the args for an arg or param
@param string $regex Pattern to match against
@return array|null Interpreted YAML document, or null. | [
"Get",
"the",
"args",
"for",
"an",
"arg",
"or",
"param"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/DocParser.php#L164-L196 | train |
wp-cli/wp-cli | php/WP_CLI/Bootstrap/RegisterDeferredCommands.php | RegisterDeferredCommands.add_deferred_commands | public function add_deferred_commands() {
$deferred_additions = \WP_CLI::get_deferred_additions();
foreach ( $deferred_additions as $name => $addition ) {
\WP_CLI::debug(
sprintf(
'Adding deferred command: %s => %s',
$name,
json_encode( $addition )
),
'bootstrap'
);
\WP_CLI::add_command(
$name,
$addition['callable'],
$addition['args']
);
}
} | php | public function add_deferred_commands() {
$deferred_additions = \WP_CLI::get_deferred_additions();
foreach ( $deferred_additions as $name => $addition ) {
\WP_CLI::debug(
sprintf(
'Adding deferred command: %s => %s',
$name,
json_encode( $addition )
),
'bootstrap'
);
\WP_CLI::add_command(
$name,
$addition['callable'],
$addition['args']
);
}
} | [
"public",
"function",
"add_deferred_commands",
"(",
")",
"{",
"$",
"deferred_additions",
"=",
"\\",
"WP_CLI",
"::",
"get_deferred_additions",
"(",
")",
";",
"foreach",
"(",
"$",
"deferred_additions",
"as",
"$",
"name",
"=>",
"$",
"addition",
")",
"{",
"\\",
"WP_CLI",
"::",
"debug",
"(",
"sprintf",
"(",
"'Adding deferred command: %s => %s'",
",",
"$",
"name",
",",
"json_encode",
"(",
"$",
"addition",
")",
")",
",",
"'bootstrap'",
")",
";",
"\\",
"WP_CLI",
"::",
"add_command",
"(",
"$",
"name",
",",
"$",
"addition",
"[",
"'callable'",
"]",
",",
"$",
"addition",
"[",
"'args'",
"]",
")",
";",
"}",
"}"
] | Add deferred commands that are still waiting to be processed. | [
"Add",
"deferred",
"commands",
"that",
"are",
"still",
"waiting",
"to",
"be",
"processed",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Bootstrap/RegisterDeferredCommands.php#L41-L60 | train |
wp-cli/wp-cli | utils/contrib-list.php | Contrib_List_Command.get_project_milestones | private static function get_project_milestones( $project, $args = array() ) {
$request_url = sprintf( 'https://api.github.com/repos/%s/milestones', $project );
list( $body, $headers ) = self::make_github_api_request( $request_url, $args );
return $body;
} | php | private static function get_project_milestones( $project, $args = array() ) {
$request_url = sprintf( 'https://api.github.com/repos/%s/milestones', $project );
list( $body, $headers ) = self::make_github_api_request( $request_url, $args );
return $body;
} | [
"private",
"static",
"function",
"get_project_milestones",
"(",
"$",
"project",
",",
"$",
"args",
"=",
"array",
"(",
")",
")",
"{",
"$",
"request_url",
"=",
"sprintf",
"(",
"'https://api.github.com/repos/%s/milestones'",
",",
"$",
"project",
")",
";",
"list",
"(",
"$",
"body",
",",
"$",
"headers",
")",
"=",
"self",
"::",
"make_github_api_request",
"(",
"$",
"request_url",
",",
"$",
"args",
")",
";",
"return",
"$",
"body",
";",
"}"
] | Get the milestones for a given project
@param string $project
@return array | [
"Get",
"the",
"milestones",
"for",
"a",
"given",
"project"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/utils/contrib-list.php#L121-L125 | train |
wp-cli/wp-cli | utils/contrib-list.php | Contrib_List_Command.parse_contributors_from_pull_requests | private static function parse_contributors_from_pull_requests( $pull_requests ) {
$contributors = array();
foreach ( $pull_requests as $pull_request ) {
if ( ! empty( $pull_request->user ) ) {
$contributors[ $pull_request->user->html_url ] = $pull_request->user->login;
}
}
return $contributors;
} | php | private static function parse_contributors_from_pull_requests( $pull_requests ) {
$contributors = array();
foreach ( $pull_requests as $pull_request ) {
if ( ! empty( $pull_request->user ) ) {
$contributors[ $pull_request->user->html_url ] = $pull_request->user->login;
}
}
return $contributors;
} | [
"private",
"static",
"function",
"parse_contributors_from_pull_requests",
"(",
"$",
"pull_requests",
")",
"{",
"$",
"contributors",
"=",
"array",
"(",
")",
";",
"foreach",
"(",
"$",
"pull_requests",
"as",
"$",
"pull_request",
")",
"{",
"if",
"(",
"!",
"empty",
"(",
"$",
"pull_request",
"->",
"user",
")",
")",
"{",
"$",
"contributors",
"[",
"$",
"pull_request",
"->",
"user",
"->",
"html_url",
"]",
"=",
"$",
"pull_request",
"->",
"user",
"->",
"login",
";",
"}",
"}",
"return",
"$",
"contributors",
";",
"}"
] | Parse the contributors from pull request objects
@param array $pull_requests
@return array | [
"Parse",
"the",
"contributors",
"from",
"pull",
"request",
"objects"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/utils/contrib-list.php#L171-L179 | train |
wp-cli/wp-cli | utils/contrib-list.php | Contrib_List_Command.make_github_api_request | private static function make_github_api_request( $url, $args = array() ) {
$headers = array(
'Accept' => 'application/vnd.github.v3+json',
'User-Agent' => 'WP-CLI',
);
$token = getenv( 'GITHUB_TOKEN' );
if ( false !== $token ) {
$headers['Authorization'] = 'token ' . $token;
}
$response = Utils\http_request( 'GET', $url, $args, $headers );
if ( 200 !== $response->status_code ) {
WP_CLI::error( sprintf( 'GitHub API returned: %s (HTTP code %d)', $response->body, $response->status_code ) );
}
return array( json_decode( $response->body ), $response->headers );
} | php | private static function make_github_api_request( $url, $args = array() ) {
$headers = array(
'Accept' => 'application/vnd.github.v3+json',
'User-Agent' => 'WP-CLI',
);
$token = getenv( 'GITHUB_TOKEN' );
if ( false !== $token ) {
$headers['Authorization'] = 'token ' . $token;
}
$response = Utils\http_request( 'GET', $url, $args, $headers );
if ( 200 !== $response->status_code ) {
WP_CLI::error( sprintf( 'GitHub API returned: %s (HTTP code %d)', $response->body, $response->status_code ) );
}
return array( json_decode( $response->body ), $response->headers );
} | [
"private",
"static",
"function",
"make_github_api_request",
"(",
"$",
"url",
",",
"$",
"args",
"=",
"array",
"(",
")",
")",
"{",
"$",
"headers",
"=",
"array",
"(",
"'Accept'",
"=>",
"'application/vnd.github.v3+json'",
",",
"'User-Agent'",
"=>",
"'WP-CLI'",
",",
")",
";",
"$",
"token",
"=",
"getenv",
"(",
"'GITHUB_TOKEN'",
")",
";",
"if",
"(",
"false",
"!==",
"$",
"token",
")",
"{",
"$",
"headers",
"[",
"'Authorization'",
"]",
"=",
"'token '",
".",
"$",
"token",
";",
"}",
"$",
"response",
"=",
"Utils",
"\\",
"http_request",
"(",
"'GET'",
",",
"$",
"url",
",",
"$",
"args",
",",
"$",
"headers",
")",
";",
"if",
"(",
"200",
"!==",
"$",
"response",
"->",
"status_code",
")",
"{",
"WP_CLI",
"::",
"error",
"(",
"sprintf",
"(",
"'GitHub API returned: %s (HTTP code %d)'",
",",
"$",
"response",
"->",
"body",
",",
"$",
"response",
"->",
"status_code",
")",
")",
";",
"}",
"return",
"array",
"(",
"json_decode",
"(",
"$",
"response",
"->",
"body",
")",
",",
"$",
"response",
"->",
"headers",
")",
";",
"}"
] | Make a request to the GitHub API
@param string $url
@param string $args
@return array | [
"Make",
"a",
"request",
"to",
"the",
"GitHub",
"API"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/utils/contrib-list.php#L188-L202 | train |
wp-cli/wp-cli | php/WP_CLI/Iterators/Query.php | Query.adjust_offset_for_shrinking_result_set | private function adjust_offset_for_shrinking_result_set() {
if ( empty( $this->count_query ) ) {
return;
}
$row_count = $this->db->get_var( $this->count_query );
if ( $row_count < $this->row_count ) {
$this->offset -= $this->row_count - $row_count;
}
$this->row_count = $row_count;
} | php | private function adjust_offset_for_shrinking_result_set() {
if ( empty( $this->count_query ) ) {
return;
}
$row_count = $this->db->get_var( $this->count_query );
if ( $row_count < $this->row_count ) {
$this->offset -= $this->row_count - $row_count;
}
$this->row_count = $row_count;
} | [
"private",
"function",
"adjust_offset_for_shrinking_result_set",
"(",
")",
"{",
"if",
"(",
"empty",
"(",
"$",
"this",
"->",
"count_query",
")",
")",
"{",
"return",
";",
"}",
"$",
"row_count",
"=",
"$",
"this",
"->",
"db",
"->",
"get_var",
"(",
"$",
"this",
"->",
"count_query",
")",
";",
"if",
"(",
"$",
"row_count",
"<",
"$",
"this",
"->",
"row_count",
")",
"{",
"$",
"this",
"->",
"offset",
"-=",
"$",
"this",
"->",
"row_count",
"-",
"$",
"row_count",
";",
"}",
"$",
"this",
"->",
"row_count",
"=",
"$",
"row_count",
";",
"}"
] | 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. | [
"Reduces",
"the",
"offset",
"when",
"the",
"query",
"row",
"count",
"shrinks"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Iterators/Query.php#L57-L69 | train |
wp-cli/wp-cli | php/WP_CLI/Configurator.php | Configurator.get_aliases | public function get_aliases() {
$runtime_alias = getenv( 'WP_CLI_RUNTIME_ALIAS' );
if ( false !== $runtime_alias ) {
$returned_aliases = array();
foreach ( json_decode( $runtime_alias, true ) as $key => $value ) {
if ( preg_match( '#' . self::ALIAS_REGEX . '#', $key ) ) {
$returned_aliases[ $key ] = array();
foreach ( self::$alias_spec as $i ) {
if ( isset( $value[ $i ] ) ) {
$returned_aliases[ $key ][ $i ] = $value[ $i ];
}
}
}
}
return $returned_aliases;
}
return $this->aliases;
} | php | public function get_aliases() {
$runtime_alias = getenv( 'WP_CLI_RUNTIME_ALIAS' );
if ( false !== $runtime_alias ) {
$returned_aliases = array();
foreach ( json_decode( $runtime_alias, true ) as $key => $value ) {
if ( preg_match( '#' . self::ALIAS_REGEX . '#', $key ) ) {
$returned_aliases[ $key ] = array();
foreach ( self::$alias_spec as $i ) {
if ( isset( $value[ $i ] ) ) {
$returned_aliases[ $key ][ $i ] = $value[ $i ];
}
}
}
}
return $returned_aliases;
}
return $this->aliases;
} | [
"public",
"function",
"get_aliases",
"(",
")",
"{",
"$",
"runtime_alias",
"=",
"getenv",
"(",
"'WP_CLI_RUNTIME_ALIAS'",
")",
";",
"if",
"(",
"false",
"!==",
"$",
"runtime_alias",
")",
"{",
"$",
"returned_aliases",
"=",
"array",
"(",
")",
";",
"foreach",
"(",
"json_decode",
"(",
"$",
"runtime_alias",
",",
"true",
")",
"as",
"$",
"key",
"=>",
"$",
"value",
")",
"{",
"if",
"(",
"preg_match",
"(",
"'#'",
".",
"self",
"::",
"ALIAS_REGEX",
".",
"'#'",
",",
"$",
"key",
")",
")",
"{",
"$",
"returned_aliases",
"[",
"$",
"key",
"]",
"=",
"array",
"(",
")",
";",
"foreach",
"(",
"self",
"::",
"$",
"alias_spec",
"as",
"$",
"i",
")",
"{",
"if",
"(",
"isset",
"(",
"$",
"value",
"[",
"$",
"i",
"]",
")",
")",
"{",
"$",
"returned_aliases",
"[",
"$",
"key",
"]",
"[",
"$",
"i",
"]",
"=",
"$",
"value",
"[",
"$",
"i",
"]",
";",
"}",
"}",
"}",
"}",
"return",
"$",
"returned_aliases",
";",
"}",
"return",
"$",
"this",
"->",
"aliases",
";",
"}"
] | Get any aliases defined in config files.
@return array | [
"Get",
"any",
"aliases",
"defined",
"in",
"config",
"files",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Configurator.php#L94-L112 | train |
wp-cli/wp-cli | php/WP_CLI/Configurator.php | Configurator.parse_args | public function parse_args( $arguments ) {
list( $positional_args, $mixed_args, $global_assoc, $local_assoc ) = self::extract_assoc( $arguments );
list( $assoc_args, $runtime_config ) = $this->unmix_assoc_args( $mixed_args, $global_assoc, $local_assoc );
return array( $positional_args, $assoc_args, $runtime_config );
} | php | public function parse_args( $arguments ) {
list( $positional_args, $mixed_args, $global_assoc, $local_assoc ) = self::extract_assoc( $arguments );
list( $assoc_args, $runtime_config ) = $this->unmix_assoc_args( $mixed_args, $global_assoc, $local_assoc );
return array( $positional_args, $assoc_args, $runtime_config );
} | [
"public",
"function",
"parse_args",
"(",
"$",
"arguments",
")",
"{",
"list",
"(",
"$",
"positional_args",
",",
"$",
"mixed_args",
",",
"$",
"global_assoc",
",",
"$",
"local_assoc",
")",
"=",
"self",
"::",
"extract_assoc",
"(",
"$",
"arguments",
")",
";",
"list",
"(",
"$",
"assoc_args",
",",
"$",
"runtime_config",
")",
"=",
"$",
"this",
"->",
"unmix_assoc_args",
"(",
"$",
"mixed_args",
",",
"$",
"global_assoc",
",",
"$",
"local_assoc",
")",
";",
"return",
"array",
"(",
"$",
"positional_args",
",",
"$",
"assoc_args",
",",
"$",
"runtime_config",
")",
";",
"}"
] | Splits a list of arguments into positional, associative and config.
@param array(string)
@return array(array) | [
"Splits",
"a",
"list",
"of",
"arguments",
"into",
"positional",
"associative",
"and",
"config",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Configurator.php#L120-L124 | train |
wp-cli/wp-cli | php/WP_CLI/Configurator.php | Configurator.extract_assoc | public static function extract_assoc( $arguments ) {
$positional_args = array();
$assoc_args = array();
$global_assoc = array();
$local_assoc = array();
foreach ( $arguments as $arg ) {
$positional_arg = null;
$assoc_arg = null;
if ( preg_match( '|^--no-([^=]+)$|', $arg, $matches ) ) {
$assoc_arg = array( $matches[1], false );
} elseif ( preg_match( '|^--([^=]+)$|', $arg, $matches ) ) {
$assoc_arg = array( $matches[1], true );
} elseif ( preg_match( '|^--([^=]+)=(.*)|s', $arg, $matches ) ) {
$assoc_arg = array( $matches[1], $matches[2] );
} else {
$positional = $arg;
}
if ( ! is_null( $assoc_arg ) ) {
$assoc_args[] = $assoc_arg;
if ( count( $positional_args ) ) {
$local_assoc[] = $assoc_arg;
} else {
$global_assoc[] = $assoc_arg;
}
} elseif ( ! is_null( $positional ) ) {
$positional_args[] = $positional;
}
}
return array( $positional_args, $assoc_args, $global_assoc, $local_assoc );
} | php | public static function extract_assoc( $arguments ) {
$positional_args = array();
$assoc_args = array();
$global_assoc = array();
$local_assoc = array();
foreach ( $arguments as $arg ) {
$positional_arg = null;
$assoc_arg = null;
if ( preg_match( '|^--no-([^=]+)$|', $arg, $matches ) ) {
$assoc_arg = array( $matches[1], false );
} elseif ( preg_match( '|^--([^=]+)$|', $arg, $matches ) ) {
$assoc_arg = array( $matches[1], true );
} elseif ( preg_match( '|^--([^=]+)=(.*)|s', $arg, $matches ) ) {
$assoc_arg = array( $matches[1], $matches[2] );
} else {
$positional = $arg;
}
if ( ! is_null( $assoc_arg ) ) {
$assoc_args[] = $assoc_arg;
if ( count( $positional_args ) ) {
$local_assoc[] = $assoc_arg;
} else {
$global_assoc[] = $assoc_arg;
}
} elseif ( ! is_null( $positional ) ) {
$positional_args[] = $positional;
}
}
return array( $positional_args, $assoc_args, $global_assoc, $local_assoc );
} | [
"public",
"static",
"function",
"extract_assoc",
"(",
"$",
"arguments",
")",
"{",
"$",
"positional_args",
"=",
"array",
"(",
")",
";",
"$",
"assoc_args",
"=",
"array",
"(",
")",
";",
"$",
"global_assoc",
"=",
"array",
"(",
")",
";",
"$",
"local_assoc",
"=",
"array",
"(",
")",
";",
"foreach",
"(",
"$",
"arguments",
"as",
"$",
"arg",
")",
"{",
"$",
"positional_arg",
"=",
"null",
";",
"$",
"assoc_arg",
"=",
"null",
";",
"if",
"(",
"preg_match",
"(",
"'|^--no-([^=]+)$|'",
",",
"$",
"arg",
",",
"$",
"matches",
")",
")",
"{",
"$",
"assoc_arg",
"=",
"array",
"(",
"$",
"matches",
"[",
"1",
"]",
",",
"false",
")",
";",
"}",
"elseif",
"(",
"preg_match",
"(",
"'|^--([^=]+)$|'",
",",
"$",
"arg",
",",
"$",
"matches",
")",
")",
"{",
"$",
"assoc_arg",
"=",
"array",
"(",
"$",
"matches",
"[",
"1",
"]",
",",
"true",
")",
";",
"}",
"elseif",
"(",
"preg_match",
"(",
"'|^--([^=]+)=(.*)|s'",
",",
"$",
"arg",
",",
"$",
"matches",
")",
")",
"{",
"$",
"assoc_arg",
"=",
"array",
"(",
"$",
"matches",
"[",
"1",
"]",
",",
"$",
"matches",
"[",
"2",
"]",
")",
";",
"}",
"else",
"{",
"$",
"positional",
"=",
"$",
"arg",
";",
"}",
"if",
"(",
"!",
"is_null",
"(",
"$",
"assoc_arg",
")",
")",
"{",
"$",
"assoc_args",
"[",
"]",
"=",
"$",
"assoc_arg",
";",
"if",
"(",
"count",
"(",
"$",
"positional_args",
")",
")",
"{",
"$",
"local_assoc",
"[",
"]",
"=",
"$",
"assoc_arg",
";",
"}",
"else",
"{",
"$",
"global_assoc",
"[",
"]",
"=",
"$",
"assoc_arg",
";",
"}",
"}",
"elseif",
"(",
"!",
"is_null",
"(",
"$",
"positional",
")",
")",
"{",
"$",
"positional_args",
"[",
"]",
"=",
"$",
"positional",
";",
"}",
"}",
"return",
"array",
"(",
"$",
"positional_args",
",",
"$",
"assoc_args",
",",
"$",
"global_assoc",
",",
"$",
"local_assoc",
")",
";",
"}"
] | Splits positional args from associative args.
@param array
@return array(array) | [
"Splits",
"positional",
"args",
"from",
"associative",
"args",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Configurator.php#L132-L165 | train |
wp-cli/wp-cli | php/WP_CLI/Configurator.php | Configurator.unmix_assoc_args | private function unmix_assoc_args( $mixed_args, $global_assoc = array(), $local_assoc = array() ) {
$assoc_args = array();
$runtime_config = array();
if ( getenv( 'WP_CLI_STRICT_ARGS_MODE' ) ) {
foreach ( $global_assoc as $tmp ) {
list( $key, $value ) = $tmp;
if ( isset( $this->spec[ $key ] ) && false !== $this->spec[ $key ]['runtime'] ) {
$this->assoc_arg_to_runtime_config( $key, $value, $runtime_config );
}
}
foreach ( $local_assoc as $tmp ) {
$assoc_args[ $tmp[0] ] = $tmp[1];
}
} else {
foreach ( $mixed_args as $tmp ) {
list( $key, $value ) = $tmp;
if ( isset( $this->spec[ $key ] ) && false !== $this->spec[ $key ]['runtime'] ) {
$this->assoc_arg_to_runtime_config( $key, $value, $runtime_config );
} else {
$assoc_args[ $key ] = $value;
}
}
}
return array( $assoc_args, $runtime_config );
} | php | private function unmix_assoc_args( $mixed_args, $global_assoc = array(), $local_assoc = array() ) {
$assoc_args = array();
$runtime_config = array();
if ( getenv( 'WP_CLI_STRICT_ARGS_MODE' ) ) {
foreach ( $global_assoc as $tmp ) {
list( $key, $value ) = $tmp;
if ( isset( $this->spec[ $key ] ) && false !== $this->spec[ $key ]['runtime'] ) {
$this->assoc_arg_to_runtime_config( $key, $value, $runtime_config );
}
}
foreach ( $local_assoc as $tmp ) {
$assoc_args[ $tmp[0] ] = $tmp[1];
}
} else {
foreach ( $mixed_args as $tmp ) {
list( $key, $value ) = $tmp;
if ( isset( $this->spec[ $key ] ) && false !== $this->spec[ $key ]['runtime'] ) {
$this->assoc_arg_to_runtime_config( $key, $value, $runtime_config );
} else {
$assoc_args[ $key ] = $value;
}
}
}
return array( $assoc_args, $runtime_config );
} | [
"private",
"function",
"unmix_assoc_args",
"(",
"$",
"mixed_args",
",",
"$",
"global_assoc",
"=",
"array",
"(",
")",
",",
"$",
"local_assoc",
"=",
"array",
"(",
")",
")",
"{",
"$",
"assoc_args",
"=",
"array",
"(",
")",
";",
"$",
"runtime_config",
"=",
"array",
"(",
")",
";",
"if",
"(",
"getenv",
"(",
"'WP_CLI_STRICT_ARGS_MODE'",
")",
")",
"{",
"foreach",
"(",
"$",
"global_assoc",
"as",
"$",
"tmp",
")",
"{",
"list",
"(",
"$",
"key",
",",
"$",
"value",
")",
"=",
"$",
"tmp",
";",
"if",
"(",
"isset",
"(",
"$",
"this",
"->",
"spec",
"[",
"$",
"key",
"]",
")",
"&&",
"false",
"!==",
"$",
"this",
"->",
"spec",
"[",
"$",
"key",
"]",
"[",
"'runtime'",
"]",
")",
"{",
"$",
"this",
"->",
"assoc_arg_to_runtime_config",
"(",
"$",
"key",
",",
"$",
"value",
",",
"$",
"runtime_config",
")",
";",
"}",
"}",
"foreach",
"(",
"$",
"local_assoc",
"as",
"$",
"tmp",
")",
"{",
"$",
"assoc_args",
"[",
"$",
"tmp",
"[",
"0",
"]",
"]",
"=",
"$",
"tmp",
"[",
"1",
"]",
";",
"}",
"}",
"else",
"{",
"foreach",
"(",
"$",
"mixed_args",
"as",
"$",
"tmp",
")",
"{",
"list",
"(",
"$",
"key",
",",
"$",
"value",
")",
"=",
"$",
"tmp",
";",
"if",
"(",
"isset",
"(",
"$",
"this",
"->",
"spec",
"[",
"$",
"key",
"]",
")",
"&&",
"false",
"!==",
"$",
"this",
"->",
"spec",
"[",
"$",
"key",
"]",
"[",
"'runtime'",
"]",
")",
"{",
"$",
"this",
"->",
"assoc_arg_to_runtime_config",
"(",
"$",
"key",
",",
"$",
"value",
",",
"$",
"runtime_config",
")",
";",
"}",
"else",
"{",
"$",
"assoc_args",
"[",
"$",
"key",
"]",
"=",
"$",
"value",
";",
"}",
"}",
"}",
"return",
"array",
"(",
"$",
"assoc_args",
",",
"$",
"runtime_config",
")",
";",
"}"
] | Separate runtime parameters from command-specific parameters.
@param array $mixed_args
@return array | [
"Separate",
"runtime",
"parameters",
"from",
"command",
"-",
"specific",
"parameters",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Configurator.php#L173-L200 | train |
wp-cli/wp-cli | php/WP_CLI/Configurator.php | Configurator.merge_yml | public function merge_yml( $path, $current_alias = null ) {
$yaml = self::load_yml( $path );
if ( ! empty( $yaml['_']['inherit'] ) ) {
$this->merge_yml( $yaml['_']['inherit'], $current_alias );
}
// Prepare the base path for absolutized alias paths
$yml_file_dir = $path ? dirname( $path ) : false;
foreach ( $yaml as $key => $value ) {
if ( preg_match( '#' . self::ALIAS_REGEX . '#', $key ) ) {
$this->aliases[ $key ] = array();
$is_alias = false;
foreach ( self::$alias_spec as $i ) {
if ( isset( $value[ $i ] ) ) {
if ( 'path' === $i && ! isset( $value['ssh'] ) ) {
self::absolutize( $value[ $i ], $yml_file_dir );
}
$this->aliases[ $key ][ $i ] = $value[ $i ];
$is_alias = true;
}
}
// If it's not an alias, it might be a group of aliases
if ( ! $is_alias && is_array( $value ) ) {
$alias_group = array();
foreach ( $value as $i => $k ) {
if ( preg_match( '#' . self::ALIAS_REGEX . '#', $k ) ) {
$alias_group[] = $k;
}
}
$this->aliases[ $key ] = $alias_group;
}
} elseif ( ! isset( $this->spec[ $key ] ) || false === $this->spec[ $key ]['file'] ) {
if ( isset( $this->extra_config[ $key ] )
&& ! empty( $yaml['_']['merge'] )
&& is_array( $this->extra_config[ $key ] )
&& is_array( $value ) ) {
$this->extra_config[ $key ] = array_merge( $this->extra_config[ $key ], $value );
} else {
$this->extra_config[ $key ] = $value;
}
} elseif ( $this->spec[ $key ]['multiple'] ) {
self::arrayify( $value );
$this->config[ $key ] = array_merge( $this->config[ $key ], $value );
} else {
if ( $current_alias && in_array( $key, self::$alias_spec, true ) ) {
continue;
}
$this->config[ $key ] = $value;
}
}
} | php | public function merge_yml( $path, $current_alias = null ) {
$yaml = self::load_yml( $path );
if ( ! empty( $yaml['_']['inherit'] ) ) {
$this->merge_yml( $yaml['_']['inherit'], $current_alias );
}
// Prepare the base path for absolutized alias paths
$yml_file_dir = $path ? dirname( $path ) : false;
foreach ( $yaml as $key => $value ) {
if ( preg_match( '#' . self::ALIAS_REGEX . '#', $key ) ) {
$this->aliases[ $key ] = array();
$is_alias = false;
foreach ( self::$alias_spec as $i ) {
if ( isset( $value[ $i ] ) ) {
if ( 'path' === $i && ! isset( $value['ssh'] ) ) {
self::absolutize( $value[ $i ], $yml_file_dir );
}
$this->aliases[ $key ][ $i ] = $value[ $i ];
$is_alias = true;
}
}
// If it's not an alias, it might be a group of aliases
if ( ! $is_alias && is_array( $value ) ) {
$alias_group = array();
foreach ( $value as $i => $k ) {
if ( preg_match( '#' . self::ALIAS_REGEX . '#', $k ) ) {
$alias_group[] = $k;
}
}
$this->aliases[ $key ] = $alias_group;
}
} elseif ( ! isset( $this->spec[ $key ] ) || false === $this->spec[ $key ]['file'] ) {
if ( isset( $this->extra_config[ $key ] )
&& ! empty( $yaml['_']['merge'] )
&& is_array( $this->extra_config[ $key ] )
&& is_array( $value ) ) {
$this->extra_config[ $key ] = array_merge( $this->extra_config[ $key ], $value );
} else {
$this->extra_config[ $key ] = $value;
}
} elseif ( $this->spec[ $key ]['multiple'] ) {
self::arrayify( $value );
$this->config[ $key ] = array_merge( $this->config[ $key ], $value );
} else {
if ( $current_alias && in_array( $key, self::$alias_spec, true ) ) {
continue;
}
$this->config[ $key ] = $value;
}
}
} | [
"public",
"function",
"merge_yml",
"(",
"$",
"path",
",",
"$",
"current_alias",
"=",
"null",
")",
"{",
"$",
"yaml",
"=",
"self",
"::",
"load_yml",
"(",
"$",
"path",
")",
";",
"if",
"(",
"!",
"empty",
"(",
"$",
"yaml",
"[",
"'_'",
"]",
"[",
"'inherit'",
"]",
")",
")",
"{",
"$",
"this",
"->",
"merge_yml",
"(",
"$",
"yaml",
"[",
"'_'",
"]",
"[",
"'inherit'",
"]",
",",
"$",
"current_alias",
")",
";",
"}",
"// Prepare the base path for absolutized alias paths",
"$",
"yml_file_dir",
"=",
"$",
"path",
"?",
"dirname",
"(",
"$",
"path",
")",
":",
"false",
";",
"foreach",
"(",
"$",
"yaml",
"as",
"$",
"key",
"=>",
"$",
"value",
")",
"{",
"if",
"(",
"preg_match",
"(",
"'#'",
".",
"self",
"::",
"ALIAS_REGEX",
".",
"'#'",
",",
"$",
"key",
")",
")",
"{",
"$",
"this",
"->",
"aliases",
"[",
"$",
"key",
"]",
"=",
"array",
"(",
")",
";",
"$",
"is_alias",
"=",
"false",
";",
"foreach",
"(",
"self",
"::",
"$",
"alias_spec",
"as",
"$",
"i",
")",
"{",
"if",
"(",
"isset",
"(",
"$",
"value",
"[",
"$",
"i",
"]",
")",
")",
"{",
"if",
"(",
"'path'",
"===",
"$",
"i",
"&&",
"!",
"isset",
"(",
"$",
"value",
"[",
"'ssh'",
"]",
")",
")",
"{",
"self",
"::",
"absolutize",
"(",
"$",
"value",
"[",
"$",
"i",
"]",
",",
"$",
"yml_file_dir",
")",
";",
"}",
"$",
"this",
"->",
"aliases",
"[",
"$",
"key",
"]",
"[",
"$",
"i",
"]",
"=",
"$",
"value",
"[",
"$",
"i",
"]",
";",
"$",
"is_alias",
"=",
"true",
";",
"}",
"}",
"// If it's not an alias, it might be a group of aliases",
"if",
"(",
"!",
"$",
"is_alias",
"&&",
"is_array",
"(",
"$",
"value",
")",
")",
"{",
"$",
"alias_group",
"=",
"array",
"(",
")",
";",
"foreach",
"(",
"$",
"value",
"as",
"$",
"i",
"=>",
"$",
"k",
")",
"{",
"if",
"(",
"preg_match",
"(",
"'#'",
".",
"self",
"::",
"ALIAS_REGEX",
".",
"'#'",
",",
"$",
"k",
")",
")",
"{",
"$",
"alias_group",
"[",
"]",
"=",
"$",
"k",
";",
"}",
"}",
"$",
"this",
"->",
"aliases",
"[",
"$",
"key",
"]",
"=",
"$",
"alias_group",
";",
"}",
"}",
"elseif",
"(",
"!",
"isset",
"(",
"$",
"this",
"->",
"spec",
"[",
"$",
"key",
"]",
")",
"||",
"false",
"===",
"$",
"this",
"->",
"spec",
"[",
"$",
"key",
"]",
"[",
"'file'",
"]",
")",
"{",
"if",
"(",
"isset",
"(",
"$",
"this",
"->",
"extra_config",
"[",
"$",
"key",
"]",
")",
"&&",
"!",
"empty",
"(",
"$",
"yaml",
"[",
"'_'",
"]",
"[",
"'merge'",
"]",
")",
"&&",
"is_array",
"(",
"$",
"this",
"->",
"extra_config",
"[",
"$",
"key",
"]",
")",
"&&",
"is_array",
"(",
"$",
"value",
")",
")",
"{",
"$",
"this",
"->",
"extra_config",
"[",
"$",
"key",
"]",
"=",
"array_merge",
"(",
"$",
"this",
"->",
"extra_config",
"[",
"$",
"key",
"]",
",",
"$",
"value",
")",
";",
"}",
"else",
"{",
"$",
"this",
"->",
"extra_config",
"[",
"$",
"key",
"]",
"=",
"$",
"value",
";",
"}",
"}",
"elseif",
"(",
"$",
"this",
"->",
"spec",
"[",
"$",
"key",
"]",
"[",
"'multiple'",
"]",
")",
"{",
"self",
"::",
"arrayify",
"(",
"$",
"value",
")",
";",
"$",
"this",
"->",
"config",
"[",
"$",
"key",
"]",
"=",
"array_merge",
"(",
"$",
"this",
"->",
"config",
"[",
"$",
"key",
"]",
",",
"$",
"value",
")",
";",
"}",
"else",
"{",
"if",
"(",
"$",
"current_alias",
"&&",
"in_array",
"(",
"$",
"key",
",",
"self",
"::",
"$",
"alias_spec",
",",
"true",
")",
")",
"{",
"continue",
";",
"}",
"$",
"this",
"->",
"config",
"[",
"$",
"key",
"]",
"=",
"$",
"value",
";",
"}",
"}",
"}"
] | Load a YAML file of parameters into scope.
@param string $path Path to YAML file. | [
"Load",
"a",
"YAML",
"file",
"of",
"parameters",
"into",
"scope",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Configurator.php#L223-L272 | train |
wp-cli/wp-cli | php/WP_CLI/Configurator.php | Configurator.merge_array | public function merge_array( $config ) {
foreach ( $this->spec as $key => $details ) {
if ( false !== $details['runtime'] && isset( $config[ $key ] ) ) {
$value = $config[ $key ];
if ( 'require' === $key ) {
$value = \WP_CLI\Utils\expand_globs( $value );
}
if ( $details['multiple'] ) {
self::arrayify( $value );
$this->config[ $key ] = array_merge( $this->config[ $key ], $value );
} else {
$this->config[ $key ] = $value;
}
}
}
} | php | public function merge_array( $config ) {
foreach ( $this->spec as $key => $details ) {
if ( false !== $details['runtime'] && isset( $config[ $key ] ) ) {
$value = $config[ $key ];
if ( 'require' === $key ) {
$value = \WP_CLI\Utils\expand_globs( $value );
}
if ( $details['multiple'] ) {
self::arrayify( $value );
$this->config[ $key ] = array_merge( $this->config[ $key ], $value );
} else {
$this->config[ $key ] = $value;
}
}
}
} | [
"public",
"function",
"merge_array",
"(",
"$",
"config",
")",
"{",
"foreach",
"(",
"$",
"this",
"->",
"spec",
"as",
"$",
"key",
"=>",
"$",
"details",
")",
"{",
"if",
"(",
"false",
"!==",
"$",
"details",
"[",
"'runtime'",
"]",
"&&",
"isset",
"(",
"$",
"config",
"[",
"$",
"key",
"]",
")",
")",
"{",
"$",
"value",
"=",
"$",
"config",
"[",
"$",
"key",
"]",
";",
"if",
"(",
"'require'",
"===",
"$",
"key",
")",
"{",
"$",
"value",
"=",
"\\",
"WP_CLI",
"\\",
"Utils",
"\\",
"expand_globs",
"(",
"$",
"value",
")",
";",
"}",
"if",
"(",
"$",
"details",
"[",
"'multiple'",
"]",
")",
"{",
"self",
"::",
"arrayify",
"(",
"$",
"value",
")",
";",
"$",
"this",
"->",
"config",
"[",
"$",
"key",
"]",
"=",
"array_merge",
"(",
"$",
"this",
"->",
"config",
"[",
"$",
"key",
"]",
",",
"$",
"value",
")",
";",
"}",
"else",
"{",
"$",
"this",
"->",
"config",
"[",
"$",
"key",
"]",
"=",
"$",
"value",
";",
"}",
"}",
"}",
"}"
] | Merge an array of values into the configurator config.
@param array $config | [
"Merge",
"an",
"array",
"of",
"values",
"into",
"the",
"configurator",
"config",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Configurator.php#L279-L296 | train |
wp-cli/wp-cli | php/WP_CLI/Configurator.php | Configurator.load_yml | private static function load_yml( $yml_file ) {
if ( ! $yml_file ) {
return array();
}
$config = Spyc::YAMLLoad( $yml_file );
// Make sure config-file-relative paths are made absolute.
$yml_file_dir = dirname( $yml_file );
if ( isset( $config['path'] ) ) {
self::absolutize( $config['path'], $yml_file_dir );
}
if ( isset( $config['require'] ) ) {
self::arrayify( $config['require'] );
$config['require'] = \WP_CLI\Utils\expand_globs( $config['require'] );
foreach ( $config['require'] as &$path ) {
self::absolutize( $path, $yml_file_dir );
}
}
// Backwards compat
// Command 'core config' was moved to 'config create'.
if ( isset( $config['core config'] ) ) {
$config['config create'] = $config['core config'];
unset( $config['core config'] );
}
// Command 'checksum core' was moved to 'core verify-checksums'.
if ( isset( $config['checksum core'] ) ) {
$config['core verify-checksums'] = $config['checksum core'];
unset( $config['checksum core'] );
}
// Command 'checksum plugin' was moved to 'plugin verify-checksums'.
if ( isset( $config['checksum plugin'] ) ) {
$config['plugin verify-checksums'] = $config['checksum plugin'];
unset( $config['checksum plugin'] );
}
return $config;
} | php | private static function load_yml( $yml_file ) {
if ( ! $yml_file ) {
return array();
}
$config = Spyc::YAMLLoad( $yml_file );
// Make sure config-file-relative paths are made absolute.
$yml_file_dir = dirname( $yml_file );
if ( isset( $config['path'] ) ) {
self::absolutize( $config['path'], $yml_file_dir );
}
if ( isset( $config['require'] ) ) {
self::arrayify( $config['require'] );
$config['require'] = \WP_CLI\Utils\expand_globs( $config['require'] );
foreach ( $config['require'] as &$path ) {
self::absolutize( $path, $yml_file_dir );
}
}
// Backwards compat
// Command 'core config' was moved to 'config create'.
if ( isset( $config['core config'] ) ) {
$config['config create'] = $config['core config'];
unset( $config['core config'] );
}
// Command 'checksum core' was moved to 'core verify-checksums'.
if ( isset( $config['checksum core'] ) ) {
$config['core verify-checksums'] = $config['checksum core'];
unset( $config['checksum core'] );
}
// Command 'checksum plugin' was moved to 'plugin verify-checksums'.
if ( isset( $config['checksum plugin'] ) ) {
$config['plugin verify-checksums'] = $config['checksum plugin'];
unset( $config['checksum plugin'] );
}
return $config;
} | [
"private",
"static",
"function",
"load_yml",
"(",
"$",
"yml_file",
")",
"{",
"if",
"(",
"!",
"$",
"yml_file",
")",
"{",
"return",
"array",
"(",
")",
";",
"}",
"$",
"config",
"=",
"Spyc",
"::",
"YAMLLoad",
"(",
"$",
"yml_file",
")",
";",
"// Make sure config-file-relative paths are made absolute.",
"$",
"yml_file_dir",
"=",
"dirname",
"(",
"$",
"yml_file",
")",
";",
"if",
"(",
"isset",
"(",
"$",
"config",
"[",
"'path'",
"]",
")",
")",
"{",
"self",
"::",
"absolutize",
"(",
"$",
"config",
"[",
"'path'",
"]",
",",
"$",
"yml_file_dir",
")",
";",
"}",
"if",
"(",
"isset",
"(",
"$",
"config",
"[",
"'require'",
"]",
")",
")",
"{",
"self",
"::",
"arrayify",
"(",
"$",
"config",
"[",
"'require'",
"]",
")",
";",
"$",
"config",
"[",
"'require'",
"]",
"=",
"\\",
"WP_CLI",
"\\",
"Utils",
"\\",
"expand_globs",
"(",
"$",
"config",
"[",
"'require'",
"]",
")",
";",
"foreach",
"(",
"$",
"config",
"[",
"'require'",
"]",
"as",
"&",
"$",
"path",
")",
"{",
"self",
"::",
"absolutize",
"(",
"$",
"path",
",",
"$",
"yml_file_dir",
")",
";",
"}",
"}",
"// Backwards compat",
"// Command 'core config' was moved to 'config create'.",
"if",
"(",
"isset",
"(",
"$",
"config",
"[",
"'core config'",
"]",
")",
")",
"{",
"$",
"config",
"[",
"'config create'",
"]",
"=",
"$",
"config",
"[",
"'core config'",
"]",
";",
"unset",
"(",
"$",
"config",
"[",
"'core config'",
"]",
")",
";",
"}",
"// Command 'checksum core' was moved to 'core verify-checksums'.",
"if",
"(",
"isset",
"(",
"$",
"config",
"[",
"'checksum core'",
"]",
")",
")",
"{",
"$",
"config",
"[",
"'core verify-checksums'",
"]",
"=",
"$",
"config",
"[",
"'checksum core'",
"]",
";",
"unset",
"(",
"$",
"config",
"[",
"'checksum core'",
"]",
")",
";",
"}",
"// Command 'checksum plugin' was moved to 'plugin verify-checksums'.",
"if",
"(",
"isset",
"(",
"$",
"config",
"[",
"'checksum plugin'",
"]",
")",
")",
"{",
"$",
"config",
"[",
"'plugin verify-checksums'",
"]",
"=",
"$",
"config",
"[",
"'checksum plugin'",
"]",
";",
"unset",
"(",
"$",
"config",
"[",
"'checksum plugin'",
"]",
")",
";",
"}",
"return",
"$",
"config",
";",
"}"
] | Load values from a YAML file.
@param string $yml_file Path to the YAML file
@return array $config Declared configuration values | [
"Load",
"values",
"from",
"a",
"YAML",
"file",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Configurator.php#L304-L344 | train |
wp-cli/wp-cli | php/WP_CLI/Configurator.php | Configurator.absolutize | private static function absolutize( &$path, $base ) {
if ( ! empty( $path ) && ! \WP_CLI\Utils\is_path_absolute( $path ) ) {
$path = $base . DIRECTORY_SEPARATOR . $path;
}
} | php | private static function absolutize( &$path, $base ) {
if ( ! empty( $path ) && ! \WP_CLI\Utils\is_path_absolute( $path ) ) {
$path = $base . DIRECTORY_SEPARATOR . $path;
}
} | [
"private",
"static",
"function",
"absolutize",
"(",
"&",
"$",
"path",
",",
"$",
"base",
")",
"{",
"if",
"(",
"!",
"empty",
"(",
"$",
"path",
")",
"&&",
"!",
"\\",
"WP_CLI",
"\\",
"Utils",
"\\",
"is_path_absolute",
"(",
"$",
"path",
")",
")",
"{",
"$",
"path",
"=",
"$",
"base",
".",
"DIRECTORY_SEPARATOR",
".",
"$",
"path",
";",
"}",
"}"
] | Make a path absolute.
@param string $path Path to file.
@param string $base Base path to prepend. | [
"Make",
"a",
"path",
"absolute",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/Configurator.php#L361-L365 | train |
wp-cli/wp-cli | php/class-wp-cli.php | WP_CLI.set_url | public static function set_url( $url ) {
self::debug( 'Set URL: ' . $url, 'bootstrap' );
$url_parts = Utils\parse_url( $url );
self::set_url_params( $url_parts );
} | php | public static function set_url( $url ) {
self::debug( 'Set URL: ' . $url, 'bootstrap' );
$url_parts = Utils\parse_url( $url );
self::set_url_params( $url_parts );
} | [
"public",
"static",
"function",
"set_url",
"(",
"$",
"url",
")",
"{",
"self",
"::",
"debug",
"(",
"'Set URL: '",
".",
"$",
"url",
",",
"'bootstrap'",
")",
";",
"$",
"url_parts",
"=",
"Utils",
"\\",
"parse_url",
"(",
"$",
"url",
")",
";",
"self",
"::",
"set_url_params",
"(",
"$",
"url_parts",
")",
";",
"}"
] | Set the context in which WP-CLI should be run | [
"Set",
"the",
"context",
"in",
"which",
"WP",
"-",
"CLI",
"should",
"be",
"run"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/class-wp-cli.php#L103-L107 | train |
wp-cli/wp-cli | php/class-wp-cli.php | WP_CLI.add_hook | public static function add_hook( $when, $callback ) {
if ( array_key_exists( $when, self::$hooks_passed ) ) {
self::debug(
sprintf(
'Immediately invoking on passed hook "%s": %s',
$when,
Utils\describe_callable( $callback )
),
'hooks'
);
call_user_func_array( $callback, (array) self::$hooks_passed[ $when ] );
}
self::$hooks[ $when ][] = $callback;
} | php | public static function add_hook( $when, $callback ) {
if ( array_key_exists( $when, self::$hooks_passed ) ) {
self::debug(
sprintf(
'Immediately invoking on passed hook "%s": %s',
$when,
Utils\describe_callable( $callback )
),
'hooks'
);
call_user_func_array( $callback, (array) self::$hooks_passed[ $when ] );
}
self::$hooks[ $when ][] = $callback;
} | [
"public",
"static",
"function",
"add_hook",
"(",
"$",
"when",
",",
"$",
"callback",
")",
"{",
"if",
"(",
"array_key_exists",
"(",
"$",
"when",
",",
"self",
"::",
"$",
"hooks_passed",
")",
")",
"{",
"self",
"::",
"debug",
"(",
"sprintf",
"(",
"'Immediately invoking on passed hook \"%s\": %s'",
",",
"$",
"when",
",",
"Utils",
"\\",
"describe_callable",
"(",
"$",
"callback",
")",
")",
",",
"'hooks'",
")",
";",
"call_user_func_array",
"(",
"$",
"callback",
",",
"(",
"array",
")",
"self",
"::",
"$",
"hooks_passed",
"[",
"$",
"when",
"]",
")",
";",
"}",
"self",
"::",
"$",
"hooks",
"[",
"$",
"when",
"]",
"[",
"]",
"=",
"$",
"callback",
";",
"}"
] | 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 | [
"Schedule",
"a",
"callback",
"to",
"be",
"executed",
"at",
"a",
"certain",
"point",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/class-wp-cli.php#L244-L258 | train |
wp-cli/wp-cli | php/class-wp-cli.php | WP_CLI.do_hook | public static function do_hook( $when ) {
$args = func_num_args() > 1
? array_slice( func_get_args(), 1 )
: array();
self::$hooks_passed[ $when ] = $args;
if ( ! isset( self::$hooks[ $when ] ) ) {
return;
}
self::debug(
sprintf(
'Processing hook "%s" with %d callbacks',
$when,
count( self::$hooks[ $when ] )
),
'hooks'
);
foreach ( self::$hooks[ $when ] as $callback ) {
self::debug(
sprintf(
'On hook "%s": %s',
$when,
Utils\describe_callable( $callback )
),
'hooks'
);
call_user_func_array( $callback, $args );
}
} | php | public static function do_hook( $when ) {
$args = func_num_args() > 1
? array_slice( func_get_args(), 1 )
: array();
self::$hooks_passed[ $when ] = $args;
if ( ! isset( self::$hooks[ $when ] ) ) {
return;
}
self::debug(
sprintf(
'Processing hook "%s" with %d callbacks',
$when,
count( self::$hooks[ $when ] )
),
'hooks'
);
foreach ( self::$hooks[ $when ] as $callback ) {
self::debug(
sprintf(
'On hook "%s": %s',
$when,
Utils\describe_callable( $callback )
),
'hooks'
);
call_user_func_array( $callback, $args );
}
} | [
"public",
"static",
"function",
"do_hook",
"(",
"$",
"when",
")",
"{",
"$",
"args",
"=",
"func_num_args",
"(",
")",
">",
"1",
"?",
"array_slice",
"(",
"func_get_args",
"(",
")",
",",
"1",
")",
":",
"array",
"(",
")",
";",
"self",
"::",
"$",
"hooks_passed",
"[",
"$",
"when",
"]",
"=",
"$",
"args",
";",
"if",
"(",
"!",
"isset",
"(",
"self",
"::",
"$",
"hooks",
"[",
"$",
"when",
"]",
")",
")",
"{",
"return",
";",
"}",
"self",
"::",
"debug",
"(",
"sprintf",
"(",
"'Processing hook \"%s\" with %d callbacks'",
",",
"$",
"when",
",",
"count",
"(",
"self",
"::",
"$",
"hooks",
"[",
"$",
"when",
"]",
")",
")",
",",
"'hooks'",
")",
";",
"foreach",
"(",
"self",
"::",
"$",
"hooks",
"[",
"$",
"when",
"]",
"as",
"$",
"callback",
")",
"{",
"self",
"::",
"debug",
"(",
"sprintf",
"(",
"'On hook \"%s\": %s'",
",",
"$",
"when",
",",
"Utils",
"\\",
"describe_callable",
"(",
"$",
"callback",
")",
")",
",",
"'hooks'",
")",
";",
"call_user_func_array",
"(",
"$",
"callback",
",",
"$",
"args",
")",
";",
"}",
"}"
] | 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 | [
"Execute",
"callbacks",
"registered",
"to",
"a",
"given",
"hook",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/class-wp-cli.php#L274-L306 | train |
wp-cli/wp-cli | php/class-wp-cli.php | WP_CLI.add_wp_hook | public static function add_wp_hook( $tag, $function_to_add, $priority = 10, $accepted_args = 1 ) {
global $wp_filter, $merged_filters;
if ( function_exists( 'add_filter' ) ) {
add_filter( $tag, $function_to_add, $priority, $accepted_args );
} else {
$idx = self::wp_hook_build_unique_id( $tag, $function_to_add, $priority );
// phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited -- This is intentional & the purpose of this function.
$wp_filter[ $tag ][ $priority ][ $idx ] = array(
'function' => $function_to_add,
'accepted_args' => $accepted_args,
);
unset( $merged_filters[ $tag ] );
}
return true;
} | php | public static function add_wp_hook( $tag, $function_to_add, $priority = 10, $accepted_args = 1 ) {
global $wp_filter, $merged_filters;
if ( function_exists( 'add_filter' ) ) {
add_filter( $tag, $function_to_add, $priority, $accepted_args );
} else {
$idx = self::wp_hook_build_unique_id( $tag, $function_to_add, $priority );
// phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited -- This is intentional & the purpose of this function.
$wp_filter[ $tag ][ $priority ][ $idx ] = array(
'function' => $function_to_add,
'accepted_args' => $accepted_args,
);
unset( $merged_filters[ $tag ] );
}
return true;
} | [
"public",
"static",
"function",
"add_wp_hook",
"(",
"$",
"tag",
",",
"$",
"function_to_add",
",",
"$",
"priority",
"=",
"10",
",",
"$",
"accepted_args",
"=",
"1",
")",
"{",
"global",
"$",
"wp_filter",
",",
"$",
"merged_filters",
";",
"if",
"(",
"function_exists",
"(",
"'add_filter'",
")",
")",
"{",
"add_filter",
"(",
"$",
"tag",
",",
"$",
"function_to_add",
",",
"$",
"priority",
",",
"$",
"accepted_args",
")",
";",
"}",
"else",
"{",
"$",
"idx",
"=",
"self",
"::",
"wp_hook_build_unique_id",
"(",
"$",
"tag",
",",
"$",
"function_to_add",
",",
"$",
"priority",
")",
";",
"// phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited -- This is intentional & the purpose of this function.",
"$",
"wp_filter",
"[",
"$",
"tag",
"]",
"[",
"$",
"priority",
"]",
"[",
"$",
"idx",
"]",
"=",
"array",
"(",
"'function'",
"=>",
"$",
"function_to_add",
",",
"'accepted_args'",
"=>",
"$",
"accepted_args",
",",
")",
";",
"unset",
"(",
"$",
"merged_filters",
"[",
"$",
"tag",
"]",
")",
";",
"}",
"return",
"true",
";",
"}"
] | 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 | [
"Add",
"a",
"callback",
"to",
"a",
"WordPress",
"action",
"or",
"filter",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/class-wp-cli.php#L324-L341 | train |
wp-cli/wp-cli | php/class-wp-cli.php | WP_CLI.defer_command_addition | private static function defer_command_addition( $name, $parent, $callable, $args = array() ) {
$args['is_deferred'] = true;
self::$deferred_additions[ $name ] = array(
'parent' => $parent,
'callable' => $callable,
'args' => $args,
);
self::add_hook(
"after_add_command:$parent",
function () use ( $name ) {
$deferred_additions = WP_CLI::get_deferred_additions();
if ( ! array_key_exists( $name, $deferred_additions ) ) {
return;
}
$callable = $deferred_additions[ $name ]['callable'];
$args = $deferred_additions[ $name ]['args'];
WP_CLI::remove_deferred_addition( $name );
WP_CLI::add_command( $name, $callable, $args );
}
);
} | php | private static function defer_command_addition( $name, $parent, $callable, $args = array() ) {
$args['is_deferred'] = true;
self::$deferred_additions[ $name ] = array(
'parent' => $parent,
'callable' => $callable,
'args' => $args,
);
self::add_hook(
"after_add_command:$parent",
function () use ( $name ) {
$deferred_additions = WP_CLI::get_deferred_additions();
if ( ! array_key_exists( $name, $deferred_additions ) ) {
return;
}
$callable = $deferred_additions[ $name ]['callable'];
$args = $deferred_additions[ $name ]['args'];
WP_CLI::remove_deferred_addition( $name );
WP_CLI::add_command( $name, $callable, $args );
}
);
} | [
"private",
"static",
"function",
"defer_command_addition",
"(",
"$",
"name",
",",
"$",
"parent",
",",
"$",
"callable",
",",
"$",
"args",
"=",
"array",
"(",
")",
")",
"{",
"$",
"args",
"[",
"'is_deferred'",
"]",
"=",
"true",
";",
"self",
"::",
"$",
"deferred_additions",
"[",
"$",
"name",
"]",
"=",
"array",
"(",
"'parent'",
"=>",
"$",
"parent",
",",
"'callable'",
"=>",
"$",
"callable",
",",
"'args'",
"=>",
"$",
"args",
",",
")",
";",
"self",
"::",
"add_hook",
"(",
"\"after_add_command:$parent\"",
",",
"function",
"(",
")",
"use",
"(",
"$",
"name",
")",
"{",
"$",
"deferred_additions",
"=",
"WP_CLI",
"::",
"get_deferred_additions",
"(",
")",
";",
"if",
"(",
"!",
"array_key_exists",
"(",
"$",
"name",
",",
"$",
"deferred_additions",
")",
")",
"{",
"return",
";",
"}",
"$",
"callable",
"=",
"$",
"deferred_additions",
"[",
"$",
"name",
"]",
"[",
"'callable'",
"]",
";",
"$",
"args",
"=",
"$",
"deferred_additions",
"[",
"$",
"name",
"]",
"[",
"'args'",
"]",
";",
"WP_CLI",
"::",
"remove_deferred_addition",
"(",
"$",
"name",
")",
";",
"WP_CLI",
"::",
"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. | [
"Defer",
"command",
"addition",
"for",
"a",
"sub",
"-",
"command",
"if",
"the",
"parent",
"command",
"is",
"not",
"yet",
"registered",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/class-wp-cli.php#L625-L648 | train |
wp-cli/wp-cli | php/class-wp-cli.php | WP_CLI.remove_deferred_addition | public static function remove_deferred_addition( $name ) {
if ( ! array_key_exists( $name, self::$deferred_additions ) ) {
self::warning( "Trying to remove a non-existent command addition '{$name}'." );
}
unset( self::$deferred_additions[ $name ] );
} | php | public static function remove_deferred_addition( $name ) {
if ( ! array_key_exists( $name, self::$deferred_additions ) ) {
self::warning( "Trying to remove a non-existent command addition '{$name}'." );
}
unset( self::$deferred_additions[ $name ] );
} | [
"public",
"static",
"function",
"remove_deferred_addition",
"(",
"$",
"name",
")",
"{",
"if",
"(",
"!",
"array_key_exists",
"(",
"$",
"name",
",",
"self",
"::",
"$",
"deferred_additions",
")",
")",
"{",
"self",
"::",
"warning",
"(",
"\"Trying to remove a non-existent command addition '{$name}'.\"",
")",
";",
"}",
"unset",
"(",
"self",
"::",
"$",
"deferred_additions",
"[",
"$",
"name",
"]",
")",
";",
"}"
] | Remove a command addition from the list of outstanding deferred additions. | [
"Remove",
"a",
"command",
"addition",
"from",
"the",
"list",
"of",
"outstanding",
"deferred",
"additions",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/class-wp-cli.php#L662-L668 | train |
wp-cli/wp-cli | php/class-wp-cli.php | WP_CLI.error_multi_line | public static function error_multi_line( $message_lines ) {
if ( ! isset( self::get_runner()->assoc_args['completions'] ) && is_array( $message_lines ) ) {
self::$logger->error_multi_line( array_map( array( __CLASS__, 'error_to_string' ), $message_lines ) );
}
} | php | public static function error_multi_line( $message_lines ) {
if ( ! isset( self::get_runner()->assoc_args['completions'] ) && is_array( $message_lines ) ) {
self::$logger->error_multi_line( array_map( array( __CLASS__, 'error_to_string' ), $message_lines ) );
}
} | [
"public",
"static",
"function",
"error_multi_line",
"(",
"$",
"message_lines",
")",
"{",
"if",
"(",
"!",
"isset",
"(",
"self",
"::",
"get_runner",
"(",
")",
"->",
"assoc_args",
"[",
"'completions'",
"]",
")",
"&&",
"is_array",
"(",
"$",
"message_lines",
")",
")",
"{",
"self",
"::",
"$",
"logger",
"->",
"error_multi_line",
"(",
"array_map",
"(",
"array",
"(",
"__CLASS__",
",",
"'error_to_string'",
")",
",",
"$",
"message_lines",
")",
")",
";",
"}",
"}"
] | 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. | [
"Display",
"a",
"multi",
"-",
"line",
"error",
"message",
"in",
"a",
"red",
"box",
".",
"Doesn",
"t",
"exit",
"script",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/class-wp-cli.php#L879-L883 | train |
wp-cli/wp-cli | php/class-wp-cli.php | WP_CLI.confirm | public static function confirm( $question, $assoc_args = array() ) {
if ( ! \WP_CLI\Utils\get_flag_value( $assoc_args, 'yes' ) ) {
fwrite( STDOUT, $question . ' [y/n] ' );
$answer = strtolower( trim( fgets( STDIN ) ) );
if ( 'y' !== $answer ) {
exit;
}
}
} | php | public static function confirm( $question, $assoc_args = array() ) {
if ( ! \WP_CLI\Utils\get_flag_value( $assoc_args, 'yes' ) ) {
fwrite( STDOUT, $question . ' [y/n] ' );
$answer = strtolower( trim( fgets( STDIN ) ) );
if ( 'y' !== $answer ) {
exit;
}
}
} | [
"public",
"static",
"function",
"confirm",
"(",
"$",
"question",
",",
"$",
"assoc_args",
"=",
"array",
"(",
")",
")",
"{",
"if",
"(",
"!",
"\\",
"WP_CLI",
"\\",
"Utils",
"\\",
"get_flag_value",
"(",
"$",
"assoc_args",
",",
"'yes'",
")",
")",
"{",
"fwrite",
"(",
"STDOUT",
",",
"$",
"question",
".",
"' [y/n] '",
")",
";",
"$",
"answer",
"=",
"strtolower",
"(",
"trim",
"(",
"fgets",
"(",
"STDIN",
")",
")",
")",
";",
"if",
"(",
"'y'",
"!==",
"$",
"answer",
")",
"{",
"exit",
";",
"}",
"}",
"}"
] | 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. | [
"Ask",
"for",
"confirmation",
"before",
"running",
"a",
"destructive",
"operation",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/class-wp-cli.php#L903-L913 | train |
wp-cli/wp-cli | php/class-wp-cli.php | WP_CLI.get_value_from_arg_or_stdin | public static function get_value_from_arg_or_stdin( $args, $index ) {
if ( isset( $args[ $index ] ) ) {
$raw_value = $args[ $index ];
} else {
// We don't use file_get_contents() here because it doesn't handle
// Ctrl-D properly, when typing in the value interactively.
$raw_value = '';
while ( false !== ( $line = fgets( STDIN ) ) ) {
$raw_value .= $line;
}
}
return $raw_value;
} | php | public static function get_value_from_arg_or_stdin( $args, $index ) {
if ( isset( $args[ $index ] ) ) {
$raw_value = $args[ $index ];
} else {
// We don't use file_get_contents() here because it doesn't handle
// Ctrl-D properly, when typing in the value interactively.
$raw_value = '';
while ( false !== ( $line = fgets( STDIN ) ) ) {
$raw_value .= $line;
}
}
return $raw_value;
} | [
"public",
"static",
"function",
"get_value_from_arg_or_stdin",
"(",
"$",
"args",
",",
"$",
"index",
")",
"{",
"if",
"(",
"isset",
"(",
"$",
"args",
"[",
"$",
"index",
"]",
")",
")",
"{",
"$",
"raw_value",
"=",
"$",
"args",
"[",
"$",
"index",
"]",
";",
"}",
"else",
"{",
"// We don't use file_get_contents() here because it doesn't handle",
"// Ctrl-D properly, when typing in the value interactively.",
"$",
"raw_value",
"=",
"''",
";",
"while",
"(",
"false",
"!==",
"(",
"$",
"line",
"=",
"fgets",
"(",
"STDIN",
")",
")",
")",
"{",
"$",
"raw_value",
".=",
"$",
"line",
";",
"}",
"}",
"return",
"$",
"raw_value",
";",
"}"
] | 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 | [
"Read",
"value",
"from",
"a",
"positional",
"argument",
"or",
"from",
"STDIN",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/class-wp-cli.php#L923-L936 | train |
wp-cli/wp-cli | php/class-wp-cli.php | WP_CLI.read_value | public static function read_value( $raw_value, $assoc_args = array() ) {
if ( \WP_CLI\Utils\get_flag_value( $assoc_args, 'format' ) === 'json' ) {
$value = json_decode( $raw_value, true );
if ( null === $value ) {
self::error( sprintf( 'Invalid JSON: %s', $raw_value ) );
}
} else {
$value = $raw_value;
}
return $value;
} | php | public static function read_value( $raw_value, $assoc_args = array() ) {
if ( \WP_CLI\Utils\get_flag_value( $assoc_args, 'format' ) === 'json' ) {
$value = json_decode( $raw_value, true );
if ( null === $value ) {
self::error( sprintf( 'Invalid JSON: %s', $raw_value ) );
}
} else {
$value = $raw_value;
}
return $value;
} | [
"public",
"static",
"function",
"read_value",
"(",
"$",
"raw_value",
",",
"$",
"assoc_args",
"=",
"array",
"(",
")",
")",
"{",
"if",
"(",
"\\",
"WP_CLI",
"\\",
"Utils",
"\\",
"get_flag_value",
"(",
"$",
"assoc_args",
",",
"'format'",
")",
"===",
"'json'",
")",
"{",
"$",
"value",
"=",
"json_decode",
"(",
"$",
"raw_value",
",",
"true",
")",
";",
"if",
"(",
"null",
"===",
"$",
"value",
")",
"{",
"self",
"::",
"error",
"(",
"sprintf",
"(",
"'Invalid JSON: %s'",
",",
"$",
"raw_value",
")",
")",
";",
"}",
"}",
"else",
"{",
"$",
"value",
"=",
"$",
"raw_value",
";",
"}",
"return",
"$",
"value",
";",
"}"
] | Read a value, from various formats.
@access public
@category Input
@param mixed $value
@param array $assoc_args | [
"Read",
"a",
"value",
"from",
"various",
"formats",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/class-wp-cli.php#L947-L958 | train |
wp-cli/wp-cli | php/class-wp-cli.php | WP_CLI.print_value | public static function print_value( $value, $assoc_args = array() ) {
if ( \WP_CLI\Utils\get_flag_value( $assoc_args, 'format' ) === 'json' ) {
$value = json_encode( $value );
} elseif ( \WP_CLI\Utils\get_flag_value( $assoc_args, 'format' ) === 'yaml' ) {
$value = Spyc::YAMLDump( $value, 2, 0 );
} elseif ( is_array( $value ) || is_object( $value ) ) {
$value = var_export( $value, true );
}
echo $value . "\n";
} | php | public static function print_value( $value, $assoc_args = array() ) {
if ( \WP_CLI\Utils\get_flag_value( $assoc_args, 'format' ) === 'json' ) {
$value = json_encode( $value );
} elseif ( \WP_CLI\Utils\get_flag_value( $assoc_args, 'format' ) === 'yaml' ) {
$value = Spyc::YAMLDump( $value, 2, 0 );
} elseif ( is_array( $value ) || is_object( $value ) ) {
$value = var_export( $value, true );
}
echo $value . "\n";
} | [
"public",
"static",
"function",
"print_value",
"(",
"$",
"value",
",",
"$",
"assoc_args",
"=",
"array",
"(",
")",
")",
"{",
"if",
"(",
"\\",
"WP_CLI",
"\\",
"Utils",
"\\",
"get_flag_value",
"(",
"$",
"assoc_args",
",",
"'format'",
")",
"===",
"'json'",
")",
"{",
"$",
"value",
"=",
"json_encode",
"(",
"$",
"value",
")",
";",
"}",
"elseif",
"(",
"\\",
"WP_CLI",
"\\",
"Utils",
"\\",
"get_flag_value",
"(",
"$",
"assoc_args",
",",
"'format'",
")",
"===",
"'yaml'",
")",
"{",
"$",
"value",
"=",
"Spyc",
"::",
"YAMLDump",
"(",
"$",
"value",
",",
"2",
",",
"0",
")",
";",
"}",
"elseif",
"(",
"is_array",
"(",
"$",
"value",
")",
"||",
"is_object",
"(",
"$",
"value",
")",
")",
"{",
"$",
"value",
"=",
"var_export",
"(",
"$",
"value",
",",
"true",
")",
";",
"}",
"echo",
"$",
"value",
".",
"\"\\n\"",
";",
"}"
] | Display a value, in various formats
@param mixed $value Value to display.
@param array $assoc_args Arguments passed to the command, determining format. | [
"Display",
"a",
"value",
"in",
"various",
"formats"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/class-wp-cli.php#L966-L976 | train |
wp-cli/wp-cli | php/class-wp-cli.php | WP_CLI.error_to_string | public static function error_to_string( $errors ) {
if ( is_string( $errors ) ) {
return $errors;
}
// Only json_encode() the data when it needs it
$render_data = function( $data ) {
if ( is_array( $data ) || is_object( $data ) ) {
return json_encode( $data );
}
return '"' . $data . '"';
};
if ( is_object( $errors ) && is_a( $errors, 'WP_Error' ) ) {
foreach ( $errors->get_error_messages() as $message ) {
if ( $errors->get_error_data() ) {
return $message . ' ' . $render_data( $errors->get_error_data() );
}
return $message;
}
}
} | php | public static function error_to_string( $errors ) {
if ( is_string( $errors ) ) {
return $errors;
}
// Only json_encode() the data when it needs it
$render_data = function( $data ) {
if ( is_array( $data ) || is_object( $data ) ) {
return json_encode( $data );
}
return '"' . $data . '"';
};
if ( is_object( $errors ) && is_a( $errors, 'WP_Error' ) ) {
foreach ( $errors->get_error_messages() as $message ) {
if ( $errors->get_error_data() ) {
return $message . ' ' . $render_data( $errors->get_error_data() );
}
return $message;
}
}
} | [
"public",
"static",
"function",
"error_to_string",
"(",
"$",
"errors",
")",
"{",
"if",
"(",
"is_string",
"(",
"$",
"errors",
")",
")",
"{",
"return",
"$",
"errors",
";",
"}",
"// Only json_encode() the data when it needs it",
"$",
"render_data",
"=",
"function",
"(",
"$",
"data",
")",
"{",
"if",
"(",
"is_array",
"(",
"$",
"data",
")",
"||",
"is_object",
"(",
"$",
"data",
")",
")",
"{",
"return",
"json_encode",
"(",
"$",
"data",
")",
";",
"}",
"return",
"'\"'",
".",
"$",
"data",
".",
"'\"'",
";",
"}",
";",
"if",
"(",
"is_object",
"(",
"$",
"errors",
")",
"&&",
"is_a",
"(",
"$",
"errors",
",",
"'WP_Error'",
")",
")",
"{",
"foreach",
"(",
"$",
"errors",
"->",
"get_error_messages",
"(",
")",
"as",
"$",
"message",
")",
"{",
"if",
"(",
"$",
"errors",
"->",
"get_error_data",
"(",
")",
")",
"{",
"return",
"$",
"message",
".",
"' '",
".",
"$",
"render_data",
"(",
"$",
"errors",
"->",
"get_error_data",
"(",
")",
")",
";",
"}",
"return",
"$",
"message",
";",
"}",
"}",
"}"
] | Convert a wp_error into a string
@param mixed $errors
@return string | [
"Convert",
"a",
"wp_error",
"into",
"a",
"string"
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/class-wp-cli.php#L984-L1007 | train |
wp-cli/wp-cli | php/class-wp-cli.php | WP_CLI.launch_self | public static function launch_self( $command, $args = array(), $assoc_args = array(), $exit_on_error = true, $return_detailed = false, $runtime_args = array() ) {
$reused_runtime_args = array(
'path',
'url',
'user',
'allow-root',
);
foreach ( $reused_runtime_args as $key ) {
if ( isset( $runtime_args[ $key ] ) ) {
$assoc_args[ $key ] = $runtime_args[ $key ];
continue;
}
$value = self::get_runner()->config[ $key ];
if ( $value ) {
$assoc_args[ $key ] = $value;
}
}
$php_bin = escapeshellarg( Utils\get_php_binary() );
$script_path = $GLOBALS['argv'][0];
if ( getenv( 'WP_CLI_CONFIG_PATH' ) ) {
$config_path = getenv( 'WP_CLI_CONFIG_PATH' );
} else {
$config_path = Utils\get_home_dir() . '/.wp-cli/config.yml';
}
$config_path = escapeshellarg( $config_path );
$args = implode( ' ', array_map( 'escapeshellarg', $args ) );
$assoc_args = \WP_CLI\Utils\assoc_args_to_str( $assoc_args );
$full_command = "WP_CLI_CONFIG_PATH={$config_path} {$php_bin} {$script_path} {$command} {$args} {$assoc_args}";
return self::launch( $full_command, $exit_on_error, $return_detailed );
} | php | public static function launch_self( $command, $args = array(), $assoc_args = array(), $exit_on_error = true, $return_detailed = false, $runtime_args = array() ) {
$reused_runtime_args = array(
'path',
'url',
'user',
'allow-root',
);
foreach ( $reused_runtime_args as $key ) {
if ( isset( $runtime_args[ $key ] ) ) {
$assoc_args[ $key ] = $runtime_args[ $key ];
continue;
}
$value = self::get_runner()->config[ $key ];
if ( $value ) {
$assoc_args[ $key ] = $value;
}
}
$php_bin = escapeshellarg( Utils\get_php_binary() );
$script_path = $GLOBALS['argv'][0];
if ( getenv( 'WP_CLI_CONFIG_PATH' ) ) {
$config_path = getenv( 'WP_CLI_CONFIG_PATH' );
} else {
$config_path = Utils\get_home_dir() . '/.wp-cli/config.yml';
}
$config_path = escapeshellarg( $config_path );
$args = implode( ' ', array_map( 'escapeshellarg', $args ) );
$assoc_args = \WP_CLI\Utils\assoc_args_to_str( $assoc_args );
$full_command = "WP_CLI_CONFIG_PATH={$config_path} {$php_bin} {$script_path} {$command} {$args} {$assoc_args}";
return self::launch( $full_command, $exit_on_error, $return_detailed );
} | [
"public",
"static",
"function",
"launch_self",
"(",
"$",
"command",
",",
"$",
"args",
"=",
"array",
"(",
")",
",",
"$",
"assoc_args",
"=",
"array",
"(",
")",
",",
"$",
"exit_on_error",
"=",
"true",
",",
"$",
"return_detailed",
"=",
"false",
",",
"$",
"runtime_args",
"=",
"array",
"(",
")",
")",
"{",
"$",
"reused_runtime_args",
"=",
"array",
"(",
"'path'",
",",
"'url'",
",",
"'user'",
",",
"'allow-root'",
",",
")",
";",
"foreach",
"(",
"$",
"reused_runtime_args",
"as",
"$",
"key",
")",
"{",
"if",
"(",
"isset",
"(",
"$",
"runtime_args",
"[",
"$",
"key",
"]",
")",
")",
"{",
"$",
"assoc_args",
"[",
"$",
"key",
"]",
"=",
"$",
"runtime_args",
"[",
"$",
"key",
"]",
";",
"continue",
";",
"}",
"$",
"value",
"=",
"self",
"::",
"get_runner",
"(",
")",
"->",
"config",
"[",
"$",
"key",
"]",
";",
"if",
"(",
"$",
"value",
")",
"{",
"$",
"assoc_args",
"[",
"$",
"key",
"]",
"=",
"$",
"value",
";",
"}",
"}",
"$",
"php_bin",
"=",
"escapeshellarg",
"(",
"Utils",
"\\",
"get_php_binary",
"(",
")",
")",
";",
"$",
"script_path",
"=",
"$",
"GLOBALS",
"[",
"'argv'",
"]",
"[",
"0",
"]",
";",
"if",
"(",
"getenv",
"(",
"'WP_CLI_CONFIG_PATH'",
")",
")",
"{",
"$",
"config_path",
"=",
"getenv",
"(",
"'WP_CLI_CONFIG_PATH'",
")",
";",
"}",
"else",
"{",
"$",
"config_path",
"=",
"Utils",
"\\",
"get_home_dir",
"(",
")",
".",
"'/.wp-cli/config.yml'",
";",
"}",
"$",
"config_path",
"=",
"escapeshellarg",
"(",
"$",
"config_path",
")",
";",
"$",
"args",
"=",
"implode",
"(",
"' '",
",",
"array_map",
"(",
"'escapeshellarg'",
",",
"$",
"args",
")",
")",
";",
"$",
"assoc_args",
"=",
"\\",
"WP_CLI",
"\\",
"Utils",
"\\",
"assoc_args_to_str",
"(",
"$",
"assoc_args",
")",
";",
"$",
"full_command",
"=",
"\"WP_CLI_CONFIG_PATH={$config_path} {$php_bin} {$script_path} {$command} {$args} {$assoc_args}\"",
";",
"return",
"self",
"::",
"launch",
"(",
"$",
"full_command",
",",
"$",
"exit_on_error",
",",
"$",
"return_detailed",
")",
";",
"}"
] | 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|ProcessRun The command exit status, or a ProcessRun instance | [
"Run",
"a",
"WP",
"-",
"CLI",
"command",
"in",
"a",
"new",
"process",
"reusing",
"the",
"current",
"runtime",
"arguments",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/class-wp-cli.php#L1071-L1108 | train |
wp-cli/wp-cli | php/class-wp-cli.php | WP_CLI.get_config | public static function get_config( $key = null ) {
if ( null === $key ) {
return self::get_runner()->config;
}
if ( ! isset( self::get_runner()->config[ $key ] ) ) {
self::warning( "Unknown config option '$key'." );
return null;
}
return self::get_runner()->config[ $key ];
} | php | public static function get_config( $key = null ) {
if ( null === $key ) {
return self::get_runner()->config;
}
if ( ! isset( self::get_runner()->config[ $key ] ) ) {
self::warning( "Unknown config option '$key'." );
return null;
}
return self::get_runner()->config[ $key ];
} | [
"public",
"static",
"function",
"get_config",
"(",
"$",
"key",
"=",
"null",
")",
"{",
"if",
"(",
"null",
"===",
"$",
"key",
")",
"{",
"return",
"self",
"::",
"get_runner",
"(",
")",
"->",
"config",
";",
"}",
"if",
"(",
"!",
"isset",
"(",
"self",
"::",
"get_runner",
"(",
")",
"->",
"config",
"[",
"$",
"key",
"]",
")",
")",
"{",
"self",
"::",
"warning",
"(",
"\"Unknown config option '$key'.\"",
")",
";",
"return",
"null",
";",
"}",
"return",
"self",
"::",
"get_runner",
"(",
")",
"->",
"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 | [
"Get",
"values",
"of",
"global",
"configuration",
"parameters",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/class-wp-cli.php#L1156-L1167 | train |
wp-cli/wp-cli | php/WP_CLI/SynopsisParser.php | SynopsisParser.render | public static function render( &$synopsis ) {
if ( ! is_array( $synopsis ) ) {
return '';
}
$bits = [
'positional' => '',
'assoc' => '',
'generic' => '',
'flag' => '',
];
$reordered_synopsis = [
'positional' => [],
'assoc' => [],
'generic' => [],
'flag' => [],
];
foreach ( $bits as $key => &$value ) {
foreach ( $synopsis as $arg ) {
if ( empty( $arg['type'] )
|| $key !== $arg['type'] ) {
continue;
}
if ( empty( $arg['name'] ) && 'generic' !== $arg['type'] ) {
continue;
}
if ( 'positional' === $key ) {
$rendered_arg = "<{$arg['name']}>";
$reordered_synopsis['positional'] [] = $arg;
} elseif ( 'assoc' === $key ) {
$arg_value = isset( $arg['value']['name'] ) ? $arg['value']['name'] : $arg['name'];
$rendered_arg = "--{$arg['name']}=<{$arg_value}>";
$reordered_synopsis['assoc'] [] = $arg;
} elseif ( 'generic' === $key ) {
$rendered_arg = '--<field>=<value>';
$reordered_synopsis['generic'] [] = $arg;
} elseif ( 'flag' === $key ) {
$rendered_arg = "--{$arg['name']}";
$reordered_synopsis['flag'] [] = $arg;
}
if ( ! empty( $arg['repeating'] ) ) {
$rendered_arg = "{$rendered_arg}...";
}
if ( ! empty( $arg['optional'] ) ) {
$rendered_arg = "[{$rendered_arg}]";
}
$value .= "{$rendered_arg} ";
}
}
$rendered = '';
foreach ( $bits as $v ) {
if ( ! empty( $v ) ) {
$rendered .= $v;
}
}
$synopsis = array_merge(
$reordered_synopsis['positional'],
$reordered_synopsis['assoc'],
$reordered_synopsis['generic'],
$reordered_synopsis['flag']
);
return rtrim( $rendered, ' ' );
} | php | public static function render( &$synopsis ) {
if ( ! is_array( $synopsis ) ) {
return '';
}
$bits = [
'positional' => '',
'assoc' => '',
'generic' => '',
'flag' => '',
];
$reordered_synopsis = [
'positional' => [],
'assoc' => [],
'generic' => [],
'flag' => [],
];
foreach ( $bits as $key => &$value ) {
foreach ( $synopsis as $arg ) {
if ( empty( $arg['type'] )
|| $key !== $arg['type'] ) {
continue;
}
if ( empty( $arg['name'] ) && 'generic' !== $arg['type'] ) {
continue;
}
if ( 'positional' === $key ) {
$rendered_arg = "<{$arg['name']}>";
$reordered_synopsis['positional'] [] = $arg;
} elseif ( 'assoc' === $key ) {
$arg_value = isset( $arg['value']['name'] ) ? $arg['value']['name'] : $arg['name'];
$rendered_arg = "--{$arg['name']}=<{$arg_value}>";
$reordered_synopsis['assoc'] [] = $arg;
} elseif ( 'generic' === $key ) {
$rendered_arg = '--<field>=<value>';
$reordered_synopsis['generic'] [] = $arg;
} elseif ( 'flag' === $key ) {
$rendered_arg = "--{$arg['name']}";
$reordered_synopsis['flag'] [] = $arg;
}
if ( ! empty( $arg['repeating'] ) ) {
$rendered_arg = "{$rendered_arg}...";
}
if ( ! empty( $arg['optional'] ) ) {
$rendered_arg = "[{$rendered_arg}]";
}
$value .= "{$rendered_arg} ";
}
}
$rendered = '';
foreach ( $bits as $v ) {
if ( ! empty( $v ) ) {
$rendered .= $v;
}
}
$synopsis = array_merge(
$reordered_synopsis['positional'],
$reordered_synopsis['assoc'],
$reordered_synopsis['generic'],
$reordered_synopsis['flag']
);
return rtrim( $rendered, ' ' );
} | [
"public",
"static",
"function",
"render",
"(",
"&",
"$",
"synopsis",
")",
"{",
"if",
"(",
"!",
"is_array",
"(",
"$",
"synopsis",
")",
")",
"{",
"return",
"''",
";",
"}",
"$",
"bits",
"=",
"[",
"'positional'",
"=>",
"''",
",",
"'assoc'",
"=>",
"''",
",",
"'generic'",
"=>",
"''",
",",
"'flag'",
"=>",
"''",
",",
"]",
";",
"$",
"reordered_synopsis",
"=",
"[",
"'positional'",
"=>",
"[",
"]",
",",
"'assoc'",
"=>",
"[",
"]",
",",
"'generic'",
"=>",
"[",
"]",
",",
"'flag'",
"=>",
"[",
"]",
",",
"]",
";",
"foreach",
"(",
"$",
"bits",
"as",
"$",
"key",
"=>",
"&",
"$",
"value",
")",
"{",
"foreach",
"(",
"$",
"synopsis",
"as",
"$",
"arg",
")",
"{",
"if",
"(",
"empty",
"(",
"$",
"arg",
"[",
"'type'",
"]",
")",
"||",
"$",
"key",
"!==",
"$",
"arg",
"[",
"'type'",
"]",
")",
"{",
"continue",
";",
"}",
"if",
"(",
"empty",
"(",
"$",
"arg",
"[",
"'name'",
"]",
")",
"&&",
"'generic'",
"!==",
"$",
"arg",
"[",
"'type'",
"]",
")",
"{",
"continue",
";",
"}",
"if",
"(",
"'positional'",
"===",
"$",
"key",
")",
"{",
"$",
"rendered_arg",
"=",
"\"<{$arg['name']}>\"",
";",
"$",
"reordered_synopsis",
"[",
"'positional'",
"]",
"[",
"]",
"=",
"$",
"arg",
";",
"}",
"elseif",
"(",
"'assoc'",
"===",
"$",
"key",
")",
"{",
"$",
"arg_value",
"=",
"isset",
"(",
"$",
"arg",
"[",
"'value'",
"]",
"[",
"'name'",
"]",
")",
"?",
"$",
"arg",
"[",
"'value'",
"]",
"[",
"'name'",
"]",
":",
"$",
"arg",
"[",
"'name'",
"]",
";",
"$",
"rendered_arg",
"=",
"\"--{$arg['name']}=<{$arg_value}>\"",
";",
"$",
"reordered_synopsis",
"[",
"'assoc'",
"]",
"[",
"]",
"=",
"$",
"arg",
";",
"}",
"elseif",
"(",
"'generic'",
"===",
"$",
"key",
")",
"{",
"$",
"rendered_arg",
"=",
"'--<field>=<value>'",
";",
"$",
"reordered_synopsis",
"[",
"'generic'",
"]",
"[",
"]",
"=",
"$",
"arg",
";",
"}",
"elseif",
"(",
"'flag'",
"===",
"$",
"key",
")",
"{",
"$",
"rendered_arg",
"=",
"\"--{$arg['name']}\"",
";",
"$",
"reordered_synopsis",
"[",
"'flag'",
"]",
"[",
"]",
"=",
"$",
"arg",
";",
"}",
"if",
"(",
"!",
"empty",
"(",
"$",
"arg",
"[",
"'repeating'",
"]",
")",
")",
"{",
"$",
"rendered_arg",
"=",
"\"{$rendered_arg}...\"",
";",
"}",
"if",
"(",
"!",
"empty",
"(",
"$",
"arg",
"[",
"'optional'",
"]",
")",
")",
"{",
"$",
"rendered_arg",
"=",
"\"[{$rendered_arg}]\"",
";",
"}",
"$",
"value",
".=",
"\"{$rendered_arg} \"",
";",
"}",
"}",
"$",
"rendered",
"=",
"''",
";",
"foreach",
"(",
"$",
"bits",
"as",
"$",
"v",
")",
"{",
"if",
"(",
"!",
"empty",
"(",
"$",
"v",
")",
")",
"{",
"$",
"rendered",
".=",
"$",
"v",
";",
"}",
"}",
"$",
"synopsis",
"=",
"array_merge",
"(",
"$",
"reordered_synopsis",
"[",
"'positional'",
"]",
",",
"$",
"reordered_synopsis",
"[",
"'assoc'",
"]",
",",
"$",
"reordered_synopsis",
"[",
"'generic'",
"]",
",",
"$",
"reordered_synopsis",
"[",
"'flag'",
"]",
")",
";",
"return",
"rtrim",
"(",
"$",
"rendered",
",",
"' '",
")",
";",
"}"
] | 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. | [
"Render",
"the",
"Synopsis",
"into",
"a",
"format",
"string",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/SynopsisParser.php#L44-L113 | train |
wp-cli/wp-cli | php/WP_CLI/SynopsisParser.php | SynopsisParser.classify_token | private static function classify_token( $token ) {
$param = array();
list( $param['optional'], $token ) = self::is_optional( $token );
list( $param['repeating'], $token ) = self::is_repeating( $token );
$p_name = '([a-z-_0-9]+)';
$p_value = '([a-zA-Z-_|,0-9]+)';
if ( '--<field>=<value>' === $token ) {
$param['type'] = 'generic';
} elseif ( preg_match( "/^<($p_value)>$/", $token, $matches ) ) {
$param['type'] = 'positional';
$param['name'] = $matches[1];
} elseif ( preg_match( "/^--(?:\\[no-\\])?$p_name/", $token, $matches ) ) {
$param['name'] = $matches[1];
$value = substr( $token, strlen( $matches[0] ) );
// substr returns false <= PHP 5.6, and '' PHP 7+
if ( false === $value || '' === $value ) {
$param['type'] = 'flag';
} else {
$param['type'] = 'assoc';
list( $param['value']['optional'], $value ) = self::is_optional( $value );
if ( preg_match( "/^=<$p_value>$/", $value, $matches ) ) {
$param['value']['name'] = $matches[1];
} else {
$param = array(
'type' => 'unknown',
);
}
}
} else {
$param['type'] = 'unknown';
}
return $param;
} | php | private static function classify_token( $token ) {
$param = array();
list( $param['optional'], $token ) = self::is_optional( $token );
list( $param['repeating'], $token ) = self::is_repeating( $token );
$p_name = '([a-z-_0-9]+)';
$p_value = '([a-zA-Z-_|,0-9]+)';
if ( '--<field>=<value>' === $token ) {
$param['type'] = 'generic';
} elseif ( preg_match( "/^<($p_value)>$/", $token, $matches ) ) {
$param['type'] = 'positional';
$param['name'] = $matches[1];
} elseif ( preg_match( "/^--(?:\\[no-\\])?$p_name/", $token, $matches ) ) {
$param['name'] = $matches[1];
$value = substr( $token, strlen( $matches[0] ) );
// substr returns false <= PHP 5.6, and '' PHP 7+
if ( false === $value || '' === $value ) {
$param['type'] = 'flag';
} else {
$param['type'] = 'assoc';
list( $param['value']['optional'], $value ) = self::is_optional( $value );
if ( preg_match( "/^=<$p_value>$/", $value, $matches ) ) {
$param['value']['name'] = $matches[1];
} else {
$param = array(
'type' => 'unknown',
);
}
}
} else {
$param['type'] = 'unknown';
}
return $param;
} | [
"private",
"static",
"function",
"classify_token",
"(",
"$",
"token",
")",
"{",
"$",
"param",
"=",
"array",
"(",
")",
";",
"list",
"(",
"$",
"param",
"[",
"'optional'",
"]",
",",
"$",
"token",
")",
"=",
"self",
"::",
"is_optional",
"(",
"$",
"token",
")",
";",
"list",
"(",
"$",
"param",
"[",
"'repeating'",
"]",
",",
"$",
"token",
")",
"=",
"self",
"::",
"is_repeating",
"(",
"$",
"token",
")",
";",
"$",
"p_name",
"=",
"'([a-z-_0-9]+)'",
";",
"$",
"p_value",
"=",
"'([a-zA-Z-_|,0-9]+)'",
";",
"if",
"(",
"'--<field>=<value>'",
"===",
"$",
"token",
")",
"{",
"$",
"param",
"[",
"'type'",
"]",
"=",
"'generic'",
";",
"}",
"elseif",
"(",
"preg_match",
"(",
"\"/^<($p_value)>$/\"",
",",
"$",
"token",
",",
"$",
"matches",
")",
")",
"{",
"$",
"param",
"[",
"'type'",
"]",
"=",
"'positional'",
";",
"$",
"param",
"[",
"'name'",
"]",
"=",
"$",
"matches",
"[",
"1",
"]",
";",
"}",
"elseif",
"(",
"preg_match",
"(",
"\"/^--(?:\\\\[no-\\\\])?$p_name/\"",
",",
"$",
"token",
",",
"$",
"matches",
")",
")",
"{",
"$",
"param",
"[",
"'name'",
"]",
"=",
"$",
"matches",
"[",
"1",
"]",
";",
"$",
"value",
"=",
"substr",
"(",
"$",
"token",
",",
"strlen",
"(",
"$",
"matches",
"[",
"0",
"]",
")",
")",
";",
"// substr returns false <= PHP 5.6, and '' PHP 7+",
"if",
"(",
"false",
"===",
"$",
"value",
"||",
"''",
"===",
"$",
"value",
")",
"{",
"$",
"param",
"[",
"'type'",
"]",
"=",
"'flag'",
";",
"}",
"else",
"{",
"$",
"param",
"[",
"'type'",
"]",
"=",
"'assoc'",
";",
"list",
"(",
"$",
"param",
"[",
"'value'",
"]",
"[",
"'optional'",
"]",
",",
"$",
"value",
")",
"=",
"self",
"::",
"is_optional",
"(",
"$",
"value",
")",
";",
"if",
"(",
"preg_match",
"(",
"\"/^=<$p_value>$/\"",
",",
"$",
"value",
",",
"$",
"matches",
")",
")",
"{",
"$",
"param",
"[",
"'value'",
"]",
"[",
"'name'",
"]",
"=",
"$",
"matches",
"[",
"1",
"]",
";",
"}",
"else",
"{",
"$",
"param",
"=",
"array",
"(",
"'type'",
"=>",
"'unknown'",
",",
")",
";",
"}",
"}",
"}",
"else",
"{",
"$",
"param",
"[",
"'type'",
"]",
"=",
"'unknown'",
";",
"}",
"return",
"$",
"param",
";",
"}"
] | Classify argument attributes based on its syntax.
@param string $token
@return array $param | [
"Classify",
"argument",
"attributes",
"based",
"on",
"its",
"syntax",
"."
] | 564bf7b7cf1ac833071d1afed5d649d2a7198e15 | https://github.com/wp-cli/wp-cli/blob/564bf7b7cf1ac833071d1afed5d649d2a7198e15/php/WP_CLI/SynopsisParser.php#L121-L161 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.