|', $original_message, $matches ) ) {
$message .= ' ' . $matches[1];
}
$search_replace = [
'' => '`',
'' => '`',
];
$message = str_replace( array_keys( $search_replace ), array_values( $search_replace ), $message );
$message = namespace\strip_tags( $message );
$message = html_entity_decode( $message, ENT_COMPAT, 'UTF-8' );
return $message;
}
/**
* @param string $url
* @return string
*/
function wp_redirect_handler( $url ) {
WP_CLI::warning( 'Some code is trying to do a URL redirect. Backtrace:' );
ob_start();
debug_print_backtrace();
fwrite( STDERR, ob_get_clean() );
return $url;
}
/**
* @param string $since Version number.
* @param string $path File to include.
* @return void
*/
function maybe_require( $since, $path ) {
if ( wp_version_compare( $since, '>=' ) ) {
require $path;
}
}
/**
*
* @param class-string $class_name
* @param bool $insecure
*
* @return \WP_Upgrader Upgrader instance.
* @throws \ReflectionException
*/
function get_upgrader( $class_name, $insecure = false ) {
if ( ! class_exists( '\WP_Upgrader' ) ) {
if ( file_exists( ABSPATH . 'wp-admin/includes/class-wp-upgrader.php' ) ) {
include ABSPATH . 'wp-admin/includes/class-wp-upgrader.php';
}
}
if ( ! class_exists( '\WP_Upgrader_Skin' ) ) {
if ( file_exists( ABSPATH . 'wp-admin/includes/class-wp-upgrader-skin.php' ) ) {
include ABSPATH . 'wp-admin/includes/class-wp-upgrader-skin.php';
}
}
$uses_insecure_flag = false;
$reflection = new ReflectionClass( $class_name );
$constructor = $reflection->getConstructor();
if ( $constructor ) {
$arguments = $constructor->getParameters();
/** @var ReflectionParameter $argument */
foreach ( $arguments as $argument ) {
if ( 'insecure' === $argument->name ) {
$uses_insecure_flag = true;
break;
}
}
}
if ( $uses_insecure_flag ) {
return new $class_name( new UpgraderSkin(), $insecure );
} else {
return new $class_name( new UpgraderSkin() );
}
}
/**
* Converts a plugin basename back into a friendly slug.
*
* @param string $basename
* @return string
*/
function get_plugin_name( $basename ) {
if ( false === strpos( $basename, '/' ) ) {
$name = basename( $basename, '.php' );
} else {
$name = dirname( $basename );
}
return $name;
}
/**
* Determine whether a plugin is skipped.
*
* @param string $file
* @return bool
*/
function is_plugin_skipped( $file ) {
$name = get_plugin_name( str_replace( WP_PLUGIN_DIR . '/', '', $file ) );
$skipped_plugins = WP_CLI::get_runner()->config['skip-plugins'];
if ( true === $skipped_plugins ) {
return true;
}
if ( ! is_array( $skipped_plugins ) ) {
$skipped_plugins = explode( ',', $skipped_plugins );
}
return in_array( $name, array_filter( $skipped_plugins ), true );
}
/**
* Get theme name from path.
*
* @param string $path
* @return string
*/
function get_theme_name( $path ) {
return basename( $path );
}
/**
* Determine whether a theme is skipped.
*
* @param string $path
* @return bool
*/
function is_theme_skipped( $path ) {
$name = get_theme_name( $path );
$skipped_themes = WP_CLI::get_runner()->config['skip-themes'];
if ( true === $skipped_themes ) {
return true;
}
if ( ! is_array( $skipped_themes ) ) {
$skipped_themes = explode( ',', $skipped_themes );
}
return in_array( $name, array_filter( $skipped_themes ), true );
}
/**
* Register the sidebar for unused widgets.
* Core does this in /wp-admin/widgets.php, which isn't helpful.
*
* @return void
*/
function wp_register_unused_sidebar() {
register_sidebar(
[
'name' => __( 'Inactive Widgets' ),
'id' => 'wp_inactive_widgets',
'class' => 'inactive-sidebar',
'description' => __( 'Drag widgets here to remove them from the sidebar but keep their settings.' ),
'before_widget' => '',
'after_widget' => '',
'before_title' => '',
'after_title' => '',
]
);
}
/**
* Attempts to determine which object cache is being used.
*
* Note that the guesses made by this function are based on the WP_Object_Cache classes
* that define the 3rd party object cache extension. Changes to those classes could render
* problems with this function's ability to determine which object cache is being used.
*
* @return string
*/
function wp_get_cache_type() {
global $_wp_using_ext_object_cache, $wp_object_cache;
$message = 'Unknown';
if ( ! empty( $_wp_using_ext_object_cache ) ) {
// Test for Memcached PECL extension memcached object cache (https://github.com/tollmanz/wordpress-memcached-backend)
if ( isset( $wp_object_cache->m ) && $wp_object_cache->m instanceof \Memcached ) {
$message = 'Memcached';
// Test for Memcache PECL extension memcached object cache (https://wordpress.org/extend/plugins/memcached/)
} elseif ( isset( $wp_object_cache->mc ) ) {
$is_memcache = true;
foreach ( $wp_object_cache->mc as $bucket ) {
if ( ! $bucket instanceof \Memcache && ! $bucket instanceof \Memcached ) {
$is_memcache = false;
}
}
if ( $is_memcache ) {
$message = 'Memcache';
}
// Test for Xcache object cache (https://plugins.svn.wordpress.org/xcache/trunk/object-cache.php)
} elseif ( $wp_object_cache instanceof \XCache_Object_Cache ) {
$message = 'Xcache';
// Test for WinCache object cache (https://wordpress.org/extend/plugins/wincache-object-cache-backend/)
} elseif ( class_exists( 'WinCache_Object_Cache' ) ) {
$message = 'WinCache';
// Test for APC object cache (https://wordpress.org/extend/plugins/apc/)
} elseif ( class_exists( 'APC_Object_Cache' ) ) {
$message = 'APC';
// Test for WP Redis (https://wordpress.org/plugins/wp-redis/)
} elseif ( isset( $wp_object_cache->redis ) && $wp_object_cache->redis instanceof \Redis ) {
$message = 'Redis';
// Test for Redis Object Cache (https://wordpress.org/plugins/redis-cache/)
} elseif ( method_exists( $wp_object_cache, 'redis_instance' ) && method_exists( $wp_object_cache, 'redis_status' ) ) {
$message = 'Redis';
// Test for Object Cache Pro (https://objectcache.pro/)
} elseif ( method_exists( $wp_object_cache, 'config' ) && method_exists( $wp_object_cache, 'connection' ) ) {
$message = 'Redis';
// Test for WP LCache Object cache (https://github.com/lcache/wp-lcache)
} elseif ( isset( $wp_object_cache->lcache ) && $wp_object_cache->lcache instanceof \LCache\Integrated ) {
$message = 'WP LCache';
} elseif ( function_exists( 'w3_instance' ) ) {
$config = w3_instance( 'W3_Config' );
if ( $config->get_boolean( 'objectcache.enabled' ) ) {
$message = 'W3TC ' . $config->get_string( 'objectcache.engine' );
}
}
} else {
$message = 'Default';
}
return $message;
}
/**
* Clear WordPress internal object caches.
*
* In long-running scripts, the internal caches on `$wp_object_cache` and `$wpdb`
* can grow to consume gigabytes of memory. Periodically calling this utility
* can help with memory management.
*
* @access public
* @category System
* @deprecated 1.5.0
*
* @return void
*/
function wp_clear_object_cache() {
global $wpdb, $wp_object_cache;
$wpdb->queries = [];
if ( function_exists( 'wp_cache_flush_runtime' ) && function_exists( 'wp_cache_supports' ) ) {
if ( wp_cache_supports( 'flush_runtime' ) ) {
wp_cache_flush_runtime();
return;
}
}
if ( ! is_object( $wp_object_cache ) ) {
return;
}
// The following are Memcached (Redux) plugin specific (see https://core.trac.wordpress.org/ticket/31463).
if ( isset( $wp_object_cache->group_ops ) ) {
$wp_object_cache->group_ops = [];
}
if ( isset( $wp_object_cache->stats ) ) {
$wp_object_cache->stats = [];
}
if ( isset( $wp_object_cache->memcache_debug ) ) {
$wp_object_cache->memcache_debug = [];
}
// Used by `WP_Object_Cache` also.
if ( isset( $wp_object_cache->cache ) ) {
$wp_object_cache->cache = [];
}
}
/**
* Get a set of tables in the database.
*
* Interprets common command-line options into a resolved set of table names.
*
* @param array $args Provided table names, or tables with wildcards.
* @param array $assoc_args Optional flags for groups of tables (e.g. --network)
* @return array
*/
function wp_get_table_names( $args, $assoc_args = [] ) {
global $wpdb;
// Abort if incompatible args supplied.
if ( get_flag_value( $assoc_args, 'base-tables-only' ) && get_flag_value( $assoc_args, 'views-only' ) ) {
WP_CLI::error( 'You cannot supply --base-tables-only and --views-only at the same time.' );
}
// Pre-load tables SQL query with Views restriction if needed.
if ( get_flag_value( $assoc_args, 'base-tables-only' ) ) {
$tables_sql = 'SHOW FULL TABLES WHERE Table_Type = "BASE TABLE"';
} elseif ( get_flag_value( $assoc_args, 'views-only' ) ) {
$tables_sql = 'SHOW FULL TABLES WHERE Table_Type = "VIEW"';
}
if ( get_flag_value( $assoc_args, 'all-tables' ) ) {
if ( empty( $tables_sql ) ) {
$tables_sql = 'SHOW TABLES';
}
// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- Query is safe, see above.
$tables = $wpdb->get_col( $tables_sql, 0 );
} elseif ( get_flag_value( $assoc_args, 'all-tables-with-prefix' ) ) {
if ( empty( $tables_sql ) ) {
$tables_sql = $wpdb->prepare( 'SHOW TABLES LIKE %s', esc_like( $wpdb->get_blog_prefix() ) . '%' );
} else {
$tables_sql .= sprintf( " AND %s LIKE '%s'", esc_sql_ident( 'Tables_in_' . $wpdb->dbname ), esc_like( $wpdb->get_blog_prefix() ) . '%' );
}
// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- Query is prepared, see above.
$tables = $wpdb->get_col( $tables_sql, 0 );
} else {
$scope = get_flag_value( $assoc_args, 'scope', 'all' );
// Note: BC change 1.5.0, taking scope into consideration for network also.
if ( get_flag_value( $assoc_args, 'network' ) && is_multisite() ) {
$network_global_scope = in_array( $scope, [ 'all', 'global', 'ms_global' ], true ) ? ( 'all' === $scope ? 'global' : $scope ) : '';
$wp_tables = array_values( $wpdb->tables( $network_global_scope ) );
if ( in_array( $scope, [ 'all', 'blog' ], true ) ) {
// Do directly for compat with old WP versions. Note: private, deleted, archived sites are not excluded.
$blog_ids = $wpdb->get_col( "SELECT blog_id FROM $wpdb->blogs WHERE site_id = $wpdb->siteid" );
foreach ( $blog_ids as $blog_id ) {
$wp_tables = array_merge( $wp_tables, array_values( $wpdb->tables( 'blog', true /*prefix*/, $blog_id ) ) );
}
}
} else {
$wp_tables = array_values( $wpdb->tables( $scope ) );
}
// The global_terms_enabled() function has been deprecated with WP 6.1+.
if ( wp_version_compare( '6.1', '>=' ) || ! global_terms_enabled() ) { // phpcs:ignore WordPress.WP.DeprecatedFunctions.global_terms_enabledFound
// Only include sitecategories when it's actually enabled.
$wp_tables = array_values( array_diff( $wp_tables, [ $wpdb->sitecategories ] ) );
}
// Note: BC change 1.5.0, tables are sorted (via TABLES view).
// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- uses esc_sql_ident() and $wpdb->_escape().
$tables = $wpdb->get_col( sprintf( "SHOW TABLES WHERE %s IN ('%s')", esc_sql_ident( 'Tables_in_' . $wpdb->dbname ), implode( "', '", $wpdb->_escape( $wp_tables ) ) ) );
if ( get_flag_value( $assoc_args, 'base-tables-only' ) || get_flag_value( $assoc_args, 'views-only' ) ) {
// Apply Views restriction args if needed.
// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- Query is prepared, see above.
$views_query_tables = $wpdb->get_col( $tables_sql, 0 );
$tables = array_intersect( $tables, $views_query_tables );
}
}
// Filter by `$args`.
if ( $args ) {
$args_tables = [];
foreach ( $args as $arg ) {
if ( false !== strpos( $arg, '*' ) || false !== strpos( $arg, '?' ) ) {
$args_tables = array_merge(
$args_tables,
array_filter(
$tables,
function ( $v ) use ( $arg ) {
return fnmatch( $arg, $v );
}
)
);
} else {
$args_tables[] = $arg;
}
}
$args_tables = array_values( array_unique( $args_tables ) );
$tables = array_values( array_intersect( $tables, $args_tables ) );
if ( empty( $tables ) ) {
WP_CLI::error( sprintf( "Couldn't find any tables matching: %s", implode( ' ', $args ) ) );
}
}
return $tables;
}
/**
* Failsafe use of the WordPress wp_strip_all_tags() function.
*
* Automatically falls back to strip_tags() function if the WP function is not
* available.
*
* @param string $string String to strip the tags from.
* @return string String devoid of tags.
*/
function strip_tags( $string ) {
if ( function_exists( 'wp_strip_all_tags' ) ) {
return \wp_strip_all_tags( $string );
}
$string = preg_replace(
'@<(script|style)[^>]*?>.*?@si',
'',
$string
);
// phpcs:ignore WordPress.WP.AlternativeFunctions.strip_tags_strip_tags -- Fallback.
$string = \strip_tags( $string );
return trim( $string );
}
#.*?$)|(?>//.*?$)|(?>/\*.*?\*/)|(?>\'(?:(?=(\\\\?))\1.)*?\')|(?>"(?:(?=(\\\\?))\2.)*?")|(?\b__FILE__\b)|(?\b__DIR__\b)%ms';
/**
* Check if a certain path is within a Phar archive.
*
* If no path is provided, the function checks whether the current WP_CLI instance is
* running from within a Phar archive.
*
* @param string|null $path Optional. Path to check. Defaults to null, which checks WP_CLI_ROOT.
* @return bool Whether path is within a Phar archive.
*/
function inside_phar( $path = null ) {
if ( null === $path ) {
if ( ! defined( 'WP_CLI_ROOT' ) ) {
return false;
}
$path = WP_CLI_ROOT;
}
return 0 === strpos( $path, PHAR_STREAM_PREFIX );
}
/**
* Extract a file from a Phar archive.
*
* Files that need to be read by external programs have to be extracted from the Phar archive.
* If the file is not within a Phar archive, the function returns the path unchanged.
*
* @param string $path Path to the file to extract.
* @return string Path to the extracted file.
*/
function extract_from_phar( $path ) {
if ( ! inside_phar( $path ) ) {
return $path;
}
$fname = basename( $path );
$tmp_path = get_temp_dir() . uniqid( 'wp-cli-extract-from-phar-', true ) . "-$fname";
copy( $path, $tmp_path );
register_shutdown_function(
function () use ( $tmp_path ) {
if ( file_exists( $tmp_path ) ) {
unlink( $tmp_path );
}
}
);
return $tmp_path;
}
/**
* Load dependencies.
*
* @return void|never
*/
function load_dependencies() {
if ( inside_phar() ) {
if ( file_exists( WP_CLI_ROOT . '/vendor/autoload.php' ) ) {
require WP_CLI_ROOT . '/vendor/autoload.php';
} elseif ( file_exists( dirname( dirname( WP_CLI_ROOT ) ) . '/autoload.php' ) ) {
require dirname( dirname( WP_CLI_ROOT ) ) . '/autoload.php';
}
return;
}
$has_autoload = false;
foreach ( get_vendor_paths() as $vendor_path ) {
if ( file_exists( $vendor_path . '/autoload.php' ) ) {
require $vendor_path . '/autoload.php';
$has_autoload = true;
break;
}
}
if ( ! $has_autoload ) {
fwrite( STDERR, "Internal error: Can't find Composer autoloader.\nTry running: composer install\n" );
exit( 3 );
}
}
/**
* Return vendor paths.
*
* @return array List of paths.
*/
function get_vendor_paths() {
$vendor_paths = [
WP_CLI_ROOT . '/../../../vendor', // Part of a larger project / installed via Composer (preferred).
WP_CLI_ROOT . '/vendor', // Top-level project / installed as Git clone.
];
$maybe_composer_json = WP_CLI_ROOT . '/../../../composer.json';
if ( file_exists( $maybe_composer_json ) && is_readable( $maybe_composer_json ) ) {
$composer = json_decode( file_get_contents( $maybe_composer_json ) );
if ( ! empty( $composer->config ) && ! empty( $composer->config->{'vendor-dir'} ) ) {
array_unshift( $vendor_paths, WP_CLI_ROOT . '/../../../' . $composer->config->{'vendor-dir'} );
}
}
return $vendor_paths;
}
/**
* Load a file.
*
* Using require() directly inside a class grants access
* to private methods to the loaded code, hence this wrapper helper.
*
* @param string $path
* @return void
*/
function load_file( $path ) {
require_once $path;
}
/**
* Load a command.
*
* @param string $name
* @return void
*/
function load_command( $name ) {
$path = WP_CLI_ROOT . "/php/commands/$name.php";
if ( is_readable( $path ) ) {
include_once $path;
}
}
/**
* Like array_map(), except it returns a new iterator, instead of a modified array.
*
* Example:
*
* $arr = array('Football', 'Socker');
*
* $it = iterator_map($arr, 'strtolower', function($val) {
* return str_replace('foo', 'bar', $val);
* });
*
* foreach ( $it as $val ) {
* var_dump($val);
* }
*
* @param array|object $it Either a plain array or another iterator.
* @param callable $fn The function to apply to an element.
* @return object An iterator that applies the given callback(s).
*/
function iterator_map( $it, $fn ) {
if ( is_array( $it ) ) {
$it = new ArrayIterator( $it );
}
if ( ! method_exists( $it, 'add_transform' ) ) {
$it = new Transform( $it );
}
foreach ( array_slice( func_get_args(), 1 ) as $fn ) {
$it->add_transform( $fn );
}
return $it;
}
/**
* Search for file by walking up the directory tree until the first file is found or until $stop_check($dir) returns true.
*
* @param string|array $files The files (or file) to search for.
* @param string|null $dir The directory to start searching from; defaults to CWD.
* @param callable $stop_check Function which is passed the current dir each time a directory level is traversed.
* @return null|string Null if the file was not found.
*/
function find_file_upward( $files, $dir = null, $stop_check = null ) {
$files = (array) $files;
if ( is_null( $dir ) ) {
$dir = getcwd();
}
while ( is_readable( $dir ) ) {
// Stop walking up when the supplied callable returns true being passed the $dir
if ( is_callable( $stop_check ) && call_user_func( $stop_check, $dir ) ) {
return null;
}
foreach ( $files as $file ) {
$path = $dir . DIRECTORY_SEPARATOR . $file;
if ( file_exists( $path ) ) {
return $path;
}
}
$parent_dir = dirname( $dir );
if ( empty( $parent_dir ) || $parent_dir === $dir ) {
break;
}
$dir = $parent_dir;
}
return null;
}
/**
* Determine whether a path is absolute.
* @param string $path
* @return bool
*/
function is_path_absolute( $path ) {
// Windows.
if ( isset( $path[1] ) && ':' === $path[1] ) {
return true;
}
return isset( $path[0] ) && '/' === $path[0];
}
/**
* Composes positional arguments into a command string.
*
* @param array $args Positional arguments to compose.
* @return string
*/
function args_to_str( $args ) {
return ' ' . implode( ' ', array_map( 'escapeshellarg', $args ) );
}
/**
* Composes associative arguments into a command string.
*
* @param array $assoc_args Associative arguments to compose.
* @return string
*/
function assoc_args_to_str( $assoc_args ) {
$str = '';
foreach ( $assoc_args as $key => $value ) {
if ( true === $value ) {
$str .= " --$key";
} elseif ( is_array( $value ) ) {
foreach ( $value as $v ) {
$str .= assoc_args_to_str(
[
$key => $v,
]
);
}
} else {
$str .= " --$key=" . escapeshellarg( $value );
}
}
return $str;
}
/**
* Given a template string and an arbitrary number of arguments,
* returns the final command, with the parameters escaped.
*
* @param array $cmd
*/
function esc_cmd( $cmd ) {
if ( func_num_args() < 2 ) {
trigger_error( 'esc_cmd() requires at least two arguments.', E_USER_WARNING );
}
$args = func_get_args();
$cmd = array_shift( $args );
return vsprintf( $cmd, array_map( 'escapeshellarg', $args ) );
}
/**
* Gets path to WordPress configuration.
*
* @return string
*/
function locate_wp_config() {
static $path;
if ( null === $path ) {
$path = false;
if ( getenv( 'WP_CONFIG_PATH' ) && file_exists( getenv( 'WP_CONFIG_PATH' ) ) ) {
$path = getenv( 'WP_CONFIG_PATH' );
} elseif ( file_exists( ABSPATH . 'wp-config.php' ) ) {
$path = ABSPATH . 'wp-config.php';
} elseif ( file_exists( dirname( ABSPATH ) . '/wp-config.php' ) && ! file_exists( dirname( ABSPATH ) . '/wp-settings.php' ) ) {
$path = dirname( ABSPATH ) . '/wp-config.php';
}
if ( $path ) {
$path = realpath( $path );
}
}
return $path;
}
/**
* Compare a WordPress version.
*
* @param string $since
* @param string $operator
* @return bool
*/
function wp_version_compare( $since, $operator ) {
$wp_version = str_replace( '-src', '', $GLOBALS['wp_version'] );
$since = str_replace( '-src', '', $since );
return version_compare( $wp_version, $since, $operator );
}
/**
* Render a collection of items as an ASCII table, JSON, CSV, YAML, list of ids, or count.
*
* Given a collection of items with a consistent data structure:
*
* ```
* $items = array(
* array(
* 'key' => 'foo',
* 'value' => 'bar',
* )
* );
* ```
*
* Render `$items` as an ASCII table:
*
* ```
* WP_CLI\Utils\format_items( 'table', $items, array( 'key', 'value' ) );
*
* # +-----+-------+
* # | key | value |
* # +-----+-------+
* # | foo | bar |
* # +-----+-------+
* ```
*
* Or render `$items` as YAML:
*
* ```
* WP_CLI\Utils\format_items( 'yaml', $items, array( 'key', 'value' ) );
*
* # ---
* # -
* # key: foo
* # value: bar
* ```
*
* @access public
* @category Output
*
* @param string $format Format to use: 'table', 'json', 'csv', 'yaml', 'ids', 'count'.
* @param array $items An array of items to output.
* @param array|string $fields Named fields for each item of data. Can be array or comma-separated list.
*/
function format_items( $format, $items, $fields ) {
$assoc_args = [
'format' => $format,
'fields' => $fields,
];
$formatter = new Formatter( $assoc_args );
$formatter->display_items( $items );
}
/**
* Write data as CSV to a given file.
*
* @access public
*
* @param resource $fd File descriptor.
* @param array $rows Array of rows to output.
* @param array $headers List of CSV columns (optional).
*/
function write_csv( $fd, $rows, $headers = [] ) {
if ( ! empty( $headers ) ) {
$headers = array_map( __NAMESPACE__ . '\escape_csv_value', $headers );
fputcsv( $fd, $headers, ',', '"', '\\' );
}
foreach ( $rows as $row ) {
if ( ! empty( $headers ) ) {
$row = pick_fields( $row, $headers );
}
$row = array_map( __NAMESPACE__ . '\escape_csv_value', $row );
fputcsv( $fd, array_values( $row ), ',', '"', '\\' );
}
}
/**
* Pick fields from an associative array or object.
*
* @param array|object $item Associative array or object to pick fields from.
* @param array $fields List of fields to pick.
* @return array
*/
function pick_fields( $item, $fields ) {
$values = [];
if ( is_object( $item ) ) {
foreach ( $fields as $field ) {
$values[ $field ] = isset( $item->$field ) ? $item->$field : null;
}
} else {
foreach ( $fields as $field ) {
$values[ $field ] = isset( $item[ $field ] ) ? $item[ $field ] : null;
}
}
return $values;
}
/**
* Launch system's $EDITOR for the user to edit some text.
*
* @access public
* @category Input
*
* @param string $input Some form of text to edit (e.g. post content).
* @param string $title Title to display in the editor.
* @param string $ext Extension to use with the temp file.
* @return string|bool Edited text, if file is saved from editor; false, if no change to file.
*/
function launch_editor_for_input( $input, $title = 'WP-CLI', $ext = 'tmp' ) {
check_proc_available( 'launch_editor_for_input' );
$tmpdir = get_temp_dir();
do {
$tmpfile = basename( $title );
$tmpfile = preg_replace( '|\.[^.]*$|', '', $tmpfile );
$tmpfile .= '-' . substr( md5( (string) mt_rand() ), 0, 6 ); // phpcs:ignore WordPress.WP.AlternativeFunctions.rand_mt_rand -- no crypto and WP not loaded.
$tmpfile = $tmpdir . $tmpfile . '.' . $ext;
$fp = fopen( $tmpfile, 'xb' );
if ( ! $fp && is_writable( $tmpdir ) && file_exists( $tmpfile ) ) {
$tmpfile = '';
continue;
}
if ( $fp ) {
fclose( $fp );
}
} while ( ! $tmpfile );
if ( ! $tmpfile ) {
WP_CLI::error( 'Error creating temporary file.' );
}
file_put_contents( $tmpfile, $input );
$editor = getenv( 'EDITOR' );
if ( ! $editor ) {
$editor = is_windows() ? 'notepad' : 'vi';
}
$descriptorspec = [ STDIN, STDOUT, STDERR ];
$process = proc_open_compat( "$editor " . escapeshellarg( $tmpfile ), $descriptorspec, $pipes );
$r = proc_close( $process );
if ( $r ) {
exit( $r );
}
$output = file_get_contents( $tmpfile );
unlink( $tmpfile );
if ( $output === $input ) {
return false;
}
return $output;
}
/**
* @param string $raw_host MySQL host string, as defined in wp-config.php.
*
* @return array
*/
function mysql_host_to_cli_args( $raw_host ) {
$assoc_args = [];
/**
* If the host string begins with 'p:' for a persistent db connection,
* replace 'p:' with nothing.
*/
if ( substr( $raw_host, 0, 2 ) === 'p:' ) {
$raw_host = substr_replace( $raw_host, '', 0, 2 );
}
$host_parts = explode( ':', $raw_host );
if ( count( $host_parts ) === 2 ) {
list( $assoc_args['host'], $extra ) = $host_parts;
$extra = trim( $extra );
if ( is_numeric( $extra ) ) {
$assoc_args['port'] = (int) $extra;
$assoc_args['protocol'] = 'tcp';
} elseif ( '' !== $extra ) {
$assoc_args['socket'] = $extra;
}
} else {
$assoc_args['host'] = $raw_host;
}
return $assoc_args;
}
/**
* Run a MySQL command and optionally return the output.
*
* @since v2.5.0 Deprecated $descriptors argument.
*
* @param string $cmd Command to run.
* @param array $assoc_args Associative array of arguments to use.
* @param mixed $_ Deprecated. Former $descriptors argument.
* @param bool $send_to_shell Optional. Whether to send STDOUT and STDERR
* immediately to the shell. Defaults to true.
* @param bool $interactive Optional. Whether MySQL is meant to be
* executed as an interactive process. Defaults
* to false.
*
* @return array {
* Associative array containing STDOUT and STDERR output.
*
* @type string $stdout Output that was sent to STDOUT.
* @type string $stderr Output that was sent to STDERR.
* @type int $exit_code Exit code of the process.
* }
*/
function run_mysql_command( $cmd, $assoc_args, $_ = null, $send_to_shell = true, $interactive = false ) {
check_proc_available( 'run_mysql_command' );
$descriptors = ( $interactive || $send_to_shell ) ?
[
0 => STDIN,
1 => STDOUT,
2 => STDERR,
] :
[
0 => STDIN,
1 => [ 'pipe', 'w' ],
2 => [ 'pipe', 'w' ],
];
$stdout = '';
$stderr = '';
$pipes = [];
if ( isset( $assoc_args['host'] ) ) {
// phpcs:ignore WordPress.DB.RestrictedFunctions.mysql_mysql_host_to_cli_args -- Misidentified as PHP native MySQL function.
$assoc_args = array_merge( $assoc_args, mysql_host_to_cli_args( $assoc_args['host'] ) );
}
if ( isset( $assoc_args['pass'] ) ) {
$old_password = getenv( 'MYSQL_PWD' );
putenv( 'MYSQL_PWD=' . $assoc_args['pass'] );
unset( $assoc_args['pass'] );
}
$final_cmd = force_env_on_nix_systems( $cmd ) . assoc_args_to_str( $assoc_args );
WP_CLI::debug( 'Final MySQL command: ' . $final_cmd, 'db' );
$process = proc_open_compat( $final_cmd, $descriptors, $pipes );
if ( isset( $old_password ) ) {
putenv( 'MYSQL_PWD=' . $old_password );
}
if ( ! $process ) {
WP_CLI::debug( 'Failed to create a valid process using proc_open_compat()', 'db' );
exit( 1 );
}
if ( is_resource( $process ) && ! $send_to_shell && ! $interactive ) {
$stdout = stream_get_contents( $pipes[1] );
$stderr = stream_get_contents( $pipes[2] );
fclose( $pipes[1] );
fclose( $pipes[2] );
}
$exit_code = proc_close( $process );
if ( $exit_code && ( $send_to_shell || $interactive ) ) {
exit( $exit_code );
}
return [
$stdout,
$stderr,
$exit_code,
];
}
/**
* Render PHP or other types of files using Mustache templates.
*
* IMPORTANT: Automatic HTML escaping is disabled!
*
* @param string $template_name
* @param array $data
*/
function mustache_render( $template_name, $data = [] ) {
if ( ! file_exists( $template_name ) ) {
$template_name = WP_CLI_ROOT . "/templates/$template_name";
}
$template = file_get_contents( $template_name );
$mustache = new Mustache_Engine(
[
'escape' => function ( $val ) {
return $val; },
]
);
return $mustache->render( $template, $data );
}
/**
* Create a progress bar to display percent completion of a given operation.
*
* Progress bar is written to STDOUT, and disabled when command is piped. Progress
* advances with `$progress->tick()`, and completes with `$progress->finish()`.
* Process bar also indicates elapsed time and expected total time.
*
* ```
* # `wp user generate` ticks progress bar each time a new user is created.
* #
* # $ wp user generate --count=500
* # Generating users 22 % [=======> ] 0:05 / 0:23
*
* $progress = \WP_CLI\Utils\make_progress_bar( 'Generating users', $count );
* for ( $i = 0; $i < $count; $i++ ) {
* // uses wp_insert_user() to insert the user
* $progress->tick();
* }
* $progress->finish();
* ```
*
* @access public
* @category Output
*
* @param string $message Text to display before the progress bar.
* @param integer $count Total number of ticks to be performed.
* @param int $interval Optional. The interval in milliseconds between updates. Default 100.
* @return \cli\progress\Bar|\WP_CLI\NoOp
*/
function make_progress_bar( $message, $count, $interval = 100 ) {
if ( Shell::isPiped() ) {
return new NoOp();
}
return new Bar( $message, $count, $interval );
}
/**
* Helper function to use wp_parse_url when available or fall back to PHP's
* parse_url if not.
*
* Additionally, this adds 'http://' to the URL if no scheme was found.
*
* @param string $url The URL to parse.
* @param int $component Optional. The specific component to retrieve.
* Use one of the PHP predefined constants to
* specify which one. Defaults to -1 (= return
* all parts as an array).
* @param bool $auto_add_scheme Optional. Automatically add an http:// scheme if
* none was found. Defaults to true.
* @return mixed False on parse failure; Array of URL components on success;
* When a specific component has been requested: null if the
* component doesn't exist in the given URL; a string or - in the
* case of PHP_URL_PORT - integer when it does. See parse_url()'s
* return values.
*/
function parse_url( $url, $component = - 1, $auto_add_scheme = true ) {
if (
function_exists( 'wp_parse_url' )
&& (
-1 === $component
|| wp_version_compare( '4.7', '>=' )
)
) {
$url_parts = wp_parse_url( $url, $component );
} else {
// phpcs:ignore WordPress.WP.AlternativeFunctions.parse_url_parse_url -- Fallback.
$url_parts = \parse_url( $url, $component );
}
// phpcs:ignore WordPress.WP.AlternativeFunctions.parse_url_parse_url -- Own version based on WP one.
if ( $auto_add_scheme && ! parse_url( $url, PHP_URL_SCHEME, false ) ) {
// phpcs:ignore WordPress.WP.AlternativeFunctions.parse_url_parse_url -- Own version based on WP one.
$url_parts = parse_url( 'http://' . $url, $component, false );
}
return $url_parts;
}
/**
* Check if we're running in a Windows environment (cmd.exe).
*
* @return bool
*/
function is_windows() {
$test_is_windows = getenv( 'WP_CLI_TEST_IS_WINDOWS' );
return false !== $test_is_windows ? (bool) $test_is_windows : strtoupper( substr( PHP_OS, 0, 3 ) ) === 'WIN';
}
/**
* Replace magic constants in some PHP source code.
*
* Replaces the __FILE__ and __DIR__ magic constants with the values they are
* supposed to represent at runtime.
*
* @param string $source The PHP code to manipulate.
* @param string $path The path to use instead of the magic constants.
* @return string Adapted PHP code.
*/
function replace_path_consts( $source, $path ) {
// Solve issue with Windows allowing single quotes in account names.
$file = addslashes( $path );
if ( file_exists( $file ) ) {
$file = realpath( $file );
}
$dir = dirname( $file );
// Replace __FILE__ and __DIR__ constants with value of $file or $dir.
return preg_replace_callback(
FILE_DIR_PATTERN,
static function ( $matches ) use ( $file, $dir ) {
if ( ! empty( $matches['file'] ) ) {
return "'{$file}'";
}
if ( ! empty( $matches['dir'] ) ) {
return "'{$dir}'";
}
return $matches[0];
},
$source
);
}
/**
* Make a HTTP request to a remote URL.
*
* Wraps the Requests HTTP library to ensure every request includes a cert.
*
* ```
* # `wp core download` verifies the hash for a downloaded WordPress archive
*
* $md5_response = Utils\http_request( 'GET', $download_url . '.md5' );
* if ( 20 != substr( $md5_response->status_code, 0, 2 ) ) {
* WP_CLI::error( "Couldn't access md5 hash for release (HTTP code {$response->status_code})" );
* }
* ```
*
* @access public
*
* @param string $method HTTP method (GET, POST, DELETE, etc.).
* @param string $url URL to make the HTTP request to.
* @param array|null $data Data to send either as a query string for GET/HEAD requests,
* or in the body for POST requests.
* @param array $headers Add specific headers to the request.
* @param array $options {
* Optional. An associative array of additional request options.
*
* @type bool $halt_on_error Whether or not command execution should be halted on error. Default: true
* @type bool|string $verify A boolean to use enable/disable SSL verification
* or string absolute path to CA cert to use.
* Defaults to detected CA cert bundled with the Requests library.
* @type bool $insecure Whether to retry automatically without certificate validation.
* }
* @return object
* @throws RuntimeException If the request failed.
* @throws ExitException If the request failed and $halt_on_error is true.
*/
function http_request( $method, $url, $data = null, $headers = [], $options = [] ) {
$insecure = isset( $options['insecure'] ) && (bool) $options['insecure'];
$halt_on_error = ! isset( $options['halt_on_error'] ) || (bool) $options['halt_on_error'];
unset( $options['halt_on_error'] );
if ( ! isset( $options['verify'] ) ) {
// 'curl.cainfo' enforces the CA file to use, otherwise fallback to system-wide defaults then use the embedded CA file.
$options['verify'] = ! empty( ini_get( 'curl.cainfo' ) ) ? ini_get( 'curl.cainfo' ) : true;
}
$options = WP_CLI::do_hook( 'http_request_options', $options );
RequestsLibrary::register_autoloader();
$request_method = [ RequestsLibrary::get_class_name(), 'request' ];
try {
try {
return $request_method( $url, $headers, $data, $method, $options );
} catch ( Exception $exception ) {
if ( RequestsLibrary::is_requests_exception( $exception ) ) {
if (
true !== $options['verify']
|| 'curlerror' !== $exception->getType()
|| curl_errno( $exception->getData() ) !== CURLE_SSL_CACERT
) {
throw $exception;
}
$options['verify'] = get_default_cacert( $halt_on_error );
return $request_method( $url, $headers, $data, $method, $options );
}
throw $exception;
}
} catch ( Exception $exception ) {
if ( RequestsLibrary::is_requests_exception( $exception ) ) {
// CURLE_SSL_CACERT_BADFILE only defined for PHP >= 7.
if (
! $insecure
||
'curlerror' !== $exception->getType()
||
! in_array( curl_errno( $exception->getData() ), [ CURLE_SSL_CONNECT_ERROR, CURLE_SSL_CERTPROBLEM, 77 /*CURLE_SSL_CACERT_BADFILE*/ ], true )
) {
$error_msg = sprintf( "Failed to get url '%s': %s.", $url, $exception->getMessage() );
if ( $halt_on_error ) {
WP_CLI::error( $error_msg );
}
throw new RuntimeException( $error_msg, 0, $exception );
}
$warning = sprintf(
"Re-trying without verify after failing to get verified url '%s' %s.",
$url,
$exception->getMessage()
);
WP_CLI::warning( $warning );
// Disable certificate validation for the next try.
$options['verify'] = false;
try {
return $request_method( $url, $headers, $data, $method, $options );
} catch ( Exception $exception ) {
if ( RequestsLibrary::is_requests_exception( $exception ) ) {
$error_msg = sprintf( "Failed to get non-verified url '%s' %s.", $url, $exception->getMessage() );
if ( $halt_on_error ) {
WP_CLI::error( $error_msg );
}
throw new RuntimeException( $error_msg, 0, $exception );
}
throw $exception;
}
}
throw $exception;
}
}
/**
* Gets the full path to the default CA cert.
*
* @param bool $halt_on_error Whether or not command execution should be halted on error. Default: false
* @return string Absolute path to the default CA cert.
* @throws RuntimeException If unable to locate the cert.
* @throws ExitException If unable to locate the cert and $halt_on_error is true.
*/
function get_default_cacert( $halt_on_error = false ) {
$cert_path = RequestsLibrary::get_bundled_certificate_path();
$error_msg = 'Cannot find SSL certificate.';
if ( inside_phar( $cert_path ) ) {
// cURL can't read Phar archives.
return extract_from_phar( $cert_path );
}
if ( file_exists( $cert_path ) ) {
return $cert_path;
}
if ( $halt_on_error ) {
WP_CLI::error( $error_msg );
}
throw new RuntimeException( $error_msg );
}
/**
* Increments a version string using the "x.y.z-pre" format.
*
* Can increment the major, minor or patch number by one.
* If $new_version == "same" the version string is not changed.
* If $new_version is not a known keyword, it will be used as the new version string directly.
*
* @param string $current_version
* @param string $new_version
* @return string
*/
function increment_version( $current_version, $new_version ) {
// split version assuming the format is x.y.z-pre.
$current_version = explode( '-', $current_version, 2 );
$current_version[0] = explode( '.', $current_version[0] );
switch ( $new_version ) {
case 'same':
// do nothing.
break;
case 'patch':
++$current_version[0][2];
$current_version = [ $current_version[0] ]; // Drop possible pre-release info.
break;
case 'minor':
++$current_version[0][1];
$current_version[0][2] = 0;
$current_version = [ $current_version[0] ]; // Drop possible pre-release info.
break;
case 'major':
++$current_version[0][0];
$current_version[0][1] = 0;
$current_version[0][2] = 0;
$current_version = [ $current_version[0] ]; // Drop possible pre-release info.
break;
default: // not a keyword.
$current_version = [ [ $new_version ] ];
break;
}
// Reconstruct version string.
$current_version[0] = implode( '.', $current_version[0] );
$current_version = implode( '-', $current_version );
return $current_version;
}
/**
* Compare two version strings to get the named semantic version.
*
* @access public
*
* @param string $new_version
* @param string $original_version
* @return string 'major', 'minor', 'patch'
*/
function get_named_sem_ver( $new_version, $original_version ) {
if ( ! Comparator::greaterThan( $new_version, $original_version ) ) {
return '';
}
$parts = explode( '-', $original_version );
$bits = explode( '.', $parts[0] );
$major = $bits[0];
if ( isset( $bits[1] ) ) {
$minor = $bits[1];
}
if ( isset( $bits[2] ) ) {
$patch = $bits[2];
}
try {
if ( isset( $minor ) && Semver::satisfies( $new_version, "{$major}.{$minor}.x" ) ) {
return 'patch';
}
if ( Semver::satisfies( $new_version, "{$major}.x.x" ) ) {
return 'minor';
}
} catch ( \UnexpectedValueException $e ) {
return '';
}
return 'major';
}
/**
* Return the flag value or, if it's not set, the $default value.
*
* Because flags can be negated (e.g. --no-quiet to negate --quiet), this
* function provides a safer alternative to using
* `isset( $assoc_args['quiet'] )` or similar.
*
* @access public
* @category Input
*
* @param array $assoc_args Arguments array.
* @param string $flag Flag to get the value.
* @param mixed $default Default value for the flag. Default: NULL.
* @return mixed
*/
function get_flag_value( $assoc_args, $flag, $default = null ) {
return isset( $assoc_args[ $flag ] ) ? $assoc_args[ $flag ] : $default;
}
/**
* Get the home directory.
*
* @access public
* @category System
*
* @return string
*/
function get_home_dir() {
$home = getenv( 'HOME' );
if ( ! $home ) {
// In Windows $HOME may not be defined.
$home = getenv( 'HOMEDRIVE' ) . getenv( 'HOMEPATH' );
}
return rtrim( $home, '/\\' );
}
/**
* Appends a trailing slash.
*
* @access public
* @category System
*
* @param string $string What to add the trailing slash to.
* @return string String with trailing slash added.
*/
function trailingslashit( $string ) {
if ( ! is_string( $string ) ) {
return '/';
}
return rtrim( $string, '/\\' ) . '/';
}
/**
* Normalize a filesystem path.
*
* On Windows systems, replaces backslashes with forward slashes
* and forces upper-case drive letters.
* Allows for two leading slashes for Windows network shares, but
* ensures that all other duplicate slashes are reduced to a single one.
* Ensures upper-case drive letters on Windows systems.
*
* @access public
* @category System
*
* @param string $path Path to normalize.
* @return string Normalized path.
*/
function normalize_path( $path ) {
$path = str_replace( '\\', '/', $path );
$path = preg_replace( '|(?<=.)/+|', '/', $path );
if ( ':' === substr( $path, 1, 1 ) ) {
$path = ucfirst( $path );
}
return $path;
}
/**
* Convert Windows EOLs to *nix.
*
* @param string $str String to convert.
* @return string String with carriage return / newline pairs reduced to newlines.
*/
function normalize_eols( $str ) {
return str_replace( "\r\n", "\n", $str );
}
/**
* Get the system's temp directory. Warns user if it isn't writable.
*
* @access public
* @category System
*
* @return string
*/
function get_temp_dir() {
static $temp = '';
if ( $temp ) {
return $temp;
}
// `sys_get_temp_dir()` introduced PHP 5.2.1. Will always return something.
$temp = trailingslashit( sys_get_temp_dir() );
if ( ! is_writable( $temp ) ) {
WP_CLI::warning( "Temp directory isn't writable: {$temp}" );
}
return $temp;
}
/**
* Parse a SSH url for its host, port, and path.
*
* Similar to parse_url(), but adds support for defined SSH aliases.
*
* ```
* host OR host/path/to/wordpress OR host:port/path/to/wordpress
* ```
*
* @access public
*
* @param string $url
* @param int $component
* @return mixed
*/
function parse_ssh_url( $url, $component = -1 ) {
preg_match( '#^((docker|docker\-compose|docker\-compose\-run|ssh|vagrant):)?(([^@:]+)@)?([^:/~]+)(:([\d]*))?((/|~)(.+))?$#', $url, $matches );
$bits = [];
foreach ( [
2 => 'scheme',
4 => 'user',
5 => 'host',
7 => 'port',
8 => 'path',
] as $i => $key ) {
if ( ! empty( $matches[ $i ] ) ) {
$bits[ $key ] = $matches[ $i ];
}
}
// Find the hostname from `vagrant ssh-config` automatically.
if ( preg_match( '/^vagrant:?/', $url ) ) {
if ( 'vagrant' === $bits['host'] && empty( $bits['scheme'] ) ) {
$bits['scheme'] = 'vagrant';
$bits['host'] = '';
}
}
switch ( $component ) {
case PHP_URL_SCHEME:
return isset( $bits['scheme'] ) ? $bits['scheme'] : null;
case PHP_URL_USER:
return isset( $bits['user'] ) ? $bits['user'] : null;
case PHP_URL_HOST:
return isset( $bits['host'] ) ? $bits['host'] : null;
case PHP_URL_PATH:
return isset( $bits['path'] ) ? $bits['path'] : null;
case PHP_URL_PORT:
return isset( $bits['port'] ) ? $bits['port'] : null;
default:
return $bits;
}
}
/**
* Report the results of the same operation against multiple resources.
*
* @access public
* @category Input
*
* @param string $noun Resource being affected (e.g. plugin).
* @param string $verb Type of action happening to the noun (e.g. activate).
* @param integer $total Total number of resource being affected.
* @param integer $successes Number of successful operations.
* @param integer $failures Number of failures.
* @param null|integer $skips Optional. Number of skipped operations. Default null (don't show skips).
* @return void
*/
function report_batch_operation_results( $noun, $verb, $total, $successes, $failures, $skips = null ) {
$plural_noun = $noun . 's';
$past_tense_verb = past_tense_verb( $verb );
$past_tense_verb_upper = ucfirst( $past_tense_verb );
if ( $failures ) {
$failed_skipped_message = null === $skips ? '' : " ({$failures} failed" . ( $skips ? ", {$skips} skipped" : '' ) . ')';
if ( $successes ) {
WP_CLI::error( "Only {$past_tense_verb} {$successes} of {$total} {$plural_noun}{$failed_skipped_message}." );
} else {
WP_CLI::error( "No {$plural_noun} {$past_tense_verb}{$failed_skipped_message}." );
}
} else {
$skipped_message = $skips ? " ({$skips} skipped)" : '';
if ( $successes || $skips ) {
WP_CLI::success( "{$past_tense_verb_upper} {$successes} of {$total} {$plural_noun}{$skipped_message}." );
} else {
$message = $total > 1 ? ucfirst( $plural_noun ) : ucfirst( $noun );
WP_CLI::success( "{$message} already {$past_tense_verb}." );
}
}
}
/**
* Parse a string of command line arguments into an $argv-esqe variable.
*
* @access public
* @category Input
*
* @param string $arguments
* @return array
*/
function parse_str_to_argv( $arguments ) {
preg_match_all( '/(?:--[^\s=]+=(["\'])((\\{2})*|(?:[^\1]+?[^\\\\](\\{2})*))\1|--[^\s=]+=[^\s]+|--[^\s=]+|(["\'])((\\{2})*|(?:[^\5]+?[^\\\\](\\{2})*))\5|[^\s]+)/', $arguments, $matches );
$argv = $matches[0];
return array_map(
static function ( $arg ) {
foreach ( [ '"', "'" ] as $char ) {
if ( substr( $arg, 0, 1 ) === $char && substr( $arg, -1 ) === $char ) {
$arg = substr( $arg, 1, -1 );
break;
}
}
return $arg;
},
$argv
);
}
/**
* Locale-independent version of basename()
*
* @access public
*
* @param string $path
* @param string $suffix
* @return string
*/
function basename( $path, $suffix = '' ) {
// phpcs:ignore WordPress.PHP.DiscouragedPHPFunctions.urlencode_urlencode -- Format required by wordpress.org API.
return urldecode( \basename( str_replace( [ '%2F', '%5C' ], '/', urlencode( $path ) ), $suffix ) );
}
/**
* Checks whether the output of the current script is a TTY or a pipe / redirect
*
* Returns `true` if `STDOUT` output is being redirected to a pipe or a file; `false` is
* output is being sent directly to the terminal.
*
* If an env variable `SHELL_PIPE` exists, the returned result depends on its
* value. Strings like `1`, `0`, `yes`, `no`, that validate to booleans are accepted.
*
* To enable ASCII formatting even when the shell is piped, use the
* ENV variable `SHELL_PIPE=0`.
* ```
* SHELL_PIPE=0 wp plugin list | cat
* ```
*
* Note that the db command forwards to the mysql client, which is unaware of the env
* variable. For db commands, pass the `--table` option instead.
* ```
* wp db query --table "SELECT 1" | cat
* ```
*
* @access public
*
* @return bool
*/
function isPiped() { // phpcs:ignore WordPress.NamingConventions.ValidFunctionName.FunctionNameInvalid -- Renaming would break BC.
$shell_pipe = getenv( 'SHELL_PIPE' );
if ( false !== $shell_pipe ) {
return filter_var( $shell_pipe, FILTER_VALIDATE_BOOLEAN );
}
return function_exists( 'posix_isatty' ) && ! posix_isatty( STDOUT );
}
/**
* Expand within paths to their matching paths.
*
* Has no effect on paths which do not use glob patterns.
*
* @param string|array $paths Single path as a string, or an array of paths.
* @param int|'default' $flags Optional. Flags to pass to glob. Defaults to GLOB_BRACE.
* @return array Expanded paths.
*/
function expand_globs( $paths, $flags = 'default' ) {
// Compatibility for systems without GLOB_BRACE.
$glob_func = 'glob';
if ( 'default' === $flags ) {
if ( ! defined( 'GLOB_BRACE' ) || getenv( 'WP_CLI_TEST_EXPAND_GLOBS_NO_GLOB_BRACE' ) ) {
$glob_func = 'WP_CLI\Utils\glob_brace';
} else {
$flags = GLOB_BRACE;
}
}
$expanded = [];
foreach ( (array) $paths as $path ) {
$matching = [ $path ];
if ( preg_match( '/[' . preg_quote( '*?[]{}!', '/' ) . ']/', $path ) ) {
$matching = $glob_func( $path, $flags ) ?: [];
}
$expanded = array_merge( $expanded, $matching );
}
return array_values( array_unique( $expanded ) );
}
/**
* Simulate a `glob()` with the `GLOB_BRACE` flag set. For systems (eg Alpine Linux) built against a libc library (eg https://www.musl-libc.org/) that lacks it.
* Copied and adapted from Zend Framework's `Glob::fallbackGlob()` and Glob::nextBraceSub()`.
*
* Zend Framework (https://framework.zend.com/)
*
* @link https://github.com/zendframework/zf2 for the canonical source repository
* @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (https://www.zend.com)
* @license https://framework.zend.com/license/new-bsd New BSD License
*
* @param string $pattern Filename pattern.
* @param void $dummy_flags Not used.
* @return array Array of paths.
*/
function glob_brace( $pattern, $dummy_flags = null ) { // phpcs:ignore Generic.CodeAnalysis.UnusedFunctionParameter.FoundAfterLastUsed -- $dummy_flags is needed for compatibility with the libc implementation.
static $next_brace_sub;
if ( ! $next_brace_sub ) {
// Find the end of the subpattern in a brace expression.
$next_brace_sub = function ( $pattern, $current ) {
$length = strlen( $pattern );
$depth = 0;
while ( $current < $length ) {
if ( '\\' === $pattern[ $current ] ) {
if ( ++$current === $length ) {
break;
}
++$current;
} else {
if ( ( '}' === $pattern[ $current ] && 0 === $depth-- ) || ( ',' === $pattern[ $current ] && 0 === $depth ) ) {
break;
}
if ( '{' === $pattern[ $current++ ] ) {
++$depth;
}
}
}
return $current < $length ? $current : null;
};
}
$length = strlen( $pattern );
// Find first opening brace.
for ( $begin = 0; $begin < $length; $begin++ ) {
if ( '\\' === $pattern[ $begin ] ) {
++$begin;
} elseif ( '{' === $pattern[ $begin ] ) {
break;
}
}
// Find comma or matching closing brace.
$next = $next_brace_sub( $pattern, $begin + 1 );
if ( null === $next ) {
return glob( $pattern );
}
$rest = $next;
// Point `$rest` to matching closing brace.
while ( '}' !== $pattern[ $rest ] ) {
$rest = $next_brace_sub( $pattern, $rest + 1 );
if ( null === $rest ) {
return glob( $pattern );
}
}
$paths = [];
$p = $begin + 1;
// For each comma-separated subpattern.
do {
$subpattern = substr( $pattern, 0, $begin )
. substr( $pattern, $p, $next - $p )
. substr( $pattern, $rest + 1 );
$result = glob_brace( $subpattern );
if ( ! empty( $result ) ) {
$paths = array_merge( $paths, $result );
}
if ( '}' === $pattern[ $next ] ) {
break;
}
$p = $next + 1;
$next = $next_brace_sub( $pattern, $p );
} while ( null !== $next );
return array_values( array_unique( $paths ) );
}
/**
* Get the closest suggestion for a mistyped target term amongst a list of
* options.
*
* Uses the Levenshtein algorithm to calculate the relative "distance" between
* terms.
*
* If the "distance" to the closest term is higher than the threshold, an empty
* string is returned.
*
* @param string $target Target term to get a suggestion for.
* @param array $options Array with possible options.
* @param int $threshold Threshold above which to return an empty string.
* @return string
*/
function get_suggestion( $target, array $options, $threshold = 2 ) {
$suggestion_map = [
'add' => 'create',
'check' => 'check-update',
'capability' => 'cap',
'clear' => 'flush',
'decrement' => 'decr',
'del' => 'delete',
'directory' => 'dir',
'exec' => 'eval',
'exec-file' => 'eval-file',
'increment' => 'incr',
'language' => 'locale',
'lang' => 'locale',
'new' => 'create',
'number' => 'count',
'remove' => 'delete',
'regen' => 'regenerate',
'rep' => 'replace',
'repl' => 'replace',
'trash' => 'delete',
'v' => 'version',
];
if ( array_key_exists( $target, $suggestion_map ) && in_array( $suggestion_map[ $target ], $options, true ) ) {
return $suggestion_map[ $target ];
}
if ( empty( $options ) ) {
return '';
}
foreach ( $options as $option ) {
$distance = levenshtein( $option, $target );
$levenshtein[ $option ] = $distance;
}
// Sort known command strings by distance to user entry.
asort( $levenshtein );
// Fetch the closest command string.
reset( $levenshtein );
$suggestion = key( $levenshtein );
// Only return a suggestion if below a given threshold.
return $levenshtein[ $suggestion ] <= $threshold && $suggestion !== $target
? (string) $suggestion
: '';
}
/**
* Get a Phar-safe version of a path.
*
* For paths inside a Phar, this strips the outer filesystem's location to
* reduce the path to what it needs to be within the Phar archive.
*
* Use the __FILE__ or __DIR__ constants as a starting point.
*
* @param string $path An absolute path that might be within a Phar.
* @return string A Phar-safe version of the path.
*/
function phar_safe_path( $path ) {
if ( ! inside_phar() ) {
return $path;
}
return str_replace(
PHAR_STREAM_PREFIX . rtrim( WP_CLI_PHAR_PATH, '/' ) . '/',
PHAR_STREAM_PREFIX,
$path
);
}
/**
* Maybe prefix command string with "/usr/bin/env".
* Removes (if there) if Windows, adds (if not there) if not.
*
* @param string $command
* @return string
*/
function force_env_on_nix_systems( $command ) {
$env_prefix = '/usr/bin/env ';
$env_prefix_len = strlen( $env_prefix );
if ( is_windows() ) {
if ( 0 === strncmp( $command, $env_prefix, $env_prefix_len ) ) {
$command = substr( $command, $env_prefix_len );
}
} elseif ( 0 !== strncmp( $command, $env_prefix, $env_prefix_len ) ) {
$command = $env_prefix . $command;
}
return $command;
}
/**
* Check that `proc_open()` and `proc_close()` haven't been disabled.
*
* @param string $context Optional. If set will appear in error message. Default null.
* @param bool $return Optional. If set will return false rather than error out. Default false.
* @return bool
*/
function check_proc_available( $context = null, $return = false ) {
if ( ! function_exists( 'proc_open' ) || ! function_exists( 'proc_close' ) ) {
if ( $return ) {
return false;
}
$msg = 'The PHP functions `proc_open()` and/or `proc_close()` are disabled. Please check your PHP ini directive `disable_functions` or suhosin settings.';
if ( $context ) {
WP_CLI::error( sprintf( "Cannot do '%s': %s", $context, $msg ) );
} else {
WP_CLI::error( $msg );
}
}
return true;
}
/**
* Returns past tense of verb, with limited accuracy. Only regular verbs catered for, apart from "reset".
*
* @param string $verb Verb to return past tense of.
* @return string
*/
function past_tense_verb( $verb ) {
static $irregular = [
'reset' => 'reset',
];
if ( isset( $irregular[ $verb ] ) ) {
return $irregular[ $verb ];
}
$last = substr( $verb, -1 );
if ( 'e' === $last ) {
$verb = substr( $verb, 0, -1 );
} elseif ( 'y' === $last && ! preg_match( '/[aeiou]y$/', $verb ) ) {
$verb = substr( $verb, 0, -1 ) . 'i';
} elseif ( preg_match( '/^[^aeiou]*[aeiou][^aeiouhwxy]$/', $verb ) ) {
// Rule of thumb that most (all?) one-voweled regular verbs ending in vowel + consonant (excluding "h", "w", "x", "y") double their final consonant - misses many cases (eg "submit").
$verb .= $last;
}
return $verb . 'ed';
}
/**
* Get the path to the PHP binary used when executing WP-CLI.
*
* Environment values permit specific binaries to be indicated.
*
* @access public
* @category System
*
* @return string
*/
function get_php_binary() {
// Phar installs always use PHP_BINARY.
if ( inside_phar() ) {
return PHP_BINARY;
}
$wp_cli_php_used = getenv( 'WP_CLI_PHP_USED' );
if ( false !== $wp_cli_php_used ) {
return $wp_cli_php_used;
}
$wp_cli_php = getenv( 'WP_CLI_PHP' );
if ( false !== $wp_cli_php ) {
return $wp_cli_php;
}
return PHP_BINARY;
}
/**
* Windows compatible `proc_open()`.
* Works around bug in PHP, and also deals with *nix-like `ENV_VAR=blah cmd` environment variable prefixes.
*
* @access public
*
* @param string $cmd Command to execute.
* @param array $descriptorspec Indexed array of descriptor numbers and their values.
* @param array &$pipes Indexed array of file pointers that correspond to PHP's end of any pipes that are created.
* @param string $cwd Initial working directory for the command.
* @param array $env Array of environment variables.
* @param array $other_options Array of additional options (Windows only).
* @return resource Command stripped of any environment variable settings.
*/
function proc_open_compat( $cmd, $descriptorspec, &$pipes, $cwd = null, $env = null, $other_options = null ) {
if ( is_windows() ) {
$cmd = _proc_open_compat_win_env( $cmd, $env );
}
return proc_open( $cmd, $descriptorspec, $pipes, $cwd, $env, $other_options );
}
/**
* For use by `proc_open_compat()` only. Separated out for ease of testing. Windows only.
* Turns *nix-like `ENV_VAR=blah command` environment variable prefixes into stripped `cmd` with prefixed environment variables added to passed in environment array.
*
* @access private
*
* @param string $cmd Command to execute.
* @param array &$env Array of existing environment variables. Will be modified if any settings in command.
* @return string Command stripped of any environment variable settings.
*/
function _proc_open_compat_win_env( $cmd, &$env ) {
if ( false !== strpos( $cmd, '=' ) ) {
while ( preg_match( '/^([A-Za-z_][A-Za-z0-9_]*)=("[^"]*"|[^ ]*) /', $cmd, $matches ) ) {
$cmd = substr( $cmd, strlen( $matches[0] ) );
if ( null === $env ) {
$env = [];
}
$env[ $matches[1] ] = isset( $matches[2][0] ) && '"' === $matches[2][0] ? substr( $matches[2], 1, -1 ) : $matches[2];
}
}
return $cmd;
}
/**
* First half of escaping for LIKE special characters % and _ before preparing for MySQL.
*
* Use this only before wpdb::prepare() or esc_sql(). Reversing the order is very bad for security.
*
* Copied from core "wp-includes/wp-db.php". Avoids dependency on WP 4.4 wpdb.
*
* @access public
*
* @param string $text The raw text to be escaped. The input typed by the user should have no
* extra or deleted slashes.
* @return string Text in the form of a LIKE phrase. The output is not SQL safe. Call $wpdb::prepare()
* or real_escape next.
*/
function esc_like( $text ) {
global $wpdb;
// Check if the esc_like() method exists on the global $wpdb object.
// We need to do this because to ensure compatibilty layers like the
// SQLite integration plugin still work.
if ( null !== $wpdb && method_exists( $wpdb, 'esc_like' ) ) {
return $wpdb->esc_like( $text );
}
return addcslashes( $text, '_%\\' );
}
/**
* Escapes (backticks) MySQL identifiers (aka schema object names) - i.e. column names, table names, and database/index/alias/view etc names.
* See https://dev.mysql.com/doc/refman/5.5/en/identifiers.html
*
* @param string|array $idents A single identifier or an array of identifiers.
* @return string|array An escaped string if given a string, or an array of escaped strings if given an array of strings.
*/
function esc_sql_ident( $idents ) {
$backtick = static function ( $v ) {
// Escape any backticks in the identifier by doubling.
return '`' . str_replace( '`', '``', $v ) . '`';
};
if ( is_string( $idents ) ) {
return $backtick( $idents );
}
return array_map( $backtick, $idents );
}
/**
* Check whether a given string is a valid JSON representation.
*
* @param string $argument String to evaluate.
* @param bool $ignore_scalars Optional. Whether to ignore scalar values.
* Defaults to true.
* @return bool Whether the provided string is a valid JSON representation.
*/
function is_json( $argument, $ignore_scalars = true ) {
if ( ! is_string( $argument ) || '' === $argument ) {
return false;
}
if ( $ignore_scalars && ! in_array( $argument[0], [ '{', '[' ], true ) ) {
return false;
}
json_decode( $argument, $assoc = true );
return json_last_error() === JSON_ERROR_NONE;
}
/**
* Parse known shell arrays included in the $assoc_args array.
*
* @param array $assoc_args Associative array of arguments.
* @param array $array_arguments Array of argument keys that should receive an
* array through the shell.
* @return array
*/
function parse_shell_arrays( $assoc_args, $array_arguments ) {
if ( empty( $assoc_args ) || empty( $array_arguments ) ) {
return $assoc_args;
}
foreach ( $array_arguments as $key ) {
if ( array_key_exists( $key, $assoc_args ) && is_json( $assoc_args[ $key ] ) ) {
$assoc_args[ $key ] = json_decode( $assoc_args[ $key ], $assoc = true );
}
}
return $assoc_args;
}
/**
* Describe a callable as a string.
*
* @param callable $callable The callable to describe.
* @return string String description of the callable.
*/
function describe_callable( $callable ) {
try {
if ( $callable instanceof Closure ) {
$reflection = new ReflectionFunction( $callable );
return "Closure in file {$reflection->getFileName()} at line {$reflection->getStartLine()}";
}
if ( is_array( $callable ) ) {
if ( is_object( $callable[0] ) ) {
return sprintf(
'%s->%s()',
get_class( $callable[0] ),
$callable[1]
);
}
return sprintf( '%s::%s()', $callable[0], $callable[1] );
}
return gettype( $callable );
} catch ( Exception $exception ) {
return 'Callable of unknown type';
}
}
/**
* Checks if the given class and method pair is a valid callable.
*
* This accommodates changes to `is_callable()` in PHP 8 that mean an array of a
* classname and instance method is no longer callable.
*
* @param array $pair The class and method pair to check.
* @return bool
*/
function is_valid_class_and_method_pair( $pair ) {
if ( ! is_array( $pair ) || 2 !== count( $pair ) ) {
return false;
}
if ( ! is_string( $pair[0] ) || ! is_string( $pair[1] ) ) {
return false;
}
if ( ! class_exists( $pair[0] ) ) {
return false;
}
if ( ! method_exists( $pair[0], $pair[1] ) ) {
return false;
}
return true;
}
/**
* Pluralizes a noun in a grammatically correct way.
*
* @param string $noun Noun to be pluralized. Needs to be in singular form.
* @param int|null $count Optional. Count of the nouns, to decide whether to
* pluralize. Will pluralize unconditionally if none
* provided.
* @return string Pluralized noun.
*/
function pluralize( $noun, $count = null ) {
if ( 1 === $count ) {
return $noun;
}
return Inflector::pluralize( $noun );
}
/**
* Return the detected database type.
*
* Can be either 'sqlite' (if in a WordPress installation with the SQLite drop-in),
* 'mysql', or 'mariadb'.
*
* @return string Database type.
*/
function get_db_type() {
static $db_type = null;
if ( defined( 'SQLITE_DB_DROPIN_VERSION' ) ) {
return 'sqlite';
}
if ( null !== $db_type ) {
return $db_type;
}
$db_type = 'mysql';
$binary = get_mysql_binary_path();
if ( '' !== $binary ) {
$result = Process::create( "$binary --version", null, null )->run();
if ( 0 === $result->return_code ) {
$db_type = ( false !== strpos( $result->stdout, 'MariaDB' ) ) ? 'mariadb' : 'mysql';
}
}
return $db_type;
}
/**
* Get the path to the MySQL or MariaDB binary.
*
* If the MySQL binary is provided by MariaDB (as determined by the version string),
* prefers the actual MariaDB binary.
*
* @since 2.12.0 Now also checks for MariaDB.
*
* @return string Path to the MySQL/MariaDB binary, or an empty string if not found.
*/
function get_mysql_binary_path() {
static $path = null;
if ( null !== $path ) {
return $path;
}
$path = '';
$mysql = Process::create( '/usr/bin/env which mysql', null, null )->run();
$mariadb = Process::create( '/usr/bin/env which mariadb', null, null )->run();
$mysql_binary = trim( $mysql->stdout );
$mariadb_binary = trim( $mariadb->stdout );
if ( 0 === $mysql->return_code ) {
if ( '' !== $mysql_binary ) {
$path = $mysql_binary;
$result = Process::create( "$mysql_binary --version", null, null )->run();
// It's actually MariaDB disguised as MySQL.
if ( 0 === $result->return_code && false !== strpos( $result->stdout, 'MariaDB' ) && 0 === $mariadb->return_code ) {
$path = $mariadb_binary;
}
}
} elseif ( 0 === $mariadb->return_code ) {
$path = $mariadb_binary;
}
return $path;
}
/**
* Get the version of the MySQL or MariaDB database.
*
* @since 2.12.0 Now also checks for MariaDB.
*
* @return string Version of the MySQL/MariaDB database,
* or an empty string if not found.
*/
function get_mysql_version() {
static $version = null;
if ( null !== $version ) {
return $version;
}
$db_type = get_db_type();
if ( 'sqlite' !== $db_type ) {
$result = Process::create( "/usr/bin/env $db_type --version", null, null )->run();
if ( 0 !== $result->return_code ) {
$version = '';
} else {
$version = trim( $result->stdout );
}
}
return $version;
}
/**
* Returns the correct `dump` command based on the detected database type.
*
* @return string The appropriate dump command.
*/
function get_sql_dump_command() {
return 'mariadb' === get_db_type() ? 'mariadb-dump' : 'mysqldump';
}
/**
* Returns the correct `check` command based on the detected database type.
*
* @return string The appropriate check command.
*/
function get_sql_check_command() {
return 'mariadb' === get_db_type() ? 'mariadb-check' : 'mysqlcheck';
}
/**
* Get the SQL modes of the MySQL session.
*
* @return string[] Array of SQL modes, or an empty array if they couldn't be
* read.
*/
function get_sql_modes() {
static $sql_modes = null;
if ( null !== $sql_modes ) {
return $sql_modes;
}
$binary = get_mysql_binary_path();
if ( '' === $binary ) {
$sql_modes = [];
} else {
$result = Process::create( "$binary --no-auto-rehash --batch --skip-column-names --execute=\"SELECT @@SESSION.sql_mode\"", null, null )->run();
if ( 0 !== $result->return_code ) {
$sql_modes = [];
} else {
$sql_modes = array_filter(
array_map(
'trim',
preg_split( "/\r\n|\n|\r/", $result->stdout )
)
);
}
}
return $sql_modes;
}
/**
* Get the WP-CLI cache directory.
*
* @return string
*/
function get_cache_dir() {
$home = get_home_dir();
return getenv( 'WP_CLI_CACHE_DIR' ) ? : "$home/.wp-cli/cache";
}
/**
* Check whether any input is passed to STDIN.
*
* @return bool
*/
function has_stdin() {
$handle = fopen( 'php://stdin', 'r' );
$read = array( $handle );
$write = null;
$except = null;
$streams = stream_select( $read, $write, $except, 0 );
fclose( $handle );
return 1 === $streams;
}
/**
* Return description of WP_CLI hooks used in @when tag
*
* @param string $hook Name of WP_CLI hook
*
* @return string|null
*/
function get_hook_description( $hook ) {
$events = [
'find_command_to_run_pre' => 'just before WP-CLI finds the command to run.',
'before_registering_contexts' => 'before the contexts are registered.',
'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.',
];
if ( array_key_exists( $hook, $events ) ) {
return $events[ $hook ];
}
return null;
}
/**
* Escape a value for CSV output.
*
* Values that start with the following characters are escaping with a single
* quote: =, +, -, @, TAB (0x09) and CR (0x0D).
*
* @param string $value Value to escape.
* @return string Escaped value.
*/
function escape_csv_value( $value ) {
if ( null === $value ) {
return '';
}
// Convert to string if not already
$value = (string) $value;
if (
in_array(
substr( $value, 0, 1 ),
[ '=', '+', '-', '@', "\t", "\r" ],
true
)
) {
return "'{$value}";
}
return $value;
}
error ) ) {
wp_die( $wpdb->error );
}
// Set the database table prefix and the format specifiers for database table columns.
$GLOBALS['table_prefix'] = $table_prefix;
wp_set_wpdb_vars();
// Start the WordPress object cache, or an external object cache if the drop-in is present.
wp_start_object_cache();
// Attach the default filters.
require ABSPATH . WPINC . '/default-filters.php';
// Initialize multisite if enabled.
if ( is_multisite() ) {
Utils\maybe_require( '4.6-alpha-37575', ABSPATH . WPINC . '/class-wp-site-query.php' );
Utils\maybe_require( '4.6-alpha-37896', ABSPATH . WPINC . '/class-wp-network-query.php' );
require ABSPATH . WPINC . '/ms-blogs.php';
require ABSPATH . WPINC . '/ms-settings.php';
} elseif ( ! defined( 'MULTISITE' ) ) {
define( 'MULTISITE', false );
}
register_shutdown_function( 'shutdown_action_hook' );
// Stop most of WordPress from being loaded if we just want the basics.
if ( SHORTINIT ) {
return false;
}
// Load the L10n library.
require_once ABSPATH . WPINC . '/l10n.php';
// WP-CLI: Permit Utils\wp_not_installed() to run on < WP 4.0
apply_filters( 'nocache_headers', [] );
// Run the installer if WordPress is not installed.
wp_not_installed();
// Load most of WordPress.
require ABSPATH . WPINC . '/class-wp-walker.php';
require ABSPATH . WPINC . '/class-wp-ajax-response.php';
require ABSPATH . WPINC . '/formatting.php';
require ABSPATH . WPINC . '/capabilities.php';
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-roles.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-role.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-user.php' );
require ABSPATH . WPINC . '/query.php';
Utils\maybe_require( '3.7-alpha-25139', ABSPATH . WPINC . '/date.php' );
require ABSPATH . WPINC . '/theme.php';
require ABSPATH . WPINC . '/class-wp-theme.php';
require ABSPATH . WPINC . '/template.php';
require ABSPATH . WPINC . '/user.php';
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-user-query.php' );
Utils\maybe_require( '4.0', ABSPATH . WPINC . '/session.php' );
require ABSPATH . WPINC . '/meta.php';
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-meta-query.php' );
Utils\maybe_require( '4.5-alpha-35776', ABSPATH . WPINC . '/class-wp-metadata-lazyloader.php' );
require ABSPATH . WPINC . '/general-template.php';
require ABSPATH . WPINC . '/link-template.php';
require ABSPATH . WPINC . '/author-template.php';
require ABSPATH . WPINC . '/post.php';
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-walker-page.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-walker-page-dropdown.php' );
Utils\maybe_require( '4.6-alpha-37890', ABSPATH . WPINC . '/class-wp-post-type.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-post.php' );
require ABSPATH . WPINC . '/post-template.php';
Utils\maybe_require( '3.6-alpha-23451', ABSPATH . WPINC . '/revision.php' );
Utils\maybe_require( '3.6-alpha-23451', ABSPATH . WPINC . '/post-formats.php' );
require ABSPATH . WPINC . '/post-thumbnail-template.php';
require ABSPATH . WPINC . '/category.php';
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-walker-category.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-walker-category-dropdown.php' );
require ABSPATH . WPINC . '/category-template.php';
require ABSPATH . WPINC . '/comment.php';
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-comment.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-comment-query.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-walker-comment.php' );
require ABSPATH . WPINC . '/comment-template.php';
require ABSPATH . WPINC . '/rewrite.php';
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-rewrite.php' );
require ABSPATH . WPINC . '/feed.php';
require ABSPATH . WPINC . '/bookmark.php';
require ABSPATH . WPINC . '/bookmark-template.php';
require ABSPATH . WPINC . '/kses.php';
require ABSPATH . WPINC . '/cron.php';
require ABSPATH . WPINC . '/deprecated.php';
require ABSPATH . WPINC . '/script-loader.php';
require ABSPATH . WPINC . '/taxonomy.php';
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-term.php' );
Utils\maybe_require( '4.6-alpha-37575', ABSPATH . WPINC . '/class-wp-term-query.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-tax-query.php' );
require ABSPATH . WPINC . '/update.php';
require ABSPATH . WPINC . '/canonical.php';
require ABSPATH . WPINC . '/shortcodes.php';
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/embed.php' );
require ABSPATH . WPINC . '/class-wp-embed.php';
require ABSPATH . WPINC . '/media.php';
Utils\maybe_require( '4.4-alpha-34903', ABSPATH . WPINC . '/class-wp-oembed-controller.php' );
require ABSPATH . WPINC . '/http.php';
require_once ABSPATH . WPINC . '/class-http.php';
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-http-streams.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-http-curl.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-http-proxy.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-http-cookie.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-http-encoding.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-http-response.php' );
Utils\maybe_require( '4.6-alpha-37438', ABSPATH . WPINC . '/class-wp-http-requests-response.php' );
require ABSPATH . WPINC . '/widgets.php';
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-widget.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/class-wp-widget-factory.php' );
require ABSPATH . WPINC . '/nav-menu.php';
require ABSPATH . WPINC . '/nav-menu-template.php';
require ABSPATH . WPINC . '/admin-bar.php';
Utils\maybe_require( '4.4-alpha-34928', ABSPATH . WPINC . '/rest-api.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/rest-api/class-wp-rest-server.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/rest-api/class-wp-rest-response.php' );
Utils\maybe_require( '4.4-beta4-35719', ABSPATH . WPINC . '/rest-api/class-wp-rest-request.php' );
// Load multisite-specific files.
if ( is_multisite() ) {
require ABSPATH . WPINC . '/ms-functions.php';
require ABSPATH . WPINC . '/ms-default-filters.php';
require ABSPATH . WPINC . '/ms-deprecated.php';
}
// Define constants that rely on the API to obtain the default value.
// Define must-use plugin directory constants, which may be overridden in the sunrise.php drop-in.
wp_plugin_directory_constants();
$symlinked_plugins_supported = function_exists( 'wp_register_plugin_realpath' );
if ( $symlinked_plugins_supported ) {
$GLOBALS['wp_plugin_paths'] = [];
}
// Load must-use plugins.
foreach ( wp_get_mu_plugins() as $mu_plugin ) {
include_once $mu_plugin;
}
unset( $mu_plugin );
// Load network activated plugins.
if ( is_multisite() ) {
foreach ( wp_get_active_network_plugins() as $network_plugin ) {
if ( $symlinked_plugins_supported ) {
wp_register_plugin_realpath( $network_plugin );
}
include_once $network_plugin;
}
unset( $network_plugin );
}
do_action( 'muplugins_loaded' );
if ( is_multisite() ) {
ms_cookie_constants();
}
// Define constants after multisite is loaded. Cookie-related constants may be overridden in ms_network_cookies().
wp_cookie_constants();
// Define and enforce our SSL constants.
wp_ssl_constants();
// Create common globals.
require ABSPATH . WPINC . '/vars.php';
// Make taxonomies and posts available to plugins and themes.
// @plugin authors: warning: these get registered again on the init hook.
create_initial_taxonomies();
create_initial_post_types();
// Register the default theme directory root
register_theme_directory( get_theme_root() );
// Load active plugins.
foreach ( wp_get_active_and_valid_plugins() as $plugin ) {
if ( $symlinked_plugins_supported ) {
wp_register_plugin_realpath( $plugin );
}
include_once $plugin;
}
unset( $plugin, $symlinked_plugins_supported );
// Load pluggable functions.
require ABSPATH . WPINC . '/pluggable.php';
require ABSPATH . WPINC . '/pluggable-deprecated.php';
// Set internal encoding.
wp_set_internal_encoding();
// Run wp_cache_postload() if object cache is enabled and the function exists.
if ( WP_CACHE && function_exists( 'wp_cache_postload' ) ) {
wp_cache_postload();
}
do_action( 'plugins_loaded' );
// Define constants which affect functionality if not already defined.
wp_functionality_constants();
if ( ! function_exists( 'get_magic_quotes_gpc' ) ) {
// Provide compat fallback for newer PHP version (7.4+) on older WordPress core versions.
function get_magic_quotes_gpc() {
return false;
}
}
// Add magic quotes and set up $_REQUEST ( $_GET + $_POST )
wp_magic_quotes();
do_action( 'sanitize_comment_cookies' );
/**
* WordPress Query object
* @since 2.0.0
* @global object $wp_the_query
*/
$GLOBALS['wp_the_query'] = new WP_Query();
/**
* Holds the reference to @see $wp_the_query
* Use this global for WordPress queries
* @since 1.5.0
* @global object $wp_query
*/
$GLOBALS['wp_query'] = $GLOBALS['wp_the_query'];
/**
* Holds the WordPress Rewrite object for creating pretty URLs
* @since 1.5.0
* @global object $wp_rewrite
*/
$GLOBALS['wp_rewrite'] = new WP_Rewrite();
/**
* WordPress Object
* @since 2.0.0
* @global object $wp
*/
$GLOBALS['wp'] = new WP();
/**
* WordPress Widget Factory Object
* @since 2.8.0
* @global object $wp_widget_factory
*/
$GLOBALS['wp_widget_factory'] = new WP_Widget_Factory();
/**
* WordPress User Roles
* @since 2.0.0
* @global object $wp_roles
*/
$GLOBALS['wp_roles'] = new WP_Roles();
do_action( 'setup_theme' );
// Define the template related constants.
wp_templating_constants();
// Load the default text localization domain.
load_default_textdomain();
$locale = get_locale();
$locale_file = WP_LANG_DIR . "/$locale.php";
if ( ( 0 === validate_file( $locale ) ) && is_readable( $locale_file ) ) {
require $locale_file;
}
unset( $locale_file );
// Pull in locale data after loading text domain.
require_once ABSPATH . WPINC . '/locale.php';
/**
* WordPress Locale object for loading locale domain date and various strings.
* @since 2.1.0
* @global object $wp_locale
*/
$GLOBALS['wp_locale'] = new WP_Locale();
// Load the functions for the active theme, for both parent and child theme if applicable.
// phpcs:disable WordPress.WP.DiscouragedConstants.STYLESHEETPATHUsageFound,WordPress.WP.DiscouragedConstants.TEMPLATEPATHUsageFound
global $pagenow;
if ( ! defined( 'WP_INSTALLING' ) || 'wp-activate.php' === $pagenow ) {
if ( TEMPLATEPATH !== STYLESHEETPATH && file_exists( STYLESHEETPATH . '/functions.php' ) ) {
include STYLESHEETPATH . '/functions.php';
}
if ( file_exists( TEMPLATEPATH . '/functions.php' ) ) {
include TEMPLATEPATH . '/functions.php';
}
}
// phpcs:enable WordPress.WP.DiscouragedConstants
do_action( 'after_setup_theme' );
// Set up current user.
$GLOBALS['wp']->init();
/**
* Most of WP is loaded at this stage, and the user is authenticated. WP continues
* to load on the init hook that follows (e.g. widgets), and many plugins instantiate
* themselves on it for all sorts of reasons (e.g. they need a user, a taxonomy, etc.).
*
* If you wish to plug an action once WP is loaded, use the wp_loaded hook below.
*/
do_action( 'init' );
// Check site status.
# if ( is_multisite() ) { // WP-CLI
if ( is_multisite() && ! defined( 'WP_INSTALLING' ) ) {
$file = ms_site_check();
if ( true !== $file ) {
require $file;
die();
}
unset( $file );
}
/**
* This hook is fired once WP, all plugins, and the theme are fully loaded and instantiated.
*
* AJAX requests should use wp-admin/admin-ajax.php. admin-ajax.php can handle requests for
* users not logged in.
*
* @link https://developer.wordpress.org/plugins/javascript/ajax/
*
* @since 3.0.0
*/
do_action( 'wp_loaded' );
]
* : Render output in a particular format.
* ---
* default: yaml
* options:
* - yaml
* - json
* - var_export
* ---
*
* ## EXAMPLES
*
* # List all available aliases.
* $ wp cli alias list
* ---
* @all: Run command against every registered alias.
* @prod:
* ssh: runcommand@runcommand.io~/webapps/production
* @dev:
* ssh: vagrant@192.168.50.10/srv/www/runcommand.dev
* @both:
* - @prod
* - @dev
*
* @subcommand list
*/
public function list_( $args, $assoc_args ) {
WP_CLI::print_value( WP_CLI::get_runner()->aliases, $assoc_args );
}
/**
* Gets the value for an alias.
*
* ## OPTIONS
*
*
* : Key for the alias.
*
* ## EXAMPLES
*
* # Get alias.
* $ wp cli alias get @prod
* ssh: dev@somedeve.env:12345/home/dev/
*/
public function get( $args, $assoc_args ) {
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}" );
}
}
/**
* Creates an alias.
*
* ## OPTIONS
*
*
* : Key for the alias.
*
* [--set-user=]
* : Set user for alias.
*
* [--set-url=]
* : Set url for alias.
*
* [--set-path=]
* : Set path for alias.
*
* [--set-ssh=]
* : Set ssh for alias.
*
* [--set-http=]
* : Set http for alias.
*
* [--grouping=]
* : For grouping multiple aliases.
*
* [--config=]
* : Config file to be considered for operations.
* ---
* default: global
* options:
* - global
* - project
* ---
*
* ## EXAMPLES
*
* # Add alias to global config.
* $ wp cli alias add @prod --set-ssh=login@host --set-path=/path/to/wordpress/install/ --set-user=wpcli
* Success: Added '@prod' alias.
*
* # Add alias to project config.
* $ wp cli alias add @prod --set-ssh=login@host --set-path=/path/to/wordpress/install/ --set-user=wpcli --config=project
* Success: Added '@prod' alias.
*
* # Add group of aliases.
* $ wp cli alias add @multiservers --grouping=servera,serverb
* Success: Added '@multiservers' alias.
*/
public function add( $args, $assoc_args ) {
$config = ( ! empty( $assoc_args['config'] ) ? $assoc_args['config'] : 'global' );
list( $config_path, $aliases ) = $this->get_aliases_data( $config, '', true );
$this->validate_config_file( $config_path );
$alias = $args[0];
$grouping = Utils\get_flag_value( $assoc_args, 'grouping' );
$this->validate_input( $assoc_args, $grouping );
if ( isset( $aliases[ $alias ] ) ) {
WP_CLI::error( "Key '{$alias}' exists already." );
}
if ( null === $grouping ) {
$aliases = $this->build_aliases( $aliases, $alias, $assoc_args, false );
} else {
$aliases = $this->build_aliases( $aliases, $alias, $assoc_args, true, $grouping );
}
$this->process_aliases( $aliases, $alias, $config_path, 'Added' );
}
/**
* Deletes an alias.
*
* ## OPTIONS
*
*
* : Key for the alias.
*
* [--config=]
* : Config file to be considered for operations.
* ---
* options:
* - global
* - project
* ---
*
* ## EXAMPLES
*
* # Delete alias.
* $ wp cli alias delete @prod
* Success: Deleted '@prod' alias.
*
* # Delete project alias.
* $ wp cli alias delete @prod --config=project
* Success: Deleted '@prod' alias.
*/
public function delete( $args, $assoc_args ) {
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' );
}
/**
* Updates an alias.
*
* ## OPTIONS
*
*
* : Key for the alias.
*
* [--set-user=]
* : Set user for alias.
*
* [--set-url=]
* : Set url for alias.
*
* [--set-path=]
* : Set path for alias.
*
* [--set-ssh=]
* : Set ssh for alias.
*
* [--set-http=]
* : Set http for alias.
*
* [--grouping=]
* : For grouping multiple aliases.
*
* [--config=]
* : Config file to be considered for operations.
* ---
* options:
* - global
* - project
* ---
*
* ## EXAMPLES
*
* # Update alias.
* $ wp cli alias update @prod --set-user=newuser --set-path=/new/path/to/wordpress/install/
* Success: Updated 'prod' alias.
*
* # Update project alias.
* $ wp cli alias update @prod --set-user=newuser --set-path=/new/path/to/wordpress/install/ --config=project
* Success: Updated 'prod' alias.
*/
public function update( $args, $assoc_args ) {
$config = ( ! empty( $assoc_args['config'] ) ? $assoc_args['config'] : '' );
$alias = $args[0];
$grouping = Utils\get_flag_value( $assoc_args, 'grouping' );
list( $config_path, $aliases ) = $this->get_aliases_data( $config, $alias, true );
$this->validate_config_file( $config_path );
$this->validate_input( $assoc_args, $grouping );
if ( empty( $aliases[ $alias ] ) ) {
WP_CLI::error( "No alias found with key '{$alias}'." );
}
if ( null === $grouping ) {
$aliases = $this->build_aliases( $aliases, $alias, $assoc_args, false, '', true );
} else {
$aliases = $this->build_aliases( $aliases, $alias, $assoc_args, true, $grouping, true );
}
$this->process_aliases( $aliases, $alias, $config_path, 'Updated' );
}
/**
* Check whether an alias is a group.
*
* ## OPTIONS
*
*
* : Key for the alias.
*
* ## EXAMPLES
*
* # Checks whether the alias is a group; exit status 0 if it is, otherwise 1.
* $ wp cli alias is-group @prod
* $ echo $?
* 1
*
* @subcommand is-group
*/
public function is_group( $args, $assoc_args = array() ) {
$alias = $args[0];
$aliases = WP_CLI::get_runner()->aliases;
if ( empty( $aliases[ $alias ] ) ) {
WP_CLI::error( "No alias found with key '{$alias}'." );
}
// how do we know the alias is a group?
// + array keys are numeric
// + array values begin with '@'
$first_item = $aliases[ $alias ];
$first_item_key = key( $first_item );
$first_item_value = $first_item[ $first_item_key ];
if ( is_numeric( $first_item_key ) && substr( $first_item_value, 0, 1 ) === '@' ) {
WP_CLI::halt( 0 );
}
WP_CLI::halt( 1 );
}
/**
* 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.
* @param bool $create_config_file Optional. If a config file doesn't exist,
* should it be created? Defaults to false.
*
* @return array Config Path and Aliases in it.
* @throws ExitException
*/
private function get_aliases_data( $config, $alias, $create_config_file = false ) {
$global_config_path = WP_CLI::get_runner()->get_global_config_path( $create_config_file );
$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 [ $config_path, $aliases ];
}
/**
* Check if the config file exists and is writable.
*
* @param string $config_path Path to config file.
*
* @return void
*/
private function validate_config_file( $config_path ) {
if ( ! file_exists( $config_path ) || ! is_writable( $config_path ) ) {
WP_CLI::error( "Config file does not exist: {$config_path}" );
}
}
/**
* Return aliases array.
*
* @param array $aliases Current aliases data.
* @param string $alias Name of alias.
* @param array $assoc_args Associative arguments.
* @param bool $is_grouping Check if its a grouping operation.
* @param string $grouping Grouping value.
* @param bool $is_update Is this an update operation?
*
* @return mixed
*/
private function build_aliases( $aliases, $alias, $assoc_args, $is_grouping, $grouping = '', $is_update = false ) {
$alias = $this->normalize_alias( $alias );
if ( $is_grouping ) {
$valid_assoc_args = [ '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;
}
}
}
} elseif ( ! 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;
}
/**
* Validate input of passed arguments.
*
* @param array $assoc_args Arguments array.
* @param string $grouping Grouping argument value.
*
* @throws ExitException
*/
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 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 ExitException
*/
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.' );
}
}
/**
* Save aliases data to config file.
*
* @param array $aliases Current aliases data.
* @param string $alias Name of alias.
* @param string $config_path Path to config file.
* @param string $operation Current operation string fro message.
*/
private function process_aliases( $aliases, $alias, $config_path, $operation = '' ) {
$alias = $this->normalize_alias( $alias );
// 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." );
}
}
/**
* Normalize the alias to an expected format.
*
* - Add @ if not present.
*
* @param string $alias Name of alias.
*/
private function normalize_alias( $alias ) {
// Check if the alias starts with the @.
// See: https://github.com/wp-cli/wp-cli/issues/5391
if ( strpos( $alias, '@' ) !== 0 ) {
$alias = '@' . ltrim( $alias, '@' );
}
return $alias;
}
}
is_enabled() ) {
WP_CLI::error( 'Cache directory does not exist.' );
}
$cache->clear();
WP_CLI::success( 'Cache cleared.' );
}
/**
* Prunes the internal cache.
*
* Removes all cached files except for the newest version of each one.
*
* ## EXAMPLES
*
* $ wp cli cache prune
* Success: Cache pruned.
*
* @subcommand prune
*/
public function cache_prune() {
$cache = WP_CLI::get_cache();
if ( ! $cache->is_enabled() ) {
WP_CLI::error( 'Cache directory does not exist.' );
}
$cache->prune();
WP_CLI::success( 'Cache pruned.' );
}
}
$command->get_name(),
'description' => $command->get_shortdesc(),
'longdesc' => $command->get_longdesc(),
'hook' => $command->get_hook(),
];
foreach ( $command->get_subcommands() as $subcommand ) {
$dump['subcommands'][] = $this->command_to_array( $subcommand );
}
if ( empty( $dump['subcommands'] ) ) {
$dump['synopsis'] = (string) $command->get_synopsis();
}
return $dump;
}
/**
* Prints WP-CLI version.
*
* ## EXAMPLES
*
* # Display CLI version.
* $ wp cli version
* WP-CLI 0.24.1
*/
public function version() {
WP_CLI::line( 'WP-CLI ' . WP_CLI_VERSION );
}
/**
* Prints 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://make.wordpress.org/cli/handbook/references/config/) for more details on global
* and project config YAML files.
*
* ## OPTIONS
*
* [--format=]
* : Render output in a particular format.
* ---
* default: list
* options:
* - list
* - json
* ---
*
* ## EXAMPLES
*
* # Display various data about the CLI environment.
* $ wp cli info
* OS: Linux 4.10.0-42-generic #46~16.04.1-Ubuntu SMP Mon Dec 4 15:57:59 UTC 2017 x86_64
* Shell: /usr/bin/zsh
* PHP binary: /usr/bin/php
* PHP version: 7.1.12-1+ubuntu16.04.1+deb.sury.org+1
* php.ini used: /etc/php/7.1/cli/php.ini
* WP-CLI root dir: phar://wp-cli.phar
* WP-CLI packages dir: /home/person/.wp-cli/packages/
* WP-CLI global config:
* WP-CLI project config:
* WP-CLI version: 1.5.0
*/
public function info( $_, $assoc_args ) {
// 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' );
}
$php_bin = Utils\get_php_binary();
$runner = WP_CLI::get_runner();
$packages_dir = $runner->get_packages_dir_path();
if ( ! is_dir( $packages_dir ) ) {
$packages_dir = null;
}
if ( Utils\get_flag_value( $assoc_args, 'format' ) === 'json' ) {
$info = [
'system_os' => $system_os,
'shell' => $shell,
'php_binary_path' => $php_bin,
'php_version' => PHP_VERSION,
'php_ini_used' => get_cfg_var( 'cfg_file_path' ),
'mysql_binary_path' => Utils\get_mysql_binary_path(),
'mysql_version' => Utils\get_mysql_version(),
'sql_modes' => Utils\get_sql_modes(),
'wp_cli_dir_path' => WP_CLI_ROOT,
'wp_cli_vendor_path' => WP_CLI_VENDOR_DIR,
'wp_cli_phar_path' => defined( 'WP_CLI_PHAR_PATH' ) ? WP_CLI_PHAR_PATH : '',
'wp_cli_packages_dir_path' => $packages_dir,
'wp_cli_cache_dir_path' => Utils\get_cache_dir(),
'global_config_path' => $runner->global_config_path,
'project_config_path' => $runner->project_config_path,
'wp_cli_version' => WP_CLI_VERSION,
];
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( "MySQL binary:\t" . Utils\get_mysql_binary_path() );
WP_CLI::line( "MySQL version:\t" . Utils\get_mysql_version() );
WP_CLI::line( "SQL modes:\t" . implode( ',', Utils\get_sql_modes() ) );
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 cache dir:\t" . Utils\get_cache_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 );
}
}
/**
* Checks 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=]
* : Prints the value of a single field for each update.
*
* [--fields=]
* : Limit the output to specific object fields. Defaults to version,update_type,package_url,status,requires_php.
*
* [--format=]
* : Render output in a particular format.
* ---
* default: table
* options:
* - table
* - csv
* - json
* - count
* - yaml
* ---
*
* ## EXAMPLES
*
* # Check for update.
* $ wp cli check-update
* Success: WP-CLI is at the latest version.
*
* # Check for update and new version is available.
* $ wp cli check-update
* +---------+-------------+-------------------------------------------------------------------------------+
* | version | update_type | package_url |
* +---------+-------------+-------------------------------------------------------------------------------+
* | 0.24.1 | patch | https://github.com/wp-cli/wp-cli/releases/download/v0.24.1/wp-cli-0.24.1.phar |
* +---------+-------------+-------------------------------------------------------------------------------+
*
* @subcommand check-update
*/
public function check_update( $_, $assoc_args ) {
$updates = $this->get_updates( $assoc_args );
if ( $updates ) {
$formatter = new Formatter(
$assoc_args,
[ 'version', 'update_type', 'package_url', 'status', 'requires_php' ]
);
$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." );
}
}
/**
* Updates WP-CLI to the latest release.
*
* Default behavior is to check the releases API for the newest stable
* version, and prompt if one is available.
*
* Use `--stable` to install or reinstall the latest stable version.
*
* Use `--nightly` to install the latest built version of the master branch.
* While not recommended for production, nightly contains the latest and
* greatest, and should be stable enough for development and staging
* environments.
*
* Only works for the Phar installation mechanism.
*
* ## OPTIONS
*
* [--patch]
* : Only perform patch updates.
*
* [--minor]
* : Only perform minor updates.
*
* [--major]
* : Only perform major updates.
*
* [--stable]
* : Update to the latest stable release. Skips update check.
*
* [--nightly]
* : Update to the latest built version of the master branch. Potentially unstable.
*
* [--yes]
* : Do not prompt for confirmation.
*
* [--insecure]
* : Retry without certificate validation if TLS handshake fails. Note: This makes the request vulnerable to a MITM attack.
*
* ## EXAMPLES
*
* # Update CLI.
* $ wp cli update
* You are currently using WP-CLI version 0.24.0. Would you like to update to 0.24.1? [y/n] y
* Downloading from https://github.com/wp-cli/wp-cli/releases/download/v0.24.1/wp-cli-0.24.1.phar...
* New version works. Proceeding to replace.
* Success: Updated WP-CLI to 0.24.1.
*/
public function update( $_, $assoc_args ) {
if ( ! Utils\inside_phar() ) {
WP_CLI::error( 'You can only self-update Phar files.' );
}
$old_phar = realpath( $_SERVER['argv'][0] );
if ( ! is_writable( $old_phar ) ) {
WP_CLI::error( sprintf( '%s is not writable by current user.', $old_phar ) );
} elseif ( ! is_writable( dirname( $old_phar ) ) ) {
WP_CLI::error( sprintf( '%s is not writable by current user.', dirname( $old_phar ) ) );
}
if ( Utils\get_flag_value( $assoc_args, 'nightly' ) ) {
WP_CLI::confirm( sprintf( 'You are currently using WP-CLI version %s. Would you like to update to the latest nightly version?', WP_CLI_VERSION ), $assoc_args );
$download_url = 'https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli-nightly.phar';
$md5_url = 'https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli-nightly.phar.md5';
$sha512_url = 'https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli-nightly.phar.sha512';
} elseif ( Utils\get_flag_value( $assoc_args, 'stable' ) ) {
WP_CLI::confirm( sprintf( 'You are currently using WP-CLI version %s. Would you like to update to the latest stable release?', WP_CLI_VERSION ), $assoc_args );
$download_url = 'https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar';
$md5_url = 'https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar.md5';
$sha512_url = 'https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar.sha512';
} else {
$updates = $this->get_updates( $assoc_args );
$newest = $this->array_find(
$updates,
static function ( $update ) {
return 'available' === $update['status'];
}
);
if ( ! $newest ) {
$update_type = $this->get_update_type_str( $assoc_args );
WP_CLI::success( "WP-CLI is at the latest{$update_type}version." );
return;
}
WP_CLI::confirm( sprintf( 'You have version %s. Would you like to update to %s?', WP_CLI_VERSION, $newest['version'] ), $assoc_args );
$download_url = $newest['package_url'];
$md5_url = str_replace( '.phar', '.phar.md5', $download_url );
$sha512_url = str_replace( '.phar', '.phar.sha512', $download_url );
}
WP_CLI::log( sprintf( 'Downloading from %s...', $download_url ) );
$temp = Utils\get_temp_dir() . uniqid( 'wp_', true ) . '.phar';
$headers = [];
$options = [
'timeout' => 600, // 10 minutes ought to be enough for everybody.
'filename' => $temp,
'insecure' => (bool) Utils\get_flag_value( $assoc_args, 'insecure', false ),
];
Utils\http_request( 'GET', $download_url, null, $headers, $options );
unset( $options['filename'] );
$this->validate_hashes( $temp, $sha512_url, $md5_url );
$allow_root = WP_CLI::get_runner()->config['allow-root'] ? '--allow-root' : '';
$php_binary = Utils\get_php_binary();
$process = Process::create( "{$php_binary} $temp --info {$allow_root}" );
$result = $process->run();
if ( 0 !== $result->return_code || false === stripos( $result->stdout, 'WP-CLI version' ) ) {
$multi_line = explode( PHP_EOL, $result->stderr );
WP_CLI::error_multi_line( $multi_line );
WP_CLI::error( 'The downloaded PHAR is broken, try running wp cli update again.' );
}
WP_CLI::log( 'New version works. Proceeding to replace.' );
$mode = fileperms( $old_phar ) & 511;
if ( false === chmod( $temp, $mode ) ) {
WP_CLI::error( sprintf( 'Cannot chmod %s.', $temp ) );
}
class_exists( '\cli\Colors' ); // This autoloads \cli\Colors - after we move the file we no longer have access to this class.
if ( false === rename( $temp, $old_phar ) ) {
WP_CLI::error( sprintf( 'Cannot move %s to %s', $temp, $old_phar ) );
}
if ( Utils\get_flag_value( $assoc_args, 'nightly', false ) ) {
$updated_version = 'the latest nightly release';
} elseif ( Utils\get_flag_value( $assoc_args, 'stable', false ) ) {
$updated_version = 'the latest stable release';
} else {
$updated_version = isset( $newest['version'] ) ? $newest['version'] : '';
}
WP_CLI::success( sprintf( 'Updated WP-CLI to %s.', $updated_version ) );
}
/**
* @param string $file Release file path.
* @param string $sha512_url URL to sha512 hash.
* @param string $md5_url URL to md5 hash.
*
* @return void
* @throws \WP_CLI\ExitException
*/
private function validate_hashes( $file, $sha512_url, $md5_url ) {
$algos = [
'sha512' => $sha512_url,
'md5' => $md5_url,
];
foreach ( $algos as $algo => $url ) {
$response = Utils\http_request( 'GET', $url );
if ( '20' !== substr( $response->status_code, 0, 2 ) ) {
WP_CLI::log( "Couldn't access $algo hash for release (HTTP code {$response->status_code})." );
continue;
}
$file_hash = hash_file( $algo, $file );
$release_hash = trim( $response->body );
if ( $file_hash === $release_hash ) {
WP_CLI::log( "$algo hash verified: $release_hash" );
return;
} else {
WP_CLI::error( "$algo hash for download ($file_hash) is different than the release hash ($release_hash)." );
}
}
WP_CLI::error( 'Release hash verification failed.' );
}
/**
* Returns update information.
*/
private function get_updates( $assoc_args ) {
$url = 'https://api.github.com/repos/wp-cli/wp-cli/releases?per_page=100';
$options = [
'timeout' => 30,
'insecure' => (bool) Utils\get_flag_value( $assoc_args, 'insecure', false ),
];
$headers = [
'Accept' => 'application/json',
];
$github_token = getenv( 'GITHUB_TOKEN' );
if ( false !== $github_token ) {
$headers['Authorization'] = 'token ' . $github_token;
}
$response = Utils\http_request( 'GET', $url, null, $headers, $options );
if ( ! $response->success || 200 !== $response->status_code ) {
WP_CLI::error( sprintf( 'Failed to get latest version (HTTP code %d).', $response->status_code ) );
}
$release_data = json_decode( $response->body );
$updates = [
'major' => false,
'minor' => false,
'patch' => false,
];
$updates_unavailable = [];
foreach ( $release_data as $release ) {
// Get rid of leading "v" if there is one set.
$release_version = $release->tag_name;
if ( 'v' === substr( $release_version, 0, 1 ) ) {
$release_version = ltrim( $release_version, 'v' );
}
$update_type = Utils\get_named_sem_ver( $release_version, WP_CLI_VERSION );
if ( ! $update_type ) {
continue;
}
// Release is older than one we already have on file.
if ( ! empty( $updates[ $update_type ] ) && ! Comparator::greaterThan( $release_version, $updates[ $update_type ]['version'] ) ) {
continue;
}
$package_url = null;
$manifest_data = null;
foreach ( $release->assets as $asset ) {
if ( ! isset( $asset->browser_download_url ) ) {
continue;
}
if ( substr( $asset->browser_download_url, - strlen( '.phar' ) ) === '.phar' ) {
$package_url = $asset->browser_download_url;
}
// The manifest.json file, if it exists, contains information about PHP version requirements and similar.
if ( substr( $asset->browser_download_url, - strlen( 'manifest.json' ) ) === 'manifest.json' ) {
$response = Utils\http_request( 'GET', $asset->browser_download_url, null, $headers, $options );
if ( $response->success ) {
$manifest_data = json_decode( $response->body );
}
}
}
if ( ! $package_url ) {
continue;
}
// Release requires a newer version of PHP.
if (
isset( $manifest_data->requires_php ) &&
! Comparator::greaterThanOrEqualTo( PHP_VERSION, $manifest_data->requires_php )
) {
$updates_unavailable[] = [
'version' => $release_version,
'update_type' => $update_type,
'package_url' => $release->assets[0]->browser_download_url,
'status' => 'unavailable',
'requires_php' => $manifest_data->requires_php,
];
} else {
$updates[ $update_type ] = [
'version' => $release_version,
'update_type' => $update_type,
'package_url' => $release->assets[0]->browser_download_url,
'status' => 'available',
'requires_php' => isset( $manifest_data->requires_php ) ? $manifest_data->requires_php : '',
];
}
}
foreach ( $updates as $type => $value ) {
if ( empty( $value ) ) {
unset( $updates[ $type ] );
}
}
foreach ( [ 'major', 'minor', 'patch' ] as $type ) {
if ( true === Utils\get_flag_value( $assoc_args, $type ) ) {
return ! empty( $updates[ $type ] ) ? [ $updates[ $type ] ] : false;
}
}
if ( empty( $updates ) && preg_match( '#-alpha-(.+)$#', WP_CLI_VERSION, $matches ) ) {
$version_url = 'https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/NIGHTLY_VERSION';
$response = Utils\http_request( 'GET', $version_url, null, [], $options );
if ( ! $response->success || 200 !== $response->status_code ) {
WP_CLI::error( sprintf( 'Failed to get current nightly version (HTTP code %d)', $response->status_code ) );
}
$nightly_version = trim( $response->body );
if ( WP_CLI_VERSION !== $nightly_version ) {
$manifest_data = null;
// The manifest.json file, if it exists, contains information about PHP version requirements and similar.
$response = Utils\http_request( 'GET', 'https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli-nightly.manifest.json', null, $headers, $options );
if ( $response->success ) {
$manifest_data = json_decode( $response->body );
}
// Release requires a newer version of PHP.
if (
isset( $manifest_data->requires_php ) &&
! Comparator::greaterThanOrEqualTo( PHP_VERSION, $manifest_data->requires_php )
) {
$updates_unavailable[] = [
'version' => $nightly_version,
'update_type' => 'nightly',
'package_url' => 'https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli-nightly.phar',
'status' => 'unvailable',
'requires_php' => $manifest_data->requires_php,
];
} else {
$updates['nightly'] = [
'version' => $nightly_version,
'update_type' => 'nightly',
'package_url' => 'https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli-nightly.phar',
'status' => 'available',
'requires_php' => isset( $manifest_data->requires_php ) ? $manifest_data->requires_php : '',
];
}
}
}
return array_merge( $updates_unavailable, array_values( $updates ) );
}
/**
* Returns the the first element of the passed array for which the
* callback returns true.
*
* Polyfill for the `array_find()` function introduced in PHP 8.3.
*
* @param array $arr Array to search.
* @param callable $callback The callback function for each element in the array.
* @return mixed First array element for which the callback returns true, null otherwise.
*/
private function array_find( $arr, $callback ) {
if ( function_exists( '\array_find' ) ) {
// phpcs:ignore PHPCompatibility.FunctionUse.NewFunctions.array_findFound
return \array_find( $arr, $callback );
}
foreach ( $arr as $key => $value ) {
if ( $callback( $value, $key ) ) {
return $value;
}
}
return null;
}
/**
* Dumps the list of global parameters, as JSON or in var_export format.
*
* ## OPTIONS
*
* [--with-values]
* : Display current values also.
*
* [--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' => '=',
* 'file' => '',
* 'synopsis' => '',
* 'default' => NULL,
* 'multiple' => false,
* 'desc' => 'Path to the WordPress files.',
* ),
* 'url' =>
* array (
*
* @subcommand param-dump
*/
public function param_dump( $_, $assoc_args ) {
$spec = WP_CLI::get_configurator()->get_spec();
if ( 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' === Utils\get_flag_value( $assoc_args, 'format' ) ) {
var_export( $spec );
} else {
echo json_encode( $spec );
}
}
/**
* Dumps the list of installed commands, as JSON.
*
* ## EXAMPLES
*
* # Dump the list of installed commands.
* $ wp cli cmd-dump
* {"name":"wp","description":"Manage WordPress through the command-line.","longdesc":"\n\n## GLOBAL PARAMETERS\n\n --path=\n Path to the WordPress files.\n\n --ssh=\n Perform operation against a remote server over SSH (or a container using scheme of "docker" or "docker-compose").\n\n --url=\n Pretend request came from given URL. In multisite, this argument is how the target site is specified. \n\n --user=\n
*
* @subcommand cmd-dump
*/
public function cmd_dump() {
echo json_encode( $this->command_to_array( WP_CLI::get_root_command() ) );
}
/**
* Generates tab completion strings.
*
* ## OPTIONS
*
* --line=
* : The current command line to be executed.
*
* --point=
* : The index to the current cursor position relative to the beginning of the command.
*
* ## EXAMPLES
*
* # Generate tab completion strings.
* $ wp cli completions --line='wp eva' --point=100
* eval
* eval-file
*/
public function completions( $_, $assoc_args ) {
$line = substr( $assoc_args['line'], 0, $assoc_args['point'] );
$compl = new Completions( $line );
$compl->render();
}
/**
* Get a string representing the type of update being checked for.
*/
private function get_update_type_str( $assoc_args ) {
$update_type = ' ';
foreach ( [ 'major', 'minor', 'patch' ] as $type ) {
if ( true === Utils\get_flag_value( $assoc_args, $type ) ) {
$update_type = ' ' . $type . ' ';
break;
}
}
return $update_type;
}
/**
* 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
* ...
* : 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
*
* # Install a WP-CLI package if not already installed
* $ if ! $(wp cli has-command doctor); then wp package install wp-cli/doctor-command; fi
* Installing package wp-cli/doctor-command (dev-main || dev-master || dev-trunk)
* Updating /home/person/.wp-cli/packages/composer.json to require the package...
* Using Composer to install the package...
* ---
* Success: Package installed.
*
* @subcommand has-command
*
* @when after_wp_load
*/
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 );
}
}
...]
* : Get help on a specific command.
*
* ## EXAMPLES
*
* # get help for `core` command
* wp help core
*
* # get help for `core download` subcommand
* wp help core download
*/
public function __invoke( $args, $assoc_args ) {
$r = WP_CLI::get_runner()->find_command_to_run( $args );
if ( is_array( $r ) ) {
list( $command ) = $r;
self::show_help( $command );
exit;
}
}
private static function show_help( $command ) {
$out = self::get_initial_markdown( $command );
// Remove subcommands if in columns - will wordwrap separately.
$subcommands = '';
$column_subpattern = '[ \t]+[^\t]+\t+';
if ( preg_match( '/(^## SUBCOMMANDS[^\n]*\n+' . $column_subpattern . '.+?)(?:^##|\z)/ms', $out, $matches, PREG_OFFSET_CAPTURE ) ) {
$subcommands = $matches[1][0];
$subcommands_header = "## SUBCOMMANDS\n";
$out = substr_replace( $out, $subcommands_header, $matches[1][1], strlen( $subcommands ) );
}
$out .= self::parse_reference_links( $command->get_longdesc() );
// Definition lists.
$out = preg_replace_callback( '/([^\n]+)\n: (.+?)(\n\n|$)/s', [ __CLASS__, 'rewrap_param_desc' ], $out );
// Ensure lines with no leading whitespace that aren't section headers are indented.
$out = preg_replace( '/^((?! |\t|##).)/m', "\t$1", $out );
$tab = str_repeat( ' ', 2 );
// Need to de-tab for wordwrapping to work properly.
$out = str_replace( "\t", $tab, $out );
$wordwrap_width = Shell::columns();
// Wordwrap with indent.
$out = preg_replace_callback(
'/^( *)([^\n]+)\n/m',
function ( $matches ) use ( $wordwrap_width ) {
return $matches[1] . str_replace( "\n", "\n{$matches[1]}", wordwrap( $matches[2], $wordwrap_width - strlen( $matches[1] ) ) ) . "\n";
},
$out
);
if ( $subcommands ) {
// Wordwrap with column indent.
$subcommands = preg_replace_callback(
'/^(' . $column_subpattern . ')([^\n]+)\n/m',
function ( $matches ) use ( $wordwrap_width, $tab ) {
// Need to de-tab for wordwrapping to work properly.
$matches[1] = str_replace( "\t", $tab, $matches[1] );
$matches[2] = str_replace( "\t", $tab, $matches[2] );
$padding_len = strlen( $matches[1] );
$padding = str_repeat( ' ', $padding_len );
return $matches[1] . str_replace( "\n", "\n$padding", wordwrap( $matches[2], $wordwrap_width - $padding_len ) ) . "\n";
},
$subcommands
);
// Put subcommands back.
$out = str_replace( $subcommands_header, $subcommands, $out );
}
// Section headers.
$out = preg_replace( '/^## ([A-Z ]+)/m', WP_CLI::colorize( '%9\1%n' ), $out );
self::pass_through_pager( $out );
}
private static function rewrap_param_desc( $matches ) {
$param = $matches[1];
$desc = self::indent( "\t\t", $matches[2] );
return "\t$param\n$desc\n\n";
}
private static function indent( $whitespace, $text ) {
$lines = explode( "\n", $text );
foreach ( $lines as &$line ) {
$line = $whitespace . $line;
}
return implode( "\n", $lines );
}
private static function pass_through_pager( $out ) {
if ( ! Utils\check_proc_available( null /*context*/, true /*return*/ ) ) {
WP_CLI::line( $out );
WP_CLI::debug( 'Warning: check_proc_available() failed in pass_through_pager().', 'help' );
return -1;
}
$pager = getenv( 'PAGER' );
if ( false === $pager ) {
$pager = Utils\is_windows() ? 'more' : 'less -R';
}
// For Windows 7 need to set code page to something other than Unicode (65001) to get around "Not enough memory." error with `more.com` on PHP 7.1+.
if ( 'more' === $pager && defined( 'PHP_WINDOWS_VERSION_MAJOR' ) && PHP_WINDOWS_VERSION_MAJOR < 10 && function_exists( 'sapi_windows_cp_set' ) ) {
// Note will also apply to Windows 8 (see https://msdn.microsoft.com/en-us/library/windows/desktop/ms724832.aspx) but probably harmless anyway.
$cp = getenv( 'WP_CLI_WINDOWS_CODE_PAGE' ) ?: 1252; // Code page 1252 is the most used so probably the most compat.
// phpcs:ignore PHPCompatibility.FunctionUse.NewFunctions -- Wrapped in function_exists() call.
sapi_windows_cp_set( $cp ); // `sapi_windows_cp_set()` introduced PHP 7.1.
}
// Convert string to file handle.
$fd = fopen( 'php://temp', 'r+b' );
fwrite( $fd, $out );
rewind( $fd );
$descriptorspec = [
0 => $fd,
1 => STDOUT,
2 => STDERR,
];
return proc_close( Utils\proc_open_compat( $pager, $descriptorspec, $pipes ) );
}
private static function get_initial_markdown( $command ) {
$name = implode( ' ', Dispatcher\get_path( $command ) );
$binding = [
'name' => $name,
'shortdesc' => $command->get_shortdesc(),
];
$binding['synopsis'] = "$name " . $command->get_synopsis();
$alias = $command->get_alias();
if ( $alias ) {
$binding['alias'] = $alias;
}
$hook_name = $command->get_hook();
$hook_description = $hook_name ? Utils\get_hook_description( $hook_name ) : null;
if ( $hook_description && 'after_wp_load' !== $hook_name ) {
if ( $command->can_have_subcommands() ) {
$binding['shortdesc'] .= "\n\nUnless overridden, these commands run on the '$hook_name' hook, $hook_description";
} else {
$binding['shortdesc'] .= "\n\nThis command runs on the '$hook_name' hook, $hook_description";
}
}
if ( $command->can_have_subcommands() ) {
$binding['has-subcommands']['subcommands'] = self::render_subcommands( $command );
}
return Utils\mustache_render( 'man.mustache', $binding );
}
private static function render_subcommands( $command ) {
$subcommands = [];
foreach ( $command->get_subcommands() as $subcommand ) {
if ( WP_CLI::get_runner()->is_command_disabled( $subcommand ) ) {
continue;
}
$subcommands[ $subcommand->get_name() ] = $subcommand->get_shortdesc();
}
$max_len = self::get_max_len( array_keys( $subcommands ) );
$lines = [];
foreach ( $subcommands as $name => $desc ) {
$lines[] = str_pad( $name, $max_len ) . "\t\t\t" . $desc;
}
return $lines;
}
private static function get_max_len( $strings ) {
$max_len = 0;
foreach ( $strings as $str ) {
$len = strlen( $str );
if ( $len > $max_len ) {
$max_len = $len;
}
}
return $max_len;
}
/**
* Parse reference links from longdescription.
*
* @param string $longdesc The longdescription from the `$command->get_longdesc()`.
* @return string The longdescription which has links as footnote.
*/
private static function parse_reference_links( $longdesc ) {
$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 = []; // 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;
}
}
*/
class SymfonyClassCollectionLoader
{
private static $loaded;
const HEADER = <<<'EOS'
\s*$/'), '', file_get_contents($r->getFileName()));
}
$cache = $cacheDir . '/' . $name . $extension;
$header = sprintf(self::HEADER, date('Y'));
self::writeCacheFile($cache, $header . substr(self::stripComments(' true,
self::PRAGMA_BLOCKS => true,
self::PRAGMA_ANCHORED_DOT => true,
self::PRAGMA_DYNAMIC_NAMES => true,
);
// Template cache
private $templates = array();
// Environment
private $templateClassPrefix = '__Mustache_';
private $cache;
private $lambdaCache;
private $cacheLambdaTemplates = false;
private $loader;
private $partialsLoader;
private $helpers;
private $escape;
private $entityFlags = ENT_COMPAT;
private $charset = 'UTF-8';
private $logger;
private $strictCallables = false;
private $pragmas = array();
private $delimiters;
private $buggyPropertyShadowing = false;
// Services
private $tokenizer;
private $parser;
private $compiler;
/**
* Mustache class constructor.
*
* Passing an $options array allows overriding certain Mustache options during instantiation:
*
* $options = array(
* // The class prefix for compiled templates. Defaults to '__Mustache_'.
* 'template_class_prefix' => '__MyTemplates_',
*
* // A Mustache cache instance or a cache directory string for compiled templates.
* // Mustache will not cache templates unless this is set.
* 'cache' => dirname(__FILE__).'/tmp/cache/mustache',
*
* // Override default permissions for cache files. Defaults to using the system-defined umask. It is
* // *strongly* recommended that you configure your umask properly rather than overriding permissions here.
* 'cache_file_mode' => 0666,
*
* // Optionally, enable caching for lambda section templates. This is generally not recommended, as lambda
* // sections are often too dynamic to benefit from caching.
* 'cache_lambda_templates' => true,
*
* // Customize the tag delimiters used by this engine instance. Note that overriding here changes the
* // delimiters used to parse all templates and partials loaded by this instance. To override just for a
* // single template, use an inline "change delimiters" tag at the start of the template file:
* //
* // {{=<% %>=}}
* //
* 'delimiters' => '<% %>',
*
* // A Mustache template loader instance. Uses a StringLoader if not specified.
* 'loader' => new Mustache_Loader_FilesystemLoader(dirname(__FILE__).'/views'),
*
* // A Mustache loader instance for partials.
* 'partials_loader' => new Mustache_Loader_FilesystemLoader(dirname(__FILE__).'/views/partials'),
*
* // An array of Mustache partials. Useful for quick-and-dirty string template loading, but not as
* // efficient or lazy as a Filesystem (or database) loader.
* 'partials' => array('foo' => file_get_contents(dirname(__FILE__).'/views/partials/foo.mustache')),
*
* // An array of 'helpers'. Helpers can be global variables or objects, closures (e.g. for higher order
* // sections), or any other valid Mustache context value. They will be prepended to the context stack,
* // so they will be available in any template loaded by this Mustache instance.
* 'helpers' => array('i18n' => function ($text) {
* // do something translatey here...
* }),
*
* // An 'escape' callback, responsible for escaping double-mustache variables.
* 'escape' => function ($value) {
* return htmlspecialchars($buffer, ENT_COMPAT, 'UTF-8');
* },
*
* // Type argument for `htmlspecialchars`. Defaults to ENT_COMPAT. You may prefer ENT_QUOTES.
* 'entity_flags' => ENT_QUOTES,
*
* // Character set for `htmlspecialchars`. Defaults to 'UTF-8'. Use 'UTF-8'.
* 'charset' => 'ISO-8859-1',
*
* // A Mustache Logger instance. No logging will occur unless this is set. Using a PSR-3 compatible
* // logging library -- such as Monolog -- is highly recommended. A simple stream logger implementation is
* // available as well:
* 'logger' => new Mustache_Logger_StreamLogger('php://stderr'),
*
* // Only treat Closure instances and invokable classes as callable. If true, values like
* // `array('ClassName', 'methodName')` and `array($classInstance, 'methodName')`, which are traditionally
* // "callable" in PHP, are not called to resolve variables for interpolation or section contexts. This
* // helps protect against arbitrary code execution when user input is passed directly into the template.
* // This currently defaults to false, but will default to true in v3.0.
* 'strict_callables' => true,
*
* // Enable pragmas across all templates, regardless of the presence of pragma tags in the individual
* // templates.
* 'pragmas' => [Mustache_Engine::PRAGMA_FILTERS],
* );
*
* @throws Mustache_Exception_InvalidArgumentException If `escape` option is not callable
*
* @param array $options (default: array())
*/
public function __construct(array $options = array())
{
if (isset($options['template_class_prefix'])) {
if ((string) $options['template_class_prefix'] === '') {
throw new Mustache_Exception_InvalidArgumentException('Mustache Constructor "template_class_prefix" must not be empty');
}
$this->templateClassPrefix = $options['template_class_prefix'];
}
if (isset($options['cache'])) {
$cache = $options['cache'];
if (is_string($cache)) {
$mode = isset($options['cache_file_mode']) ? $options['cache_file_mode'] : null;
$cache = new Mustache_Cache_FilesystemCache($cache, $mode);
}
$this->setCache($cache);
}
if (isset($options['cache_lambda_templates'])) {
$this->cacheLambdaTemplates = (bool) $options['cache_lambda_templates'];
}
if (isset($options['loader'])) {
$this->setLoader($options['loader']);
}
if (isset($options['partials_loader'])) {
$this->setPartialsLoader($options['partials_loader']);
}
if (isset($options['partials'])) {
$this->setPartials($options['partials']);
}
if (isset($options['helpers'])) {
$this->setHelpers($options['helpers']);
}
if (isset($options['escape'])) {
if (!is_callable($options['escape'])) {
throw new Mustache_Exception_InvalidArgumentException('Mustache Constructor "escape" option must be callable');
}
$this->escape = $options['escape'];
}
if (isset($options['entity_flags'])) {
$this->entityFlags = $options['entity_flags'];
}
if (isset($options['charset'])) {
$this->charset = $options['charset'];
}
if (isset($options['logger'])) {
$this->setLogger($options['logger']);
}
if (isset($options['strict_callables'])) {
$this->strictCallables = $options['strict_callables'];
}
if (isset($options['delimiters'])) {
$this->delimiters = $options['delimiters'];
}
if (isset($options['pragmas'])) {
foreach ($options['pragmas'] as $pragma) {
if (!isset(self::$knownPragmas[$pragma])) {
throw new Mustache_Exception_InvalidArgumentException(sprintf('Unknown pragma: "%s".', $pragma));
}
$this->pragmas[$pragma] = true;
}
}
if (isset($options['buggy_property_shadowing'])) {
$this->buggyPropertyShadowing = (bool) $options['buggy_property_shadowing'];
}
}
/**
* Shortcut 'render' invocation.
*
* Equivalent to calling `$mustache->loadTemplate($template)->render($context);`
*
* @see Mustache_Engine::loadTemplate
* @see Mustache_Template::render
*
* @param string $template
* @param mixed $context (default: array())
*
* @return string Rendered template
*/
public function render($template, $context = array())
{
return $this->loadTemplate($template)->render($context);
}
/**
* Get the current Mustache escape callback.
*
* @return callable|null
*/
public function getEscape()
{
return $this->escape;
}
/**
* Get the current Mustache entitity type to escape.
*
* @return int
*/
public function getEntityFlags()
{
return $this->entityFlags;
}
/**
* Get the current Mustache character set.
*
* @return string
*/
public function getCharset()
{
return $this->charset;
}
/**
* Check whether to use buggy property shadowing.
*
* See https://github.com/bobthecow/mustache.php/pull/410
*/
public function useBuggyPropertyShadowing()
{
return $this->buggyPropertyShadowing;
}
/**
* Get the current globally enabled pragmas.
*
* @return array
*/
public function getPragmas()
{
return array_keys($this->pragmas);
}
/**
* Set the Mustache template Loader instance.
*
* @param Mustache_Loader $loader
*/
public function setLoader(Mustache_Loader $loader)
{
$this->loader = $loader;
}
/**
* Get the current Mustache template Loader instance.
*
* If no Loader instance has been explicitly specified, this method will instantiate and return
* a StringLoader instance.
*
* @return Mustache_Loader
*/
public function getLoader()
{
if (!isset($this->loader)) {
$this->loader = new Mustache_Loader_StringLoader();
}
return $this->loader;
}
/**
* Set the Mustache partials Loader instance.
*
* @param Mustache_Loader $partialsLoader
*/
public function setPartialsLoader(Mustache_Loader $partialsLoader)
{
$this->partialsLoader = $partialsLoader;
}
/**
* Get the current Mustache partials Loader instance.
*
* If no Loader instance has been explicitly specified, this method will instantiate and return
* an ArrayLoader instance.
*
* @return Mustache_Loader
*/
public function getPartialsLoader()
{
if (!isset($this->partialsLoader)) {
$this->partialsLoader = new Mustache_Loader_ArrayLoader();
}
return $this->partialsLoader;
}
/**
* Set partials for the current partials Loader instance.
*
* @throws Mustache_Exception_RuntimeException If the current Loader instance is immutable
*
* @param array $partials (default: array())
*/
public function setPartials(array $partials = array())
{
if (!isset($this->partialsLoader)) {
$this->partialsLoader = new Mustache_Loader_ArrayLoader();
}
if (!$this->partialsLoader instanceof Mustache_Loader_MutableLoader) {
throw new Mustache_Exception_RuntimeException('Unable to set partials on an immutable Mustache Loader instance');
}
$this->partialsLoader->setTemplates($partials);
}
/**
* Set an array of Mustache helpers.
*
* An array of 'helpers'. Helpers can be global variables or objects, closures (e.g. for higher order sections), or
* any other valid Mustache context value. They will be prepended to the context stack, so they will be available in
* any template loaded by this Mustache instance.
*
* @throws Mustache_Exception_InvalidArgumentException if $helpers is not an array or Traversable
*
* @param array|Traversable $helpers
*/
public function setHelpers($helpers)
{
if (!is_array($helpers) && !$helpers instanceof Traversable) {
throw new Mustache_Exception_InvalidArgumentException('setHelpers expects an array of helpers');
}
$this->getHelpers()->clear();
foreach ($helpers as $name => $helper) {
$this->addHelper($name, $helper);
}
}
/**
* Get the current set of Mustache helpers.
*
* @see Mustache_Engine::setHelpers
*
* @return Mustache_HelperCollection
*/
public function getHelpers()
{
if (!isset($this->helpers)) {
$this->helpers = new Mustache_HelperCollection();
}
return $this->helpers;
}
/**
* Add a new Mustache helper.
*
* @see Mustache_Engine::setHelpers
*
* @param string $name
* @param mixed $helper
*/
public function addHelper($name, $helper)
{
$this->getHelpers()->add($name, $helper);
}
/**
* Get a Mustache helper by name.
*
* @see Mustache_Engine::setHelpers
*
* @param string $name
*
* @return mixed Helper
*/
public function getHelper($name)
{
return $this->getHelpers()->get($name);
}
/**
* Check whether this Mustache instance has a helper.
*
* @see Mustache_Engine::setHelpers
*
* @param string $name
*
* @return bool True if the helper is present
*/
public function hasHelper($name)
{
return $this->getHelpers()->has($name);
}
/**
* Remove a helper by name.
*
* @see Mustache_Engine::setHelpers
*
* @param string $name
*/
public function removeHelper($name)
{
$this->getHelpers()->remove($name);
}
/**
* Set the Mustache Logger instance.
*
* @throws Mustache_Exception_InvalidArgumentException If logger is not an instance of Mustache_Logger or Psr\Log\LoggerInterface
*
* @param Mustache_Logger|Psr\Log\LoggerInterface $logger
*/
public function setLogger($logger = null)
{
if ($logger !== null && !($logger instanceof Mustache_Logger || is_a($logger, 'Psr\\Log\\LoggerInterface'))) {
throw new Mustache_Exception_InvalidArgumentException('Expected an instance of Mustache_Logger or Psr\\Log\\LoggerInterface.');
}
if ($this->getCache()->getLogger() === null) {
$this->getCache()->setLogger($logger);
}
$this->logger = $logger;
}
/**
* Get the current Mustache Logger instance.
*
* @return Mustache_Logger|Psr\Log\LoggerInterface
*/
public function getLogger()
{
return $this->logger;
}
/**
* Set the Mustache Tokenizer instance.
*
* @param Mustache_Tokenizer $tokenizer
*/
public function setTokenizer(Mustache_Tokenizer $tokenizer)
{
$this->tokenizer = $tokenizer;
}
/**
* Get the current Mustache Tokenizer instance.
*
* If no Tokenizer instance has been explicitly specified, this method will instantiate and return a new one.
*
* @return Mustache_Tokenizer
*/
public function getTokenizer()
{
if (!isset($this->tokenizer)) {
$this->tokenizer = new Mustache_Tokenizer();
}
return $this->tokenizer;
}
/**
* Set the Mustache Parser instance.
*
* @param Mustache_Parser $parser
*/
public function setParser(Mustache_Parser $parser)
{
$this->parser = $parser;
}
/**
* Get the current Mustache Parser instance.
*
* If no Parser instance has been explicitly specified, this method will instantiate and return a new one.
*
* @return Mustache_Parser
*/
public function getParser()
{
if (!isset($this->parser)) {
$this->parser = new Mustache_Parser();
}
return $this->parser;
}
/**
* Set the Mustache Compiler instance.
*
* @param Mustache_Compiler $compiler
*/
public function setCompiler(Mustache_Compiler $compiler)
{
$this->compiler = $compiler;
}
/**
* Get the current Mustache Compiler instance.
*
* If no Compiler instance has been explicitly specified, this method will instantiate and return a new one.
*
* @return Mustache_Compiler
*/
public function getCompiler()
{
if (!isset($this->compiler)) {
$this->compiler = new Mustache_Compiler();
}
return $this->compiler;
}
/**
* Set the Mustache Cache instance.
*
* @param Mustache_Cache $cache
*/
public function setCache(Mustache_Cache $cache)
{
if (isset($this->logger) && $cache->getLogger() === null) {
$cache->setLogger($this->getLogger());
}
$this->cache = $cache;
}
/**
* Get the current Mustache Cache instance.
*
* If no Cache instance has been explicitly specified, this method will instantiate and return a new one.
*
* @return Mustache_Cache
*/
public function getCache()
{
if (!isset($this->cache)) {
$this->setCache(new Mustache_Cache_NoopCache());
}
return $this->cache;
}
/**
* Get the current Lambda Cache instance.
*
* If 'cache_lambda_templates' is enabled, this is the default cache instance. Otherwise, it is a NoopCache.
*
* @see Mustache_Engine::getCache
*
* @return Mustache_Cache
*/
protected function getLambdaCache()
{
if ($this->cacheLambdaTemplates) {
return $this->getCache();
}
if (!isset($this->lambdaCache)) {
$this->lambdaCache = new Mustache_Cache_NoopCache();
}
return $this->lambdaCache;
}
/**
* Helper method to generate a Mustache template class.
*
* This method must be updated any time options are added which make it so
* the same template could be parsed and compiled multiple different ways.
*
* @param string|Mustache_Source $source
*
* @return string Mustache Template class name
*/
public function getTemplateClassName($source)
{
// For the most part, adding a new option here should do the trick.
//
// Pick a value here which is unique for each possible way the template
// could be compiled... but not necessarily unique per option value. See
// escape below, which only needs to differentiate between 'custom' and
// 'default' escapes.
//
// Keep this list in alphabetical order :)
$chunks = array(
'charset' => $this->charset,
'delimiters' => $this->delimiters ? $this->delimiters : '{{ }}',
'entityFlags' => $this->entityFlags,
'escape' => isset($this->escape) ? 'custom' : 'default',
'key' => ($source instanceof Mustache_Source) ? $source->getKey() : 'source',
'pragmas' => $this->getPragmas(),
'strictCallables' => $this->strictCallables,
'version' => self::VERSION,
);
$key = json_encode($chunks);
// Template Source instances have already provided their own source key. For strings, just include the whole
// source string in the md5 hash.
if (!$source instanceof Mustache_Source) {
$key .= "\n" . $source;
}
return $this->templateClassPrefix . md5($key);
}
/**
* Load a Mustache Template by name.
*
* @param string $name
*
* @return Mustache_Template
*/
public function loadTemplate($name)
{
return $this->loadSource($this->getLoader()->load($name));
}
/**
* Load a Mustache partial Template by name.
*
* This is a helper method used internally by Template instances for loading partial templates. You can most likely
* ignore it completely.
*
* @param string $name
*
* @return Mustache_Template
*/
public function loadPartial($name)
{
try {
if (isset($this->partialsLoader)) {
$loader = $this->partialsLoader;
} elseif (isset($this->loader) && !$this->loader instanceof Mustache_Loader_StringLoader) {
$loader = $this->loader;
} else {
throw new Mustache_Exception_UnknownTemplateException($name);
}
return $this->loadSource($loader->load($name));
} catch (Mustache_Exception_UnknownTemplateException $e) {
// If the named partial cannot be found, log then return null.
$this->log(
Mustache_Logger::WARNING,
'Partial not found: "{name}"',
array('name' => $e->getTemplateName())
);
}
}
/**
* Load a Mustache lambda Template by source.
*
* This is a helper method used by Template instances to generate subtemplates for Lambda sections. You can most
* likely ignore it completely.
*
* @param string $source
* @param string $delims (default: null)
*
* @return Mustache_Template
*/
public function loadLambda($source, $delims = null)
{
if ($delims !== null) {
$source = $delims . "\n" . $source;
}
return $this->loadSource($source, $this->getLambdaCache());
}
/**
* Instantiate and return a Mustache Template instance by source.
*
* Optionally provide a Mustache_Cache instance. This is used internally by Mustache_Engine::loadLambda to respect
* the 'cache_lambda_templates' configuration option.
*
* @see Mustache_Engine::loadTemplate
* @see Mustache_Engine::loadPartial
* @see Mustache_Engine::loadLambda
*
* @param string|Mustache_Source $source
* @param Mustache_Cache $cache (default: null)
*
* @return Mustache_Template
*/
private function loadSource($source, $cache = null)
{
$className = $this->getTemplateClassName($source);
if (!isset($this->templates[$className])) {
if ($cache === null || ! $cache instanceof Mustache_Cache) {
$cache = $this->getCache();
}
if (!class_exists($className, false)) {
if (!$cache->load($className)) {
$compiled = $this->compile($source);
$cache->cache($className, $compiled);
}
}
$this->log(
Mustache_Logger::DEBUG,
'Instantiating template: "{className}"',
array('className' => $className)
);
$this->templates[$className] = new $className($this);
}
return $this->templates[$className];
}
/**
* Helper method to tokenize a Mustache template.
*
* @see Mustache_Tokenizer::scan
*
* @param string $source
*
* @return array Tokens
*/
private function tokenize($source)
{
return $this->getTokenizer()->scan($source, $this->delimiters);
}
/**
* Helper method to parse a Mustache template.
*
* @see Mustache_Parser::parse
*
* @param string $source
*
* @return array Token tree
*/
private function parse($source)
{
$parser = $this->getParser();
$parser->setPragmas($this->getPragmas());
return $parser->parse($this->tokenize($source));
}
/**
* Helper method to compile a Mustache template.
*
* @see Mustache_Compiler::compile
*
* @param string|Mustache_Source $source
*
* @return string generated Mustache template class code
*/
private function compile($source)
{
$name = $this->getTemplateClassName($source);
$this->log(
Mustache_Logger::INFO,
'Compiling template to "{className}" class',
array('className' => $name)
);
if ($source instanceof Mustache_Source) {
$source = $source->getSource();
}
$tree = $this->parse($source);
$compiler = $this->getCompiler();
$compiler->setPragmas($this->getPragmas());
return $compiler->compile($source, $tree, $name, isset($this->escape), $this->charset, $this->strictCallables, $this->entityFlags);
}
/**
* Add a log record if logging is enabled.
*
* @param int $level The logging level
* @param string $message The log message
* @param array $context The log context
*/
private function log($level, $message, array $context = array())
{
if (isset($this->logger)) {
$this->logger->log($level, $message, $context);
}
}
}
filterName = $filterName;
$message = sprintf('Unknown filter: %s', $filterName);
if (version_compare(PHP_VERSION, '5.3.0', '>=')) {
parent::__construct($message, 0, $previous);
} else {
parent::__construct($message); // @codeCoverageIgnore
}
}
public function getFilterName()
{
return $this->filterName;
}
}
helperName = $helperName;
$message = sprintf('Unknown helper: %s', $helperName);
if (version_compare(PHP_VERSION, '5.3.0', '>=')) {
parent::__construct($message, 0, $previous);
} else {
parent::__construct($message); // @codeCoverageIgnore
}
}
public function getHelperName()
{
return $this->helperName;
}
}
token = $token;
if (version_compare(PHP_VERSION, '5.3.0', '>=')) {
parent::__construct($msg, 0, $previous);
} else {
parent::__construct($msg); // @codeCoverageIgnore
}
}
/**
* @return array
*/
public function getToken()
{
return $this->token;
}
}
templateName = $templateName;
$message = sprintf('Unknown template: %s', $templateName);
if (version_compare(PHP_VERSION, '5.3.0', '>=')) {
parent::__construct($message, 0, $previous);
} else {
parent::__construct($message); // @codeCoverageIgnore
}
}
public function getTemplateName()
{
return $this->templateName;
}
}
lineNum = -1;
$this->lineTokens = 0;
$this->pragmas = $this->defaultPragmas;
$this->pragmaFilters = isset($this->pragmas[Mustache_Engine::PRAGMA_FILTERS]);
$this->pragmaBlocks = isset($this->pragmas[Mustache_Engine::PRAGMA_BLOCKS]);
$this->pragmaDynamicNames = isset($this->pragmas[Mustache_Engine::PRAGMA_DYNAMIC_NAMES]);
return $this->buildTree($tokens);
}
/**
* Enable pragmas across all templates, regardless of the presence of pragma
* tags in the individual templates.
*
* @internal Users should set global pragmas in Mustache_Engine, not here :)
*
* @param string[] $pragmas
*/
public function setPragmas(array $pragmas)
{
$this->pragmas = array();
foreach ($pragmas as $pragma) {
$this->enablePragma($pragma);
}
$this->defaultPragmas = $this->pragmas;
}
/**
* Helper method for recursively building a parse tree.
*
* @throws Mustache_Exception_SyntaxException when nesting errors or mismatched section tags are encountered
*
* @param array &$tokens Set of Mustache tokens
* @param array $parent Parent token (default: null)
*
* @return array Mustache Token parse tree
*/
private function buildTree(array &$tokens, $parent = null)
{
$nodes = array();
while (!empty($tokens)) {
$token = array_shift($tokens);
if ($token[Mustache_Tokenizer::LINE] === $this->lineNum) {
$this->lineTokens++;
} else {
$this->lineNum = $token[Mustache_Tokenizer::LINE];
$this->lineTokens = 0;
}
if ($token[Mustache_Tokenizer::TYPE] !== Mustache_Tokenizer::T_COMMENT) {
if ($this->pragmaDynamicNames && isset($token[Mustache_Tokenizer::NAME])) {
list($name, $isDynamic) = $this->getDynamicName($token);
if ($isDynamic) {
$token[Mustache_Tokenizer::NAME] = $name;
$token[Mustache_Tokenizer::DYNAMIC] = true;
}
}
if ($this->pragmaFilters && isset($token[Mustache_Tokenizer::NAME])) {
list($name, $filters) = $this->getNameAndFilters($token[Mustache_Tokenizer::NAME]);
if (!empty($filters)) {
$token[Mustache_Tokenizer::NAME] = $name;
$token[Mustache_Tokenizer::FILTERS] = $filters;
}
}
}
switch ($token[Mustache_Tokenizer::TYPE]) {
case Mustache_Tokenizer::T_DELIM_CHANGE:
$this->checkIfTokenIsAllowedInParent($parent, $token);
$this->clearStandaloneLines($nodes, $tokens);
break;
case Mustache_Tokenizer::T_SECTION:
case Mustache_Tokenizer::T_INVERTED:
$this->checkIfTokenIsAllowedInParent($parent, $token);
$this->clearStandaloneLines($nodes, $tokens);
$nodes[] = $this->buildTree($tokens, $token);
break;
case Mustache_Tokenizer::T_END_SECTION:
if (!isset($parent)) {
$msg = sprintf(
'Unexpected closing tag: /%s on line %d',
$token[Mustache_Tokenizer::NAME],
$token[Mustache_Tokenizer::LINE]
);
throw new Mustache_Exception_SyntaxException($msg, $token);
}
$sameName = $token[Mustache_Tokenizer::NAME] !== $parent[Mustache_Tokenizer::NAME];
$tokenDynamic = isset($token[Mustache_Tokenizer::DYNAMIC]) && $token[Mustache_Tokenizer::DYNAMIC];
$parentDynamic = isset($parent[Mustache_Tokenizer::DYNAMIC]) && $parent[Mustache_Tokenizer::DYNAMIC];
if ($sameName || ($tokenDynamic !== $parentDynamic)) {
$msg = sprintf(
'Nesting error: %s%s (on line %d) vs. %s%s (on line %d)',
$parentDynamic ? '*' : '',
$parent[Mustache_Tokenizer::NAME],
$parent[Mustache_Tokenizer::LINE],
$tokenDynamic ? '*' : '',
$token[Mustache_Tokenizer::NAME],
$token[Mustache_Tokenizer::LINE]
);
throw new Mustache_Exception_SyntaxException($msg, $token);
}
$this->clearStandaloneLines($nodes, $tokens);
$parent[Mustache_Tokenizer::END] = $token[Mustache_Tokenizer::INDEX];
$parent[Mustache_Tokenizer::NODES] = $nodes;
return $parent;
case Mustache_Tokenizer::T_PARTIAL:
$this->checkIfTokenIsAllowedInParent($parent, $token);
//store the whitespace prefix for laters!
if ($indent = $this->clearStandaloneLines($nodes, $tokens)) {
$token[Mustache_Tokenizer::INDENT] = $indent[Mustache_Tokenizer::VALUE];
}
$nodes[] = $token;
break;
case Mustache_Tokenizer::T_PARENT:
$this->checkIfTokenIsAllowedInParent($parent, $token);
$nodes[] = $this->buildTree($tokens, $token);
break;
case Mustache_Tokenizer::T_BLOCK_VAR:
if ($this->pragmaBlocks) {
// BLOCKS pragma is enabled, let's do this!
if (isset($parent) && $parent[Mustache_Tokenizer::TYPE] === Mustache_Tokenizer::T_PARENT) {
$token[Mustache_Tokenizer::TYPE] = Mustache_Tokenizer::T_BLOCK_ARG;
}
$this->clearStandaloneLines($nodes, $tokens);
$nodes[] = $this->buildTree($tokens, $token);
} else {
// pretend this was just a normal "escaped" token...
$token[Mustache_Tokenizer::TYPE] = Mustache_Tokenizer::T_ESCAPED;
// TODO: figure out how to figure out if there was a space after this dollar:
$token[Mustache_Tokenizer::NAME] = '$' . $token[Mustache_Tokenizer::NAME];
$nodes[] = $token;
}
break;
case Mustache_Tokenizer::T_PRAGMA:
$this->enablePragma($token[Mustache_Tokenizer::NAME]);
// no break
case Mustache_Tokenizer::T_COMMENT:
$this->clearStandaloneLines($nodes, $tokens);
$nodes[] = $token;
break;
default:
$nodes[] = $token;
break;
}
}
if (isset($parent)) {
$msg = sprintf(
'Missing closing tag: %s opened on line %d',
$parent[Mustache_Tokenizer::NAME],
$parent[Mustache_Tokenizer::LINE]
);
throw new Mustache_Exception_SyntaxException($msg, $parent);
}
return $nodes;
}
/**
* Clear standalone line tokens.
*
* Returns a whitespace token for indenting partials, if applicable.
*
* @param array $nodes Parsed nodes
* @param array $tokens Tokens to be parsed
*
* @return array|null Resulting indent token, if any
*/
private function clearStandaloneLines(array &$nodes, array &$tokens)
{
if ($this->lineTokens > 1) {
// this is the third or later node on this line, so it can't be standalone
return;
}
$prev = null;
if ($this->lineTokens === 1) {
// this is the second node on this line, so it can't be standalone
// unless the previous node is whitespace.
if ($prev = end($nodes)) {
if (!$this->tokenIsWhitespace($prev)) {
return;
}
}
}
if ($next = reset($tokens)) {
// If we're on a new line, bail.
if ($next[Mustache_Tokenizer::LINE] !== $this->lineNum) {
return;
}
// If the next token isn't whitespace, bail.
if (!$this->tokenIsWhitespace($next)) {
return;
}
if (count($tokens) !== 1) {
// Unless it's the last token in the template, the next token
// must end in newline for this to be standalone.
if (substr($next[Mustache_Tokenizer::VALUE], -1) !== "\n") {
return;
}
}
// Discard the whitespace suffix
array_shift($tokens);
}
if ($prev) {
// Return the whitespace prefix, if any
return array_pop($nodes);
}
}
/**
* Check whether token is a whitespace token.
*
* True if token type is T_TEXT and value is all whitespace characters.
*
* @param array $token
*
* @return bool True if token is a whitespace token
*/
private function tokenIsWhitespace(array $token)
{
if ($token[Mustache_Tokenizer::TYPE] === Mustache_Tokenizer::T_TEXT) {
return preg_match('/^\s*$/', $token[Mustache_Tokenizer::VALUE]);
}
return false;
}
/**
* Check whether a token is allowed inside a parent tag.
*
* @throws Mustache_Exception_SyntaxException if an invalid token is found inside a parent tag
*
* @param array|null $parent
* @param array $token
*/
private function checkIfTokenIsAllowedInParent($parent, array $token)
{
if (isset($parent) && $parent[Mustache_Tokenizer::TYPE] === Mustache_Tokenizer::T_PARENT) {
throw new Mustache_Exception_SyntaxException('Illegal content in < parent tag', $token);
}
}
/**
* Parse dynamic names.
*
* @throws Mustache_Exception_SyntaxException when a tag does not allow *
* @throws Mustache_Exception_SyntaxException on multiple *s, or dots or filters with *
*/
private function getDynamicName(array $token)
{
$name = $token[Mustache_Tokenizer::NAME];
$isDynamic = false;
if (preg_match('/^\s*\*\s*/', $name)) {
$this->ensureTagAllowsDynamicNames($token);
$name = preg_replace('/^\s*\*\s*/', '', $name);
$isDynamic = true;
}
return array($name, $isDynamic);
}
/**
* Check whether the given token supports dynamic tag names.
*
* @throws Mustache_Exception_SyntaxException when a tag does not allow *
*
* @param array $token
*/
private function ensureTagAllowsDynamicNames(array $token)
{
switch ($token[Mustache_Tokenizer::TYPE]) {
case Mustache_Tokenizer::T_PARTIAL:
case Mustache_Tokenizer::T_PARENT:
case Mustache_Tokenizer::T_END_SECTION:
return;
}
$msg = sprintf(
'Invalid dynamic name: %s in %s tag',
$token[Mustache_Tokenizer::NAME],
Mustache_Tokenizer::getTagName($token[Mustache_Tokenizer::TYPE])
);
throw new Mustache_Exception_SyntaxException($msg, $token);
}
/**
* Split a tag name into name and filters.
*
* @param string $name
*
* @return array [Tag name, Array of filters]
*/
private function getNameAndFilters($name)
{
$filters = array_map('trim', explode('|', $name));
$name = array_shift($filters);
return array($name, $filters);
}
/**
* Enable a pragma.
*
* @param string $name
*/
private function enablePragma($name)
{
$this->pragmas[$name] = true;
switch ($name) {
case Mustache_Engine::PRAGMA_BLOCKS:
$this->pragmaBlocks = true;
break;
case Mustache_Engine::PRAGMA_FILTERS:
$this->pragmaFilters = true;
break;
case Mustache_Engine::PRAGMA_DYNAMIC_NAMES:
$this->pragmaDynamicNames = true;
break;
}
}
}
load('foo'); // equivalent to `file_get_contents(dirname(__FILE__).'/views/foo.mustache');
*
* This is probably the most useful Mustache Loader implementation. It can be used for partials and normal Templates:
*
* $m = new Mustache(array(
* 'loader' => new Mustache_Loader_FilesystemLoader(dirname(__FILE__).'/views'),
* 'partials_loader' => new Mustache_Loader_FilesystemLoader(dirname(__FILE__).'/views/partials'),
* ));
*/
class Mustache_Loader_FilesystemLoader implements Mustache_Loader
{
private $baseDir;
private $extension = '.mustache';
private $templates = array();
/**
* Mustache filesystem Loader constructor.
*
* Passing an $options array allows overriding certain Loader options during instantiation:
*
* $options = array(
* // The filename extension used for Mustache templates. Defaults to '.mustache'
* 'extension' => '.ms',
* );
*
* @throws Mustache_Exception_RuntimeException if $baseDir does not exist
*
* @param string $baseDir Base directory containing Mustache template files
* @param array $options Array of Loader options (default: array())
*/
public function __construct($baseDir, array $options = array())
{
$this->baseDir = $baseDir;
if (strpos($this->baseDir, '://') === false) {
$this->baseDir = realpath($this->baseDir);
}
if ($this->shouldCheckPath() && !is_dir($this->baseDir)) {
throw new Mustache_Exception_RuntimeException(sprintf('FilesystemLoader baseDir must be a directory: %s', $baseDir));
}
if (array_key_exists('extension', $options)) {
if (empty($options['extension'])) {
$this->extension = '';
} else {
$this->extension = '.' . ltrim($options['extension'], '.');
}
}
}
/**
* Load a Template by name.
*
* $loader = new Mustache_Loader_FilesystemLoader(dirname(__FILE__).'/views');
* $loader->load('admin/dashboard'); // loads "./views/admin/dashboard.mustache";
*
* @param string $name
*
* @return string Mustache Template source
*/
public function load($name)
{
if (!isset($this->templates[$name])) {
$this->templates[$name] = $this->loadFile($name);
}
return $this->templates[$name];
}
/**
* Helper function for loading a Mustache file by name.
*
* @throws Mustache_Exception_UnknownTemplateException If a template file is not found
*
* @param string $name
*
* @return string Mustache Template source
*/
protected function loadFile($name)
{
$fileName = $this->getFileName($name);
if ($this->shouldCheckPath() && !file_exists($fileName)) {
throw new Mustache_Exception_UnknownTemplateException($name);
}
return file_get_contents($fileName);
}
/**
* Helper function for getting a Mustache template file name.
*
* @param string $name
*
* @return string Template file name
*/
protected function getFileName($name)
{
$fileName = $this->baseDir . '/' . $name;
if (substr($fileName, 0 - strlen($this->extension)) !== $this->extension) {
$fileName .= $this->extension;
}
return $fileName;
}
/**
* Only check if baseDir is a directory and requested templates are files if
* baseDir is using the filesystem stream wrapper.
*
* @return bool Whether to check `is_dir` and `file_exists`
*/
protected function shouldCheckPath()
{
return strpos($this->baseDir, '://') === false || strpos($this->baseDir, 'file://') === 0;
}
}
'{{ bar }}',
* 'baz' => 'Hey {{ qux }}!'
* );
*
* $tpl = $loader->load('foo'); // '{{ bar }}'
*
* The ArrayLoader is used internally as a partials loader by Mustache_Engine instance when an array of partials
* is set. It can also be used as a quick-and-dirty Template loader.
*/
class Mustache_Loader_ArrayLoader implements Mustache_Loader, Mustache_Loader_MutableLoader
{
private $templates;
/**
* ArrayLoader constructor.
*
* @param array $templates Associative array of Template source (default: array())
*/
public function __construct(array $templates = array())
{
$this->templates = $templates;
}
/**
* Load a Template.
*
* @throws Mustache_Exception_UnknownTemplateException If a template file is not found
*
* @param string $name
*
* @return string Mustache Template source
*/
public function load($name)
{
if (!isset($this->templates[$name])) {
throw new Mustache_Exception_UnknownTemplateException($name);
}
return $this->templates[$name];
}
/**
* Set an associative array of Template sources for this loader.
*
* @param array $templates
*/
public function setTemplates(array $templates)
{
$this->templates = $templates;
}
/**
* Set a Template source by name.
*
* @param string $name
* @param string $template Mustache Template source
*/
public function setTemplate($name, $template)
{
$this->templates[$name] = $template;
}
}
loaders = array();
foreach ($loaders as $loader) {
$this->addLoader($loader);
}
}
/**
* Add a Loader instance.
*
* @param Mustache_Loader $loader
*/
public function addLoader(Mustache_Loader $loader)
{
$this->loaders[] = $loader;
}
/**
* Load a Template by name.
*
* @throws Mustache_Exception_UnknownTemplateException If a template file is not found
*
* @param string $name
*
* @return string Mustache Template source
*/
public function load($name)
{
foreach ($this->loaders as $loader) {
try {
return $loader->load($name);
} catch (Mustache_Exception_UnknownTemplateException $e) {
// do nothing, check the next loader.
}
}
throw new Mustache_Exception_UnknownTemplateException($name);
}
}
load('{{ foo }}'); // '{{ foo }}'
*
* This is the default Template Loader instance used by Mustache:
*
* $m = new Mustache;
* $tpl = $m->loadTemplate('{{ foo }}');
* echo $tpl->render(array('foo' => 'bar')); // "bar"
*/
class Mustache_Loader_StringLoader implements Mustache_Loader
{
/**
* Load a Template by source.
*
* @param string $name Mustache Template source
*
* @return string Mustache Template source
*/
public function load($name)
{
return $name;
}
}
load('hello');
* $goodbye = $loader->load('goodbye');
*
* __halt_compiler();
*
* @@ hello
* Hello, {{ planet }}!
*
* @@ goodbye
* Goodbye, cruel {{ planet }}
*
* Templates are deliniated by lines containing only `@@ name`.
*
* The InlineLoader is well-suited to micro-frameworks such as Silex:
*
* $app->register(new MustacheServiceProvider, array(
* 'mustache.loader' => new Mustache_Loader_InlineLoader(__FILE__, __COMPILER_HALT_OFFSET__)
* ));
*
* $app->get('/{name}', function ($name) use ($app) {
* return $app['mustache']->render('hello', compact('name'));
* })
* ->value('name', 'world');
*
* // ...
*
* __halt_compiler();
*
* @@ hello
* Hello, {{ name }}!
*/
class Mustache_Loader_InlineLoader implements Mustache_Loader
{
protected $fileName;
protected $offset;
protected $templates;
/**
* The InlineLoader requires a filename and offset to process templates.
*
* The magic constants `__FILE__` and `__COMPILER_HALT_OFFSET__` are usually
* perfectly suited to the job:
*
* $loader = new Mustache_Loader_InlineLoader(__FILE__, __COMPILER_HALT_OFFSET__);
*
* Note that this only works if the loader is instantiated inside the same
* file as the inline templates. If the templates are located in another
* file, it would be necessary to manually specify the filename and offset.
*
* @param string $fileName The file to parse for inline templates
* @param int $offset A string offset for the start of the templates.
* This usually coincides with the `__halt_compiler`
* call, and the `__COMPILER_HALT_OFFSET__`
*/
public function __construct($fileName, $offset)
{
if (!is_file($fileName)) {
throw new Mustache_Exception_InvalidArgumentException('InlineLoader expects a valid filename.');
}
if (!is_int($offset) || $offset < 0) {
throw new Mustache_Exception_InvalidArgumentException('InlineLoader expects a valid file offset.');
}
$this->fileName = $fileName;
$this->offset = $offset;
}
/**
* Load a Template by name.
*
* @throws Mustache_Exception_UnknownTemplateException If a template file is not found
*
* @param string $name
*
* @return string Mustache Template source
*/
public function load($name)
{
$this->loadTemplates();
if (!array_key_exists($name, $this->templates)) {
throw new Mustache_Exception_UnknownTemplateException($name);
}
return $this->templates[$name];
}
/**
* Parse and load templates from the end of a source file.
*/
protected function loadTemplates()
{
if ($this->templates === null) {
$this->templates = array();
$data = file_get_contents($this->fileName, false, null, $this->offset);
foreach (preg_split("/^@@(?= [\w\d\.]+$)/m", $data, -1) as $chunk) {
if (trim($chunk)) {
list($name, $content) = explode("\n", $chunk, 2);
$this->templates[trim($name)] = trim($content);
}
}
}
}
}
'.ms',
* 'stat_props' => array('size', 'mtime'),
* );
*
* Specifying 'stat_props' overrides the stat properties used to invalidate the template cache. By default, this
* uses 'mtime' and 'size', but this can be set to any of the properties supported by stat():
*
* http://php.net/manual/en/function.stat.php
*
* You can also disable filesystem stat entirely:
*
* $options = array('stat_props' => null);
*
* But with great power comes great responsibility. Namely, if you disable stat-based cache invalidation,
* YOU MUST CLEAR THE TEMPLATE CACHE YOURSELF when your templates change. Make it part of your build or deploy
* process so you don't forget!
*
* @throws Mustache_Exception_RuntimeException if $baseDir does not exist.
*
* @param string $baseDir Base directory containing Mustache template files.
* @param array $options Array of Loader options (default: array())
*/
public function __construct($baseDir, array $options = array())
{
parent::__construct($baseDir, $options);
if (array_key_exists('stat_props', $options)) {
if (empty($options['stat_props'])) {
$this->statProps = array();
} else {
$this->statProps = $options['stat_props'];
}
} else {
$this->statProps = array('size', 'mtime');
}
}
/**
* Helper function for loading a Mustache file by name.
*
* @throws Mustache_Exception_UnknownTemplateException If a template file is not found.
*
* @param string $name
*
* @return Mustache_Source Mustache Template source
*/
protected function loadFile($name)
{
$fileName = $this->getFileName($name);
if (!file_exists($fileName)) {
throw new Mustache_Exception_UnknownTemplateException($name);
}
return new Mustache_Source_FilesystemSource($fileName, $this->statProps);
}
}
log(
Mustache_Logger::WARNING,
'Template cache disabled, evaluating "{className}" class at runtime',
array('className' => $key)
);
eval('?>' . $value);
}
}
cache($className, $compiledSource);
*
* The FilesystemCache benefits from any opcode caching that may be setup in your environment. So do that, k?
*/
class Mustache_Cache_FilesystemCache extends Mustache_Cache_AbstractCache
{
private $baseDir;
private $fileMode;
/**
* Filesystem cache constructor.
*
* @param string $baseDir Directory for compiled templates
* @param int $fileMode Override default permissions for cache files. Defaults to using the system-defined umask
*/
public function __construct($baseDir, $fileMode = null)
{
$this->baseDir = $baseDir;
$this->fileMode = $fileMode;
}
/**
* Load the class from cache using `require_once`.
*
* @param string $key
*
* @return bool
*/
public function load($key)
{
$fileName = $this->getCacheFilename($key);
if (!is_file($fileName)) {
return false;
}
require_once $fileName;
return true;
}
/**
* Cache and load the compiled class.
*
* @param string $key
* @param string $value
*/
public function cache($key, $value)
{
$fileName = $this->getCacheFilename($key);
$this->log(
Mustache_Logger::DEBUG,
'Writing to template cache: "{fileName}"',
array('fileName' => $fileName)
);
$this->writeFile($fileName, $value);
$this->load($key);
}
/**
* Build the cache filename.
* Subclasses should override for custom cache directory structures.
*
* @param string $name
*
* @return string
*/
protected function getCacheFilename($name)
{
return sprintf('%s/%s.php', $this->baseDir, $name);
}
/**
* Create cache directory.
*
* @throws Mustache_Exception_RuntimeException If unable to create directory
*
* @param string $fileName
*
* @return string
*/
private function buildDirectoryForFilename($fileName)
{
$dirName = dirname($fileName);
if (!is_dir($dirName)) {
$this->log(
Mustache_Logger::INFO,
'Creating Mustache template cache directory: "{dirName}"',
array('dirName' => $dirName)
);
@mkdir($dirName, 0777, true);
// @codeCoverageIgnoreStart
if (!is_dir($dirName)) {
throw new Mustache_Exception_RuntimeException(sprintf('Failed to create cache directory "%s".', $dirName));
}
// @codeCoverageIgnoreEnd
}
return $dirName;
}
/**
* Write cache file.
*
* @throws Mustache_Exception_RuntimeException If unable to write file
*
* @param string $fileName
* @param string $value
*/
private function writeFile($fileName, $value)
{
$dirName = $this->buildDirectoryForFilename($fileName);
$this->log(
Mustache_Logger::DEBUG,
'Caching compiled template to "{fileName}"',
array('fileName' => $fileName)
);
$tempFile = tempnam($dirName, basename($fileName));
if (false !== @file_put_contents($tempFile, $value)) {
if (@rename($tempFile, $fileName)) {
$mode = isset($this->fileMode) ? $this->fileMode : (0666 & ~umask());
@chmod($fileName, $mode);
return;
}
// @codeCoverageIgnoreStart
$this->log(
Mustache_Logger::ERROR,
'Unable to rename Mustache temp cache file: "{tempName}" -> "{fileName}"',
array('tempName' => $tempFile, 'fileName' => $fileName)
);
// @codeCoverageIgnoreEnd
}
// @codeCoverageIgnoreStart
throw new Mustache_Exception_RuntimeException(sprintf('Failed to write cache file "%s".', $fileName));
// @codeCoverageIgnoreEnd
}
}
logger;
}
/**
* Set a logger instance.
*
* @param Mustache_Logger|Psr\Log\LoggerInterface $logger
*/
public function setLogger($logger = null)
{
if ($logger !== null && !($logger instanceof Mustache_Logger || is_a($logger, 'Psr\\Log\\LoggerInterface'))) {
throw new Mustache_Exception_InvalidArgumentException('Expected an instance of Mustache_Logger or Psr\\Log\\LoggerInterface.');
}
$this->logger = $logger;
}
/**
* Add a log record if logging is enabled.
*
* @param string $level The logging level
* @param string $message The log message
* @param array $context The log context
*/
protected function log($level, $message, array $context = array())
{
if (isset($this->logger)) {
$this->logger->log($level, $message, $context);
}
}
}
$helper` pairs.
*
* @throws Mustache_Exception_InvalidArgumentException if the $helpers argument isn't an array or Traversable
*
* @param array|Traversable $helpers (default: null)
*/
public function __construct($helpers = null)
{
if ($helpers === null) {
return;
}
if (!is_array($helpers) && !$helpers instanceof Traversable) {
throw new Mustache_Exception_InvalidArgumentException('HelperCollection constructor expects an array of helpers');
}
foreach ($helpers as $name => $helper) {
$this->add($name, $helper);
}
}
/**
* Magic mutator.
*
* @see Mustache_HelperCollection::add
*
* @param string $name
* @param mixed $helper
*/
public function __set($name, $helper)
{
$this->add($name, $helper);
}
/**
* Add a helper to this collection.
*
* @param string $name
* @param mixed $helper
*/
public function add($name, $helper)
{
$this->helpers[$name] = $helper;
}
/**
* Magic accessor.
*
* @see Mustache_HelperCollection::get
*
* @param string $name
*
* @return mixed Helper
*/
public function __get($name)
{
return $this->get($name);
}
/**
* Get a helper by name.
*
* @throws Mustache_Exception_UnknownHelperException If helper does not exist
*
* @param string $name
*
* @return mixed Helper
*/
public function get($name)
{
if (!$this->has($name)) {
throw new Mustache_Exception_UnknownHelperException($name);
}
return $this->helpers[$name];
}
/**
* Magic isset().
*
* @see Mustache_HelperCollection::has
*
* @param string $name
*
* @return bool True if helper is present
*/
public function __isset($name)
{
return $this->has($name);
}
/**
* Check whether a given helper is present in the collection.
*
* @param string $name
*
* @return bool True if helper is present
*/
public function has($name)
{
return array_key_exists($name, $this->helpers);
}
/**
* Magic unset().
*
* @see Mustache_HelperCollection::remove
*
* @param string $name
*/
public function __unset($name)
{
$this->remove($name);
}
/**
* Check whether a given helper is present in the collection.
*
* @throws Mustache_Exception_UnknownHelperException if the requested helper is not present
*
* @param string $name
*/
public function remove($name)
{
if (!$this->has($name)) {
throw new Mustache_Exception_UnknownHelperException($name);
}
unset($this->helpers[$name]);
}
/**
* Clear the helper collection.
*
* Removes all helpers from this collection
*/
public function clear()
{
$this->helpers = array();
}
/**
* Check whether the helper collection is empty.
*
* @return bool True if the collection is empty
*/
public function isEmpty()
{
return empty($this->helpers);
}
}
stack = array($context);
}
$this->buggyPropertyShadowing = $buggyPropertyShadowing;
}
/**
* Push a new Context frame onto the stack.
*
* @param mixed $value Object or array to use for context
*/
public function push($value)
{
array_push($this->stack, $value);
}
/**
* Push a new Context frame onto the block context stack.
*
* @param mixed $value Object or array to use for block context
*/
public function pushBlockContext($value)
{
array_push($this->blockStack, $value);
}
/**
* Pop the last Context frame from the stack.
*
* @return mixed Last Context frame (object or array)
*/
public function pop()
{
return array_pop($this->stack);
}
/**
* Pop the last block Context frame from the stack.
*
* @return mixed Last block Context frame (object or array)
*/
public function popBlockContext()
{
return array_pop($this->blockStack);
}
/**
* Get the last Context frame.
*
* @return mixed Last Context frame (object or array)
*/
public function last()
{
return end($this->stack);
}
/**
* Find a variable in the Context stack.
*
* Starting with the last Context frame (the context of the innermost section), and working back to the top-level
* rendering context, look for a variable with the given name:
*
* * If the Context frame is an associative array which contains the key $id, returns the value of that element.
* * If the Context frame is an object, this will check first for a public method, then a public property named
* $id. Failing both of these, it will try `__isset` and `__get` magic methods.
* * If a value named $id is not found in any Context frame, returns an empty string.
*
* @param string $id Variable name
*
* @return mixed Variable value, or '' if not found
*/
public function find($id)
{
return $this->findVariableInStack($id, $this->stack);
}
/**
* Find a 'dot notation' variable in the Context stack.
*
* Note that dot notation traversal bubbles through scope differently than the regular find method. After finding
* the initial chunk of the dotted name, each subsequent chunk is searched for only within the value of the previous
* result. For example, given the following context stack:
*
* $data = array(
* 'name' => 'Fred',
* 'child' => array(
* 'name' => 'Bob'
* ),
* );
*
* ... and the Mustache following template:
*
* {{ child.name }}
*
* ... the `name` value is only searched for within the `child` value of the global Context, not within parent
* Context frames.
*
* @param string $id Dotted variable selector
* @param bool $strictCallables (default: false)
*
* @return mixed Variable value, or '' if not found
*/
public function findDot($id, $strictCallables = false)
{
$chunks = explode('.', $id);
$first = array_shift($chunks);
$value = $this->findVariableInStack($first, $this->stack);
// This wasn't really a dotted name, so we can just return the value.
if (empty($chunks)) {
return $value;
}
foreach ($chunks as $chunk) {
$isCallable = $strictCallables ? (is_object($value) && is_callable($value)) : (!is_string($value) && is_callable($value));
if ($isCallable) {
$value = $value();
} elseif ($value === '') {
return $value;
}
$value = $this->findVariableInStack($chunk, array($value));
}
return $value;
}
/**
* Find an 'anchored dot notation' variable in the Context stack.
*
* This is the same as findDot(), except it looks in the top of the context
* stack for the first value, rather than searching the whole context stack
* and starting from there.
*
* @see Mustache_Context::findDot
*
* @throws Mustache_Exception_InvalidArgumentException if given an invalid anchored dot $id
*
* @param string $id Dotted variable selector
*
* @return mixed Variable value, or '' if not found
*/
public function findAnchoredDot($id)
{
$chunks = explode('.', $id);
$first = array_shift($chunks);
if ($first !== '') {
throw new Mustache_Exception_InvalidArgumentException(sprintf('Unexpected id for findAnchoredDot: %s', $id));
}
$value = $this->last();
foreach ($chunks as $chunk) {
if ($value === '') {
return $value;
}
$value = $this->findVariableInStack($chunk, array($value));
}
return $value;
}
/**
* Find an argument in the block context stack.
*
* @param string $id
*
* @return mixed Variable value, or '' if not found
*/
public function findInBlock($id)
{
foreach ($this->blockStack as $context) {
if (array_key_exists($id, $context)) {
return $context[$id];
}
}
return '';
}
/**
* Helper function to find a variable in the Context stack.
*
* @see Mustache_Context::find
*
* @param string $id Variable name
* @param array $stack Context stack
*
* @return mixed Variable value, or '' if not found
*/
private function findVariableInStack($id, array $stack)
{
for ($i = count($stack) - 1; $i >= 0; $i--) {
$frame = &$stack[$i];
switch (gettype($frame)) {
case 'object':
if (!($frame instanceof Closure)) {
// Note that is_callable() *will not work here*
// See https://github.com/bobthecow/mustache.php/wiki/Magic-Methods
if (method_exists($frame, $id)) {
return $frame->$id();
}
if (isset($frame->$id)) {
return $frame->$id;
}
// Preserve backwards compatibility with a property shadowing bug in
// Mustache.php <= 2.14.2
// See https://github.com/bobthecow/mustache.php/pull/410
if ($this->buggyPropertyShadowing) {
if ($frame instanceof ArrayAccess && isset($frame[$id])) {
return $frame[$id];
}
} else {
if (property_exists($frame, $id)) {
$rp = new \ReflectionProperty($frame, $id);
if ($rp->isPublic()) {
return $frame->$id;
}
}
if ($frame instanceof ArrayAccess && $frame->offsetExists($id)) {
return $frame[$id];
}
}
}
break;
case 'array':
if (array_key_exists($id, $frame)) {
return $frame[$id];
}
break;
}
}
return '';
}
}
mustache = $mustache;
}
/**
* Mustache Template instances can be treated as a function and rendered by simply calling them.
*
* $m = new Mustache_Engine;
* $tpl = $m->loadTemplate('Hello, {{ name }}!');
* echo $tpl(array('name' => 'World')); // "Hello, World!"
*
* @see Mustache_Template::render
*
* @param mixed $context Array or object rendering context (default: array())
*
* @return string Rendered template
*/
public function __invoke($context = array())
{
return $this->render($context);
}
/**
* Render this template given the rendering context.
*
* @param mixed $context Array or object rendering context (default: array())
*
* @return string Rendered template
*/
public function render($context = array())
{
return $this->renderInternal(
$this->prepareContextStack($context)
);
}
/**
* Internal rendering method implemented by Mustache Template concrete subclasses.
*
* This is where the magic happens :)
*
* NOTE: This method is not part of the Mustache.php public API.
*
* @param Mustache_Context $context
* @param string $indent (default: '')
*
* @return string Rendered template
*/
abstract public function renderInternal(Mustache_Context $context, $indent = '');
/**
* Tests whether a value should be iterated over (e.g. in a section context).
*
* In most languages there are two distinct array types: list and hash (or whatever you want to call them). Lists
* should be iterated, hashes should be treated as objects. Mustache follows this paradigm for Ruby, Javascript,
* Java, Python, etc.
*
* PHP, however, treats lists and hashes as one primitive type: array. So Mustache.php needs a way to distinguish
* between between a list of things (numeric, normalized array) and a set of variables to be used as section context
* (associative array). In other words, this will be iterated over:
*
* $items = array(
* array('name' => 'foo'),
* array('name' => 'bar'),
* array('name' => 'baz'),
* );
*
* ... but this will be used as a section context block:
*
* $items = array(
* 1 => array('name' => 'foo'),
* 'banana' => array('name' => 'bar'),
* 42 => array('name' => 'baz'),
* );
*
* @param mixed $value
*
* @return bool True if the value is 'iterable'
*/
protected function isIterable($value)
{
switch (gettype($value)) {
case 'object':
return $value instanceof Traversable;
case 'array':
$i = 0;
foreach ($value as $k => $v) {
if ($k !== $i++) {
return false;
}
}
return true;
default:
return false;
}
}
/**
* Helper method to prepare the Context stack.
*
* Adds the Mustache HelperCollection to the stack's top context frame if helpers are present.
*
* @param mixed $context Optional first context frame (default: null)
*
* @return Mustache_Context
*/
protected function prepareContextStack($context = null)
{
$stack = new Mustache_Context(null, $this->mustache->useBuggyPropertyShadowing());
$helpers = $this->mustache->getHelpers();
if (!$helpers->isEmpty()) {
$stack->push($helpers);
}
if (!empty($context)) {
$stack->push($context);
}
return $stack;
}
/**
* Resolve a context value.
*
* Invoke the value if it is callable, otherwise return the value.
*
* @param mixed $value
* @param Mustache_Context $context
*
* @return string
*/
protected function resolveValue($value, Mustache_Context $context)
{
if (($this->strictCallables ? is_object($value) : !is_string($value)) && is_callable($value)) {
$result = call_user_func($value);
if (is_string($result)) {
return $this->mustache
->loadLambda($result)
->renderInternal($context);
}
return $result;
}
return $value;
}
}
';
const T_PARENT = '<';
const T_DELIM_CHANGE = '=';
const T_ESCAPED = '_v';
const T_UNESCAPED = '{';
const T_UNESCAPED_2 = '&';
const T_TEXT = '_t';
const T_PRAGMA = '%';
const T_BLOCK_VAR = '$';
const T_BLOCK_ARG = '$arg';
// Valid token types
private static $tagTypes = array(
self::T_SECTION => true,
self::T_INVERTED => true,
self::T_END_SECTION => true,
self::T_COMMENT => true,
self::T_PARTIAL => true,
self::T_PARENT => true,
self::T_DELIM_CHANGE => true,
self::T_ESCAPED => true,
self::T_UNESCAPED => true,
self::T_UNESCAPED_2 => true,
self::T_PRAGMA => true,
self::T_BLOCK_VAR => true,
);
private static $tagNames = array(
self::T_SECTION => 'section',
self::T_INVERTED => 'inverted section',
self::T_END_SECTION => 'section end',
self::T_COMMENT => 'comment',
self::T_PARTIAL => 'partial',
self::T_PARENT => 'parent',
self::T_DELIM_CHANGE => 'set delimiter',
self::T_ESCAPED => 'variable',
self::T_UNESCAPED => 'unescaped variable',
self::T_UNESCAPED_2 => 'unescaped variable',
self::T_PRAGMA => 'pragma',
self::T_BLOCK_VAR => 'block variable',
self::T_BLOCK_ARG => 'block variable',
);
// Token properties
const TYPE = 'type';
const NAME = 'name';
const DYNAMIC = 'dynamic';
const OTAG = 'otag';
const CTAG = 'ctag';
const LINE = 'line';
const INDEX = 'index';
const END = 'end';
const INDENT = 'indent';
const NODES = 'nodes';
const VALUE = 'value';
const FILTERS = 'filters';
private $state;
private $tagType;
private $buffer;
private $tokens;
private $seenTag;
private $line;
private $otag;
private $otagChar;
private $otagLen;
private $ctag;
private $ctagChar;
private $ctagLen;
/**
* Scan and tokenize template source.
*
* @throws Mustache_Exception_SyntaxException when mismatched section tags are encountered
* @throws Mustache_Exception_InvalidArgumentException when $delimiters string is invalid
*
* @param string $text Mustache template source to tokenize
* @param string $delimiters Optionally, pass initial opening and closing delimiters (default: empty string)
*
* @return array Set of Mustache tokens
*/
public function scan($text, $delimiters = '')
{
// Setting mbstring.func_overload makes things *really* slow.
// Let's do everyone a favor and scan this string as ASCII instead.
//
// The INI directive was removed in PHP 8.0 so we don't need to check there (and can drop it
// when we remove support for older versions of PHP).
//
// @codeCoverageIgnoreStart
$encoding = null;
if (version_compare(PHP_VERSION, '8.0.0', '<')) {
if (function_exists('mb_internal_encoding') && ini_get('mbstring.func_overload') & 2) {
$encoding = mb_internal_encoding();
mb_internal_encoding('ASCII');
}
}
// @codeCoverageIgnoreEnd
$this->reset();
if (is_string($delimiters) && $delimiters = trim($delimiters)) {
$this->setDelimiters($delimiters);
}
$len = strlen($text);
for ($i = 0; $i < $len; $i++) {
switch ($this->state) {
case self::IN_TEXT:
$char = $text[$i];
// Test whether it's time to change tags.
if ($char === $this->otagChar && substr($text, $i, $this->otagLen) === $this->otag) {
$i--;
$this->flushBuffer();
$this->state = self::IN_TAG_TYPE;
} else {
$this->buffer .= $char;
if ($char === "\n") {
$this->flushBuffer();
$this->line++;
}
}
break;
case self::IN_TAG_TYPE:
$i += $this->otagLen - 1;
$char = $text[$i + 1];
if (isset(self::$tagTypes[$char])) {
$tag = $char;
$this->tagType = $tag;
} else {
$tag = null;
$this->tagType = self::T_ESCAPED;
}
if ($this->tagType === self::T_DELIM_CHANGE) {
$i = $this->changeDelimiters($text, $i);
$this->state = self::IN_TEXT;
} elseif ($this->tagType === self::T_PRAGMA) {
$i = $this->addPragma($text, $i);
$this->state = self::IN_TEXT;
} else {
if ($tag !== null) {
$i++;
}
$this->state = self::IN_TAG;
}
$this->seenTag = $i;
break;
default:
$char = $text[$i];
// Test whether it's time to change tags.
if ($char === $this->ctagChar && substr($text, $i, $this->ctagLen) === $this->ctag) {
$token = array(
self::TYPE => $this->tagType,
self::NAME => trim($this->buffer),
self::OTAG => $this->otag,
self::CTAG => $this->ctag,
self::LINE => $this->line,
self::INDEX => ($this->tagType === self::T_END_SECTION) ? $this->seenTag - $this->otagLen : $i + $this->ctagLen,
);
if ($this->tagType === self::T_UNESCAPED) {
// Clean up `{{{ tripleStache }}}` style tokens.
if ($this->ctag === '}}') {
if (($i + 2 < $len) && $text[$i + 2] === '}') {
$i++;
} else {
$msg = sprintf(
'Mismatched tag delimiters: %s on line %d',
$token[self::NAME],
$token[self::LINE]
);
throw new Mustache_Exception_SyntaxException($msg, $token);
}
} else {
$lastName = $token[self::NAME];
if (substr($lastName, -1) === '}') {
$token[self::NAME] = trim(substr($lastName, 0, -1));
} else {
$msg = sprintf(
'Mismatched tag delimiters: %s on line %d',
$token[self::NAME],
$token[self::LINE]
);
throw new Mustache_Exception_SyntaxException($msg, $token);
}
}
}
$this->buffer = '';
$i += $this->ctagLen - 1;
$this->state = self::IN_TEXT;
$this->tokens[] = $token;
} else {
$this->buffer .= $char;
}
break;
}
}
if ($this->state !== self::IN_TEXT) {
$this->throwUnclosedTagException();
}
$this->flushBuffer();
// Restore the user's encoding...
// @codeCoverageIgnoreStart
if ($encoding) {
mb_internal_encoding($encoding);
}
// @codeCoverageIgnoreEnd
return $this->tokens;
}
/**
* Helper function to reset tokenizer internal state.
*/
private function reset()
{
$this->state = self::IN_TEXT;
$this->tagType = null;
$this->buffer = '';
$this->tokens = array();
$this->seenTag = false;
$this->line = 0;
$this->otag = '{{';
$this->otagChar = '{';
$this->otagLen = 2;
$this->ctag = '}}';
$this->ctagChar = '}';
$this->ctagLen = 2;
}
/**
* Flush the current buffer to a token.
*/
private function flushBuffer()
{
if (strlen($this->buffer) > 0) {
$this->tokens[] = array(
self::TYPE => self::T_TEXT,
self::LINE => $this->line,
self::VALUE => $this->buffer,
);
$this->buffer = '';
}
}
/**
* Change the current Mustache delimiters. Set new `otag` and `ctag` values.
*
* @throws Mustache_Exception_SyntaxException when delimiter string is invalid
*
* @param string $text Mustache template source
* @param int $index Current tokenizer index
*
* @return int New index value
*/
private function changeDelimiters($text, $index)
{
$startIndex = strpos($text, '=', $index) + 1;
$close = '=' . $this->ctag;
$closeIndex = strpos($text, $close, $index);
if ($closeIndex === false) {
$this->throwUnclosedTagException();
}
$token = array(
self::TYPE => self::T_DELIM_CHANGE,
self::LINE => $this->line,
);
try {
$this->setDelimiters(trim(substr($text, $startIndex, $closeIndex - $startIndex)));
} catch (Mustache_Exception_InvalidArgumentException $e) {
throw new Mustache_Exception_SyntaxException($e->getMessage(), $token);
}
$this->tokens[] = $token;
return $closeIndex + strlen($close) - 1;
}
/**
* Set the current Mustache `otag` and `ctag` delimiters.
*
* @throws Mustache_Exception_InvalidArgumentException when delimiter string is invalid
*
* @param string $delimiters
*/
private function setDelimiters($delimiters)
{
if (!preg_match('/^\s*(\S+)\s+(\S+)\s*$/', $delimiters, $matches)) {
throw new Mustache_Exception_InvalidArgumentException(sprintf('Invalid delimiters: %s', $delimiters));
}
list($_, $otag, $ctag) = $matches;
$this->otag = $otag;
$this->otagChar = $otag[0];
$this->otagLen = strlen($otag);
$this->ctag = $ctag;
$this->ctagChar = $ctag[0];
$this->ctagLen = strlen($ctag);
}
/**
* Add pragma token.
*
* Pragmas are hoisted to the front of the template, so all pragma tokens
* will appear at the front of the token list.
*
* @param string $text
* @param int $index
*
* @return int New index value
*/
private function addPragma($text, $index)
{
$end = strpos($text, $this->ctag, $index);
if ($end === false) {
$this->throwUnclosedTagException();
}
$pragma = trim(substr($text, $index + 2, $end - $index - 2));
// Pragmas are hoisted to the front of the template.
array_unshift($this->tokens, array(
self::TYPE => self::T_PRAGMA,
self::NAME => $pragma,
self::LINE => 0,
));
return $end + $this->ctagLen - 1;
}
private function throwUnclosedTagException()
{
$name = trim($this->buffer);
if ($name !== '') {
$msg = sprintf('Unclosed tag: %s on line %d', $name, $this->line);
} else {
$msg = sprintf('Unclosed tag on line %d', $this->line);
}
throw new Mustache_Exception_SyntaxException($msg, array(
self::TYPE => $this->tagType,
self::NAME => $name,
self::OTAG => $this->otag,
self::CTAG => $this->ctag,
self::LINE => $this->line,
self::INDEX => $this->seenTag - $this->otagLen,
));
}
/**
* Get the human readable name for a tag type.
*
* @param string $tagType One of the tokenizer T_* constants
*
* @return string
*/
static function getTagName($tagType)
{
return isset(self::$tagNames[$tagType]) ? self::$tagNames[$tagType] : 'unknown';
}
}
log(Mustache_Logger::EMERGENCY, $message, $context);
}
/**
* Action must be taken immediately.
*
* Example: Entire website down, database unavailable, etc. This should
* trigger the SMS alerts and wake you up.
*
* @param string $message
* @param array $context
*/
public function alert($message, array $context = array())
{
$this->log(Mustache_Logger::ALERT, $message, $context);
}
/**
* Critical conditions.
*
* Example: Application component unavailable, unexpected exception.
*
* @param string $message
* @param array $context
*/
public function critical($message, array $context = array())
{
$this->log(Mustache_Logger::CRITICAL, $message, $context);
}
/**
* Runtime errors that do not require immediate action but should typically
* be logged and monitored.
*
* @param string $message
* @param array $context
*/
public function error($message, array $context = array())
{
$this->log(Mustache_Logger::ERROR, $message, $context);
}
/**
* Exceptional occurrences that are not errors.
*
* Example: Use of deprecated APIs, poor use of an API, undesirable things
* that are not necessarily wrong.
*
* @param string $message
* @param array $context
*/
public function warning($message, array $context = array())
{
$this->log(Mustache_Logger::WARNING, $message, $context);
}
/**
* Normal but significant events.
*
* @param string $message
* @param array $context
*/
public function notice($message, array $context = array())
{
$this->log(Mustache_Logger::NOTICE, $message, $context);
}
/**
* Interesting events.
*
* Example: User logs in, SQL logs.
*
* @param string $message
* @param array $context
*/
public function info($message, array $context = array())
{
$this->log(Mustache_Logger::INFO, $message, $context);
}
/**
* Detailed debug information.
*
* @param string $message
* @param array $context
*/
public function debug($message, array $context = array())
{
$this->log(Mustache_Logger::DEBUG, $message, $context);
}
}
100,
self::INFO => 200,
self::NOTICE => 250,
self::WARNING => 300,
self::ERROR => 400,
self::CRITICAL => 500,
self::ALERT => 550,
self::EMERGENCY => 600,
);
protected $level;
protected $stream = null;
protected $url = null;
/**
* @throws InvalidArgumentException if the logging level is unknown
*
* @param resource|string $stream Resource instance or URL
* @param int $level The minimum logging level at which this handler will be triggered
*/
public function __construct($stream, $level = Mustache_Logger::ERROR)
{
$this->setLevel($level);
if (is_resource($stream)) {
$this->stream = $stream;
} else {
$this->url = $stream;
}
}
/**
* Close stream resources.
*/
public function __destruct()
{
if (is_resource($this->stream)) {
fclose($this->stream);
}
}
/**
* Set the minimum logging level.
*
* @throws Mustache_Exception_InvalidArgumentException if the logging level is unknown
*
* @param int $level The minimum logging level which will be written
*/
public function setLevel($level)
{
if (!array_key_exists($level, self::$levels)) {
throw new Mustache_Exception_InvalidArgumentException(sprintf('Unexpected logging level: %s', $level));
}
$this->level = $level;
}
/**
* Get the current minimum logging level.
*
* @return int
*/
public function getLevel()
{
return $this->level;
}
/**
* Logs with an arbitrary level.
*
* @throws Mustache_Exception_InvalidArgumentException if the logging level is unknown
*
* @param mixed $level
* @param string $message
* @param array $context
*/
public function log($level, $message, array $context = array())
{
if (!array_key_exists($level, self::$levels)) {
throw new Mustache_Exception_InvalidArgumentException(sprintf('Unexpected logging level: %s', $level));
}
if (self::$levels[$level] >= self::$levels[$this->level]) {
$this->writeLog($level, $message, $context);
}
}
/**
* Write a record to the log.
*
* @throws Mustache_Exception_LogicException If neither a stream resource nor url is present
* @throws Mustache_Exception_RuntimeException If the stream url cannot be opened
*
* @param int $level The logging level
* @param string $message The log message
* @param array $context The log context
*/
protected function writeLog($level, $message, array $context = array())
{
if (!is_resource($this->stream)) {
if (!isset($this->url)) {
throw new Mustache_Exception_LogicException('Missing stream url, the stream can not be opened. This may be caused by a premature call to close().');
}
$this->stream = fopen($this->url, 'a');
if (!is_resource($this->stream)) {
// @codeCoverageIgnoreStart
throw new Mustache_Exception_RuntimeException(sprintf('The stream or file "%s" could not be opened.', $this->url));
// @codeCoverageIgnoreEnd
}
}
fwrite($this->stream, self::formatLine($level, $message, $context));
}
/**
* Gets the name of the logging level.
*
* @throws InvalidArgumentException if the logging level is unknown
*
* @param int $level
*
* @return string
*/
protected static function getLevelName($level)
{
return strtoupper($level);
}
/**
* Format a log line for output.
*
* @param int $level The logging level
* @param string $message The log message
* @param array $context The log context
*
* @return string
*/
protected static function formatLine($level, $message, array $context = array())
{
return sprintf(
"%s: %s\n",
self::getLevelName($level),
self::interpolateMessage($message, $context)
);
}
/**
* Interpolate context values into the message placeholders.
*
* @param string $message
* @param array $context
*
* @return string
*/
protected static function interpolateMessage($message, array $context = array())
{
if (strpos($message, '{') === false) {
return $message;
}
// build a replacement array with braces around the context keys
$replace = array();
foreach ($context as $key => $val) {
$replace['{' . $key . '}'] = $val;
}
// interpolate replacement values into the the message and return
return strtr($message, $replace);
}
}
baseDir = $realDir;
} else {
$this->baseDir = $baseDir;
}
}
/**
* Register a new instance as an SPL autoloader.
*
* @param string $baseDir Mustache library base directory (default: dirname(__FILE__).'/..')
*
* @return Mustache_Autoloader Registered Autoloader instance
*/
public static function register($baseDir = null)
{
$key = $baseDir ? $baseDir : 0;
if (!isset(self::$instances[$key])) {
self::$instances[$key] = new self($baseDir);
}
$loader = self::$instances[$key];
spl_autoload_register(array($loader, 'autoload'));
return $loader;
}
/**
* Autoload Mustache classes.
*
* @param string $class
*/
public function autoload($class)
{
if ($class[0] === '\\') {
$class = substr($class, 1);
}
if (strpos($class, 'Mustache') !== 0) {
return;
}
$file = sprintf('%s/%s.php', $this->baseDir, str_replace('_', '/', $class));
if (is_file($file)) {
require $file;
}
}
}
pragmas = $this->defaultPragmas;
$this->sections = array();
$this->blocks = array();
$this->source = $source;
$this->indentNextLine = true;
$this->customEscape = $customEscape;
$this->entityFlags = $entityFlags;
$this->charset = $charset;
$this->strictCallables = $strictCallables;
return $this->writeCode($tree, $name);
}
/**
* Enable pragmas across all templates, regardless of the presence of pragma
* tags in the individual templates.
*
* @internal Users should set global pragmas in Mustache_Engine, not here :)
*
* @param string[] $pragmas
*/
public function setPragmas(array $pragmas)
{
$this->pragmas = array();
foreach ($pragmas as $pragma) {
$this->pragmas[$pragma] = true;
}
$this->defaultPragmas = $this->pragmas;
}
/**
* Helper function for walking the Mustache token parse tree.
*
* @throws Mustache_Exception_SyntaxException upon encountering unknown token types
*
* @param array $tree Parse tree of Mustache tokens
* @param int $level (default: 0)
*
* @return string Generated PHP source code
*/
private function walk(array $tree, $level = 0)
{
$code = '';
$level++;
foreach ($tree as $node) {
switch ($node[Mustache_Tokenizer::TYPE]) {
case Mustache_Tokenizer::T_PRAGMA:
$this->pragmas[$node[Mustache_Tokenizer::NAME]] = true;
break;
case Mustache_Tokenizer::T_SECTION:
$code .= $this->section(
$node[Mustache_Tokenizer::NODES],
$node[Mustache_Tokenizer::NAME],
isset($node[Mustache_Tokenizer::FILTERS]) ? $node[Mustache_Tokenizer::FILTERS] : array(),
$node[Mustache_Tokenizer::INDEX],
$node[Mustache_Tokenizer::END],
$node[Mustache_Tokenizer::OTAG],
$node[Mustache_Tokenizer::CTAG],
$level
);
break;
case Mustache_Tokenizer::T_INVERTED:
$code .= $this->invertedSection(
$node[Mustache_Tokenizer::NODES],
$node[Mustache_Tokenizer::NAME],
isset($node[Mustache_Tokenizer::FILTERS]) ? $node[Mustache_Tokenizer::FILTERS] : array(),
$level
);
break;
case Mustache_Tokenizer::T_PARTIAL:
$code .= $this->partial(
$node[Mustache_Tokenizer::NAME],
isset($node[Mustache_Tokenizer::DYNAMIC]) ? $node[Mustache_Tokenizer::DYNAMIC] : false,
isset($node[Mustache_Tokenizer::INDENT]) ? $node[Mustache_Tokenizer::INDENT] : '',
$level
);
break;
case Mustache_Tokenizer::T_PARENT:
$code .= $this->parent(
$node[Mustache_Tokenizer::NAME],
isset($node[Mustache_Tokenizer::DYNAMIC]) ? $node[Mustache_Tokenizer::DYNAMIC] : false,
isset($node[Mustache_Tokenizer::INDENT]) ? $node[Mustache_Tokenizer::INDENT] : '',
$node[Mustache_Tokenizer::NODES],
$level
);
break;
case Mustache_Tokenizer::T_BLOCK_ARG:
$code .= $this->blockArg(
$node[Mustache_Tokenizer::NODES],
$node[Mustache_Tokenizer::NAME],
$node[Mustache_Tokenizer::INDEX],
$node[Mustache_Tokenizer::END],
$node[Mustache_Tokenizer::OTAG],
$node[Mustache_Tokenizer::CTAG],
$level
);
break;
case Mustache_Tokenizer::T_BLOCK_VAR:
$code .= $this->blockVar(
$node[Mustache_Tokenizer::NODES],
$node[Mustache_Tokenizer::NAME],
$node[Mustache_Tokenizer::INDEX],
$node[Mustache_Tokenizer::END],
$node[Mustache_Tokenizer::OTAG],
$node[Mustache_Tokenizer::CTAG],
$level
);
break;
case Mustache_Tokenizer::T_COMMENT:
break;
case Mustache_Tokenizer::T_ESCAPED:
case Mustache_Tokenizer::T_UNESCAPED:
case Mustache_Tokenizer::T_UNESCAPED_2:
$code .= $this->variable(
$node[Mustache_Tokenizer::NAME],
isset($node[Mustache_Tokenizer::FILTERS]) ? $node[Mustache_Tokenizer::FILTERS] : array(),
$node[Mustache_Tokenizer::TYPE] === Mustache_Tokenizer::T_ESCAPED,
$level
);
break;
case Mustache_Tokenizer::T_TEXT:
$code .= $this->text($node[Mustache_Tokenizer::VALUE], $level);
break;
default:
throw new Mustache_Exception_SyntaxException(sprintf('Unknown token type: %s', $node[Mustache_Tokenizer::TYPE]), $node);
}
}
return $code;
}
const KLASS = 'lambdaHelper = new Mustache_LambdaHelper($this->mustache, $context);
$buffer = \'\';
%s
return $buffer;
}
%s
%s
}';
const KLASS_NO_LAMBDAS = 'walk($tree);
$sections = implode("\n", $this->sections);
$blocks = implode("\n", $this->blocks);
$klass = empty($this->sections) && empty($this->blocks) ? self::KLASS_NO_LAMBDAS : self::KLASS;
$callable = $this->strictCallables ? $this->prepare(self::STRICT_CALLABLE) : '';
return sprintf($this->prepare($klass, 0, false, true), $name, $callable, $code, $sections, $blocks);
}
const BLOCK_VAR = '
$blockFunction = $context->findInBlock(%s);
if (is_callable($blockFunction)) {
$buffer .= call_user_func($blockFunction, $context);
%s}
';
const BLOCK_VAR_ELSE = '} else {%s';
/**
* Generate Mustache Template inheritance block variable PHP source.
*
* @param array $nodes Array of child tokens
* @param string $id Section name
* @param int $start Section start offset
* @param int $end Section end offset
* @param string $otag Current Mustache opening tag
* @param string $ctag Current Mustache closing tag
* @param int $level
*
* @return string Generated PHP source code
*/
private function blockVar($nodes, $id, $start, $end, $otag, $ctag, $level)
{
$id = var_export($id, true);
$else = $this->walk($nodes, $level);
if ($else !== '') {
$else = sprintf($this->prepare(self::BLOCK_VAR_ELSE, $level + 1, false, true), $else);
}
return sprintf($this->prepare(self::BLOCK_VAR, $level), $id, $else);
}
const BLOCK_ARG = '%s => array($this, \'block%s\'),';
/**
* Generate Mustache Template inheritance block argument PHP source.
*
* @param array $nodes Array of child tokens
* @param string $id Section name
* @param int $start Section start offset
* @param int $end Section end offset
* @param string $otag Current Mustache opening tag
* @param string $ctag Current Mustache closing tag
* @param int $level
*
* @return string Generated PHP source code
*/
private function blockArg($nodes, $id, $start, $end, $otag, $ctag, $level)
{
$key = $this->block($nodes);
$id = var_export($id, true);
return sprintf($this->prepare(self::BLOCK_ARG, $level), $id, $key);
}
const BLOCK_FUNCTION = '
public function block%s($context)
{
$indent = $buffer = \'\';%s
return $buffer;
}
';
/**
* Generate Mustache Template inheritance block function PHP source.
*
* @param array $nodes Array of child tokens
*
* @return string key of new block function
*/
private function block($nodes)
{
$code = $this->walk($nodes, 0);
$key = ucfirst(md5($code));
if (!isset($this->blocks[$key])) {
$this->blocks[$key] = sprintf($this->prepare(self::BLOCK_FUNCTION, 0), $key, $code);
}
return $key;
}
const SECTION_CALL = '
$value = $context->%s(%s%s);%s
$buffer .= $this->section%s($context, $indent, $value);
';
const SECTION = '
private function section%s(Mustache_Context $context, $indent, $value)
{
$buffer = \'\';
if (%s) {
$source = %s;
$value = call_user_func($value, $source, %s);
if (is_string($value)) {
if (strpos($value, \'{{\') === false) {
return $value;
}
return $this->mustache
->loadLambda($value%s)
->renderInternal($context);
}
}
if (!empty($value)) {
$values = $this->isIterable($value) ? $value : array($value);
foreach ($values as $value) {
$context->push($value);
%s
$context->pop();
}
}
return $buffer;
}
';
/**
* Generate Mustache Template section PHP source.
*
* @param array $nodes Array of child tokens
* @param string $id Section name
* @param string[] $filters Array of filters
* @param int $start Section start offset
* @param int $end Section end offset
* @param string $otag Current Mustache opening tag
* @param string $ctag Current Mustache closing tag
* @param int $level
*
* @return string Generated section PHP source code
*/
private function section($nodes, $id, $filters, $start, $end, $otag, $ctag, $level)
{
$source = var_export(substr($this->source, $start, $end - $start), true);
$callable = $this->getCallable();
if ($otag !== '{{' || $ctag !== '}}') {
$delimTag = var_export(sprintf('{{= %s %s =}}', $otag, $ctag), true);
$helper = sprintf('$this->lambdaHelper->withDelimiters(%s)', $delimTag);
$delims = ', ' . $delimTag;
} else {
$helper = '$this->lambdaHelper';
$delims = '';
}
$key = ucfirst(md5($delims . "\n" . $source));
if (!isset($this->sections[$key])) {
$this->sections[$key] = sprintf($this->prepare(self::SECTION), $key, $callable, $source, $helper, $delims, $this->walk($nodes, 2));
}
$method = $this->getFindMethod($id);
$id = var_export($id, true);
$findArg = $this->getFindMethodArgs($method);
$filters = $this->getFilters($filters, $level);
return sprintf($this->prepare(self::SECTION_CALL, $level), $method, $id, $findArg, $filters, $key);
}
const INVERTED_SECTION = '
$value = $context->%s(%s%s);%s
if (empty($value)) {
%s
}
';
/**
* Generate Mustache Template inverted section PHP source.
*
* @param array $nodes Array of child tokens
* @param string $id Section name
* @param string[] $filters Array of filters
* @param int $level
*
* @return string Generated inverted section PHP source code
*/
private function invertedSection($nodes, $id, $filters, $level)
{
$method = $this->getFindMethod($id);
$id = var_export($id, true);
$findArg = $this->getFindMethodArgs($method);
$filters = $this->getFilters($filters, $level);
return sprintf($this->prepare(self::INVERTED_SECTION, $level), $method, $id, $findArg, $filters, $this->walk($nodes, $level));
}
const DYNAMIC_NAME = '$this->resolveValue($context->%s(%s%s), $context)';
/**
* Generate Mustache Template dynamic name resolution PHP source.
*
* @param string $id Tag name
* @param bool $dynamic True if the name is dynamic
*
* @return string Dynamic name resolution PHP source code
*/
private function resolveDynamicName($id, $dynamic)
{
if (!$dynamic) {
return var_export($id, true);
}
$method = $this->getFindMethod($id);
$id = ($method !== 'last') ? var_export($id, true) : '';
$findArg = $this->getFindMethodArgs($method);
// TODO: filters?
return sprintf(self::DYNAMIC_NAME, $method, $id, $findArg);
}
const PARTIAL_INDENT = ', $indent . %s';
const PARTIAL = '
if ($partial = $this->mustache->loadPartial(%s)) {
$buffer .= $partial->renderInternal($context%s);
}
';
/**
* Generate Mustache Template partial call PHP source.
*
* @param string $id Partial name
* @param bool $dynamic Partial name is dynamic
* @param string $indent Whitespace indent to apply to partial
* @param int $level
*
* @return string Generated partial call PHP source code
*/
private function partial($id, $dynamic, $indent, $level)
{
if ($indent !== '') {
$indentParam = sprintf(self::PARTIAL_INDENT, var_export($indent, true));
} else {
$indentParam = '';
}
return sprintf(
$this->prepare(self::PARTIAL, $level),
$this->resolveDynamicName($id, $dynamic),
$indentParam
);
}
const PARENT = '
if ($parent = $this->mustache->loadPartial(%s)) {
$context->pushBlockContext(array(%s
));
$buffer .= $parent->renderInternal($context, $indent);
$context->popBlockContext();
}
';
const PARENT_NO_CONTEXT = '
if ($parent = $this->mustache->loadPartial(%s)) {
$buffer .= $parent->renderInternal($context, $indent);
}
';
/**
* Generate Mustache Template inheritance parent call PHP source.
*
* @param string $id Parent tag name
* @param bool $dynamic Tag name is dynamic
* @param string $indent Whitespace indent to apply to parent
* @param array $children Child nodes
* @param int $level
*
* @return string Generated PHP source code
*/
private function parent($id, $dynamic, $indent, array $children, $level)
{
$realChildren = array_filter($children, array(__CLASS__, 'onlyBlockArgs'));
$partialName = $this->resolveDynamicName($id, $dynamic);
if (empty($realChildren)) {
return sprintf($this->prepare(self::PARENT_NO_CONTEXT, $level), $partialName);
}
return sprintf(
$this->prepare(self::PARENT, $level),
$partialName,
$this->walk($realChildren, $level + 1)
);
}
/**
* Helper method for filtering out non-block-arg tokens.
*
* @param array $node
*
* @return bool True if $node is a block arg token
*/
private static function onlyBlockArgs(array $node)
{
return $node[Mustache_Tokenizer::TYPE] === Mustache_Tokenizer::T_BLOCK_ARG;
}
const VARIABLE = '
$value = $this->resolveValue($context->%s(%s%s), $context);%s
$buffer .= %s($value === null ? \'\' : %s);
';
/**
* Generate Mustache Template variable interpolation PHP source.
*
* @param string $id Variable name
* @param string[] $filters Array of filters
* @param bool $escape Escape the variable value for output?
* @param int $level
*
* @return string Generated variable interpolation PHP source
*/
private function variable($id, $filters, $escape, $level)
{
$method = $this->getFindMethod($id);
$id = ($method !== 'last') ? var_export($id, true) : '';
$findArg = $this->getFindMethodArgs($method);
$filters = $this->getFilters($filters, $level);
$value = $escape ? $this->getEscape() : '$value';
return sprintf($this->prepare(self::VARIABLE, $level), $method, $id, $findArg, $filters, $this->flushIndent(), $value);
}
const FILTER = '
$filter = $context->%s(%s%s);
if (!(%s)) {
throw new Mustache_Exception_UnknownFilterException(%s);
}
$value = call_user_func($filter, %s);%s
';
const FILTER_FIRST_VALUE = '$this->resolveValue($value, $context)';
const FILTER_VALUE = '$value';
/**
* Generate Mustache Template variable filtering PHP source.
*
* If the initial $value is a lambda it will be resolved before starting the filter chain.
*
* @param string[] $filters Array of filters
* @param int $level
* @param bool $first (default: false)
*
* @return string Generated filter PHP source
*/
private function getFilters(array $filters, $level, $first = true)
{
if (empty($filters)) {
return '';
}
$name = array_shift($filters);
$method = $this->getFindMethod($name);
$filter = ($method !== 'last') ? var_export($name, true) : '';
$findArg = $this->getFindMethodArgs($method);
$callable = $this->getCallable('$filter');
$msg = var_export($name, true);
$value = $first ? self::FILTER_FIRST_VALUE : self::FILTER_VALUE;
return sprintf($this->prepare(self::FILTER, $level), $method, $filter, $findArg, $callable, $msg, $value, $this->getFilters($filters, $level, false));
}
const LINE = '$buffer .= "\n";';
const TEXT = '$buffer .= %s%s;';
/**
* Generate Mustache Template output Buffer call PHP source.
*
* @param string $text
* @param int $level
*
* @return string Generated output Buffer call PHP source
*/
private function text($text, $level)
{
$indentNextLine = (substr($text, -1) === "\n");
$code = sprintf($this->prepare(self::TEXT, $level), $this->flushIndent(), var_export($text, true));
$this->indentNextLine = $indentNextLine;
return $code;
}
/**
* Prepare PHP source code snippet for output.
*
* @param string $text
* @param int $bonus Additional indent level (default: 0)
* @param bool $prependNewline Prepend a newline to the snippet? (default: true)
* @param bool $appendNewline Append a newline to the snippet? (default: false)
*
* @return string PHP source code snippet
*/
private function prepare($text, $bonus = 0, $prependNewline = true, $appendNewline = false)
{
$text = ($prependNewline ? "\n" : '') . trim($text);
if ($prependNewline) {
$bonus++;
}
if ($appendNewline) {
$text .= "\n";
}
return preg_replace("/\n( {8})?/", "\n" . str_repeat(' ', $bonus * 4), $text);
}
const DEFAULT_ESCAPE = 'htmlspecialchars(%s, %s, %s)';
const CUSTOM_ESCAPE = 'call_user_func($this->mustache->getEscape(), %s)';
/**
* Get the current escaper.
*
* @param string $value (default: '$value')
*
* @return string Either a custom callback, or an inline call to `htmlspecialchars`
*/
private function getEscape($value = '$value')
{
if ($this->customEscape) {
return sprintf(self::CUSTOM_ESCAPE, $value);
}
return sprintf(self::DEFAULT_ESCAPE, $value, var_export($this->entityFlags, true), var_export($this->charset, true));
}
/**
* Select the appropriate Context `find` method for a given $id.
*
* The return value will be one of `find`, `findDot`, `findAnchoredDot` or `last`.
*
* @see Mustache_Context::find
* @see Mustache_Context::findDot
* @see Mustache_Context::last
*
* @param string $id Variable name
*
* @return string `find` method name
*/
private function getFindMethod($id)
{
if ($id === '.') {
return 'last';
}
if (isset($this->pragmas[Mustache_Engine::PRAGMA_ANCHORED_DOT]) && $this->pragmas[Mustache_Engine::PRAGMA_ANCHORED_DOT]) {
if (substr($id, 0, 1) === '.') {
return 'findAnchoredDot';
}
}
if (strpos($id, '.') === false) {
return 'find';
}
return 'findDot';
}
/**
* Get the args needed for a given find method.
*
* In this case, it's "true" iff it's a "find dot" method and strict callables is enabled.
*
* @param string $method Find method name
*/
private function getFindMethodArgs($method)
{
if (($method === 'findDot' || $method === 'findAnchoredDot') && $this->strictCallables) {
return ', true';
}
return '';
}
const IS_CALLABLE = '!is_string(%s) && is_callable(%s)';
const STRICT_IS_CALLABLE = 'is_object(%s) && is_callable(%s)';
/**
* Helper function to compile strict vs lax "is callable" logic.
*
* @param string $variable (default: '$value')
*
* @return string "is callable" logic
*/
private function getCallable($variable = '$value')
{
$tpl = $this->strictCallables ? self::STRICT_IS_CALLABLE : self::IS_CALLABLE;
return sprintf($tpl, $variable, $variable);
}
const LINE_INDENT = '$indent . ';
/**
* Get the current $indent prefix to write to the buffer.
*
* @return string "$indent . " or ""
*/
private function flushIndent()
{
if (!$this->indentNextLine) {
return '';
}
$this->indentNextLine = false;
return self::LINE_INDENT;
}
}
fileName = $fileName;
$this->statProps = $statProps;
}
/**
* Get the Source key (used to generate the compiled class name).
*
* @throws Mustache_Exception_RuntimeException when a source file cannot be read
*
* @return string
*/
public function getKey()
{
$chunks = array(
'fileName' => $this->fileName,
);
if (!empty($this->statProps)) {
if (!isset($this->stat)) {
$this->stat = @stat($this->fileName);
}
if ($this->stat === false) {
throw new Mustache_Exception_RuntimeException(sprintf('Failed to read source file "%s".', $this->fileName));
}
foreach ($this->statProps as $prop) {
$chunks[$prop] = $this->stat[$prop];
}
}
return json_encode($chunks);
}
/**
* Get the template Source.
*
* @return string
*/
public function getSource()
{
return file_get_contents($this->fileName);
}
}
=}}`. (default: null)
*/
public function __construct(Mustache_Engine $mustache, Mustache_Context $context, $delims = null)
{
$this->mustache = $mustache;
$this->context = $context;
$this->delims = $delims;
}
/**
* Render a string as a Mustache template with the current rendering context.
*
* @param string $string
*
* @return string Rendered template
*/
public function render($string)
{
return $this->mustache
->loadLambda((string) $string, $this->delims)
->renderInternal($this->context);
}
/**
* Render a string as a Mustache template with the current rendering context.
*
* @param string $string
*
* @return string Rendered template
*/
public function __invoke($string)
{
return $this->render($string);
}
/**
* Get a Lambda Helper with custom delimiters.
*
* @param string $delims Custom delimiters, in the format `{{= <% %> =}}`
*
* @return Mustache_LambdaHelper
*/
public function withDelimiters($delims)
{
return new self($this->mustache, $this->context, $delims);
}
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process\Pipes;
use Symfony\Component\Process\Process;
/**
* UnixPipes implementation uses unix pipes as handles.
*
* @author Romain Neutron
*
* @internal
*/
class UnixPipes extends AbstractPipes
{
private $ttyMode;
private $ptyMode;
private $haveReadSupport;
public function __construct($ttyMode, $ptyMode, $input, $haveReadSupport)
{
$this->ttyMode = (bool) $ttyMode;
$this->ptyMode = (bool) $ptyMode;
$this->haveReadSupport = (bool) $haveReadSupport;
parent::__construct($input);
}
public function __destruct()
{
$this->close();
}
/**
* {@inheritdoc}
*/
public function getDescriptors()
{
if (!$this->haveReadSupport) {
$nullstream = fopen('/dev/null', 'c');
return [
['pipe', 'r'],
$nullstream,
$nullstream,
];
}
if ($this->ttyMode) {
return [
['file', '/dev/tty', 'r'],
['file', '/dev/tty', 'w'],
['file', '/dev/tty', 'w'],
];
}
if ($this->ptyMode && Process::isPtySupported()) {
return [
['pty'],
['pty'],
['pty'],
];
}
return [
['pipe', 'r'],
['pipe', 'w'], // stdout
['pipe', 'w'], // stderr
];
}
/**
* {@inheritdoc}
*/
public function getFiles()
{
return [];
}
/**
* {@inheritdoc}
*/
public function readAndWrite($blocking, $close = false)
{
$this->unblock();
$w = $this->write();
$read = $e = [];
$r = $this->pipes;
unset($r[0]);
// let's have a look if something changed in streams
set_error_handler([$this, 'handleError']);
if (($r || $w) && false === stream_select($r, $w, $e, 0, $blocking ? Process::TIMEOUT_PRECISION * 1E6 : 0)) {
restore_error_handler();
// if a system call has been interrupted, forget about it, let's try again
// otherwise, an error occurred, let's reset pipes
if (!$this->hasSystemCallBeenInterrupted()) {
$this->pipes = [];
}
return $read;
}
restore_error_handler();
foreach ($r as $pipe) {
// prior PHP 5.4 the array passed to stream_select is modified and
// lose key association, we have to find back the key
$read[$type = array_search($pipe, $this->pipes, true)] = '';
do {
$data = @fread($pipe, self::CHUNK_SIZE);
$read[$type] .= $data;
} while (isset($data[0]) && ($close || isset($data[self::CHUNK_SIZE - 1])));
if (!isset($read[$type][0])) {
unset($read[$type]);
}
if ($close && feof($pipe)) {
fclose($pipe);
unset($this->pipes[$type]);
}
}
return $read;
}
/**
* {@inheritdoc}
*/
public function haveReadSupport()
{
return $this->haveReadSupport;
}
/**
* {@inheritdoc}
*/
public function areOpen()
{
return (bool) $this->pipes;
}
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process\Pipes;
use Symfony\Component\Process\Exception\RuntimeException;
use Symfony\Component\Process\Process;
/**
* WindowsPipes implementation uses temporary files as handles.
*
* @see https://bugs.php.net/51800
* @see https://bugs.php.net/65650
*
* @author Romain Neutron
*
* @internal
*/
class WindowsPipes extends AbstractPipes
{
private $files = [];
private $fileHandles = [];
private $lockHandles = [];
private $readBytes = [
Process::STDOUT => 0,
Process::STDERR => 0,
];
private $haveReadSupport;
public function __construct($input, $haveReadSupport)
{
$this->haveReadSupport = (bool) $haveReadSupport;
if ($this->haveReadSupport) {
// Fix for PHP bug #51800: reading from STDOUT pipe hangs forever on Windows if the output is too big.
// Workaround for this problem is to use temporary files instead of pipes on Windows platform.
//
// @see https://bugs.php.net/51800
$pipes = [
Process::STDOUT => Process::OUT,
Process::STDERR => Process::ERR,
];
$tmpDir = sys_get_temp_dir();
$lastError = 'unknown reason';
set_error_handler(function ($type, $msg) use (&$lastError) { $lastError = $msg; });
for ($i = 0;; ++$i) {
foreach ($pipes as $pipe => $name) {
$file = sprintf('%s\\sf_proc_%02X.%s', $tmpDir, $i, $name);
if (!$h = fopen($file.'.lock', 'w')) {
if (file_exists($file.'.lock')) {
continue 2;
}
restore_error_handler();
throw new RuntimeException('A temporary file could not be opened to write the process output: '.$lastError);
}
if (!flock($h, \LOCK_EX | \LOCK_NB)) {
continue 2;
}
if (isset($this->lockHandles[$pipe])) {
flock($this->lockHandles[$pipe], \LOCK_UN);
fclose($this->lockHandles[$pipe]);
}
$this->lockHandles[$pipe] = $h;
if (!fclose(fopen($file, 'w')) || !$h = fopen($file, 'r')) {
flock($this->lockHandles[$pipe], \LOCK_UN);
fclose($this->lockHandles[$pipe]);
unset($this->lockHandles[$pipe]);
continue 2;
}
$this->fileHandles[$pipe] = $h;
$this->files[$pipe] = $file;
}
break;
}
restore_error_handler();
}
parent::__construct($input);
}
public function __destruct()
{
$this->close();
}
/**
* {@inheritdoc}
*/
public function getDescriptors()
{
if (!$this->haveReadSupport) {
$nullstream = fopen('NUL', 'c');
return [
['pipe', 'r'],
$nullstream,
$nullstream,
];
}
// We're not using pipe on Windows platform as it hangs (https://bugs.php.net/51800)
// We're not using file handles as it can produce corrupted output https://bugs.php.net/65650
// So we redirect output within the commandline and pass the nul device to the process
return [
['pipe', 'r'],
['file', 'NUL', 'w'],
['file', 'NUL', 'w'],
];
}
/**
* {@inheritdoc}
*/
public function getFiles()
{
return $this->files;
}
/**
* {@inheritdoc}
*/
public function readAndWrite($blocking, $close = false)
{
$this->unblock();
$w = $this->write();
$read = $r = $e = [];
if ($blocking) {
if ($w) {
@stream_select($r, $w, $e, 0, Process::TIMEOUT_PRECISION * 1E6);
} elseif ($this->fileHandles) {
usleep(Process::TIMEOUT_PRECISION * 1E6);
}
}
foreach ($this->fileHandles as $type => $fileHandle) {
$data = stream_get_contents($fileHandle, -1, $this->readBytes[$type]);
if (isset($data[0])) {
$this->readBytes[$type] += \strlen($data);
$read[$type] = $data;
}
if ($close) {
ftruncate($fileHandle, 0);
fclose($fileHandle);
flock($this->lockHandles[$type], \LOCK_UN);
fclose($this->lockHandles[$type]);
unset($this->fileHandles[$type], $this->lockHandles[$type]);
}
}
return $read;
}
/**
* {@inheritdoc}
*/
public function haveReadSupport()
{
return $this->haveReadSupport;
}
/**
* {@inheritdoc}
*/
public function areOpen()
{
return $this->pipes && $this->fileHandles;
}
/**
* {@inheritdoc}
*/
public function close()
{
parent::close();
foreach ($this->fileHandles as $type => $handle) {
ftruncate($handle, 0);
fclose($handle);
flock($this->lockHandles[$type], \LOCK_UN);
fclose($this->lockHandles[$type]);
}
$this->fileHandles = $this->lockHandles = [];
}
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process\Pipes;
/**
* PipesInterface manages descriptors and pipes for the use of proc_open.
*
* @author Romain Neutron
*
* @internal
*/
interface PipesInterface
{
const CHUNK_SIZE = 16384;
/**
* Returns an array of descriptors for the use of proc_open.
*
* @return array
*/
public function getDescriptors();
/**
* Returns an array of filenames indexed by their related stream in case these pipes use temporary files.
*
* @return string[]
*/
public function getFiles();
/**
* Reads data in file handles and pipes.
*
* @param bool $blocking Whether to use blocking calls or not
* @param bool $close Whether to close pipes if they've reached EOF
*
* @return string[] An array of read data indexed by their fd
*/
public function readAndWrite($blocking, $close = false);
/**
* Returns if the current state has open file handles or pipes.
*
* @return bool
*/
public function areOpen();
/**
* Returns if pipes are able to read output.
*
* @return bool
*/
public function haveReadSupport();
/**
* Closes file handles and pipes.
*/
public function close();
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process\Pipes;
use Symfony\Component\Process\Exception\InvalidArgumentException;
/**
* @author Romain Neutron
*
* @internal
*/
abstract class AbstractPipes implements PipesInterface
{
public $pipes = [];
private $inputBuffer = '';
private $input;
private $blocked = true;
private $lastError;
/**
* @param resource|string|int|float|bool|\Iterator|null $input
*/
public function __construct($input)
{
if (\is_resource($input) || $input instanceof \Iterator) {
$this->input = $input;
} elseif (\is_string($input)) {
$this->inputBuffer = $input;
} else {
$this->inputBuffer = (string) $input;
}
}
/**
* {@inheritdoc}
*/
public function close()
{
foreach ($this->pipes as $pipe) {
fclose($pipe);
}
$this->pipes = [];
}
/**
* Returns true if a system call has been interrupted.
*
* @return bool
*/
protected function hasSystemCallBeenInterrupted()
{
$lastError = $this->lastError;
$this->lastError = null;
// stream_select returns false when the `select` system call is interrupted by an incoming signal
return null !== $lastError && false !== stripos($lastError, 'interrupted system call');
}
/**
* Unblocks streams.
*/
protected function unblock()
{
if (!$this->blocked) {
return;
}
foreach ($this->pipes as $pipe) {
stream_set_blocking($pipe, 0);
}
if (\is_resource($this->input)) {
stream_set_blocking($this->input, 0);
}
$this->blocked = false;
}
/**
* Writes input to stdin.
*
* @return array|null
*
* @throws InvalidArgumentException When an input iterator yields a non supported value
*/
protected function write()
{
if (!isset($this->pipes[0])) {
return null;
}
$input = $this->input;
if ($input instanceof \Iterator) {
if (!$input->valid()) {
$input = null;
} elseif (\is_resource($input = $input->current())) {
stream_set_blocking($input, 0);
} elseif (!isset($this->inputBuffer[0])) {
if (!\is_string($input)) {
if (!is_scalar($input)) {
throw new InvalidArgumentException(sprintf('"%s" yielded a value of type "%s", but only scalars and stream resources are supported.', \get_class($this->input), \gettype($input)));
}
$input = (string) $input;
}
$this->inputBuffer = $input;
$this->input->next();
$input = null;
} else {
$input = null;
}
}
$r = $e = [];
$w = [$this->pipes[0]];
// let's have a look if something changed in streams
if (false === @stream_select($r, $w, $e, 0, 0)) {
return null;
}
foreach ($w as $stdin) {
if (isset($this->inputBuffer[0])) {
$written = fwrite($stdin, $this->inputBuffer);
$this->inputBuffer = substr($this->inputBuffer, $written);
if (isset($this->inputBuffer[0])) {
return [$this->pipes[0]];
}
}
if ($input) {
for (;;) {
$data = fread($input, self::CHUNK_SIZE);
if (!isset($data[0])) {
break;
}
$written = fwrite($stdin, $data);
$data = substr($data, $written);
if (isset($data[0])) {
$this->inputBuffer = $data;
return [$this->pipes[0]];
}
}
if (feof($input)) {
if ($this->input instanceof \Iterator) {
$this->input->next();
} else {
$this->input = null;
}
}
}
}
// no input to read on resource, buffer is empty
if (!isset($this->inputBuffer[0]) && !($this->input instanceof \Iterator ? $this->input->valid() : $this->input)) {
$this->input = null;
fclose($this->pipes[0]);
unset($this->pipes[0]);
} elseif (!$w) {
return [$this->pipes[0]];
}
return null;
}
/**
* @internal
*/
public function handleError($type, $msg)
{
$this->lastError = $msg;
}
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process\Exception;
/**
* Marker Interface for the Process Component.
*
* @author Johannes M. Schmitt
*/
interface ExceptionInterface
{
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process\Exception;
/**
* RuntimeException for the Process Component.
*
* @author Johannes M. Schmitt
*/
class RuntimeException extends \RuntimeException implements ExceptionInterface
{
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process\Exception;
/**
* InvalidArgumentException for the Process Component.
*
* @author Romain Neutron
*/
class InvalidArgumentException extends \InvalidArgumentException implements ExceptionInterface
{
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process\Exception;
use Symfony\Component\Process\Process;
/**
* Exception that is thrown when a process times out.
*
* @author Johannes M. Schmitt
*/
class ProcessTimedOutException extends RuntimeException
{
const TYPE_GENERAL = 1;
const TYPE_IDLE = 2;
private $process;
private $timeoutType;
public function __construct(Process $process, $timeoutType)
{
$this->process = $process;
$this->timeoutType = $timeoutType;
parent::__construct(sprintf(
'The process "%s" exceeded the timeout of %s seconds.',
$process->getCommandLine(),
$this->getExceededTimeout()
));
}
public function getProcess()
{
return $this->process;
}
public function isGeneralTimeout()
{
return self::TYPE_GENERAL === $this->timeoutType;
}
public function isIdleTimeout()
{
return self::TYPE_IDLE === $this->timeoutType;
}
public function getExceededTimeout()
{
switch ($this->timeoutType) {
case self::TYPE_GENERAL:
return $this->process->getTimeout();
case self::TYPE_IDLE:
return $this->process->getIdleTimeout();
default:
throw new \LogicException(sprintf('Unknown timeout type "%d".', $this->timeoutType));
}
}
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process\Exception;
/**
* LogicException for the Process Component.
*
* @author Romain Neutron
*/
class LogicException extends \LogicException implements ExceptionInterface
{
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process\Exception;
use Symfony\Component\Process\Process;
/**
* Exception for failed processes.
*
* @author Johannes M. Schmitt
*/
class ProcessFailedException extends RuntimeException
{
private $process;
public function __construct(Process $process)
{
if ($process->isSuccessful()) {
throw new InvalidArgumentException('Expected a failed process, but the given process was successful.');
}
$error = sprintf('The command "%s" failed.'."\n\nExit Code: %s(%s)\n\nWorking directory: %s",
$process->getCommandLine(),
$process->getExitCode(),
$process->getExitCodeText(),
$process->getWorkingDirectory()
);
if (!$process->isOutputDisabled()) {
$error .= sprintf("\n\nOutput:\n================\n%s\n\nError Output:\n================\n%s",
$process->getOutput(),
$process->getErrorOutput()
);
}
parent::__construct($error);
$this->process = $process;
}
public function getProcess()
{
return $this->process;
}
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process;
/**
* Generic executable finder.
*
* @author Fabien Potencier
* @author Johannes M. Schmitt
*/
class ExecutableFinder
{
private $suffixes = [];
/**
* Replaces default suffixes of executable.
*/
public function setSuffixes(array $suffixes)
{
$this->suffixes = $suffixes;
}
/**
* Adds new possible suffix to check for executable.
*
* @param string $suffix
*/
public function addSuffix($suffix)
{
$this->suffixes[] = $suffix;
}
/**
* Finds an executable by name.
*
* @param string $name The executable name (without the extension)
* @param string|null $default The default to return if no executable is found
* @param array $extraDirs Additional dirs to check into
*
* @return string|null The executable path or default value
*/
public function find($name, $default = null, array $extraDirs = [])
{
if (ini_get('open_basedir')) {
$searchPath = array_merge(explode(\PATH_SEPARATOR, ini_get('open_basedir')), $extraDirs);
$dirs = [];
foreach ($searchPath as $path) {
// Silencing against https://bugs.php.net/69240
if (@is_dir($path)) {
$dirs[] = $path;
} else {
if (basename($path) == $name && @is_executable($path)) {
return $path;
}
}
}
} else {
$dirs = array_merge(
explode(\PATH_SEPARATOR, getenv('PATH') ?: getenv('Path')),
$extraDirs
);
}
$suffixes = [];
if ('\\' === \DIRECTORY_SEPARATOR) {
$pathExt = getenv('PATHEXT');
$suffixes = $this->suffixes;
$suffixes = array_merge($suffixes, $pathExt ? explode(\PATH_SEPARATOR, $pathExt) : ['.exe', '.bat', '.cmd', '.com']);
}
$suffixes = '' !== pathinfo($name, PATHINFO_EXTENSION) ? array_merge([''], $suffixes) : array_merge($suffixes, ['']);
foreach ($suffixes as $suffix) {
foreach ($dirs as $dir) {
if ('' === $dir) {
$dir = '.';
}
if (@is_file($file = $dir.\DIRECTORY_SEPARATOR.$name.$suffix) && ('\\' === \DIRECTORY_SEPARATOR || @is_executable($file))) {
return $file;
}
if (!@is_dir($dir) && basename($dir) === $name.$suffix && @is_executable($dir)) {
return $dir;
}
}
}
if ('\\' === \DIRECTORY_SEPARATOR || !\function_exists('exec') || \strlen($name) !== strcspn($name, '/'.\DIRECTORY_SEPARATOR)) {
return $default;
}
$execResult = exec('command -v -- '.escapeshellarg($name));
if (($executablePath = substr($execResult, 0, strpos($execResult, \PHP_EOL) ?: null)) && @is_executable($executablePath)) {
return $executablePath;
}
return $default;
}
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process;
use Symfony\Component\Process\Exception\InvalidArgumentException;
/**
* ProcessUtils is a bunch of utility methods.
*
* This class contains static methods only and is not meant to be instantiated.
*
* @author Martin Hasoň
*/
class ProcessUtils
{
/**
* This class should not be instantiated.
*/
private function __construct()
{
}
/**
* Escapes a string to be used as a shell argument.
*
* @param string $argument The argument that will be escaped
*
* @return string The escaped argument
*
* @deprecated since version 3.3, to be removed in 4.0. Use a command line array or give env vars to the `Process::start/run()` method instead.
*/
public static function escapeArgument($argument)
{
@trigger_error('The '.__METHOD__.'() method is deprecated since Symfony 3.3 and will be removed in 4.0. Use a command line array or give env vars to the Process::start/run() method instead.', \E_USER_DEPRECATED);
//Fix for PHP bug #43784 escapeshellarg removes % from given string
//Fix for PHP bug #49446 escapeshellarg doesn't work on Windows
//@see https://bugs.php.net/43784
//@see https://bugs.php.net/49446
if ('\\' === \DIRECTORY_SEPARATOR) {
if ('' === $argument) {
return escapeshellarg($argument);
}
$escapedArgument = '';
$quote = false;
foreach (preg_split('/(")/', $argument, -1, \PREG_SPLIT_NO_EMPTY | \PREG_SPLIT_DELIM_CAPTURE) as $part) {
if ('"' === $part) {
$escapedArgument .= '\\"';
} elseif (self::isSurroundedBy($part, '%')) {
// Avoid environment variable expansion
$escapedArgument .= '^%"'.substr($part, 1, -1).'"^%';
} else {
// escape trailing backslash
if ('\\' === substr($part, -1)) {
$part .= '\\';
}
$quote = true;
$escapedArgument .= $part;
}
}
if ($quote) {
$escapedArgument = '"'.$escapedArgument.'"';
}
return $escapedArgument;
}
return "'".str_replace("'", "'\\''", $argument)."'";
}
/**
* Validates and normalizes a Process input.
*
* @param string $caller The name of method call that validates the input
* @param mixed $input The input to validate
*
* @return mixed The validated input
*
* @throws InvalidArgumentException In case the input is not valid
*/
public static function validateInput($caller, $input)
{
if (null !== $input) {
if (\is_resource($input)) {
return $input;
}
if (\is_string($input)) {
return $input;
}
if (is_scalar($input)) {
return (string) $input;
}
if ($input instanceof Process) {
return $input->getIterator($input::ITER_SKIP_ERR);
}
if ($input instanceof \Iterator) {
return $input;
}
if ($input instanceof \Traversable) {
return new \IteratorIterator($input);
}
throw new InvalidArgumentException(sprintf('"%s" only accepts strings, Traversable objects or stream resources.', $caller));
}
return $input;
}
private static function isSurroundedBy($arg, $char)
{
return 2 < \strlen($arg) && $char === $arg[0] && $char === $arg[\strlen($arg) - 1];
}
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process;
@trigger_error(sprintf('The %s class is deprecated since Symfony 3.4 and will be removed in 4.0. Use the Process class instead.', ProcessBuilder::class), \E_USER_DEPRECATED);
use Symfony\Component\Process\Exception\InvalidArgumentException;
use Symfony\Component\Process\Exception\LogicException;
/**
* @author Kris Wallsmith
*
* @deprecated since version 3.4, to be removed in 4.0. Use the Process class instead.
*/
class ProcessBuilder
{
private $arguments;
private $cwd;
private $env = [];
private $input;
private $timeout = 60;
private $options;
private $inheritEnv = true;
private $prefix = [];
private $outputDisabled = false;
/**
* @param string[] $arguments An array of arguments
*/
public function __construct(array $arguments = [])
{
$this->arguments = $arguments;
}
/**
* Creates a process builder instance.
*
* @param string[] $arguments An array of arguments
*
* @return static
*/
public static function create(array $arguments = [])
{
return new static($arguments);
}
/**
* Adds an unescaped argument to the command string.
*
* @param string $argument A command argument
*
* @return $this
*/
public function add($argument)
{
$this->arguments[] = $argument;
return $this;
}
/**
* Adds a prefix to the command string.
*
* The prefix is preserved when resetting arguments.
*
* @param string|array $prefix A command prefix or an array of command prefixes
*
* @return $this
*/
public function setPrefix($prefix)
{
$this->prefix = \is_array($prefix) ? $prefix : [$prefix];
return $this;
}
/**
* Sets the arguments of the process.
*
* Arguments must not be escaped.
* Previous arguments are removed.
*
* @param string[] $arguments
*
* @return $this
*/
public function setArguments(array $arguments)
{
$this->arguments = $arguments;
return $this;
}
/**
* Sets the working directory.
*
* @param string|null $cwd The working directory
*
* @return $this
*/
public function setWorkingDirectory($cwd)
{
$this->cwd = $cwd;
return $this;
}
/**
* Sets whether environment variables will be inherited or not.
*
* @param bool $inheritEnv
*
* @return $this
*/
public function inheritEnvironmentVariables($inheritEnv = true)
{
$this->inheritEnv = $inheritEnv;
return $this;
}
/**
* Sets an environment variable.
*
* Setting a variable overrides its previous value. Use `null` to unset a
* defined environment variable.
*
* @param string $name The variable name
* @param string|null $value The variable value
*
* @return $this
*/
public function setEnv($name, $value)
{
$this->env[$name] = $value;
return $this;
}
/**
* Adds a set of environment variables.
*
* Already existing environment variables with the same name will be
* overridden by the new values passed to this method. Pass `null` to unset
* a variable.
*
* @param array $variables The variables
*
* @return $this
*/
public function addEnvironmentVariables(array $variables)
{
$this->env = array_replace($this->env, $variables);
return $this;
}
/**
* Sets the input of the process.
*
* @param resource|string|int|float|bool|\Traversable|null $input The input content
*
* @return $this
*
* @throws InvalidArgumentException In case the argument is invalid
*/
public function setInput($input)
{
$this->input = ProcessUtils::validateInput(__METHOD__, $input);
return $this;
}
/**
* Sets the process timeout.
*
* To disable the timeout, set this value to null.
*
* @param float|null $timeout
*
* @return $this
*
* @throws InvalidArgumentException
*/
public function setTimeout($timeout)
{
if (null === $timeout) {
$this->timeout = null;
return $this;
}
$timeout = (float) $timeout;
if ($timeout < 0) {
throw new InvalidArgumentException('The timeout value must be a valid positive integer or float number.');
}
$this->timeout = $timeout;
return $this;
}
/**
* Adds a proc_open option.
*
* @param string $name The option name
* @param string $value The option value
*
* @return $this
*/
public function setOption($name, $value)
{
$this->options[$name] = $value;
return $this;
}
/**
* Disables fetching output and error output from the underlying process.
*
* @return $this
*/
public function disableOutput()
{
$this->outputDisabled = true;
return $this;
}
/**
* Enables fetching output and error output from the underlying process.
*
* @return $this
*/
public function enableOutput()
{
$this->outputDisabled = false;
return $this;
}
/**
* Creates a Process instance and returns it.
*
* @return Process
*
* @throws LogicException In case no arguments have been provided
*/
public function getProcess()
{
if (0 === \count($this->prefix) && 0 === \count($this->arguments)) {
throw new LogicException('You must add() command arguments before calling getProcess().');
}
$arguments = array_merge($this->prefix, $this->arguments);
$process = new Process($arguments, $this->cwd, $this->env, $this->input, $this->timeout, $this->options);
// to preserve the BC with symfony <3.3, we convert the array structure
// to a string structure to avoid the prefixing with the exec command
$process->setCommandLine($process->getCommandLine());
if ($this->inheritEnv) {
$process->inheritEnvironmentVariables();
}
if ($this->outputDisabled) {
$process->disableOutput();
}
return $process;
}
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process;
use Symfony\Component\Process\Exception\InvalidArgumentException;
use Symfony\Component\Process\Exception\LogicException;
use Symfony\Component\Process\Exception\ProcessFailedException;
use Symfony\Component\Process\Exception\ProcessTimedOutException;
use Symfony\Component\Process\Exception\RuntimeException;
use Symfony\Component\Process\Pipes\PipesInterface;
use Symfony\Component\Process\Pipes\UnixPipes;
use Symfony\Component\Process\Pipes\WindowsPipes;
/**
* Process is a thin wrapper around proc_* functions to easily
* start independent PHP processes.
*
* @author Fabien Potencier
* @author Romain Neutron
*/
class Process implements \IteratorAggregate
{
const ERR = 'err';
const OUT = 'out';
const STATUS_READY = 'ready';
const STATUS_STARTED = 'started';
const STATUS_TERMINATED = 'terminated';
const STDIN = 0;
const STDOUT = 1;
const STDERR = 2;
// Timeout Precision in seconds.
const TIMEOUT_PRECISION = 0.2;
const ITER_NON_BLOCKING = 1; // By default, iterating over outputs is a blocking call, use this flag to make it non-blocking
const ITER_KEEP_OUTPUT = 2; // By default, outputs are cleared while iterating, use this flag to keep them in memory
const ITER_SKIP_OUT = 4; // Use this flag to skip STDOUT while iterating
const ITER_SKIP_ERR = 8; // Use this flag to skip STDERR while iterating
private $callback;
private $hasCallback = false;
private $commandline;
private $cwd;
private $env;
private $input;
private $starttime;
private $lastOutputTime;
private $timeout;
private $idleTimeout;
private $options = ['suppress_errors' => true];
private $exitcode;
private $fallbackStatus = [];
private $processInformation;
private $outputDisabled = false;
private $stdout;
private $stderr;
private $enhanceWindowsCompatibility = true;
private $enhanceSigchildCompatibility;
private $process;
private $status = self::STATUS_READY;
private $incrementalOutputOffset = 0;
private $incrementalErrorOutputOffset = 0;
private $tty = false;
private $pty;
private $inheritEnv = false;
private $useFileHandles = false;
/** @var PipesInterface */
private $processPipes;
private $latestSignal;
private static $sigchild;
/**
* Exit codes translation table.
*
* User-defined errors must use exit codes in the 64-113 range.
*/
public static $exitCodes = [
0 => 'OK',
1 => 'General error',
2 => 'Misuse of shell builtins',
126 => 'Invoked command cannot execute',
127 => 'Command not found',
128 => 'Invalid exit argument',
// signals
129 => 'Hangup',
130 => 'Interrupt',
131 => 'Quit and dump core',
132 => 'Illegal instruction',
133 => 'Trace/breakpoint trap',
134 => 'Process aborted',
135 => 'Bus error: "access to undefined portion of memory object"',
136 => 'Floating point exception: "erroneous arithmetic operation"',
137 => 'Kill (terminate immediately)',
138 => 'User-defined 1',
139 => 'Segmentation violation',
140 => 'User-defined 2',
141 => 'Write to pipe with no one reading',
142 => 'Signal raised by alarm',
143 => 'Termination (request to terminate)',
// 144 - not defined
145 => 'Child process terminated, stopped (or continued*)',
146 => 'Continue if stopped',
147 => 'Stop executing temporarily',
148 => 'Terminal stop signal',
149 => 'Background process attempting to read from tty ("in")',
150 => 'Background process attempting to write to tty ("out")',
151 => 'Urgent data available on socket',
152 => 'CPU time limit exceeded',
153 => 'File size limit exceeded',
154 => 'Signal raised by timer counting virtual time: "virtual timer expired"',
155 => 'Profiling timer expired',
// 156 - not defined
157 => 'Pollable event',
// 158 - not defined
159 => 'Bad syscall',
];
/**
* @param string|array $commandline The command line to run
* @param string|null $cwd The working directory or null to use the working dir of the current PHP process
* @param array|null $env The environment variables or null to use the same environment as the current PHP process
* @param mixed|null $input The input as stream resource, scalar or \Traversable, or null for no input
* @param int|float|null $timeout The timeout in seconds or null to disable
* @param array $options An array of options for proc_open
*
* @throws RuntimeException When proc_open is not installed
*/
public function __construct($commandline, $cwd = null, array $env = null, $input = null, $timeout = 60, array $options = null)
{
if (!\function_exists('proc_open')) {
throw new RuntimeException('The Process class relies on proc_open, which is not available on your PHP installation.');
}
$this->commandline = $commandline;
$this->cwd = $cwd;
// on Windows, if the cwd changed via chdir(), proc_open defaults to the dir where PHP was started
// on Gnu/Linux, PHP builds with --enable-maintainer-zts are also affected
// @see : https://bugs.php.net/51800
// @see : https://bugs.php.net/50524
if (null === $this->cwd && (\defined('ZEND_THREAD_SAFE') || '\\' === \DIRECTORY_SEPARATOR)) {
$this->cwd = getcwd();
}
if (null !== $env) {
$this->setEnv($env);
}
$this->setInput($input);
$this->setTimeout($timeout);
$this->useFileHandles = '\\' === \DIRECTORY_SEPARATOR;
$this->pty = false;
$this->enhanceSigchildCompatibility = '\\' !== \DIRECTORY_SEPARATOR && $this->isSigchildEnabled();
if (null !== $options) {
@trigger_error(sprintf('The $options parameter of the %s constructor is deprecated since Symfony 3.3 and will be removed in 4.0.', __CLASS__), \E_USER_DEPRECATED);
$this->options = array_replace($this->options, $options);
}
}
/**
* Creates a Process instance as a command-line to be run in a shell wrapper.
*
* Command-lines are parsed by the shell of your OS (/bin/sh on Unix-like, cmd.exe on Windows.)
* This allows using e.g. pipes or conditional execution. In this mode, signals are sent to the
* shell wrapper and not to your commands.
*
* In order to inject dynamic values into command-lines, we strongly recommend using placeholders.
* This will save escaping values, which is not portable nor secure anyway:
*
* $process = Process::fromShellCommandline('my_command "${:MY_VAR}"');
* $process->run(null, ['MY_VAR' => $theValue]);
*
* @param string $command The command line to pass to the shell of the OS
* @param string|null $cwd The working directory or null to use the working dir of the current PHP process
* @param array|null $env The environment variables or null to use the same environment as the current PHP process
* @param mixed $input The input as stream resource, scalar or \Traversable, or null for no input
* @param int|float|null $timeout The timeout in seconds or null to disable
*
* @return static
*
* @throws LogicException When proc_open is not installed
*/
public static function fromShellCommandline($command, $cwd = null, array $env = null, $input = null, $timeout = 60)
{
$process = new static([], $cwd, $env, $input, $timeout);
$process->commandline = $command;
return $process;
}
public function __destruct()
{
$this->stop(0);
}
public function __clone()
{
$this->resetProcessData();
}
/**
* Runs the process.
*
* The callback receives the type of output (out or err) and
* some bytes from the output in real-time. It allows to have feedback
* from the independent process during execution.
*
* The STDOUT and STDERR are also available after the process is finished
* via the getOutput() and getErrorOutput() methods.
*
* @param callable|null $callback A PHP callback to run whenever there is some
* output available on STDOUT or STDERR
*
* @return int The exit status code
*
* @throws RuntimeException When process can't be launched
* @throws RuntimeException When process stopped after receiving signal
* @throws LogicException In case a callback is provided and output has been disabled
*
* @final since version 3.3
*/
public function run($callback = null/*, array $env = []*/)
{
$env = 1 < \func_num_args() ? func_get_arg(1) : null;
$this->start($callback, $env);
return $this->wait();
}
/**
* Runs the process.
*
* This is identical to run() except that an exception is thrown if the process
* exits with a non-zero exit code.
*
* @return $this
*
* @throws RuntimeException if PHP was compiled with --enable-sigchild and the enhanced sigchild compatibility mode is not enabled
* @throws ProcessFailedException if the process didn't terminate successfully
*
* @final since version 3.3
*/
public function mustRun(callable $callback = null/*, array $env = []*/)
{
if (!$this->enhanceSigchildCompatibility && $this->isSigchildEnabled()) {
throw new RuntimeException('This PHP has been compiled with --enable-sigchild. You must use setEnhanceSigchildCompatibility() to use this method.');
}
$env = 1 < \func_num_args() ? func_get_arg(1) : null;
if (0 !== $this->run($callback, $env)) {
throw new ProcessFailedException($this);
}
return $this;
}
/**
* Starts the process and returns after writing the input to STDIN.
*
* This method blocks until all STDIN data is sent to the process then it
* returns while the process runs in the background.
*
* The termination of the process can be awaited with wait().
*
* The callback receives the type of output (out or err) and some bytes from
* the output in real-time while writing the standard input to the process.
* It allows to have feedback from the independent process during execution.
*
* @param callable|null $callback A PHP callback to run whenever there is some
* output available on STDOUT or STDERR
*
* @throws RuntimeException When process can't be launched
* @throws RuntimeException When process is already running
* @throws LogicException In case a callback is provided and output has been disabled
*/
public function start(callable $callback = null/*, array $env = [*/)
{
if ($this->isRunning()) {
throw new RuntimeException('Process is already running.');
}
if (2 <= \func_num_args()) {
$env = func_get_arg(1);
} else {
if (__CLASS__ !== static::class) {
$r = new \ReflectionMethod($this, __FUNCTION__);
if (__CLASS__ !== $r->getDeclaringClass()->getName() && (2 > $r->getNumberOfParameters() || 'env' !== $r->getParameters()[1]->name)) {
@trigger_error(sprintf('The %s::start() method expects a second "$env" argument since Symfony 3.3. It will be made mandatory in 4.0.', static::class), \E_USER_DEPRECATED);
}
}
$env = null;
}
$this->resetProcessData();
$this->starttime = $this->lastOutputTime = microtime(true);
$this->callback = $this->buildCallback($callback);
$this->hasCallback = null !== $callback;
$descriptors = $this->getDescriptors();
$inheritEnv = $this->inheritEnv;
if (\is_array($commandline = $this->commandline)) {
$commandline = implode(' ', array_map([$this, 'escapeArgument'], $commandline));
if ('\\' !== \DIRECTORY_SEPARATOR) {
// exec is mandatory to deal with sending a signal to the process
$commandline = 'exec '.$commandline;
}
}
if (null === $env) {
$env = $this->env;
} else {
if ($this->env) {
$env += $this->env;
}
$inheritEnv = true;
}
if (null !== $env && $inheritEnv) {
$env += $this->getDefaultEnv();
} elseif (null !== $env) {
@trigger_error('Not inheriting environment variables is deprecated since Symfony 3.3 and will always happen in 4.0. Set "Process::inheritEnvironmentVariables()" to true instead.', \E_USER_DEPRECATED);
} else {
$env = $this->getDefaultEnv();
}
if ('\\' === \DIRECTORY_SEPARATOR && $this->enhanceWindowsCompatibility) {
$this->options['bypass_shell'] = true;
$commandline = $this->prepareWindowsCommandLine($commandline, $env);
} elseif (!$this->useFileHandles && $this->enhanceSigchildCompatibility && $this->isSigchildEnabled()) {
// last exit code is output on the fourth pipe and caught to work around --enable-sigchild
$descriptors[3] = ['pipe', 'w'];
// See https://unix.stackexchange.com/questions/71205/background-process-pipe-input
$commandline = '{ ('.$commandline.') <&3 3<&- 3>/dev/null & } 3<&0;';
$commandline .= 'pid=$!; echo $pid >&3; wait $pid; code=$?; echo $code >&3; exit $code';
// Workaround for the bug, when PTS functionality is enabled.
// @see : https://bugs.php.net/69442
$ptsWorkaround = fopen(__FILE__, 'r');
}
if (\defined('HHVM_VERSION')) {
$envPairs = $env;
} else {
$envPairs = [];
foreach ($env as $k => $v) {
if (false !== $v) {
$envPairs[] = $k.'='.$v;
}
}
}
if (!is_dir($this->cwd)) {
@trigger_error('The provided cwd does not exist. Command is currently ran against getcwd(). This behavior is deprecated since Symfony 3.4 and will be removed in 4.0.', \E_USER_DEPRECATED);
}
$this->process = @proc_open($commandline, $descriptors, $this->processPipes->pipes, $this->cwd, $envPairs, $this->options);
if (!\is_resource($this->process)) {
throw new RuntimeException('Unable to launch a new process.');
}
$this->status = self::STATUS_STARTED;
if (isset($descriptors[3])) {
$this->fallbackStatus['pid'] = (int) fgets($this->processPipes->pipes[3]);
}
if ($this->tty) {
return;
}
$this->updateStatus(false);
$this->checkTimeout();
}
/**
* Restarts the process.
*
* Be warned that the process is cloned before being started.
*
* @param callable|null $callback A PHP callback to run whenever there is some
* output available on STDOUT or STDERR
*
* @return static
*
* @throws RuntimeException When process can't be launched
* @throws RuntimeException When process is already running
*
* @see start()
*
* @final since version 3.3
*/
public function restart(callable $callback = null/*, array $env = []*/)
{
if ($this->isRunning()) {
throw new RuntimeException('Process is already running.');
}
$env = 1 < \func_num_args() ? func_get_arg(1) : null;
$process = clone $this;
$process->start($callback, $env);
return $process;
}
/**
* Waits for the process to terminate.
*
* The callback receives the type of output (out or err) and some bytes
* from the output in real-time while writing the standard input to the process.
* It allows to have feedback from the independent process during execution.
*
* @param callable|null $callback A valid PHP callback
*
* @return int The exitcode of the process
*
* @throws RuntimeException When process timed out
* @throws RuntimeException When process stopped after receiving signal
* @throws LogicException When process is not yet started
*/
public function wait(callable $callback = null)
{
$this->requireProcessIsStarted(__FUNCTION__);
$this->updateStatus(false);
if (null !== $callback) {
if (!$this->processPipes->haveReadSupport()) {
$this->stop(0);
throw new \LogicException('Pass the callback to the Process::start method or enableOutput to use a callback with Process::wait.');
}
$this->callback = $this->buildCallback($callback);
}
do {
$this->checkTimeout();
$running = '\\' === \DIRECTORY_SEPARATOR ? $this->isRunning() : $this->processPipes->areOpen();
$this->readPipes($running, '\\' !== \DIRECTORY_SEPARATOR || !$running);
} while ($running);
while ($this->isRunning()) {
$this->checkTimeout();
usleep(1000);
}
if ($this->processInformation['signaled'] && $this->processInformation['termsig'] !== $this->latestSignal) {
throw new RuntimeException(sprintf('The process has been signaled with signal "%s".', $this->processInformation['termsig']));
}
return $this->exitcode;
}
/**
* Returns the Pid (process identifier), if applicable.
*
* @return int|null The process id if running, null otherwise
*/
public function getPid()
{
return $this->isRunning() ? $this->processInformation['pid'] : null;
}
/**
* Sends a POSIX signal to the process.
*
* @param int $signal A valid POSIX signal (see https://php.net/pcntl.constants)
*
* @return $this
*
* @throws LogicException In case the process is not running
* @throws RuntimeException In case --enable-sigchild is activated and the process can't be killed
* @throws RuntimeException In case of failure
*/
public function signal($signal)
{
$this->doSignal($signal, true);
return $this;
}
/**
* Disables fetching output and error output from the underlying process.
*
* @return $this
*
* @throws RuntimeException In case the process is already running
* @throws LogicException if an idle timeout is set
*/
public function disableOutput()
{
if ($this->isRunning()) {
throw new RuntimeException('Disabling output while the process is running is not possible.');
}
if (null !== $this->idleTimeout) {
throw new LogicException('Output can not be disabled while an idle timeout is set.');
}
$this->outputDisabled = true;
return $this;
}
/**
* Enables fetching output and error output from the underlying process.
*
* @return $this
*
* @throws RuntimeException In case the process is already running
*/
public function enableOutput()
{
if ($this->isRunning()) {
throw new RuntimeException('Enabling output while the process is running is not possible.');
}
$this->outputDisabled = false;
return $this;
}
/**
* Returns true in case the output is disabled, false otherwise.
*
* @return bool
*/
public function isOutputDisabled()
{
return $this->outputDisabled;
}
/**
* Returns the current output of the process (STDOUT).
*
* @return string The process output
*
* @throws LogicException in case the output has been disabled
* @throws LogicException In case the process is not started
*/
public function getOutput()
{
$this->readPipesForOutput(__FUNCTION__);
if (false === $ret = stream_get_contents($this->stdout, -1, 0)) {
return '';
}
return $ret;
}
/**
* Returns the output incrementally.
*
* In comparison with the getOutput method which always return the whole
* output, this one returns the new output since the last call.
*
* @return string The process output since the last call
*
* @throws LogicException in case the output has been disabled
* @throws LogicException In case the process is not started
*/
public function getIncrementalOutput()
{
$this->readPipesForOutput(__FUNCTION__);
$latest = stream_get_contents($this->stdout, -1, $this->incrementalOutputOffset);
$this->incrementalOutputOffset = ftell($this->stdout);
if (false === $latest) {
return '';
}
return $latest;
}
/**
* Returns an iterator to the output of the process, with the output type as keys (Process::OUT/ERR).
*
* @param int $flags A bit field of Process::ITER_* flags
*
* @throws LogicException in case the output has been disabled
* @throws LogicException In case the process is not started
*
* @return \Generator
*/
public function getIterator($flags = 0)
{
$this->readPipesForOutput(__FUNCTION__, false);
$clearOutput = !(self::ITER_KEEP_OUTPUT & $flags);
$blocking = !(self::ITER_NON_BLOCKING & $flags);
$yieldOut = !(self::ITER_SKIP_OUT & $flags);
$yieldErr = !(self::ITER_SKIP_ERR & $flags);
while (null !== $this->callback || ($yieldOut && !feof($this->stdout)) || ($yieldErr && !feof($this->stderr))) {
if ($yieldOut) {
$out = stream_get_contents($this->stdout, -1, $this->incrementalOutputOffset);
if (isset($out[0])) {
if ($clearOutput) {
$this->clearOutput();
} else {
$this->incrementalOutputOffset = ftell($this->stdout);
}
yield self::OUT => $out;
}
}
if ($yieldErr) {
$err = stream_get_contents($this->stderr, -1, $this->incrementalErrorOutputOffset);
if (isset($err[0])) {
if ($clearOutput) {
$this->clearErrorOutput();
} else {
$this->incrementalErrorOutputOffset = ftell($this->stderr);
}
yield self::ERR => $err;
}
}
if (!$blocking && !isset($out[0]) && !isset($err[0])) {
yield self::OUT => '';
}
$this->checkTimeout();
$this->readPipesForOutput(__FUNCTION__, $blocking);
}
}
/**
* Clears the process output.
*
* @return $this
*/
public function clearOutput()
{
ftruncate($this->stdout, 0);
fseek($this->stdout, 0);
$this->incrementalOutputOffset = 0;
return $this;
}
/**
* Returns the current error output of the process (STDERR).
*
* @return string The process error output
*
* @throws LogicException in case the output has been disabled
* @throws LogicException In case the process is not started
*/
public function getErrorOutput()
{
$this->readPipesForOutput(__FUNCTION__);
if (false === $ret = stream_get_contents($this->stderr, -1, 0)) {
return '';
}
return $ret;
}
/**
* Returns the errorOutput incrementally.
*
* In comparison with the getErrorOutput method which always return the
* whole error output, this one returns the new error output since the last
* call.
*
* @return string The process error output since the last call
*
* @throws LogicException in case the output has been disabled
* @throws LogicException In case the process is not started
*/
public function getIncrementalErrorOutput()
{
$this->readPipesForOutput(__FUNCTION__);
$latest = stream_get_contents($this->stderr, -1, $this->incrementalErrorOutputOffset);
$this->incrementalErrorOutputOffset = ftell($this->stderr);
if (false === $latest) {
return '';
}
return $latest;
}
/**
* Clears the process output.
*
* @return $this
*/
public function clearErrorOutput()
{
ftruncate($this->stderr, 0);
fseek($this->stderr, 0);
$this->incrementalErrorOutputOffset = 0;
return $this;
}
/**
* Returns the exit code returned by the process.
*
* @return int|null The exit status code, null if the Process is not terminated
*
* @throws RuntimeException In case --enable-sigchild is activated and the sigchild compatibility mode is disabled
*/
public function getExitCode()
{
if (!$this->enhanceSigchildCompatibility && $this->isSigchildEnabled()) {
throw new RuntimeException('This PHP has been compiled with --enable-sigchild. You must use setEnhanceSigchildCompatibility() to use this method.');
}
$this->updateStatus(false);
return $this->exitcode;
}
/**
* Returns a string representation for the exit code returned by the process.
*
* This method relies on the Unix exit code status standardization
* and might not be relevant for other operating systems.
*
* @return string|null A string representation for the exit status code, null if the Process is not terminated
*
* @see http://tldp.org/LDP/abs/html/exitcodes.html
* @see http://en.wikipedia.org/wiki/Unix_signal
*/
public function getExitCodeText()
{
if (null === $exitcode = $this->getExitCode()) {
return null;
}
return isset(self::$exitCodes[$exitcode]) ? self::$exitCodes[$exitcode] : 'Unknown error';
}
/**
* Checks if the process ended successfully.
*
* @return bool true if the process ended successfully, false otherwise
*/
public function isSuccessful()
{
return 0 === $this->getExitCode();
}
/**
* Returns true if the child process has been terminated by an uncaught signal.
*
* It always returns false on Windows.
*
* @return bool
*
* @throws RuntimeException In case --enable-sigchild is activated
* @throws LogicException In case the process is not terminated
*/
public function hasBeenSignaled()
{
$this->requireProcessIsTerminated(__FUNCTION__);
if (!$this->enhanceSigchildCompatibility && $this->isSigchildEnabled()) {
throw new RuntimeException('This PHP has been compiled with --enable-sigchild. Term signal can not be retrieved.');
}
return $this->processInformation['signaled'];
}
/**
* Returns the number of the signal that caused the child process to terminate its execution.
*
* It is only meaningful if hasBeenSignaled() returns true.
*
* @return int
*
* @throws RuntimeException In case --enable-sigchild is activated
* @throws LogicException In case the process is not terminated
*/
public function getTermSignal()
{
$this->requireProcessIsTerminated(__FUNCTION__);
if ($this->isSigchildEnabled() && (!$this->enhanceSigchildCompatibility || -1 === $this->processInformation['termsig'])) {
throw new RuntimeException('This PHP has been compiled with --enable-sigchild. Term signal can not be retrieved.');
}
return $this->processInformation['termsig'];
}
/**
* Returns true if the child process has been stopped by a signal.
*
* It always returns false on Windows.
*
* @return bool
*
* @throws LogicException In case the process is not terminated
*/
public function hasBeenStopped()
{
$this->requireProcessIsTerminated(__FUNCTION__);
return $this->processInformation['stopped'];
}
/**
* Returns the number of the signal that caused the child process to stop its execution.
*
* It is only meaningful if hasBeenStopped() returns true.
*
* @return int
*
* @throws LogicException In case the process is not terminated
*/
public function getStopSignal()
{
$this->requireProcessIsTerminated(__FUNCTION__);
return $this->processInformation['stopsig'];
}
/**
* Checks if the process is currently running.
*
* @return bool true if the process is currently running, false otherwise
*/
public function isRunning()
{
if (self::STATUS_STARTED !== $this->status) {
return false;
}
$this->updateStatus(false);
return $this->processInformation['running'];
}
/**
* Checks if the process has been started with no regard to the current state.
*
* @return bool true if status is ready, false otherwise
*/
public function isStarted()
{
return self::STATUS_READY != $this->status;
}
/**
* Checks if the process is terminated.
*
* @return bool true if process is terminated, false otherwise
*/
public function isTerminated()
{
$this->updateStatus(false);
return self::STATUS_TERMINATED == $this->status;
}
/**
* Gets the process status.
*
* The status is one of: ready, started, terminated.
*
* @return string The current process status
*/
public function getStatus()
{
$this->updateStatus(false);
return $this->status;
}
/**
* Stops the process.
*
* @param int|float $timeout The timeout in seconds
* @param int $signal A POSIX signal to send in case the process has not stop at timeout, default is SIGKILL (9)
*
* @return int|null The exit-code of the process or null if it's not running
*/
public function stop($timeout = 10, $signal = null)
{
$timeoutMicro = microtime(true) + $timeout;
if ($this->isRunning()) {
// given `SIGTERM` may not be defined and that `proc_terminate` uses the constant value and not the constant itself, we use the same here
$this->doSignal(15, false);
do {
usleep(1000);
} while ($this->isRunning() && microtime(true) < $timeoutMicro);
if ($this->isRunning()) {
// Avoid exception here: process is supposed to be running, but it might have stopped just
// after this line. In any case, let's silently discard the error, we cannot do anything.
$this->doSignal($signal ?: 9, false);
}
}
if ($this->isRunning()) {
if (isset($this->fallbackStatus['pid'])) {
unset($this->fallbackStatus['pid']);
return $this->stop(0, $signal);
}
$this->close();
}
return $this->exitcode;
}
/**
* Adds a line to the STDOUT stream.
*
* @internal
*
* @param string $line The line to append
*/
public function addOutput($line)
{
$this->lastOutputTime = microtime(true);
fseek($this->stdout, 0, \SEEK_END);
fwrite($this->stdout, $line);
fseek($this->stdout, $this->incrementalOutputOffset);
}
/**
* Adds a line to the STDERR stream.
*
* @internal
*
* @param string $line The line to append
*/
public function addErrorOutput($line)
{
$this->lastOutputTime = microtime(true);
fseek($this->stderr, 0, \SEEK_END);
fwrite($this->stderr, $line);
fseek($this->stderr, $this->incrementalErrorOutputOffset);
}
/**
* Gets the command line to be executed.
*
* @return string The command to execute
*/
public function getCommandLine()
{
return \is_array($this->commandline) ? implode(' ', array_map([$this, 'escapeArgument'], $this->commandline)) : $this->commandline;
}
/**
* Sets the command line to be executed.
*
* @param string|array $commandline The command to execute
*
* @return $this
*/
public function setCommandLine($commandline)
{
$this->commandline = $commandline;
return $this;
}
/**
* Gets the process timeout (max. runtime).
*
* @return float|null The timeout in seconds or null if it's disabled
*/
public function getTimeout()
{
return $this->timeout;
}
/**
* Gets the process idle timeout (max. time since last output).
*
* @return float|null The timeout in seconds or null if it's disabled
*/
public function getIdleTimeout()
{
return $this->idleTimeout;
}
/**
* Sets the process timeout (max. runtime) in seconds.
*
* To disable the timeout, set this value to null.
*
* @param int|float|null $timeout The timeout in seconds
*
* @return $this
*
* @throws InvalidArgumentException if the timeout is negative
*/
public function setTimeout($timeout)
{
$this->timeout = $this->validateTimeout($timeout);
return $this;
}
/**
* Sets the process idle timeout (max. time since last output).
*
* To disable the timeout, set this value to null.
*
* @param int|float|null $timeout The timeout in seconds
*
* @return $this
*
* @throws LogicException if the output is disabled
* @throws InvalidArgumentException if the timeout is negative
*/
public function setIdleTimeout($timeout)
{
if (null !== $timeout && $this->outputDisabled) {
throw new LogicException('Idle timeout can not be set while the output is disabled.');
}
$this->idleTimeout = $this->validateTimeout($timeout);
return $this;
}
/**
* Enables or disables the TTY mode.
*
* @param bool $tty True to enabled and false to disable
*
* @return $this
*
* @throws RuntimeException In case the TTY mode is not supported
*/
public function setTty($tty)
{
if ('\\' === \DIRECTORY_SEPARATOR && $tty) {
throw new RuntimeException('TTY mode is not supported on Windows platform.');
}
if ($tty) {
static $isTtySupported;
if (null === $isTtySupported) {
$isTtySupported = (bool) @proc_open('echo 1 >/dev/null', [['file', '/dev/tty', 'r'], ['file', '/dev/tty', 'w'], ['file', '/dev/tty', 'w']], $pipes);
}
if (!$isTtySupported) {
throw new RuntimeException('TTY mode requires /dev/tty to be read/writable.');
}
}
$this->tty = (bool) $tty;
return $this;
}
/**
* Checks if the TTY mode is enabled.
*
* @return bool true if the TTY mode is enabled, false otherwise
*/
public function isTty()
{
return $this->tty;
}
/**
* Sets PTY mode.
*
* @param bool $bool
*
* @return $this
*/
public function setPty($bool)
{
$this->pty = (bool) $bool;
return $this;
}
/**
* Returns PTY state.
*
* @return bool
*/
public function isPty()
{
return $this->pty;
}
/**
* Gets the working directory.
*
* @return string|null The current working directory or null on failure
*/
public function getWorkingDirectory()
{
if (null === $this->cwd) {
// getcwd() will return false if any one of the parent directories does not have
// the readable or search mode set, even if the current directory does
return getcwd() ?: null;
}
return $this->cwd;
}
/**
* Sets the current working directory.
*
* @param string $cwd The new working directory
*
* @return $this
*/
public function setWorkingDirectory($cwd)
{
$this->cwd = $cwd;
return $this;
}
/**
* Gets the environment variables.
*
* @return array The current environment variables
*/
public function getEnv()
{
return $this->env;
}
/**
* Sets the environment variables.
*
* Each environment variable value should be a string.
* If it is an array, the variable is ignored.
* If it is false or null, it will be removed when
* env vars are otherwise inherited.
*
* That happens in PHP when 'argv' is registered into
* the $_ENV array for instance.
*
* @param array $env The new environment variables
*
* @return $this
*/
public function setEnv(array $env)
{
// Process can not handle env values that are arrays
$env = array_filter($env, function ($value) {
return !\is_array($value);
});
$this->env = $env;
return $this;
}
/**
* Gets the Process input.
*
* @return resource|string|\Iterator|null The Process input
*/
public function getInput()
{
return $this->input;
}
/**
* Sets the input.
*
* This content will be passed to the underlying process standard input.
*
* @param string|int|float|bool|resource|\Traversable|null $input The content
*
* @return $this
*
* @throws LogicException In case the process is running
*/
public function setInput($input)
{
if ($this->isRunning()) {
throw new LogicException('Input can not be set while the process is running.');
}
$this->input = ProcessUtils::validateInput(__METHOD__, $input);
return $this;
}
/**
* Gets the options for proc_open.
*
* @return array The current options
*
* @deprecated since version 3.3, to be removed in 4.0.
*/
public function getOptions()
{
@trigger_error(sprintf('The %s() method is deprecated since Symfony 3.3 and will be removed in 4.0.', __METHOD__), \E_USER_DEPRECATED);
return $this->options;
}
/**
* Sets the options for proc_open.
*
* @param array $options The new options
*
* @return $this
*
* @deprecated since version 3.3, to be removed in 4.0.
*/
public function setOptions(array $options)
{
@trigger_error(sprintf('The %s() method is deprecated since Symfony 3.3 and will be removed in 4.0.', __METHOD__), \E_USER_DEPRECATED);
$this->options = $options;
return $this;
}
/**
* Gets whether or not Windows compatibility is enabled.
*
* This is true by default.
*
* @return bool
*
* @deprecated since version 3.3, to be removed in 4.0. Enhanced Windows compatibility will always be enabled.
*/
public function getEnhanceWindowsCompatibility()
{
@trigger_error(sprintf('The %s() method is deprecated since Symfony 3.3 and will be removed in 4.0. Enhanced Windows compatibility will always be enabled.', __METHOD__), \E_USER_DEPRECATED);
return $this->enhanceWindowsCompatibility;
}
/**
* Sets whether or not Windows compatibility is enabled.
*
* @param bool $enhance
*
* @return $this
*
* @deprecated since version 3.3, to be removed in 4.0. Enhanced Windows compatibility will always be enabled.
*/
public function setEnhanceWindowsCompatibility($enhance)
{
@trigger_error(sprintf('The %s() method is deprecated since Symfony 3.3 and will be removed in 4.0. Enhanced Windows compatibility will always be enabled.', __METHOD__), \E_USER_DEPRECATED);
$this->enhanceWindowsCompatibility = (bool) $enhance;
return $this;
}
/**
* Returns whether sigchild compatibility mode is activated or not.
*
* @return bool
*
* @deprecated since version 3.3, to be removed in 4.0. Sigchild compatibility will always be enabled.
*/
public function getEnhanceSigchildCompatibility()
{
@trigger_error(sprintf('The %s() method is deprecated since Symfony 3.3 and will be removed in 4.0. Sigchild compatibility will always be enabled.', __METHOD__), \E_USER_DEPRECATED);
return $this->enhanceSigchildCompatibility;
}
/**
* Activates sigchild compatibility mode.
*
* Sigchild compatibility mode is required to get the exit code and
* determine the success of a process when PHP has been compiled with
* the --enable-sigchild option
*
* @param bool $enhance
*
* @return $this
*
* @deprecated since version 3.3, to be removed in 4.0.
*/
public function setEnhanceSigchildCompatibility($enhance)
{
@trigger_error(sprintf('The %s() method is deprecated since Symfony 3.3 and will be removed in 4.0. Sigchild compatibility will always be enabled.', __METHOD__), \E_USER_DEPRECATED);
$this->enhanceSigchildCompatibility = (bool) $enhance;
return $this;
}
/**
* Sets whether environment variables will be inherited or not.
*
* @param bool $inheritEnv
*
* @return $this
*/
public function inheritEnvironmentVariables($inheritEnv = true)
{
if (!$inheritEnv) {
@trigger_error('Not inheriting environment variables is deprecated since Symfony 3.3 and will always happen in 4.0. Set "Process::inheritEnvironmentVariables()" to true instead.', \E_USER_DEPRECATED);
}
$this->inheritEnv = (bool) $inheritEnv;
return $this;
}
/**
* Returns whether environment variables will be inherited or not.
*
* @return bool
*
* @deprecated since version 3.3, to be removed in 4.0. Environment variables will always be inherited.
*/
public function areEnvironmentVariablesInherited()
{
@trigger_error(sprintf('The %s() method is deprecated since Symfony 3.3 and will be removed in 4.0. Environment variables will always be inherited.', __METHOD__), \E_USER_DEPRECATED);
return $this->inheritEnv;
}
/**
* Performs a check between the timeout definition and the time the process started.
*
* In case you run a background process (with the start method), you should
* trigger this method regularly to ensure the process timeout
*
* @throws ProcessTimedOutException In case the timeout was reached
*/
public function checkTimeout()
{
if (self::STATUS_STARTED !== $this->status) {
return;
}
if (null !== $this->timeout && $this->timeout < microtime(true) - $this->starttime) {
$this->stop(0);
throw new ProcessTimedOutException($this, ProcessTimedOutException::TYPE_GENERAL);
}
if (null !== $this->idleTimeout && $this->idleTimeout < microtime(true) - $this->lastOutputTime) {
$this->stop(0);
throw new ProcessTimedOutException($this, ProcessTimedOutException::TYPE_IDLE);
}
}
/**
* Returns whether PTY is supported on the current operating system.
*
* @return bool
*/
public static function isPtySupported()
{
static $result;
if (null !== $result) {
return $result;
}
if ('\\' === \DIRECTORY_SEPARATOR) {
return $result = false;
}
return $result = (bool) @proc_open('echo 1 >/dev/null', [['pty'], ['pty'], ['pty']], $pipes);
}
/**
* Creates the descriptors needed by the proc_open.
*
* @return array
*/
private function getDescriptors()
{
if ($this->input instanceof \Iterator) {
$this->input->rewind();
}
if ('\\' === \DIRECTORY_SEPARATOR) {
$this->processPipes = new WindowsPipes($this->input, !$this->outputDisabled || $this->hasCallback);
} else {
$this->processPipes = new UnixPipes($this->isTty(), $this->isPty(), $this->input, !$this->outputDisabled || $this->hasCallback);
}
return $this->processPipes->getDescriptors();
}
/**
* Builds up the callback used by wait().
*
* The callbacks adds all occurred output to the specific buffer and calls
* the user callback (if present) with the received output.
*
* @param callable|null $callback The user defined PHP callback
*
* @return \Closure A PHP closure
*/
protected function buildCallback(callable $callback = null)
{
if ($this->outputDisabled) {
return function ($type, $data) use ($callback) {
if (null !== $callback) {
\call_user_func($callback, $type, $data);
}
};
}
$out = self::OUT;
return function ($type, $data) use ($callback, $out) {
if ($out == $type) {
$this->addOutput($data);
} else {
$this->addErrorOutput($data);
}
if (null !== $callback) {
\call_user_func($callback, $type, $data);
}
};
}
/**
* Updates the status of the process, reads pipes.
*
* @param bool $blocking Whether to use a blocking read call
*/
protected function updateStatus($blocking)
{
if (self::STATUS_STARTED !== $this->status) {
return;
}
$this->processInformation = proc_get_status($this->process);
$running = $this->processInformation['running'];
$this->readPipes($running && $blocking, '\\' !== \DIRECTORY_SEPARATOR || !$running);
if ($this->fallbackStatus && $this->enhanceSigchildCompatibility && $this->isSigchildEnabled()) {
$this->processInformation = $this->fallbackStatus + $this->processInformation;
}
if (!$running) {
$this->close();
}
}
/**
* Returns whether PHP has been compiled with the '--enable-sigchild' option or not.
*
* @return bool
*/
protected function isSigchildEnabled()
{
if (null !== self::$sigchild) {
return self::$sigchild;
}
if (!\function_exists('phpinfo') || \defined('HHVM_VERSION')) {
return self::$sigchild = false;
}
ob_start();
phpinfo(\INFO_GENERAL);
return self::$sigchild = false !== strpos(ob_get_clean(), '--enable-sigchild');
}
/**
* Reads pipes for the freshest output.
*
* @param string $caller The name of the method that needs fresh outputs
* @param bool $blocking Whether to use blocking calls or not
*
* @throws LogicException in case output has been disabled or process is not started
*/
private function readPipesForOutput($caller, $blocking = false)
{
if ($this->outputDisabled) {
throw new LogicException('Output has been disabled.');
}
$this->requireProcessIsStarted($caller);
$this->updateStatus($blocking);
}
/**
* Validates and returns the filtered timeout.
*
* @param int|float|null $timeout
*
* @return float|null
*
* @throws InvalidArgumentException if the given timeout is a negative number
*/
private function validateTimeout($timeout)
{
$timeout = (float) $timeout;
if (0.0 === $timeout) {
$timeout = null;
} elseif ($timeout < 0) {
throw new InvalidArgumentException('The timeout value must be a valid positive integer or float number.');
}
return $timeout;
}
/**
* Reads pipes, executes callback.
*
* @param bool $blocking Whether to use blocking calls or not
* @param bool $close Whether to close file handles or not
*/
private function readPipes($blocking, $close)
{
$result = $this->processPipes->readAndWrite($blocking, $close);
$callback = $this->callback;
foreach ($result as $type => $data) {
if (3 !== $type) {
$callback(self::STDOUT === $type ? self::OUT : self::ERR, $data);
} elseif (!isset($this->fallbackStatus['signaled'])) {
$this->fallbackStatus['exitcode'] = (int) $data;
}
}
}
/**
* Closes process resource, closes file handles, sets the exitcode.
*
* @return int The exitcode
*/
private function close()
{
$this->processPipes->close();
if (\is_resource($this->process)) {
proc_close($this->process);
}
$this->exitcode = $this->processInformation['exitcode'];
$this->status = self::STATUS_TERMINATED;
if (-1 === $this->exitcode) {
if ($this->processInformation['signaled'] && 0 < $this->processInformation['termsig']) {
// if process has been signaled, no exitcode but a valid termsig, apply Unix convention
$this->exitcode = 128 + $this->processInformation['termsig'];
} elseif ($this->enhanceSigchildCompatibility && $this->isSigchildEnabled()) {
$this->processInformation['signaled'] = true;
$this->processInformation['termsig'] = -1;
}
}
// Free memory from self-reference callback created by buildCallback
// Doing so in other contexts like __destruct or by garbage collector is ineffective
// Now pipes are closed, so the callback is no longer necessary
$this->callback = null;
return $this->exitcode;
}
/**
* Resets data related to the latest run of the process.
*/
private function resetProcessData()
{
$this->starttime = null;
$this->callback = null;
$this->exitcode = null;
$this->fallbackStatus = [];
$this->processInformation = null;
$this->stdout = fopen('php://temp/maxmemory:'.(1024 * 1024), 'w+b');
$this->stderr = fopen('php://temp/maxmemory:'.(1024 * 1024), 'w+b');
$this->process = null;
$this->latestSignal = null;
$this->status = self::STATUS_READY;
$this->incrementalOutputOffset = 0;
$this->incrementalErrorOutputOffset = 0;
}
/**
* Sends a POSIX signal to the process.
*
* @param int $signal A valid POSIX signal (see https://php.net/pcntl.constants)
* @param bool $throwException Whether to throw exception in case signal failed
*
* @return bool True if the signal was sent successfully, false otherwise
*
* @throws LogicException In case the process is not running
* @throws RuntimeException In case --enable-sigchild is activated and the process can't be killed
* @throws RuntimeException In case of failure
*/
private function doSignal($signal, $throwException)
{
if (null === $pid = $this->getPid()) {
if ($throwException) {
throw new LogicException('Can not send signal on a non running process.');
}
return false;
}
if ('\\' === \DIRECTORY_SEPARATOR) {
exec(sprintf('taskkill /F /T /PID %d 2>&1', $pid), $output, $exitCode);
if ($exitCode && $this->isRunning()) {
if ($throwException) {
throw new RuntimeException(sprintf('Unable to kill the process (%s).', implode(' ', $output)));
}
return false;
}
} else {
if (!$this->enhanceSigchildCompatibility || !$this->isSigchildEnabled()) {
$ok = @proc_terminate($this->process, $signal);
} elseif (\function_exists('posix_kill')) {
$ok = @posix_kill($pid, $signal);
} elseif ($ok = proc_open(sprintf('kill -%d %d', $signal, $pid), [2 => ['pipe', 'w']], $pipes)) {
$ok = false === fgets($pipes[2]);
}
if (!$ok) {
if ($throwException) {
throw new RuntimeException(sprintf('Error while sending signal `%s`.', $signal));
}
return false;
}
}
$this->latestSignal = (int) $signal;
$this->fallbackStatus['signaled'] = true;
$this->fallbackStatus['exitcode'] = -1;
$this->fallbackStatus['termsig'] = $this->latestSignal;
return true;
}
private function prepareWindowsCommandLine($cmd, array &$env)
{
$uid = uniqid('', true);
$varCount = 0;
$varCache = [];
$cmd = preg_replace_callback(
'/"(?:(
[^"%!^]*+
(?:
(?: !LF! | "(?:\^[%!^])?+" )
[^"%!^]*+
)++
) | [^"]*+ )"/x',
function ($m) use (&$env, &$varCache, &$varCount, $uid) {
if (!isset($m[1])) {
return $m[0];
}
if (isset($varCache[$m[0]])) {
return $varCache[$m[0]];
}
if (false !== strpos($value = $m[1], "\0")) {
$value = str_replace("\0", '?', $value);
}
if (false === strpbrk($value, "\"%!\n")) {
return '"'.$value.'"';
}
$value = str_replace(['!LF!', '"^!"', '"^%"', '"^^"', '""'], ["\n", '!', '%', '^', '"'], $value);
$value = '"'.preg_replace('/(\\\\*)"/', '$1$1\\"', $value).'"';
$var = $uid.++$varCount;
$env[$var] = $value;
return $varCache[$m[0]] = '!'.$var.'!';
},
$cmd
);
$cmd = 'cmd /V:ON /E:ON /D /C ('.str_replace("\n", ' ', $cmd).')';
static $comSpec;
if (!$comSpec && $comSpec = (new ExecutableFinder())->find('cmd.exe')) {
// Escape according to CommandLineToArgvW rules
$comSpec = '"'.preg_replace('{(\\\\*+)"}', '$1$1\"', $comSpec) .'"';
}
$cmd = ($comSpec !== null ? $comSpec : 'cmd').' /V:ON /E:ON /D /C ('.str_replace("\n", ' ', $cmd).')';
foreach ($this->processPipes->getFiles() as $offset => $filename) {
$cmd .= ' '.$offset.'>"'.$filename.'"';
}
return $cmd;
}
/**
* Ensures the process is running or terminated, throws a LogicException if the process has a not started.
*
* @param string $functionName The function name that was called
*
* @throws LogicException if the process has not run
*/
private function requireProcessIsStarted($functionName)
{
if (!$this->isStarted()) {
throw new LogicException(sprintf('Process must be started before calling "%s()".', $functionName));
}
}
/**
* Ensures the process is terminated, throws a LogicException if the process has a status different than `terminated`.
*
* @param string $functionName The function name that was called
*
* @throws LogicException if the process is not yet terminated
*/
private function requireProcessIsTerminated($functionName)
{
if (!$this->isTerminated()) {
throw new LogicException(sprintf('Process must be terminated before calling "%s()".', $functionName));
}
}
/**
* Escapes a string to be used as a shell argument.
*
* @param string $argument The argument that will be escaped
*
* @return string The escaped argument
*/
private function escapeArgument($argument)
{
if ('\\' !== \DIRECTORY_SEPARATOR) {
return "'".str_replace("'", "'\\''", $argument)."'";
}
if ('' === $argument = (string) $argument) {
return '""';
}
if (false !== strpos($argument, "\0")) {
$argument = str_replace("\0", '?', $argument);
}
if (!preg_match('/[\/()%!^"<>&|\s]/', $argument)) {
return $argument;
}
$argument = preg_replace('/(\\\\+)$/', '$1$1', $argument);
return '"'.str_replace(['"', '^', '%', '!', "\n"], ['""', '"^^"', '"^%"', '"^!"', '!LF!'], $argument).'"';
}
private function getDefaultEnv()
{
$env = [];
foreach ($_SERVER as $k => $v) {
if (\is_string($v) && false !== $v = getenv($k)) {
$env[$k] = $v;
}
}
foreach ($_ENV as $k => $v) {
if (\is_string($v)) {
$env[$k] = $v;
}
}
return $env;
}
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process;
use Symfony\Component\Process\Exception\RuntimeException;
/**
* PhpProcess runs a PHP script in an independent process.
*
* $p = new PhpProcess('');
* $p->run();
* print $p->getOutput()."\n";
*
* @author Fabien Potencier
*/
class PhpProcess extends Process
{
/**
* @param string $script The PHP script to run (as a string)
* @param string|null $cwd The working directory or null to use the working dir of the current PHP process
* @param array|null $env The environment variables or null to use the same environment as the current PHP process
* @param int $timeout The timeout in seconds
* @param array $options An array of options for proc_open
*/
public function __construct($script, $cwd = null, array $env = null, $timeout = 60, array $options = null)
{
$executableFinder = new PhpExecutableFinder();
if (false === $php = $executableFinder->find(false)) {
$php = null;
} else {
$php = array_merge([$php], $executableFinder->findArguments());
}
if ('phpdbg' === \PHP_SAPI) {
$file = tempnam(sys_get_temp_dir(), 'dbg');
file_put_contents($file, $script);
register_shutdown_function('unlink', $file);
$php[] = $file;
$script = null;
}
if (null !== $options) {
@trigger_error(sprintf('The $options parameter of the %s constructor is deprecated since Symfony 3.3 and will be removed in 4.0.', __CLASS__), \E_USER_DEPRECATED);
}
parent::__construct($php, $cwd, $env, $script, $timeout, $options);
}
/**
* Sets the path to the PHP binary to use.
*/
public function setPhpBinary($php)
{
$this->setCommandLine($php);
}
/**
* {@inheritdoc}
*/
public function start(callable $callback = null/*, array $env = []*/)
{
if (null === $this->getCommandLine()) {
throw new RuntimeException('Unable to find the PHP executable.');
}
$env = 1 < \func_num_args() ? func_get_arg(1) : null;
parent::start($callback, $env);
}
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process;
/**
* An executable finder specifically designed for the PHP executable.
*
* @author Fabien Potencier
* @author Johannes M. Schmitt
*/
class PhpExecutableFinder
{
private $executableFinder;
public function __construct()
{
$this->executableFinder = new ExecutableFinder();
}
/**
* Finds The PHP executable.
*
* @param bool $includeArgs Whether or not include command arguments
*
* @return string|false The PHP executable path or false if it cannot be found
*/
public function find($includeArgs = true)
{
if ($php = getenv('PHP_BINARY')) {
if (!is_executable($php) && !$php = $this->executableFinder->find($php)) {
return false;
}
if (@is_dir($php)) {
return false;
}
return $php;
}
$args = $this->findArguments();
$args = $includeArgs && $args ? ' '.implode(' ', $args) : '';
// HHVM support
if (\defined('HHVM_VERSION')) {
return (getenv('PHP_BINARY') ?: \PHP_BINARY).$args;
}
// PHP_BINARY return the current sapi executable
if (\PHP_BINARY && \in_array(\PHP_SAPI, ['cli', 'cli-server', 'phpdbg'], true)) {
return \PHP_BINARY.$args;
}
if ($php = getenv('PHP_PATH')) {
if (!@is_executable($php)) {
return false;
}
return $php;
}
if ($php = getenv('PHP_PEAR_PHP_BIN')) {
if (@is_executable($php)) {
return $php;
}
}
if (@is_executable($php = \PHP_BINDIR.('\\' === \DIRECTORY_SEPARATOR ? '\\php.exe' : '/php'))) {
return $php;
}
$dirs = [\PHP_BINDIR];
if ('\\' === \DIRECTORY_SEPARATOR) {
$dirs[] = 'C:\xampp\php\\';
}
return $this->executableFinder->find('php', false, $dirs);
}
/**
* Finds the PHP executable arguments.
*
* @return array The PHP executable arguments
*/
public function findArguments()
{
$arguments = [];
if (\defined('HHVM_VERSION')) {
$arguments[] = '--php';
} elseif ('phpdbg' === \PHP_SAPI) {
$arguments[] = '-qrr';
}
return $arguments;
}
}
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Process;
use Symfony\Component\Process\Exception\RuntimeException;
/**
* Provides a way to continuously write to the input of a Process until the InputStream is closed.
*
* @author Nicolas Grekas
*/
class InputStream implements \IteratorAggregate
{
/** @var callable|null */
private $onEmpty = null;
private $input = [];
private $open = true;
/**
* Sets a callback that is called when the write buffer becomes empty.
*/
public function onEmpty(callable $onEmpty = null)
{
$this->onEmpty = $onEmpty;
}
/**
* Appends an input to the write buffer.
*
* @param resource|string|int|float|bool|\Traversable|null $input The input to append as scalar,
* stream resource or \Traversable
*/
public function write($input)
{
if (null === $input) {
return;
}
if ($this->isClosed()) {
throw new RuntimeException(sprintf('"%s" is closed.', static::class));
}
$this->input[] = ProcessUtils::validateInput(__METHOD__, $input);
}
/**
* Closes the write buffer.
*/
public function close()
{
$this->open = false;
}
/**
* Tells whether the write buffer is closed or not.
*/
public function isClosed()
{
return !$this->open;
}
public function getIterator()
{
$this->open = true;
while ($this->open || $this->input) {
if (!$this->input) {
yield '';
continue;
}
$current = array_shift($this->input);
if ($current instanceof \Iterator) {
foreach ($current as $cur) {
yield $cur;
}
} else {
yield $current;
}
if (!$this->input && $this->open && null !== $onEmpty = $this->onEmpty) {
$this->write($onEmpty($this));
}
}
}
}
* select:
* @ _e('hello')
* @ _n('Product','Products',$n)
* @ _ef('hello %s',$user)
*
*
* @package eftec\bladeone
* @version 1.1 2019-08-09
* @link https://github.com/EFTEC/BladeOne
* @author Jorge Patricio Castro Castillo
* @copyright 2017 Jorge Patricio Castro Castillo MIT License. Don't delete this comment, its part of the license.
* @deprecated Note: It is not needing anymore (BladeOne already includes the same functionalities). It is keep for compatibility purpose.
*/
trait BladeOneLang
{
/** @var string The path to the missing translations log file. If empty then every missing key is not saved. */
public $missingLog = '';
/** @var array Hold dictionary of translations */
public static $dictionary = [];
/**
* Tries to translate the word if its in the array defined by BladeOneLang::$dictionary
* If the operation fails then, it returns the original expression without translation.
*
* @param $phrase
*
* @return string
*/
public function _e($phrase)
{
if ((!\array_key_exists($phrase, static::$dictionary))) {
$this->missingTranslation($phrase);
return $phrase;
} else {
return static::$dictionary[$phrase];
}
}
/**
* Its the same than @_e, however it parses the text (using sprintf).
* If the operation fails then, it returns the original expression without translation.
*
* @param $phrase
*
* @return string
*/
public function _ef($phrase)
{
$argv = \func_get_args();
$r = $this->_e($phrase);
$argv[0] = $r; // replace the first argument with the translation.
$result = @\call_user_func_array("sprintf", $argv);
$result = ($result === false) ? $r : $result;
return $result;
}
/**
* if num is more than one then it returns the phrase in plural, otherwise the phrase in singular.
* Note: the translation should be as follow: $msg['Person']='Person' $msg=['Person']['p']='People'
*
* @param string $phrase
* @param string $phrases
* @param int $num
*
* @return string
*/
public function _n($phrase, $phrases, $num = 0)
{
if ((!\array_key_exists($phrase, static::$dictionary))) {
$this->missingTranslation($phrase);
return ($num <= 1) ? $phrase : $phrases;
} else {
return ($num <= 1) ? $this->_e($phrase) : $this->_e($phrases);
}
}
//
/**
* Used for @_e directive.
*
* @param $expression
*
* @return string
*/
protected function compile_e($expression)
{
return $this->phpTag . "echo \$this->_e{$expression}; ?>";
}
/**
* Used for @_ef directive.
*
* @param $expression
*
* @return string
*/
protected function compile_ef($expression)
{
return $this->phpTag . "echo \$this->_ef{$expression}; ?>";
}
/**
* Used for @_n directive.
*
* @param $expression
*
* @return string
*/
protected function compile_n($expression)
{
return $this->phpTag . "echo \$this->_n{$expression}; ?>";
}
//
/**
* Log a missing translation into the file $this->missingLog.
* If the file is not defined, then it doesn't write the log.
*
* @param string $txt Message to write on.
*/
private function missingTranslation($txt)
{
if (!$this->missingLog) {
return; // if there is not a file assigned then it skips saving.
}
$fz = @\filesize($this->missingLog);
$mode = 'a';
if (\is_object($txt) || \is_array($txt)) {
$txt = \print_r($txt, true);
}
// Rewrite file if more than 100000 bytes
if ($fz > 100000) {
$mode = 'w';
}
$fp = \fopen($this->missingLog, 'w');
\fwrite($fp, $txt . "\n");
\fclose($fp);
}
}
* select:
* @ select('idCountry','value',[,$extra])
* @ item('0','--select a country'[,$extra])
* @ items($countries,'id','name',$currentCountry[,$extra])
* @ endselect()
* input:
* @ input('iduser',$currentUser,'text'[,$extra])
* button:
* @ commandbutton('idbutton','value','text'[,$extra])
*
*
* Note. The names of the tags are based in Java Server Faces (JSF)
*
* @package BladeOneHtml
* @version 1.9.2 2020-05-28 (1)
* @link https://github.com/EFTEC/BladeOne
* @author Jorge Patricio Castro Castillo
* @deprecated use https://github.com/eftec/BladeOneHtml
*/
trait BladeOneHtml
{
protected $htmlItem = []; // indicates the type of the current tag. such as select/selectgroup/etc.
protected $htmlCurrentId = []; //indicates the id of the current tag.
//
protected function compileSelect($expression)
{
$this->htmlItem[] = 'select';
return $this->phpTag . "echo \$this->select{$expression}; ?>";
}
protected function compileListBoxes($expression)
{
return $this->phpTag . "echo \$this->listboxes{$expression}; ?>";
}
protected function compileLink($expression)
{
return $this->phpTag . "echo \$this->link{$expression}; ?>";
}
protected function compileSelectGroup($expression)
{
$this->htmlItem[] = 'selectgroup';
$this->compilePush('');
return $this->phpTag . "echo \$this->select{$expression}; ?>";
}
protected function compileRadio($expression)
{
$this->htmlItem[] = 'radio';
return $this->phpTag . "echo \$this->radio{$expression}; ?>";
}
protected function compileCheckbox($expression)
{
$this->htmlItem[] = 'checkbox';
return $this->phpTag . "echo \$this->checkbox{$expression}; ?>";
}
protected function compileEndSelect()
{
$r = @\array_pop($this->htmlItem);
if (\is_null($r)) {
$this->showError("@endselect", "Missing @select or so many @endselect", true);
}
return $this->phpTag . "echo ''; ?>";
}
protected function compileEndRadio()
{
$r = @\array_pop($this->htmlItem);
if (\is_null($r)) {
return $this->showError("@EndRadio", "Missing @Radio or so many @EndRadio", true);
}
return '';
}
protected function compileEndCheckbox()
{
$r = @\array_pop($this->htmlItem);
if (\is_null($r)) {
return $this->showError("@EndCheckbox", "Missing @Checkbox or so many @EndCheckbox", true);
}
return '';
}
protected function compileItem($expression)
{
// we add a new attribute with the type of the current open tag
$r = \end($this->htmlItem);
$x = \trim($expression);
$x = "('{$r}'," . \substr($x, 1);
return $this->phpTag . "echo \$this->item{$x}; ?>";
}
protected function compileItems($expression)
{
// we add a new attribute with the type of the current open tag
$r = \end($this->htmlItem);
$x = \trim($expression);
$x = "('{$r}'," . \substr($x, 1);
return $this->phpTag . "echo \$this->items{$x}; ?>";
}
protected function compileTrio($expression)
{
// we add a new attribute with the type of the current open tag
$r = \end($this->htmlItem);
$x = \trim($expression);
$x = "('{$r}'," . \substr($x, 1);
return $this->phpTag . "echo \$this->trio{$x}; ?>";
}
protected function compileTrios($expression)
{
// we add a new attribute with the type of the current open tag
$r = \end($this->htmlItem);
$x = \trim($expression);
$x = "('{$r}'," . \substr($x, 1);
return $this->phpTag . "echo \$this->trios{$x}; ?>";
}
protected function compileInput($expression)
{
return $this->phpTag . "echo \$this->input{$expression}; ?>";
}
protected function compileFile($expression)
{
return $this->phpTag . "echo \$this->file{$expression}; ?>";
}
protected function compileImage($expression)
{
return $this->phpTag . "echo \$this->image{$expression}; ?>";
}
protected function compileTextArea($expression)
{
return $this->phpTag . "echo \$this->textArea{$expression}; ?>";
}
protected function compileHidden($expression)
{
return $this->phpTag . "echo \$this->hidden{$expression}; ?>";
}
protected function compileLabel($expression)
{
return $this->phpTag . "// {$expression} \n echo \$this->label{$expression}; ?>";
}
protected function compileCommandButton($expression)
{
return $this->phpTag . "echo \$this->commandButton{$expression}; ?>";
}
protected function compileForm($expression)
{
return $this->phpTag . "echo \$this->form{$expression}; ?>";
}
protected function compileEndForm()
{
return $this->phpTag . "echo ''; ?>";
}
//
//
public function select($name, $value, $extra = '')
{
if (\strpos($extra, 'readonly') === false) {
return "
}
* @ cache([cacheid],[duration=86400]). The id is optional. The duration of the cache is in seconds
* // content here
* @ endcache()
*
* It also adds a new function (optional) to the business or logic layer
*
* if ($blade->cacheExpired('hellocache',1,5)) { //'helloonecache' =template, =1 id cache, 5=duration (seconds)
* // cache expired, so we should do some stuff (such as read from the database)
* }
*
*
* @package BladeOneCacheRedis
* @version 0.1 2017-12-15 NOT YET IMPLEMENTED, ITS A WIP!!!!!!!!
* @link https://github.com/EFTEC/BladeOne
* @author Jorge Patricio Castro Castillo
*/
const CACHEREDIS_SCOPEURL = 1;
trait BladeOneCacheRedis
{
protected $curCacheId = 0;
protected $curCacheDuration = "";
protected $curCachePosition = 0;
protected $cacheRunning = false;
/** @var \Redis $redis */
protected $redis;
protected $redisIP = '127.0.0.1';
protected $redisPort = 6379;
protected $redisTimeOut = 2.5;
protected $redisConnected = false;
protected $redisNamespace = 'bladeonecache:';
protected $redisBase = 0;
private $cacheExpired = []; // avoids to compare the file different times.
//
public function compileCache($expression)
{
// get id of template
// if the file exists then
// compare date.
// if the date is too old then re-save.
// else
// save for the first time.
return $this->phpTag . "echo \$this->cacheStart{$expression}; if(!\$this->cacheRunning) { ?>";
}
public function compileEndCache($expression)
{
return $this->phpTag . "} // if cacheRunning\necho \$this->cacheEnd{$expression}; ?>";
}
//
public function connect($redisIP = null, $redisPort = null, $redisTimeOut = null)
{
if ($this->redisConnected) {
return true;
}
if (!\class_exists('Redis')) {
return false; // it requires redis.
}
if ($redisIP !== null) {
$this->redisIP = $redisIP;
$this->redisPort = $redisPort;
$this->redisTimeOut = $redisTimeOut;
}
$this->redis = new Redis();
// 2.5 sec timeout.
$this->redisConnected = $this->redis->connect($this->redisIP, $this->redisPort, $this->redisTimeOut);
return $this->redisConnected;
}
/**
* Returns true if the cache expired (or doesn't exist), otherwise false.
*
* @param string $templateName name of the template to use (such hello for template hello.blade.php)
* @param string $id (id of cache, optional, if not id then it adds automatically a number)
* @param int $scope scope of the cache.
* @param int $cacheDuration (duration of the cache in seconds)
* @return bool (return if the cache expired)
*/
public function cacheExpired($templateName, $id, $scope, $cacheDuration)
{
if ($this->getMode() & 1) {
return true; // forced mode, hence it always expires. (fast mode is ignored).
}
$compiledFile = $this->getCompiledFile($templateName) . '_cache' . $id;
if (isset($this->cacheExpired[$compiledFile])) {
// if the information is already in the array then returns it.
return $this->cacheExpired[$compiledFile];
}
$date = @\filemtime($compiledFile);
if ($date) {
if ($date + $cacheDuration < \time()) {
$this->cacheExpired[$compiledFile] = true;
return true; // time-out.
}
} else {
$this->cacheExpired[$compiledFile] = true;
return true; // no file
}
$this->cacheExpired[$compiledFile] = false;
return false; // cache active.
}
public function cacheStart($id = "", $cacheDuration = 86400)
{
$this->curCacheId = ($id == "") ? ($this->curCacheId + 1) : $id;
$this->curCacheDuration = $cacheDuration;
$this->curCachePosition = \strlen(\ob_get_contents());
$compiledFile = $this->getCompiledFile() . '_cache' . $this->curCacheId;
if ($this->cacheExpired('', $id, $cacheDuration)) {
$this->cacheRunning = false;
} else {
$this->cacheRunning = true;
$content = $this->getFile($compiledFile);
echo $content;
}
// getFile($fileName)
}
public function cacheEnd()
{
if (!$this->cacheRunning) {
$txt = \substr(\ob_get_contents(), $this->curCachePosition);
$compiledFile = $this->getCompiledFile() . '_cache' . $this->curCacheId;
\file_put_contents($compiledFile, $txt);
}
$this->cacheRunning = false;
}
private function keyByScope($scope)
{
$key = '';
if ($scope && CACHEREDIS_SCOPEURL) {
$key .= $_SERVER['HTTP_HOST'] . $_SERVER['PHP_SELF'];
}
}
}
* @copyright Copyright (c) 2016-2021 Jorge Patricio Castro Castillo MIT License.
* Don't delete this comment, its part of the license.
* Part of this code is based in the work of Laravel PHP Components.
* @version 3.52
* @link https://github.com/EFTEC/BladeOne
*/
class BladeOne
{
//
/** @var int BladeOne reads if the compiled file has changed. If has changed,then the file is replaced. */
const MODE_AUTO = 0;
/** @var int Then compiled file is always replaced. It's slow and it's useful for development. */
const MODE_SLOW = 1;
/** @var int The compiled file is never replaced. It's fast and it's useful for production. */
const MODE_FAST = 2;
/** @var int DEBUG MODE, the file is always compiled and the filename is identifiable. */
const MODE_DEBUG = 5;
/** @var array Hold dictionary of translations */
public static $dictionary = [];
/** @var string PHP tag. You could use < ?php or < ? (if shorttag is active in php.ini) */
public $phpTag = '
* If false (default value), then the variables defined in the include as arguments are defined globally.
* Example: (includeScope=false)
*
* @include("template",['a1'=>'abc']) // a1 is equals to abc
* @include("template",[]) // a1 is equals to abc
*
* Example: (includeScope=true)
*
* @include("template",['a1'=>'abc']) // a1 is equals to abc
* @include("template",[]) // a1 is not defined
*
*/
public $includeScope = false;
/**
* @var callable[] It allows to parse the compiled output using a function.
* This function doesn't require to return a value
* Example: this converts all compiled result in uppercase (note, content is a ref)
*
*/
public $compileCallbacks = [];
/** @var array All of the registered extensions. */
protected $extensions = [];
/** @var array All of the finished, captured sections. */
protected $sections = [];
/** @var string The template currently being compiled. For example "folder.template" */
protected $fileName;
protected $currentView;
protected $notFoundPath;
/** @var string File extension for the template files. */
protected $fileExtension = '.blade.php';
/** @var array The stack of in-progress sections. */
protected $sectionStack = [];
/** @var array The stack of in-progress loops. */
protected $loopsStack = [];
/** @var array Dictionary of variables */
protected $variables = [];
/** @var null Dictionary of global variables */
protected $variablesGlobal = [];
/** @var array All of the available compiler functions. */
protected $compilers = [
'Extensions',
'Statements',
'Comments',
'Echos',
];
/** @var string|null it allows to sets the stack */
protected $viewStack;
/** @var array used by $this->composer() */
protected $composerStack = [];
/** @var array The stack of in-progress push sections. */
protected $pushStack = [];
/** @var array All of the finished, captured push sections. */
protected $pushes = [];
/** @var int The number of active rendering operations. */
protected $renderCount = 0;
/** @var string[] Get the template path for the compiled views. */
protected $templatePath;
/** @var string Get the compiled path for the compiled views. If null then it uses the default path */
protected $compiledPath;
/** @var string the extension of the compiled file. */
protected $compileExtension = '.bladec';
/** @var array Custom "directive" dictionary. Those directives run at compile time. */
protected $customDirectives = [];
/** @var bool[] Custom directive dictionary. Those directives run at runtime. */
protected $customDirectivesRT = [];
/** @var callable Function used for resolving injected classes. */
protected $injectResolver;
/** @var array Used for conditional if. */
protected $conditions = [];
/** @var int Unique counter. It's used for extends */
protected $uidCounter = 0;
/** @var string The main url of the system. Don't use raw $_SERVER values unless the value is sanitized */
protected $baseUrl = '.';
/** @var string|null The base domain of the system */
protected $baseDomain;
/** @var string|null It stores the current canonical url. */
protected $canonicalUrl;
/** @var string|null It stores the current url including arguments */
protected $currentUrl;
/** @var string it is a relative path calculated between baseUrl and the current url. Example ../../ */
protected $relativePath = '';
/** @var string[] Dictionary of assets */
protected $assetDict;
/** @var bool if true then it removes tabs and unneeded spaces */
protected $optimize = true;
/** @var bool if false, then the template is not compiled (but executed on memory). */
protected $isCompiled = true;
/** @var bool */
protected $isRunFast = false; // stored for historical purpose.
/** @var array Array of opening and closing tags for raw echos. */
protected $rawTags = ['{!!', '!!}'];
/** @var array Array of opening and closing tags for regular echos. */
protected $contentTags = ['{{', '}}'];
/** @var array Array of opening and closing tags for escaped echos. */
protected $escapedTags = ['{{{', '}}}'];
/** @var string The "regular" / legacy echo string format. */
protected $echoFormat = '\htmlentities(%s, ENT_QUOTES, \'UTF-8\', false)';
protected $echoFormatOld = 'static::e(%s)';
/** @var array Lines that will be added at the footer of the template */
protected $footer = [];
/** @var string Placeholder to temporary mark the position of verbatim blocks. */
protected $verbatimPlaceholder = '$__verbatim__$';
/** @var array Array to temporary store the verbatim blocks found in the template. */
protected $verbatimBlocks = [];
/** @var int Counter to keep track of nested forelse statements. */
protected $forelseCounter = 0;
/** @var array The components being rendered. */
protected $componentStack = [];
/** @var array The original data passed to the component. */
protected $componentData = [];
/** @var array The slot contents for the component. */
protected $slots = [];
/** @var array The names of the slots being rendered. */
protected $slotStack = [];
/** @var string tag unique */
protected $PARENTKEY = '@parentXYZABC';
/**
* Indicates the compile mode.
* if the constant BLADEONE_MODE is defined, then it is used instead of this field.
*
* @var int=[BladeOne::MODE_AUTO,BladeOne::MODE_DEBUG,BladeOne::MODE_SLOW,BladeOne::MODE_FAST][$i]
*/
protected $mode;
/** @var int Indicates the number of open switches */
private $switchCount = 0;
/** @var bool Indicates if the switch is recently open */
private $firstCaseInSwitch = true;
//
//
/**
* Bob the constructor.
* The folder at $compiledPath is created in case it doesn't exist.
*
* @param string|array $templatePath If null then it uses (caller_folder)/views
* @param string $compiledPath If null then it uses (caller_folder)/compiles
* @param int $mode =[BladeOne::MODE_AUTO,BladeOne::MODE_DEBUG,BladeOne::MODE_FAST,BladeOne::MODE_SLOW][$i]
*/
public function __construct($templatePath = null, $compiledPath = null, $mode = 0)
{
if ($templatePath === null) {
$templatePath = \getcwd() . '/views';
}
if ($compiledPath === null) {
$compiledPath = \getcwd() . '/compiles';
}
$this->templatePath = (is_array($templatePath)) ? $templatePath : [$templatePath];
$this->compiledPath = $compiledPath;
$this->setMode($mode);
$this->authCallBack = function ($action = null, /** @noinspection PhpUnusedParameterInspection */ $subject = null) {
return \in_array($action, $this->currentPermission, true);
};
$this->authAnyCallBack = function ($array = []) {
foreach ($array as $permission) {
if (\in_array($permission, $this->currentPermission, true)) {
return true;
}
}
return false;
};
$this->errorCallBack = static function (/** @noinspection PhpUnusedParameterInspection */ $key = null) {
return false;
};
if (!\is_dir($this->compiledPath)) {
$ok = @\mkdir($this->compiledPath, 0777, true);
if ($ok === false) {
$this->showError(
'Constructing',
"Unable to create the compile folder [$this->compiledPath]. Check the permissions of it's parent folder.",
true
);
}
}
// If the traits has "Constructors", then we call them.
// Requisites.
// 1- the method must be public or protected
// 2- it must doesn't have arguments
// 3- It must have the name of the trait. i.e. trait=MyTrait, method=MyTrait()
$traits = get_declared_traits();
if ($traits !== null) {
foreach ($traits as $trait) {
$r = explode('\\', $trait);
$name = end($r);
if (is_callable([$this, $name]) && method_exists($this, $name)) {
$this->{$name}();
}
}
}
}
//
//
/**
* Show an error in the web.
*
* @param string $id Title of the error
* @param string $text Message of the error
* @param bool $critic if true then the compilation is ended, otherwise it continues
* @param bool $alwaysThrow if true then it always throw a runtime exception.
* @return string
* @throws \RuntimeException
*/
public function showError($id, $text, $critic = false, $alwaysThrow = false)
{
\ob_get_clean();
if (($this->throwOnError || $alwaysThrow) && $critic === true) {
throw new \RuntimeException("BladeOne Error [$id] $text");
} else {
echo "
";
echo "BladeOne Error [$id]: ";
echo "$text
\n";
if ($critic) {
die(1);
}
if ($this->throwOnError) {
error_log("BladeOne Error [$id] $text");
}
}
return '';
}
/**
* Escape HTML entities in a string.
*
* @param string $value
* @return string
*/
public static function e($value)
{
return (\is_array($value) || \is_object($value))
? \htmlentities(\print_r($value, true), ENT_QUOTES, 'UTF-8', false)
: \htmlentities($value, ENT_QUOTES, 'UTF-8', false);
}
protected static function convertArgCallBack($k, $v)
{
return $k . "='$v' ";
}
/**
* @param mixed|\DateTime $variable
* @param string|null $format
* @return string
*/
public function format($variable, $format = null)
{
if ($variable instanceof \DateTime) {
$format = $format === null ? 'Y/m/d' : $format;
return $variable->format($format);
}
$format = $format === null ? '%s' : $format;
return sprintf($format, $variable);
}
/**
* It converts a text into a php code with echo
* Example:
*
*
* @param string $input The input value
* @param string $quote The quote used (to quote the result)
* @param bool $parse If the result will be parsed or not. If false then it's returned without $this->e
* @return string
*/
public function wrapPHP($input, $quote = '"', $parse = true)
{
if (strpos($input, '(') !== false && !$this->isQuoted($input)) {
if ($parse) {
return $quote . $this->phpTagEcho . '$this->e(' . $input . ');?>' . $quote;
}
return $quote . $this->phpTagEcho . $input . ';?>' . $quote;
}
if (strpos($input, '$') === false) {
if ($parse) {
return self::enq($input);
}
return $input;
}
if ($parse) {
return $quote . $this->phpTagEcho . '$this->e(' . $input . ');?>' . $quote;
}
return $quote . $this->phpTagEcho . $input . ';?>' . $quote;
}
/**
* Returns true if the text is surrounded by quotes (double or single quote)
*
* @param string|null $text
* @return bool
*/
public function isQuoted($text)
{
if (!$text || strlen($text) < 2) {
return false;
}
if ($text[0] === '"' && substr($text, -1) === '"') {
return true;
}
return ($text[0] === "'" && substr($text, -1) === "'");
}
/**
* Escape HTML entities in a string.
*
* @param string $value
* @return string
*/
public static function enq($value)
{
if (\is_array($value) || \is_object($value)) {
return \htmlentities(\print_r($value, true), ENT_NOQUOTES, 'UTF-8', false);
}
return \htmlentities($value, ENT_NOQUOTES, 'UTF-8', false);
}
/**
* @param string $view example "folder.template"
* @param string|null $alias example "mynewop". If null then it uses the name of the template.
*/
public function addInclude($view, $alias = null)
{
if (!isset($alias)) {
$alias = \explode('.', $view);
$alias = \end($alias);
}
$this->directive($alias, function ($expression) use ($view) {
$expression = $this->stripParentheses($expression) ?: '[]';
return "$this->phpTag echo \$this->runChild('$view', $expression); ?>";
});
}
/**
* Register a handler for custom directives.
*
* @param string $name
* @param callable $handler
* @return void
*/
public function directive($name, callable $handler)
{
$this->customDirectives[$name] = $handler;
$this->customDirectivesRT[$name] = false;
}
/**
* Strip the parentheses from the given expression.
*
* @param string $expression
* @return string
*/
public function stripParentheses($expression)
{
if (static::startsWith($expression, '(')) {
$expression = \substr($expression, 1, -1);
}
return $expression;
}
/**
* Determine if a given string starts with a given substring.
*
* @param string $haystack
* @param string|array $needles
* @return bool
*/
public static function startsWith($haystack, $needles)
{
foreach ((array)$needles as $needle) {
if ($needle != '') {
if (\function_exists('mb_strpos')) {
if (\mb_strpos($haystack, $needle) === 0) {
return true;
}
} elseif (\strpos($haystack, $needle) === 0) {
return true;
}
}
}
return false;
}
/**
* If false then the file is not compiled and it is executed directly from the memory.
* By default the value is true
* It also sets the mode to MODE_SLOW
*
* @param bool $bool
* @return BladeOne
* @see \eftec\bladeone\BladeOne::setMode
*/
public function setIsCompiled($bool = false)
{
$this->isCompiled = $bool;
if (!$bool) {
$this->setMode(self::MODE_SLOW);
}
return $this;
}
/**
* It sets the template and compile path (without trailing slash).
*
Example:setPath("somefolder","otherfolder");
*
* @param null|string|string[] $templatePath If null then it uses the current path /views folder
* @param null|string $compiledPath If null then it uses the current path /views folder
*/
public function setPath($templatePath, $compiledPath)
{
if ($templatePath === null) {
$templatePath = \getcwd() . '/views';
}
if ($compiledPath === null) {
$compiledPath = \getcwd() . '/compiles';
}
$this->templatePath = (is_array($templatePath)) ? $templatePath : [$templatePath];
$this->compiledPath = $compiledPath;
}
/**
* @return array
*/
public function getAliasClasses()
{
return $this->aliasClasses;
}
/**
* @param array $aliasClasses
*/
public function setAliasClasses($aliasClasses)
{
$this->aliasClasses = $aliasClasses;
}
/**
* @param string $aliasName
* @param string $classWithNS
*/
public function addAliasClasses($aliasName, $classWithNS)
{
$this->aliasClasses[$aliasName] = $classWithNS;
}
//
//
/**
* Authentication. Sets with a user,role and permission
*
* @param string $user
* @param null $role
* @param array $permission
*/
public function setAuth($user = '', $role = null, $permission = [])
{
$this->currentUser = $user;
$this->currentRole = $role;
$this->currentPermission = $permission;
}
/**
* run the blade engine. It returns the result of the code.
*
* @param string HTML to parse
* @param array $data
* @return string
* @throws Exception
*/
public function runString($string, $data = [])
{
$php = $this->compileString($string);
$obLevel = \ob_get_level();
\ob_start();
\extract($data, EXTR_SKIP);
$previousError = \error_get_last();
try {
@eval('?' . '>' . $php);
} catch (Exception $e) {
while (\ob_get_level() > $obLevel) {
\ob_end_clean();
}
throw $e;
} catch (ParseError $e) { // PHP 7
while (\ob_get_level() > $obLevel) {
\ob_end_clean();
}
$this->showError('runString', $e->getMessage(). ' '.$e->getCode(), true);
return '';
}
$lastError = \error_get_last(); // PHP 5.6
if ($previousError != $lastError && $lastError['type'] == E_PARSE) {
while (\ob_get_level() > $obLevel) {
\ob_end_clean();
}
$this->showError('runString', $lastError['message']. ' '.$lastError['type'], true);
return '';
}
return \ob_get_clean();
}
/**
* Compile the given Blade template contents.
*
* @param string $value
* @return string
*/
public function compileString($value)
{
$result = '';
if (\strpos($value, '@verbatim') !== false) {
$value = $this->storeVerbatimBlocks($value);
}
$this->footer = [];
// Here we will loop through all of the tokens returned by the Zend lexer and
// parse each one into the corresponding valid PHP. We will then have this
// template as the correctly rendered PHP that can be rendered natively.
foreach (\token_get_all($value) as $token) {
$result .= \is_array($token) ? $this->parseToken($token) : $token;
}
if (!empty($this->verbatimBlocks)) {
$result = $this->restoreVerbatimBlocks($result);
}
// If there are any footer lines that need to get added to a template we will
// add them here at the end of the template. This gets used mainly for the
// template inheritance via the extends keyword that should be appended.
if (\count($this->footer) > 0) {
$result = \ltrim($result, PHP_EOL)
. PHP_EOL . \implode(PHP_EOL, \array_reverse($this->footer));
}
return $result;
}
/**
* Store the verbatim blocks and replace them with a temporary placeholder.
*
* @param string $value
* @return string
*/
protected function storeVerbatimBlocks($value)
{
return \preg_replace_callback('/(?verbatimBlocks[] = $matches[1];
return $this->verbatimPlaceholder;
}, $value);
}
/**
* Parse the tokens from the template.
*
* @param array $token
*
* @return string
*
* @see \eftec\bladeone\BladeOne::compileStatements
* @see \eftec\bladeone\BladeOne::compileExtends
* @see \eftec\bladeone\BladeOne::compileComments
* @see \eftec\bladeone\BladeOne::compileEchos
*/
protected function parseToken($token)
{
list($id, $content) = $token;
if ($id == T_INLINE_HTML) {
foreach ($this->compilers as $type) {
$content = $this->{"compile$type"}($content);
}
}
return $content;
}
/**
* Replace the raw placeholders with the original code stored in the raw blocks.
*
* @param string $result
* @return string
*/
protected function restoreVerbatimBlocks($result)
{
$result = \preg_replace_callback('/' . \preg_quote($this->verbatimPlaceholder) . '/', function () {
return \array_shift($this->verbatimBlocks);
}, $result);
$this->verbatimBlocks = [];
return $result;
}
/**
* it calculates the relative path of a web.
* This function uses the current url and the baseurl
*
* @param string $relativeWeb . Example img/images.jpg
* @return string Example ../../img/images.jpg
*/
public function relative($relativeWeb)
{
if (isset($this->assetDict[$relativeWeb])) {
return $this->assetDict[$relativeWeb];
}
// relativepath is calculated when
return $this->relativePath . $relativeWeb;
}
/**
* It add an alias to the link of the resources.
* addAssetDict('name','url/res.jpg')
* addAssetDict(['name'=>'url/res.jpg','name2'=>'url/res2.jpg');
*
* @param string|array $name example 'css/style.css', you could also add an array
* @param string $url example https://www.web.com/style.css'
*/
public function addAssetDict($name, $url = '')
{
if (\is_array($name)) {
if ($this->assetDict === null) {
$this->assetDict = $name;
} else {
$this->assetDict = \array_merge($this->assetDict, $name);
}
} else {
$this->assetDict[$name] = $url;
}
}
/**
* Compile the push statements into valid PHP.
*
* @param string $expression
* @return string
*/
public function compilePush($expression)
{
return $this->phpTag . "\$this->startPush$expression; ?>";
}
/**
* Compile the push statements into valid PHP.
*
* @param string $expression
* @return string
*/
public function compilePushOnce($expression)
{
$key = '$__pushonce__' . \trim(\substr($expression, 2, -2));
return $this->phpTag . "if(!isset($key)): $key=1; \$this->startPush$expression; ?>";
}
/**
* Compile the push statements into valid PHP.
*
* @param string $expression
* @return string
*/
public function compilePrepend($expression)
{
return $this->phpTag . "\$this->startPush$expression; ?>";
}
/**
* Start injecting content into a push section.
*
* @param string $section
* @param string $content
* @return void
*/
public function startPush($section, $content = '')
{
if ($content === '') {
if (\ob_start()) {
$this->pushStack[] = $section;
}
} else {
$this->extendPush($section, $content);
}
}
/*
* endswitch tag
*/
/**
* Append content to a given push section.
*
* @param string $section
* @param string $content
* @return void
*/
protected function extendPush($section, $content)
{
if (!isset($this->pushes[$section])) {
$this->pushes[$section] = []; // start an empty section
}
if (!isset($this->pushes[$section][$this->renderCount])) {
$this->pushes[$section][$this->renderCount] = $content;
} else {
$this->pushes[$section][$this->renderCount] .= $content;
}
}
/**
* Start injecting content into a push section.
*
* @param string $section
* @param string $content
* @return void
*/
public function startPrepend($section, $content = '')
{
if ($content === '') {
if (\ob_start()) {
\array_unshift($this->pushStack[], $section);
}
} else {
$this->extendPush($section, $content);
}
}
/**
* Stop injecting content into a push section.
*
* @return string
*/
public function stopPush()
{
if (empty($this->pushStack)) {
$this->showError('stopPush', 'Cannot end a section without first starting one', true);
}
$last = \array_pop($this->pushStack);
$this->extendPush($last, \ob_get_clean());
return $last;
}
/**
* Stop injecting content into a push section.
*
* @return string
*/
public function stopPrepend()
{
if (empty($this->pushStack)) {
$this->showError('stopPrepend', 'Cannot end a section without first starting one', true);
}
$last = \array_shift($this->pushStack);
$this->extendStartPush($last, \ob_get_clean());
return $last;
}
/**
* Append content to a given push section.
*
* @param string $section
* @param string $content
* @return void
*/
protected function extendStartPush($section, $content)
{
if (!isset($this->pushes[$section])) {
$this->pushes[$section] = []; // start an empty section
}
if (!isset($this->pushes[$section][$this->renderCount])) {
$this->pushes[$section][$this->renderCount] = $content;
} else {
$this->pushes[$section][$this->renderCount] = $content . $this->pushes[$section][$this->renderCount];
}
}
/**
* Get the string contents of a push section.
*
* @param string $section
* @param string $default
* @return string
*/
public function yieldPushContent($section, $default = '')
{
if (!isset($this->pushes[$section])) {
return $default;
}
return \implode(\array_reverse($this->pushes[$section]));
}
/**
* Get the string contents of a push section.
*
* @param int|string $each if int, then it split the foreach every $each numbers.
* if string, "c3" it means that it will split in 3 columns
* @param string $splitText
* @param string $splitEnd
* @return string
*/
public function splitForeach($each = 1, $splitText = ',', $splitEnd = '')
{
$loopStack = static::last($this->loopsStack); // array(7) { ["index"]=> int(0) ["remaining"]=> int(6) ["count"]=> int(5) ["first"]=> bool(true) ["last"]=> bool(false) ["depth"]=> int(1) ["parent"]=> NULL }
if (($loopStack['index']) == $loopStack['count'] - 1) {
return $splitEnd;
}
$eachN = 0;
if (is_numeric($each)) {
$eachN = $each;
} elseif (strlen($each) > 1) {
if ($each[0] === 'c') {
$eachN = $loopStack['count'] / substr($each, 1);
}
} else {
$eachN = PHP_INT_MAX;
}
if (($loopStack['index'] + 1) % $eachN === 0) {
return $splitText;
}
return '';
}
/**
* Return the last element in an array passing a given truth test.
*
* @param array $array
* @param callable|null $callback
* @param mixed $default
* @return mixed
*/
public static function last($array, callable $callback = null, $default = null)
{
if (\is_null($callback)) {
return empty($array) ? static::value($default) : \end($array);
}
return static::first(\array_reverse($array), $callback, $default);
}
/**
* Return the default value of the given value.
*
* @param mixed $value
* @return mixed
*/
public static function value($value)
{
return $value instanceof Closure ? $value() : $value;
}
/**
* Return the first element in an array passing a given truth test.
*
* @param array $array
* @param callable|null $callback
* @param mixed $default
* @return mixed
*/
public static function first($array, callable $callback = null, $default = null)
{
if (\is_null($callback)) {
return empty($array) ? static::value($default) : \reset($array);
}
foreach ($array as $key => $value) {
if ($callback($key, $value)) {
return $value;
}
}
return static::value($default);
}
/**
* @param string $name
* @param $args []
* @return string
* @throws BadMethodCallException
*/
public function __call($name, $args)
{
if ($name === 'if') {
return $this->registerIfStatement(isset($args[0]) ? $args[0] : null, isset($args[1]) ? $args[1] : null);
}
$this->showError('call', "function $name is not defined ", true, true);
return '';
}
/**
* Register an "if" statement directive.
*
* @param string $name
* @param callable $callback
* @return string
*/
public function registerIfStatement($name, callable $callback)
{
$this->conditions[$name] = $callback;
$this->directive($name, function ($expression) use ($name) {
$tmp = $this->stripParentheses($expression);
return $expression !== ''
? $this->phpTag . " if (\$this->check('$name', $tmp)): ?>"
: $this->phpTag . " if (\$this->check('$name')): ?>";
});
$this->directive('else' . $name, function ($expression) use ($name) {
$tmp = $this->stripParentheses($expression);
return $expression !== ''
? $this->phpTag . " elseif (\$this->check('$name', $tmp)): ?>"
: $this->phpTag . " elseif (\$this->check('$name')): ?>";
});
$this->directive('end' . $name, function () {
return $this->phpTag . ' endif; ?>';
});
return '';
}
/**
* Check the result of a condition.
*
* @param string $name
* @param array $parameters
* @return bool
*/
public function check($name, ...$parameters)
{
return \call_user_func($this->conditions[$name], ...$parameters);
}
/**
* @param bool $bool
* @param string $view name of the view
* @param array $value arrays of values
* @return string
* @throws Exception
*/
public function includeWhen($bool = false, $view = '', $value = [])
{
if ($bool) {
return $this->runChild($view, $value);
}
return '';
}
/**
* Macro of function run
*
* @param $view
* @param array $variables
* @return string
* @throws Exception
*/
public function runChild($view, $variables = [])
{
if (\is_array($variables)) {
if ($this->includeScope) {
$backup = $this->variables;
} else {
$backup = null;
}
$newVariables = \array_merge($this->variables, $variables);
} else {
if ($variables === null) {
$newVariables = $this->variables;
var_dump($newVariables);
die(1);
}
$this->showError('run/include', "RunChild: Include/run variables should be defined as array ['idx'=>'value']", true);
return '';
}
$r = $this->runInternal($view, $newVariables, false, false, $this->isRunFast);
if ($backup !== null) {
$this->variables = $backup;
}
return $r;
}
/**
* run the blade engine. It returns the result of the code.
*
* @param string $view
* @param array $variables
* @param bool $forced if true then it recompiles no matter if the compiled file exists or not.
* @param bool $isParent
* @param bool $runFast if true then the code is not compiled neither checked and it runs directly the compiled
* version.
* @return string
* @throws Exception
* @noinspection PhpUnusedParameterInspection
*/
private function runInternal($view, $variables = [], $forced = false, $isParent = true, $runFast = false)
{
$this->currentView = $view;
if (@\count($this->composerStack)) {
$this->evalComposer($view);
}
if (@\count($this->variablesGlobal) > 0) {
$this->variables = \array_merge($variables, $this->variablesGlobal);
$this->variablesGlobal = []; // used so we delete it.
} else {
$this->variables = $variables;
}
if (!$runFast) {
// a) if the compile is forced then we compile the original file, then save the file.
// b) if the compile is not forced then we read the datetime of both file and we compared.
// c) in both cases, if the compiled doesn't exist then we compile.
if ($view) {
$this->fileName = $view;
}
$result = $this->compile($view, $forced);
if (!$this->isCompiled) {
return $this->evaluateText($result, $this->variables);
}
} elseif ($view) {
$this->fileName = $view;
}
$this->isRunFast = $runFast;
return $this->evaluatePath($this->getCompiledFile(), $this->variables);
}
protected function evalComposer($view)
{
foreach ($this->composerStack as $viewKey => $fn) {
if ($this->wildCardComparison($view, $viewKey)) {
if (is_callable($fn)) {
$fn($this);
} elseif ($this->methodExistsStatic($fn, 'composer')) {
// if the method exists statically then $fn is the class and 'composer' is the name of the method
$fn::composer($this);
} elseif (is_object($fn) || class_exists($fn)) {
// if $fn is an object or it is a class and the class exists.
$instance = (is_object($fn)) ? $fn : new $fn();
if (method_exists($instance, 'composer')) {
// and the method exists inside the instance.
$instance->composer($this);
} else {
if ($this->mode === self::MODE_DEBUG) {
$this->showError('evalComposer', "BladeOne: composer() added an incorrect method [$fn]", true, true);
return;
}
$this->showError('evalComposer', 'BladeOne: composer() added an incorrect method', true, true);
return;
}
} else {
$this->showError('evalComposer', 'BladeOne: composer() added an incorrect method', true, true);
}
}
}
}
/**
* It compares with wildcards (*) and returns true if both strings are equals
* The wildcards only works at the beginning and/or at the end of the string.
* Example:
*
*
* @param string $text
* @param string|null $textWithWildcard
*
* @return bool
*/
protected function wildCardComparison($text, $textWithWildcard)
{
if (($textWithWildcard === null && $textWithWildcard === '')
|| strpos($textWithWildcard, '*') === false) {
// if the text with wildcard is null or empty or it contains two ** or it contains no * then..
return $text == $textWithWildcard;
}
if ($textWithWildcard === '*' || $textWithWildcard === '**') {
return true;
}
$c0 = $textWithWildcard[0];
$c1 = substr($textWithWildcard, -1);
$textWithWildcardClean = str_replace('*', '', $textWithWildcard);
$p0 = strpos($text, $textWithWildcardClean);
if ($p0 === false) {
// no matches.
return false;
}
if ($c0 === '*' && $c1 === '*') {
// $textWithWildcard='*asasasas*'
return true;
}
if ($c1 === '*') {
// $textWithWildcard='asasasas*'
return $p0 === 0;
}
// $textWithWildcard='*asasasas'
$len = strlen($textWithWildcardClean);
return (substr($text, -$len) === $textWithWildcardClean);
}
protected function methodExistsStatic($class, $method)
{
try {
$mc = new \ReflectionMethod($class, $method);
return $mc->isStatic();
} catch (\ReflectionException $e) {
return false;
}
}
/**
* Compile the view at the given path.
*
* @param string $templateName The name of the template. Example folder.template
* @param bool $forced If the compilation will be forced (always compile) or not.
* @return boolean|string True if the operation was correct, or false (if not exception)
* if it fails. It returns a string (the content compiled) if isCompiled=false
* @throws Exception
*/
public function compile($templateName = null, $forced = false)
{
$compiled = $this->getCompiledFile($templateName);
$template = $this->getTemplateFile($templateName);
if (!$this->isCompiled) {
$contents = $this->compileString($this->getFile($template));
$this->compileCallBacks($contents, $templateName);
return $contents;
}
if ($forced || $this->isExpired($templateName)) {
// compile the original file
$contents = $this->compileString($this->getFile($template));
$this->compileCallBacks($contents, $templateName);
$dir = \dirname($compiled);
if (!\is_dir($dir)) {
$ok = @\mkdir($dir, 0777, true);
if ($ok === false) {
$this->showError(
'Compiling',
"Unable to create the compile folder [$dir]. Check the permissions of it's parent folder.",
true
);
return false;
}
}
if ($this->optimize) {
// removes space and tabs and replaces by a single space
$contents = \preg_replace('/^ {2,}/m', ' ', $contents);
$contents = \preg_replace('/^\t{2,}/m', ' ', $contents);
}
$ok = @\file_put_contents($compiled, $contents);
if ($ok === false) {
$this->showError(
'Compiling',
"Unable to save the file [$compiled]. Check the compile folder is defined and has the right permission"
);
return false;
}
}
return true;
}
/**
* Get the full path of the compiled file.
*
* @param string $templateName
* @return string
*/
public function getCompiledFile($templateName = '')
{
$templateName = (empty($templateName)) ? $this->fileName : $templateName;
if ($this->getMode() == self::MODE_DEBUG) {
return $this->compiledPath . '/' . $templateName . $this->compileExtension;
}
return $this->compiledPath . '/' . \sha1($templateName) . $this->compileExtension;
}
/**
* Get the mode of the engine.See BladeOne::MODE_* constants
*
* @return int=[self::MODE_AUTO,self::MODE_DEBUG,self::MODE_FAST,self::MODE_SLOW][$i]
*/
public function getMode()
{
if (\defined('BLADEONE_MODE')) {
$this->mode = BLADEONE_MODE;
}
return $this->mode;
}
/**
* Set the compile mode
*
* @param $mode int=[self::MODE_AUTO,self::MODE_DEBUG,self::MODE_FAST,self::MODE_SLOW][$i]
* @return void
*/
public function setMode($mode)
{
$this->mode = $mode;
}
/**
* Get the full path of the template file.
*
Example: getTemplateFile('.abc.def')
*
* @param string $templateName template name. If not template is set then it uses the base template.
* @return string
*/
public function getTemplateFile($templateName = '')
{
$templateName = (empty($templateName)) ? $this->fileName : $templateName;
if (\strpos($templateName, '/') !== false) {
return $this->locateTemplate($templateName); // it's a literal
}
$arr = \explode('.', $templateName);
$c = \count($arr);
if ($c == 1) {
// its in the root of the template folder.
return $this->locateTemplate($templateName . $this->fileExtension);
}
$file = $arr[$c - 1];
\array_splice($arr, $c - 1, $c - 1); // delete the last element
$path = \implode('/', $arr);
return $this->locateTemplate($path . '/' . $file . $this->fileExtension);
}
/**
* Find template file with the given name in all template paths in the order the paths were written
*
* @param string $name Filename of the template (without path)
* @return string template file
*/
private function locateTemplate($name)
{
$this->notFoundPath = '';
foreach ($this->templatePath as $dir) {
$path = $dir . '/' . $name;
if (\is_file($path)) {
return $path;
}
$this->notFoundPath .= $path . ",";
}
return '';
}
/**
* Get the contents of a file.
*
* @param string $fullFileName It gets the content of a filename or returns ''.
*
* @return string
*/
public function getFile($fullFileName)
{
if (\is_file($fullFileName)) {
return \file_get_contents($fullFileName);
}
$this->showError('getFile', "File does not exist at paths (separated by comma) [$this->notFoundPath] or permission denied", true);
return '';
}
protected function compileCallBacks(&$contents, $templateName)
{
if (!empty($this->compileCallbacks)) {
foreach ($this->compileCallbacks as $callback) {
if (is_callable($callback)) {
$callback($contents, $templateName);
}
}
}
}
/**
* Determine if the view has expired.
*
* @param string|null $fileName
* @return bool
*/
public function isExpired($fileName)
{
$compiled = $this->getCompiledFile($fileName);
$template = $this->getTemplateFile($fileName);
if (!\is_file($template)) {
if ($this->mode == self::MODE_DEBUG) {
$this->showError('Read file', 'Template not found :' . $this->fileName . " on file: $template", true);
} else {
$this->showError('Read file', 'Template not found :' . $this->fileName, true);
}
}
// If the compiled file doesn't exist we will indicate that the view is expired
// so that it can be re-compiled. Else, we will verify the last modification
// of the views is less than the modification times of the compiled views.
if (!$this->compiledPath || !\is_file($compiled)) {
return true;
}
return \filemtime($compiled) < \filemtime($template);
}
/**
* Evaluates a text (string) using the current variables
*
* @param string $content
* @param array $variables
* @return string
* @throws Exception
*/
protected function evaluateText($content, $variables)
{
\ob_start();
\extract($variables);
// We'll evaluate the contents of the view inside a try/catch block so we can
// flush out any stray output that might get out before an error occurs or
// an exception is thrown. This prevents any partial views from leaking.
try {
eval(' ?>' . $content . $this->phpTag);
} catch (Exception $e) {
$this->handleViewException($e);
}
return \ltrim(\ob_get_clean());
}
/**
* Handle a view exception.
*
* @param Exception $e
* @return void
* @throws $e
*/
protected function handleViewException($e)
{
\ob_get_clean();
throw $e;
}
/**
* Evaluates a compiled file using the current variables
*
* @param string $compiledFile full path of the compile file.
* @param array $variables
* @return string
* @throws Exception
*/
protected function evaluatePath($compiledFile, $variables)
{
\ob_start();
// note, the variables are extracted locally inside this method,
// they are not global variables :-3
\extract($variables);
// We'll evaluate the contents of the view inside a try/catch block so we can
// flush out any stray output that might get out before an error occurs or
// an exception is thrown. This prevents any partial views from leaking.
try {
/** @noinspection PhpIncludeInspection */
include $compiledFile;
} catch (Exception $e) {
$this->handleViewException($e);
}
return \ltrim(\ob_get_clean());
}
/**
* @param array $views array of views
* @param array $value
* @return string
* @throws Exception
*/
public function includeFirst($views = [], $value = [])
{
foreach ($views as $view) {
if ($this->templateExist($view)) {
return $this->runChild($view, $value);
}
}
return '';
}
/**
* Returns true if the template exists. Otherwise it returns false
*
* @param $templateName
* @return bool
*/
private function templateExist($templateName)
{
$file = $this->getTemplateFile($templateName);
return \is_file($file);
}
/**
* Convert an array such as ["class1"=>"myclass","style="mystyle"] to class1='myclass' style='mystyle' string
*
* @param array|string $array array to convert
* @return string
*/
public function convertArg($array)
{
if (!\is_array($array)) {
return $array; // nothing to convert.
}
return \implode(' ', \array_map('static::convertArgCallBack', \array_keys($array), $array));
}
/**
* Returns the current token. if there is not a token then it generates a new one.
* It could require an open session.
*
* @param bool $fullToken It returns a token with the current ip.
* @param string $tokenId [optional] Name of the token.
*
* @return string
*/
public function getCsrfToken($fullToken = false, $tokenId = '_token')
{
if ($this->csrf_token == '') {
$this->regenerateToken($tokenId);
}
if ($fullToken) {
return $this->csrf_token . '|' . $this->ipClient();
}
return $this->csrf_token;
}
/**
* Regenerates the csrf token and stores in the session.
* It requires an open session.
*
* @param string $tokenId [optional] Name of the token.
*/
public function regenerateToken($tokenId = '_token')
{
try {
$this->csrf_token = \bin2hex(\random_bytes(10));
} catch (Exception $e) {
$this->csrf_token = '123456789012345678901234567890'; // unable to generates a random token.
}
@$_SESSION[$tokenId] = $this->csrf_token . '|' . $this->ipClient();
}
public function ipClient()
{
if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])
&& \preg_match('/^([d]{1,3}).([d]{1,3}).([d]{1,3}).([d]{1,3})$/', $_SERVER['HTTP_X_FORWARDED_FOR'])) {
return $_SERVER['HTTP_X_FORWARDED_FOR'];
}
return isset($_SERVER['REMOTE_ADDR']) ? $_SERVER['REMOTE_ADDR'] : '';
}
/**
* Validates if the csrf token is valid or not.
* It requires an open session.
*
* @param bool $alwaysRegenerate [optional] Default is false.
* If true then it will generate a new token regardless
* of the method.
* If false, then it will generate only if the method is POST.
* Note: You must not use true if you want to use csrf with AJAX.
*
* @param string $tokenId [optional] Name of the token.
*
* @return bool It returns true if the token is valid or it is generated. Otherwise, false.
*/
public function csrfIsValid($alwaysRegenerate = false, $tokenId = '_token')
{
if (@$_SERVER['REQUEST_METHOD'] === 'POST' && $alwaysRegenerate === false) {
$this->csrf_token = isset($_POST[$tokenId]) ? $_POST[$tokenId] : null; // ping pong the token.
return $this->csrf_token . '|' . $this->ipClient() === (isset($_SESSION[$tokenId]) ? $_SESSION[$tokenId] : null);
}
if ($this->csrf_token == '' || $alwaysRegenerate) {
// if not token then we generate a new one
$this->regenerateToken($tokenId);
}
return true;
}
/**
* Stop injecting content into a section and return its contents.
*
* @return string
*/
public function yieldSection()
{
$sc = $this->stopSection();
return isset($this->sections[$sc]) ? $this->sections[$sc] : null;
}
/**
* Stop injecting content into a section.
*
* @param bool $overwrite
* @return string
*/
public function stopSection($overwrite = false)
{
if (empty($this->sectionStack)) {
$this->showError('stopSection', 'Cannot end a section without first starting one.', true, true);
}
$last = \array_pop($this->sectionStack);
if ($overwrite) {
$this->sections[$last] = \ob_get_clean();
} else {
$this->extendSection($last, \ob_get_clean());
}
return $last;
}
/**
* Append content to a given section.
*
* @param string $section
* @param string $content
* @return void
*/
protected function extendSection($section, $content)
{
if (isset($this->sections[$section])) {
$content = \str_replace($this->PARENTKEY, $content, $this->sections[$section]);
}
$this->sections[$section] = $content;
}
public function dump($object, $jsconsole = false)
{
if (!$jsconsole) {
echo '
';
\var_dump($object);
echo '
';
} else {
/** @noinspection BadExpressionStatementJS */
/** @noinspection JSVoidFunctionReturnValueUsed */
echo '';
}
}
/**
* Start injecting content into a section.
*
* @param string $section
* @param string $content
* @return void
*/
public function startSection($section, $content = '')
{
if ($content === '') {
\ob_start() && $this->sectionStack[] = $section;
} else {
$this->extendSection($section, $content);
}
}
/**
* Stop injecting content into a section and append it.
*
* @return string
* @throws InvalidArgumentException
*/
public function appendSection()
{
if (empty($this->sectionStack)) {
$this->showError('appendSection', 'Cannot end a section without first starting one.', true, true);
}
$last = \array_pop($this->sectionStack);
if (isset($this->sections[$last])) {
$this->sections[$last] .= \ob_get_clean();
} else {
$this->sections[$last] = \ob_get_clean();
}
return $last;
}
/**
* Adds a global variable. If $varname is an array then it merges all the values.
* Example:
*
* $this->share('variable',10.5);
* $this->share('variable2','hello');
* // or we could add the two variables as:
* $this->share(['variable'=>10.5,'variable2'=>'hello']);
*
*
* @param string|array $varname It is the name of the variable or it is an associative array
* @param mixed $value
* @return $this
* @see \eftec\bladeone\BladeOne::share
*/
public function with($varname, $value = null)
{
return $this->share($varname, $value);
}
/**
* Adds a global variable. If $varname is an array then it merges all the values.
* Example:
*
* $this->share('variable',10.5);
* $this->share('variable2','hello');
* // or we could add the two variables as:
* $this->share(['variable'=>10.5,'variable2'=>'hello']);
*
*
* @param string|array $varname It is the name of the variable or it is an associative array
* @param mixed $value
* @return $this
*/
public function share($varname, $value = null)
{
if (is_array($varname)) {
$this->variablesGlobal = \array_merge($this->variablesGlobal, $varname);
} else {
$this->variablesGlobal[$varname] = $value;
}
return $this;
}
/**
* Get the string contents of a section.
*
* @param string $section
* @param string $default
* @return string
*/
public function yieldContent($section, $default = '')
{
if (isset($this->sections[$section])) {
return \str_replace($this->PARENTKEY, $default, $this->sections[$section]);
}
return $default;
}
/**
* Register a custom Blade compiler.
*
* @param callable $compiler
* @return void
*/
public function extend(callable $compiler)
{
$this->extensions[] = $compiler;
}
/**
* Register a handler for custom directives for run at runtime
*
* @param string $name
* @param callable $handler
* @return void
*/
public function directiveRT($name, callable $handler)
{
$this->customDirectives[$name] = $handler;
$this->customDirectivesRT[$name] = true;
}
/**
* Sets the escaped content tags used for the compiler.
*
* @param string $openTag
* @param string $closeTag
* @return void
*/
public function setEscapedContentTags($openTag, $closeTag)
{
$this->setContentTags($openTag, $closeTag, true);
}
/**
* Gets the content tags used for the compiler.
*
* @return array
*/
public function getContentTags()
{
return $this->getTags();
}
/**
* Sets the content tags used for the compiler.
*
* @param string $openTag
* @param string $closeTag
* @param bool $escaped
* @return void
*/
public function setContentTags($openTag, $closeTag, $escaped = false)
{
$property = ($escaped === true) ? 'escapedTags' : 'contentTags';
$this->{$property} = [\preg_quote($openTag), \preg_quote($closeTag)];
}
/**
* Gets the tags used for the compiler.
*
* @param bool $escaped
* @return array
*/
protected function getTags($escaped = false)
{
$tags = $escaped ? $this->escapedTags : $this->contentTags;
return \array_map('stripcslashes', $tags);
}
/**
* Gets the escaped content tags used for the compiler.
*
* @return array
*/
public function getEscapedContentTags()
{
return $this->getTags(true);
}
/**
* Sets the function used for resolving classes with inject.
*
* @param callable $function
*/
public function setInjectResolver(callable $function)
{
$this->injectResolver = $function;
}
/**
* Get the file extension for template files.
*
* @return string
*/
public function getFileExtension()
{
return $this->fileExtension;
}
/**
* Set the file extension for the template files.
* It must includes the leading dot e.g. .blade.php
*
* @param string $fileExtension Example: .prefix.ext
*/
public function setFileExtension($fileExtension)
{
$this->fileExtension = $fileExtension;
}
/**
* Get the file extension for template files.
*
* @return string
*/
public function getCompiledExtension()
{
return $this->compileExtension;
}
/**
* Set the file extension for the compiled files.
* Including the leading dot for the extension is required, e.g. .bladec
*
* @param $fileExtension
*/
public function setCompiledExtension($fileExtension)
{
$this->compileExtension = $fileExtension;
}
/**
* Add new loop to the stack.
*
* @param array|Countable $data
* @return void
*/
public function addLoop($data)
{
$length = \is_array($data) || $data instanceof Countable ? \count($data) : null;
$parent = static::last($this->loopsStack);
$this->loopsStack[] = [
'index' => -1,
'iteration' => 0,
'remaining' => isset($length) ? $length + 1 : null,
'count' => $length,
'first' => true,
'even' => true,
'odd' => false,
'last' => isset($length) ? $length == 1 : null,
'depth' => \count($this->loopsStack) + 1,
'parent' => $parent ? (object)$parent : null,
];
}
/**
* Increment the top loop's indices.
*
* @return object
*/
public function incrementLoopIndices()
{
$c = \count($this->loopsStack) - 1;
$loop = &$this->loopsStack[$c];
$loop['index']++;
$loop['iteration']++;
$loop['first'] = $loop['index'] == 0;
$loop['even'] = $loop['index'] % 2 == 0;
$loop['odd'] = !$loop['even'];
if (isset($loop['count'])) {
$loop['remaining']--;
$loop['last'] = $loop['index'] == $loop['count'] - 1;
}
return (object)$loop;
}
/**
* Pop a loop from the top of the loop stack.
*
* @return void
*/
public function popLoop()
{
\array_pop($this->loopsStack);
}
/**
* Get an instance of the first loop in the stack.
*
* @return object
*/
public function getFirstLoop()
{
return ($last = static::last($this->loopsStack)) ? (object)$last : null;
}
/**
* Get the rendered contents of a partial from a loop.
*
* @param string $view
* @param array $data
* @param string $iterator
* @param string $empty
* @return string
* @throws Exception
*/
public function renderEach($view, $data, $iterator, $empty = 'raw|')
{
$result = '';
if (\count($data) > 0) {
// If is actually data in the array, we will loop through the data and append
// an instance of the partial view to the final result HTML passing in the
// iterated value of this data array, allowing the views to access them.
foreach ($data as $key => $value) {
$data = ['key' => $key, $iterator => $value];
$result .= $this->runChild($view, $data);
}
} elseif (static::startsWith($empty, 'raw|')) {
$result = \substr($empty, 4);
} else {
$result = $this->run($empty, []);
}
return $result;
}
/**
* Run the blade engine. It returns the result of the code.
*
* @param string|null $view The name of the cache. Ex: "folder.folder.view" ("/folder/folder/view.blade")
* @param array $variables An associative arrays with the values to display.
* @return string
* @throws Exception
*/
public function run($view = null, $variables = [])
{
$mode = $this->getMode();
if ($view === null) {
$view = $this->viewStack;
}
$this->viewStack = null;
if ($view === null) {
$this->showError('run', 'BladeOne: view not set', true);
return '';
}
$forced = $mode & 1; // mode=1 forced:it recompiles no matter if the compiled file exists or not.
$runFast = $mode & 2; // mode=2 runfast: the code is not compiled neither checked and it runs directly the compiled
$this->sections = [];
if ($mode == 3) {
$this->showError('run', "we can't force and run fast at the same time", true);
}
return $this->runInternal($view, $variables, $forced, true, $runFast);
}
/**
* It sets the current view
* This value is cleared when it is used (method run).
* Example:
*
* $this->setView('folder.view')->share(['var1'=>20])->run(); // or $this->run('folder.view',['var1'=>20]);
*
*
* @param string $view
* @return BladeOne
*/
public function setView($view)
{
$this->viewStack = $view;
return $this;
}
/**
* It injects a function, an instance, or a method class when a view is called.
* It could be stacked. If it sets null then it clears all definitions.
* Example:
*
* $this->composer('folder.view',function($bladeOne) { $bladeOne->share('newvalue','hi there'); });
* $this->composer('folder.view','namespace1\namespace2\SomeClass'); // SomeClass must exists and it must has the
* // method 'composer'
* $this->composer('folder.*',$instance); // $instance must has the method called 'composer'
* $this->composer(); // clear all composer.
*
*
* @param string|array|null $view It could contains wildcards (*). Example: 'aa.bb.cc','*.bb.cc','aa.bb.*','*.bb.*'
*
* @param callable|string|null $functionOrClass
* @return BladeOne
*/
public function composer($view = null, $functionOrClass = null)
{
if ($view === null && $functionOrClass === null) {
$this->composerStack = [];
return $this;
}
if (is_array($view)) {
foreach ($view as $v) {
$this->composerStack[$v] = $functionOrClass;
}
} else {
$this->composerStack[$view] = $functionOrClass;
}
return $this;
}
/**
* Start a component rendering process.
*
* @param string $name
* @param array $data
* @return void
*/
public function startComponent($name, array $data = [])
{
if (\ob_start()) {
$this->componentStack[] = $name;
$this->componentData[$this->currentComponent()] = $data;
$this->slots[$this->currentComponent()] = [];
}
}
/**
* Get the index for the current component.
*
* @return int
*/
protected function currentComponent()
{
return \count($this->componentStack) - 1;
}
/**
* Render the current component.
*
* @return string
* @throws Exception
*/
public function renderComponent()
{
//echo "render ";
$name = \array_pop($this->componentStack);
//return $this->runChild($name, $this->componentData());
$cd = $this->componentData();
$clean = array_keys($cd);
$r = $this->runChild($name, $cd);
// we clean variables defined inside the component (so they are garbaged when the component is used)
foreach ($clean as $key) {
unset($this->variables[$key]);
}
return $r;
}
/**
* Get the data for the given component.
*
* @return array
*/
protected function componentData()
{
$cs = count($this->componentStack);
//echo "";
//echo " data: ";
//var_dump($this->componentData);
//echo " datac: ";
//var_dump(count($this->componentStack));
return array_merge(
$this->componentData[$cs],
['slot' => trim(ob_get_clean())],
$this->slots[$cs]
);
}
/**
* Start the slot rendering process.
*
* @param string $name
* @param string|null $content
* @return void
*/
public function slot($name, $content = null)
{
if (\count(\func_get_args()) === 2) {
$this->slots[$this->currentComponent()][$name] = $content;
} elseif (\ob_start()) {
$this->slots[$this->currentComponent()][$name] = '';
$this->slotStack[$this->currentComponent()][] = $name;
}
}
/**
* Save the slot content for rendering.
*
* @return void
*/
public function endSlot()
{
static::last($this->componentStack);
$currentSlot = \array_pop(
$this->slotStack[$this->currentComponent()]
);
$this->slots[$this->currentComponent()]
[$currentSlot] = \trim(\ob_get_clean());
}
/**
* @return string
*/
public function getPhpTag()
{
return $this->phpTag;
}
/**
* @param string $phpTag
*/
public function setPhpTag($phpTag)
{
$this->phpTag = $phpTag;
}
/**
* @return string
*/
public function getCurrentUser()
{
return $this->currentUser;
}
/**
* @param string $currentUser
*/
public function setCurrentUser($currentUser)
{
$this->currentUser = $currentUser;
}
/**
* @return string
*/
public function getCurrentRole()
{
return $this->currentRole;
}
/**
* @param string $currentRole
*/
public function setCurrentRole($currentRole)
{
$this->currentRole = $currentRole;
}
/**
* @return string[]
*/
public function getCurrentPermission()
{
return $this->currentPermission;
}
/**
* @param string[] $currentPermission
*/
public function setCurrentPermission($currentPermission)
{
$this->currentPermission = $currentPermission;
}
/**
* Returns the current base url without trailing slash.
*
* @return string
*/
public function getBaseUrl()
{
return $this->baseUrl;
}
/**
* It sets the base url and it also calculates the relative path.
* The base url defines the "root" of the project, not always the level of the domain but it could be
* any folder.
* This value is used to calculate the relativity of the resources but it is also used to set the domain.
* Note: The trailing slash is removed automatically if it's present.
* Note: We should not use arguments or name of the script.
* Examples:
*
*
* @param string $baseUrl Example http://www.web.com/folder https://www.web.com/folder/anotherfolder
* @return BladeOne
*/
public function setBaseUrl($baseUrl)
{
$this->baseUrl = \rtrim($baseUrl, '/'); // base with the url trimmed
$this->baseDomain = @parse_url($this->baseUrl)['host'];
$currentUrl = $this->getCurrentUrlCalculated();
if ($currentUrl === '') {
$this->relativePath = '';
return $this;
}
if (\strpos($currentUrl, $this->baseUrl) === 0) {
$part = \str_replace($this->baseUrl, '', $currentUrl);
$numf = \substr_count($part, '/') - 1;
$numf = ($numf > 10) ? 10 : $numf; // avoid overflow
$this->relativePath = ($numf < 0) ? '' : \str_repeat('../', $numf);
} else {
$this->relativePath = '';
}
return $this;
}
/**
* It gets the full current url calculated with the information sends by the user.
* Note: If we set baseurl, then it always uses the baseurl as domain (it's safe).
* Note: This information could be forged/faked by the end-user.
* Note: It returns empty '' if it is called in a command line interface / non-web.
* Note: It doesn't returns the user and password.
* @param bool $noArgs if true then it excludes the arguments.
* @return string
*/
public function getCurrentUrlCalculated($noArgs = false)
{
if (!isset($_SERVER['HTTP_HOST'], $_SERVER['REQUEST_URI'])) {
return '';
}
$host = $this->baseDomain !== null ? $this->baseDomain : $_SERVER['HTTP_HOST']; // <-- it could be forged!
$link = (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? "https" : "http");
$port = $_SERVER['SERVER_PORT'];
$port2 = (($link === 'http' && $port === '80') || ($link === 'https' && $port === '443')) ? '' : ':' . $port;
$link .= "://$host{$port2}$_SERVER[REQUEST_URI]";
if ($noArgs) {
$link = @explode('?', $link)[0];
}
return $link;
}
/**
* It returns the relative path to the base url or empty if not set
* Example:
*
* Note:The relative path is calculated when we set the base url.
*
* @return string
* @see \eftec\bladeone\BladeOne::setBaseUrl
*/
public function getRelativePath()
{
return $this->relativePath;
}
/**
* It gets the full current canonical url.
* Example: https://www.mysite.com/aaa/bb/php.php?aa=bb
*
*
It returns the $this->canonicalUrl value if is not null
*
Otherwise, it returns the $this->currentUrl if not null
*
Otherwise, the url is calculated with the information sends by the user
*
*
* @return string|null
*/
public function getCanonicalUrl()
{
return $this->canonicalUrl !== null ? $this->canonicalUrl : $this->getCurrentUrl();
}
/**
* It sets the full canonical url.
* Example: https://www.mysite.com/aaa/bb/php.php?aa=bb
*
* @param string|null $canonUrl
* @return BladeOne
*/
public function setCanonicalUrl($canonUrl = null)
{
$this->canonicalUrl = $canonUrl;
return $this;
}
/**
* It gets the full current url
* Example: https://www.mysite.com/aaa/bb/php.php?aa=bb
*
*
It returns the $this->currentUrl if not null
*
Otherwise, the url is calculated with the information sends by the user
*
*
* @param bool $noArgs if true then it ignore the arguments.
* @return string|null
*/
public function getCurrentUrl($noArgs = false)
{
$link = $this->currentUrl !== null ? $this->currentUrl : $this->getCurrentUrlCalculated();
if ($noArgs) {
$link = @explode('?', $link)[0];
}
return $link;
}
/**
* It sets the full current url.
* Example: https://www.mysite.com/aaa/bb/php.php?aa=bb
* Note: If the current url is not set, then the system could calculate the current url.
*
* @param string|null $currentUrl
* @return BladeOne
*/
public function setCurrentUrl($currentUrl = null)
{
$this->currentUrl = $currentUrl;
return $this;
}
/**
* If true then it optimizes the result (it removes tab and extra spaces).
*
* @param bool $bool
* @return BladeOne
*/
public function setOptimize($bool = false)
{
$this->optimize = $bool;
return $this;
}
/**
* It sets the callback function for authentication. It is used by @can and @cannot
*
* @param callable $fn
*/
public function setCanFunction(callable $fn)
{
$this->authCallBack = $fn;
}
/**
* It sets the callback function for authentication. It is used by @canany
*
* @param callable $fn
*/
public function setAnyFunction(callable $fn)
{
$this->authAnyCallBack = $fn;
}
/**
* It sets the callback function for errors. It is used by @error
*
* @param callable $fn
*/
public function setErrorFunction(callable $fn)
{
$this->errorCallBack = $fn;
}
//
//
/**
* Get the entire loop stack.
*
* @return array
*/
public function getLoopStack()
{
return $this->loopsStack;
}
/**
* It adds a string inside a quoted string
* example:
*
*
* @param $quoted
* @param $newFragment
* @return string
*/
public function addInsideQuote($quoted, $newFragment)
{
if ($this->isQuoted($quoted)) {
return substr($quoted, 0, -1) . $newFragment . substr($quoted, -1);
}
return $quoted . $newFragment;
}
/**
* Return true if the string is a php variable (it starts with $)
*
* @param string|null $text
* @return bool
*/
public function isVariablePHP($text)
{
if (!$text || strlen($text) < 2) {
return false;
}
return $text[0] === '$';
}
/**
* Its the same than @_e, however it parses the text (using sprintf).
* If the operation fails then, it returns the original expression without translation.
*
* @param $phrase
*
* @return string
*/
public function _ef($phrase)
{
$argv = \func_get_args();
$r = $this->_e($phrase);
$argv[0] = $r; // replace the first argument with the translation.
$result = @sprintf(...$argv);
return ($result == false) ? $r : $result;
}
/**
* Tries to translate the word if its in the array defined by BladeOneLang::$dictionary
* If the operation fails then, it returns the original expression without translation.
*
* @param $phrase
*
* @return string
*/
public function _e($phrase)
{
if ((!\array_key_exists($phrase, static::$dictionary))) {
$this->missingTranslation($phrase);
return $phrase;
}
return static::$dictionary[$phrase];
}
/**
* Log a missing translation into the file $this->missingLog.
* If the file is not defined, then it doesn't write the log.
*
* @param string $txt Message to write on.
*/
private function missingTranslation($txt)
{
if (!$this->missingLog) {
return; // if there is not a file assigned then it skips saving.
}
$fz = @\filesize($this->missingLog);
if (\is_object($txt) || \is_array($txt)) {
$txt = \print_r($txt, true);
}
// Rewrite file if more than 100000 bytes
$mode = ($fz > 100000) ? 'w' : 'a';
$fp = \fopen($this->missingLog, $mode);
\fwrite($fp, $txt . "\n");
\fclose($fp);
}
/**
* if num is more than one then it returns the phrase in plural, otherwise the phrase in singular.
* Note: the translation should be as follow: $msg['Person']='Person' $msg=['Person']['p']='People'
*
* @param string $phrase
* @param string $phrases
* @param int $num
*
* @return string
*/
public function _n($phrase, $phrases, $num = 0)
{
if ((!\array_key_exists($phrase, static::$dictionary))) {
$this->missingTranslation($phrase);
return ($num <= 1) ? $phrase : $phrases;
}
return ($num <= 1) ? $this->_e($phrase) : $this->_e($phrases);
}
/**
* @param $expression
* @return string
* @see \eftec\bladeone\BladeOne::getCanonicalUrl
*/
public function compileCanonical($expression = null)
{
return '';
}
/**
* @param $expression
* @return string
* @see \eftec\bladeone\BladeOne::getBaseUrl()
*/
public function compileBase($expression = null)
{
return '';
}
protected function compileUse($expression)
{
return $this->phpTag . 'use ' . $this->stripParentheses($expression) . '; ?>';
}
protected function compileSwitch($expression)
{
$this->switchCount++;
$this->firstCaseInSwitch = true;
return $this->phpTag . "switch $expression {";
}
//
//
protected function compileDump($expression)
{
return $this->phpTagEcho . " \$this->dump$expression;?>";
}
protected function compileRelative($expression)
{
return $this->phpTagEcho . " \$this->relative$expression;?>";
}
protected function compileMethod($expression)
{
$v = $this->stripParentheses($expression);
return "";
}
protected function compilecsrf($expression = null)
{
$expression = ($expression === null) ? "'_token'" : $expression;
return "";
}
protected function compileDd($expression)
{
return $this->phpTagEcho . " '
'; var_dump$expression; echo '
';?>";
}
/**
* Execute the case tag.
*
* @param $expression
* @return string
*/
protected function compileCase($expression)
{
if ($this->firstCaseInSwitch) {
$this->firstCaseInSwitch = false;
return 'case ' . $expression . ': ?>';
}
return $this->phpTag . "case $expression: ?>";
}
/**
* Compile the while statements into valid PHP.
*
* @param string $expression
* @return string
*/
protected function compileWhile($expression)
{
return $this->phpTag . "while$expression: ?>";
}
/**
* default tag used for switch/case
*
* @return string
*/
protected function compileDefault()
{
if ($this->firstCaseInSwitch) {
return $this->showError('@default', '@switch without any @case', true);
}
return $this->phpTag . 'default: ?>';
}
protected function compileEndSwitch()
{
--$this->switchCount;
if ($this->switchCount < 0) {
return $this->showError('@endswitch', 'Missing @switch', true);
}
return $this->phpTag . '} // end switch ?>';
}
/**
* Compile while statements into valid PHP.
*
* @param string $expression
* @return string
*/
protected function compileInject($expression)
{
$ex = $this->stripParentheses($expression);
$p0 = \strpos($ex, ',');
if ($p0 == false) {
$var = $this->stripQuotes($ex);
$namespace = '';
} else {
$var = $this->stripQuotes(\substr($ex, 0, $p0));
$namespace = $this->stripQuotes(\substr($ex, $p0 + 1));
}
return $this->phpTag . "\$$var = \$this->injectClass('$namespace', '$var'); ?>";
}
/**
* Remove first and end quote from a quoted string of text
*
* @param mixed $text
* @return null|string|string[]
*/
public function stripQuotes($text)
{
if (!$text || strlen($text) < 2) {
return $text;
}
$text = trim($text);
$p0 = $text[0];
$p1 = \substr($text, -1);
if ($p0 === $p1 && ($p0 === '"' || $p0 === "'")) {
return \substr($text, 1, -1);
}
return $text;
}
/**
* Execute the user defined extensions.
*
* @param string $value
* @return string
*/
protected function compileExtensions($value)
{
foreach ($this->extensions as $compiler) {
$value = $compiler($value, $this);
}
return $value;
}
/**
* Compile Blade comments into valid PHP.
*
* @param string $value
* @return string
*/
protected function compileComments($value)
{
$pattern = \sprintf('/%s--(.*?)--%s/s', $this->contentTags[0], $this->contentTags[1]);
return \preg_replace($pattern, $this->phpTag . '/*$1*/ ?>', $value);
}
/**
* Compile Blade echos into valid PHP.
*
* @param string $value
* @return string
*/
protected function compileEchos($value)
{
foreach ($this->getEchoMethods() as $method => $length) {
$value = $this->$method($value);
}
return $value;
}
/**
* Get the echo methods in the proper order for compilation.
*
* @return array
*/
protected function getEchoMethods()
{
$methods = [
'compileRawEchos' => \strlen(\stripcslashes($this->rawTags[0])),
'compileEscapedEchos' => \strlen(\stripcslashes($this->escapedTags[0])),
'compileRegularEchos' => \strlen(\stripcslashes($this->contentTags[0])),
];
\uksort($methods, static function ($method1, $method2) use ($methods) {
// Ensure the longest tags are processed first
if ($methods[$method1] > $methods[$method2]) {
return -1;
}
if ($methods[$method1] < $methods[$method2]) {
return 1;
}
// Otherwise give preference to raw tags (assuming they've overridden)
if ($method1 === 'compileRawEchos') {
return -1;
}
if ($method2 === 'compileRawEchos') {
return 1;
}
if ($method1 === 'compileEscapedEchos') {
return -1;
}
if ($method2 === 'compileEscapedEchos') {
return 1;
}
throw new BadMethodCallException("Method [$method1] not defined");
});
return $methods;
}
/**
* Compile Blade statements that start with "@".
*
* @param string $value
*
* @return array|string|string[]|null
*/
protected function compileStatements($value)
{
/**
* @param array $match
* [0]=full expression with @ and parenthesis
* [1]=expression without @ and argument
* [2]=????
* [3]=argument with parenthesis and without the first @
* [4]=argument without parenthesis.
*
* @return mixed|string
*/
$callback = function ($match) {
if (static::contains($match[1], '@')) {
// @@escaped tag
$match[0] = isset($match[3]) ? $match[1] . $match[3] : $match[1];
} else {
if (strpos($match[1], '::') !== false) {
// Someclass::method
return $this->compileStatementClass($match);
}
if (isset($this->customDirectivesRT[$match[1]])) {
if ($this->customDirectivesRT[$match[1]] == true) {
$match[0] = $this->compileStatementCustom($match);
} else {
$match[0] = \call_user_func(
$this->customDirectives[$match[1]],
$this->stripParentheses(static::get($match, 3))
);
}
} elseif (\method_exists($this, $method = 'compile' . \ucfirst($match[1]))) {
// it calls the function compile
$match[0] = $this->$method(static::get($match, 3));
} else {
return $match[0];
}
}
return isset($match[3]) ? $match[0] : $match[0] . $match[2];
};
/* return \preg_replace_callback('/\B@(@?\w+)([ \t]*)(\( ( (?>[^()]+) | (?3) )* \))?/x', $callback, $value); */
return preg_replace_callback('/\B@(@?\w+(?:::\w+)?)([ \t]*)(\( ( (?>[^()]+) | (?3) )* \))?/x', $callback, $value);
}
/**
* Determine if a given string contains a given substring.
*
* @param string $haystack
* @param string|array $needles
* @return bool
*/
public static function contains($haystack, $needles)
{
foreach ((array)$needles as $needle) {
if ($needle != '') {
if (\function_exists('mb_strpos')) {
if (\mb_strpos($haystack, $needle) !== false) {
return true;
}
} elseif (\strpos($haystack, $needle) !== false) {
return true;
}
}
}
return false;
}
private function compileStatementClass($match)
{
if (isset($match[3])) {
return $this->phpTagEcho . $this->fixNamespaceClass($match[1]) . $match[3] . '; ?>';
}
return $this->phpTagEcho . $this->fixNamespaceClass($match[1]) . '(); ?>';
}
/**
* Util method to fix namespace of a class
* Example: "SomeClass::method()" -> "\namespace\SomeClass::method()"
*
* @param string $text
*
* @return string
* @see \eftec\bladeone\BladeOne::$aliasClasses
*/
private function fixNamespaceClass($text)
{
if (strpos($text, '::') === false) {
return $text;
}
$classPart = explode('::', $text, 2);
if (isset($this->aliasClasses[$classPart[0]])) {
$classPart[0] = $this->aliasClasses[$classPart[0]];
}
return $classPart[0] . '::' . $classPart[1];
}
/**
* For compile custom directive at runtime.
*
* @param $match
* @return string
*/
protected function compileStatementCustom($match)
{
$v = $this->stripParentheses(static::get($match, 3));
$v = ($v == '') ? '' : ',' . $v;
return $this->phpTag . 'call_user_func($this->customDirectives[\'' . $match[1] . '\']' . $v . '); ?>';
}
/**
* Get an item from an array using "dot" notation.
*
* @param ArrayAccess|array $array
* @param string $key
* @param mixed $default
* @return mixed
*/
public static function get($array, $key, $default = null)
{
$accesible = \is_array($array) || $array instanceof ArrayAccess;
if (!$accesible) {
return static::value($default);
}
if (\is_null($key)) {
return $array;
}
if (static::exists($array, $key)) {
return $array[$key];
}
foreach (\explode('.', $key) as $segment) {
if (static::exists($array, $segment)) {
$array = $array[$segment];
} else {
return static::value($default);
}
}
return $array;
}
/**
* Determine if the given key exists in the provided array.
*
* @param ArrayAccess|array $array
* @param string|int $key
* @return bool
*/
public static function exists($array, $key)
{
if ($array instanceof ArrayAccess) {
return $array->offsetExists($key);
}
return \array_key_exists($key, $array);
}
/**
* This method removes the parenthesis of the expression and parse the arguments.
* @param string $expression
* @return array
*/
protected function getArgs($expression)
{
return $this->parseArgs($this->stripParentheses($expression), ' ');
}
/**
* It separates a string using a separator and excluding quotes and double quotes.
*
* @param string $text
* @param string $separator
* @return array
*/
public function parseArgs($text, $separator = ',')
{
if ($text === null || $text === '') {
return []; //nothing to convert.
}
$chars = str_split($text);
$parts = [];
$nextpart = '';
$strL = count($chars);
/** @noinspection ForeachInvariantsInspection */
for ($i = 0; $i < $strL; $i++) {
$char = $chars[$i];
if ($char === '"' || $char === "'") {
$inext = strpos($text, $char, $i + 1);
$inext = $inext === false ? $strL : $inext;
$nextpart .= substr($text, $i, $inext - $i + 1);
$i = $inext;
} else {
$nextpart .= $char;
}
if ($char === $separator) {
$parts[] = substr($nextpart, 0, -1);
$nextpart = '';
}
}
if ($nextpart !== '') {
$parts[] = $nextpart;
}
$result = [];
foreach ($parts as $part) {
$r = explode('=', $part, 2);
$result[trim($r[0])] = count($r) === 2 ? trim($r[1]) : null;
}
return $result;
}
/**
* Compile the "raw" echo statements.
*
* @param string $value
* @return string
*/
protected function compileRawEchos($value)
{
$pattern = \sprintf('/(@)?%s\s*(.+?)\s*%s(\r?\n)?/s', $this->rawTags[0], $this->rawTags[1]);
$callback = function ($matches) {
$whitespace = empty($matches[3]) ? '' : $matches[3] . $matches[3];
return $matches[1] ? \substr(
$matches[0],
1
) : $this->phpTagEcho . $this->compileEchoDefaults($matches[2]) . '; ?>' . $whitespace;
};
return \preg_replace_callback($pattern, $callback, $value);
}
/**
* Compile the default values for the echo statement.
*
* @param string $value
* @return string
*/
protected function compileEchoDefaults($value)
{
$result = \preg_replace('/^(?=\$)(.+?)(?:\s+or\s+)(.+?)$/s', 'isset($1) ? $1 : $2', $value);
if (!$this->pipeEnable) {
return $this->fixNamespaceClass($result);
}
return $this->pipeDream($this->fixNamespaceClass($result));
}
/**
* It converts a string separated by pipes | into an filtered expression.
* If the method exists (as directive), then it is used
* If the method exists (in this class) then it is used
* Otherwise, it uses a global function.
* If you want to escape the "|", then you could use "/|"
* Note: It only works if $this->pipeEnable=true and by default it is false
* Example:
*
";
}
//
}
* @ cache([cacheid],[duration=86400]). The id is optional. The duration of the cache is in seconds
* // content here
* @ endcache()
*
* It also adds a new function (optional) to the business or logic layer
*
* if ($blade->cacheExpired('hellocache',1,5)) { //'helloonecache' =template, =1 id cache, 5=duration (seconds)
* // cache expired, so we should do some stuff (such as read from the database)
* }
*
*
* @package BladeOneCache
* @version 3.42 2020-04-25
* @link https://github.com/EFTEC/BladeOne
* @author Jorge Patricio Castro Castillo
*/
trait BladeOneCache
{
protected $curCacheId = 0;
protected $curCacheDuration = 0;
protected $curCachePosition = 0;
protected $cacheRunning = false;
protected $cachePageRunning = false;
protected $cacheLog;
/**
* @var array avoids to compare the file different times. It also avoids race conditions.
*/
private $cacheExpired = [];
/**
* @var string=['get','post','getpost','request',null][$i]
*/
private $cacheStrategy;
/** @var array|null */
private $cacheStrategyIndex;
/**
* @return null|string $cacheStrategy=['get','post','getpost','request',null][$i]
*/
public function getCacheStrategy()
{
return $this->cacheStrategy;
}
/**
* It sets the cache log. If not cache log then it does not generates a log file
* The cache log stores each time a template is creates or expired.
*
* @param string $file
*/
public function setCacheLog($file)
{
$this->cacheLog=$file;
}
public function writeCacheLog($txt, $nivel)
{
if (!$this->cacheLog) {
return; // if there is not a file assigned then it skips saving.
}
$fz = @filesize($this->cacheLog);
if (is_object($txt) || is_array($txt)) {
$txt = print_r($txt, true);
}
// Rewrite file if more than 100000 bytes
$mode=($fz > 100000) ? 'w':'a';
$fp = fopen($this->cacheLog, $mode);
if ($fp === false) {
return;
}
switch ($nivel) {
case 1:
$txtNivel='expired';
break;
case 2:
$txtNivel='new';
break;
default:
$txtNivel='other';
}
$txtarg=json_encode($this->cacheUniqueGUID(false));
fwrite($fp, date('c') . "\t$txt\t$txtNivel\t$txtarg\n");
fclose($fp);
}
/**
* It sets the strategy of the cache page.
*
* @param null|string $cacheStrategy =['get','post','getpost','request',null][$i]
* @param array|null $index if null then it reads all indexes. If not, it reads a indexes.
*/
public function setCacheStrategy($cacheStrategy, $index = null)
{
$this->cacheStrategy = $cacheStrategy;
$this->cacheStrategyIndex = $index;
}
/**
* It obtains an unique GUID based in:
* get= parameters from the url
* post= parameters sends via post
* getpost = a mix between get and post
* request = get, post and cookies (including sessions)
* MD5 could generate colisions (2^64 = 18,446,744,073,709,551,616) but the end hash is the sum of the hash of
* the page + this GUID.
*
* @param bool $serialize if true then it serializes using md5
* @return string
*/
private function cacheUniqueGUID($serialize = true)
{
switch ($this->cacheStrategy) {
case 'get':
$r = $_GET;
break;
case 'post':
$r = $_POST;
break;
case 'getpost':
$arr = array_merge($_GET, $_POST);
$r = $arr;
break;
case 'request':
$r = $_REQUEST;
break;
default:
$r = null;
}
if ($this->cacheStrategyIndex === null || !is_array($r)) {
$r= serialize($r);
} else {
$copy=[];
foreach ($r as $key => $item) {
if (in_array($key, $this->cacheStrategyIndex, true)) {
$copy[$key]=$item;
}
}
$r=serialize($copy);
}
return $serialize===true ? md5($r): $r;
}
public function compileCache($expression)
{
// get id of template
// if the file exists then
// compare date.
// if the date is too old then re-save.
// else
// save for the first time.
return $this->phpTag . "echo \$this->cacheStart{$expression}; if(!\$this->cacheRunning) { ?>";
}
public function compileEndCache($expression)
{
return $this->phpTag . "} // if cacheRunning\necho \$this->cacheEnd{$expression}; ?>";
}
/**
* It get the filename of the compiled file (cached). If cache is not enabled, then it
* returns the regular file.
*
* @param string $view
* @return string The full filename
*/
private function getCompiledFileCache($view)
{
$id = $this->cacheUniqueGUID();
if ($id !== null) {
return str_replace($this->compileExtension, '_cache' . $id
. $this->compileExtension, $this->getCompiledFile($view));
}
return $this->getCompiledFile($view);
}
/**
* run the blade engine. It returns the result of the code.
*
* @param string $view The name of the cache. Ex: "folder.folder.view" ("/folder/folder/view.blade")
* @param array $variables An associative arrays with the values to display.
* @param int $ttl time to live (in second).
* @return string
*/
public function runCache($view, $variables = [], $ttl = 86400)
{
$this->cachePageRunning = true;
$cacheStatus=$this->cachePageExpired($view, $ttl);
if ($cacheStatus!==0) {
$this->writeCacheLog($view, $cacheStatus);
$this->cacheStart('_page_', $ttl);
$content = $this->run($view, $variables); // if no cache, then it runs normally.
$this->fileName = $view; // sometimes the filename is replaced (@include), so we restore it
$this->cacheEnd($content); // and it stores as a cache paged.
} else {
$content = $this->getFile($this->getCompiledFileCache($view));
}
$this->cachePageRunning = false;
return $content;
}
/**
* Returns true if the block cache expired (or doesn't exist), otherwise false.
*
* @param string $templateName name of the template to use (such hello for template hello.blade.php)
* @param string $id (id of cache, optional, if not id then it adds automatically a number)
* @param int $cacheDuration (duration of the cache in seconds)
* @return int 0=cache exists, 1= cache expired, 2=not exists, string= the cache file (if any)
*/
public function cacheExpired($templateName, $id, $cacheDuration)
{
if ($this->getMode() & 1) {
return 2; // forced mode, hence it always expires. (fast mode is ignored).
}
$compiledFile = $this->getCompiledFile($templateName) . '_cache' . $id;
return $this->cacheExpiredInt($compiledFile, $cacheDuration);
}
/**
* It returns true if the whole page expired.
*
* @param string $templateName
* @param int $cacheDuration is seconds.
* @return int 0=cache exists, 1= cache expired, 2=not exists, string= the cache content (if any)
*/
public function cachePageExpired($templateName, $cacheDuration)
{
if ($this->getMode() & 1) {
return 2; // forced mode, hence it always expires. (fast mode is ignored).
}
$compiledFile = $this->getCompiledFileCache($templateName);
return $this->CacheExpiredInt($compiledFile, $cacheDuration);
}
/**
* This method is used by cacheExpired() and cachePageExpired()
*
* @param string $compiledFile
* @param int $cacheDuration is seconds.
* @return int|mixed 0=cache exists, 1= cache expired, 2=not exists, string= the cache content (if any)
*/
private function cacheExpiredInt($compiledFile, $cacheDuration)
{
if (isset($this->cacheExpired[$compiledFile])) {
// if the information is already in the array then returns it.
return $this->cacheExpired[$compiledFile];
}
$date = @filemtime($compiledFile);
if ($date) {
if ($date + $cacheDuration < time()) {
$this->cacheExpired[$compiledFile] = 1;
return 2; // time-out.
}
} else {
$this->cacheExpired[$compiledFile] = 2;
return 1; // no file
}
$this->cacheExpired[$compiledFile] = 0;
return 0; // cache active.
}
public function cacheStart($id = '', $cacheDuration = 86400)
{
$this->curCacheId = ($id == '') ? ($this->curCacheId + 1) : $id;
$this->curCacheDuration = $cacheDuration;
$this->curCachePosition = strlen(ob_get_contents());
if ($this->cachePageRunning) {
$compiledFile = $this->getCompiledFileCache($this->fileName);
} else {
$compiledFile = $this->getCompiledFile() . '_cache' . $this->curCacheId;
}
if ($this->cacheExpired('', $id, $cacheDuration) !==0) {
$this->cacheRunning = false;
} else {
$this->cacheRunning = true;
$content = $this->getFile($compiledFile);
echo $content;
}
}
public function cacheEnd($txt = null)
{
if (!$this->cacheRunning) {
$txt = ($txt !== null) ? $txt : substr(ob_get_contents(), $this->curCachePosition);
if ($this->cachePageRunning) {
$compiledFile = $this->getCompiledFileCache($this->fileName);
} else {
$compiledFile = $this->getCompiledFile() . '_cache' . $this->curCacheId;
}
file_put_contents($compiledFile, $txt);
}
$this->cacheRunning = false;
}
}
* select:
* @ select('idCountry','value',[,$extra])
* @ item('0','--select a country'[,$extra])
* @ items($countries,'id','name',$currentCountry[,$extra])
* @ endselect()
* input:
* @ input('iduser',$currentUser,'text'[,$extra])
* button:
* @ commandbutton('idbutton','value','text'[,$extra])
*
*
* Note. The names of the tags are based in Java Server Faces (JSF)
*
* @package BladeOneHtmlBootstrap
* @version 1.9.1 2018-06-11 (1)
* @link https://github.com/EFTEC/BladeOne
* @author Jorge Patricio Castro Castillo
* @deprecated use https://github.com/eftec/BladeOneHtml
*/
trait BladeOneHtmlBootstrap
{
use BladeOneHtml {
BladeOneHtml::select as selectParent;
BladeOneHtml::input as inputParent;
BladeOneHtml::commandButton as commandButtonParent;
BladeOneHtml::textArea as textAreaParent;
BladeOneHtml::item as itemParent;
BladeOneHtml::checkbox as checkboxParent;
BladeOneHtml::compileEndCheckbox as compileEndCheckboxParent;
BladeOneHtml::radio as radioParent;
BladeOneHtml::compileEndRadio as compileEndRadioParent;
}
//
public function select($name, $value, $extra = '')
{
$extra = $this->addClass($extra, 'form-control');
return $this->selectParent($name, $value, $extra);
}
public function input($id, $value = '', $type = 'text', $extra = '')
{
$extra = $this->addClass($extra, 'form-control');
return $this->inputParent($id, $value, $type, $extra);
}
public function commandButton($id, $value = '', $text = 'Button', $type = 'submit', $extra = '')
{
$extra = $this->addClass($extra, 'btn');
return $this->commandButtonParent($id, $value, $text, $type, $extra);
}
public function textArea($id, $value = '', $extra = '')
{
$extra = $this->addClass($extra, 'form-control');
return $this->textAreaParent($id, $value, $extra);
}
public function file($id, $fullfilepath = '', $file = '', $extra = '')
{
return "
";
// return "$file
//
// convertArg($extra)." value='".static::e($fullfilepath)."' />\n";
}
/**
* @param string $id of the field
* @param string $fullfilepath full file path of the image
* @param string $file filename of the file
* @param string $extra extra field of the input file
* @return string html
*/
public function image($id, $fullfilepath = '', $file = '', $extra = '')
{
return "
";
// return "$file
//
// convertArg($extra)." value='".static::e($fullfilepath)."' />\n";
}
/**
* @param string $type type of the current open tag
* @param array|string $valueId if is an array then the first value is used as value, the second is used as
* extra
* @param $valueText
* @param array|string $selectedItem Item selected (optional)
* @param string $wrapper Wrapper of the element. For example,
%s
* @param string $extra
* @return string
* @internal param string $fieldId Field of the id
* @internal param string $fieldText Field of the value visible
*/
public function item($type, $valueId, $valueText, $selectedItem = '', $wrapper = '', $extra = '')
{
$id = @\end($this->htmlCurrentId);
$wrapper = ($wrapper == '') ? '%s' : $wrapper;
if (\is_array($selectedItem)) {
$found = \in_array($valueId, $selectedItem);
} else {
if (\is_null($selectedItem)) {
// diferentiate null = '' != 0
$found = $valueId === '' || $valueId === null;
} else {
$found = $selectedItem == $valueId;
}
}
$valueHtml = (!\is_array($valueId)) ? "value='{$valueId}'" : "value='{$valueId[0]}' data='{$valueId[1]}'";
switch ($type) {
case 'select':
$selected = ($found) ? 'selected' : '';
return \sprintf($wrapper, "\n");
break;
case 'radio':
$selected = ($found) ? 'checked' : '';
return \sprintf($wrapper, "\n");
break;
case 'checkbox':
$selected = ($found) ? 'checked' : '';
return \sprintf($wrapper, "\n");
break;
default:
return '???? type undefined: [$type] on @item ';
}
}
public function checkbox($id, $value = '', $text = '', $valueSelected = '', $extra = '')
{
$num = \func_num_args();
if ($num > 2) {
if ($value == $valueSelected) {
if (\is_array($extra)) {
$extra['checked'] = 'checked';
} else {
$extra .= ' checked="checked"';
}
}
//return '';
return '';
} else {
\array_push($this->htmlCurrentId, $id);
return '