YiiBase.php 21.2 KB
Newer Older
Qiang Xue committed
1
<?php
w  
Qiang Xue committed
2 3
/**
 * @link http://www.yiiframework.com/
Qiang Xue committed
4
 * @copyright Copyright (c) 2008 Yii Software LLC
w  
Qiang Xue committed
5 6
 * @license http://www.yiiframework.com/license/
 */
7 8
namespace yii;

Qiang Xue committed
9
use yii\base\Exception;
Qiang Xue committed
10
use yii\base\InvalidConfigException;
Qiang Xue committed
11
use yii\base\InvalidParamException;
Qiang Xue committed
12
use yii\base\UnknownClassException;
Qiang Xue committed
13
use yii\logging\Logger;
Qiang Xue committed
14

Qiang Xue committed
15
/**
w  
Qiang Xue committed
16
 * Gets the application start timestamp.
Qiang Xue committed
17
 */
w  
Qiang Xue committed
18
defined('YII_BEGIN_TIME') or define('YII_BEGIN_TIME', microtime(true));
Qiang Xue committed
19 20 21
/**
 * This constant defines whether the application should be in debug mode or not. Defaults to false.
 */
w  
Qiang Xue committed
22
defined('YII_DEBUG') or define('YII_DEBUG', false);
Qiang Xue committed
23 24 25 26 27
/**
 * This constant defines how much call stack information (file name and line number) should be logged by Yii::trace().
 * Defaults to 0, meaning no backtrace information. If it is greater than 0,
 * at most that number of call stacks will be logged. Note, only user application call stacks are considered.
 */
w  
Qiang Xue committed
28
defined('YII_TRACE_LEVEL') or define('YII_TRACE_LEVEL', 0);
Qiang Xue committed
29
/**
w  
Qiang Xue committed
30
 * This constant defines the framework installation directory.
Qiang Xue committed
31
 */
w  
Qiang Xue committed
32
defined('YII_PATH') or define('YII_PATH', __DIR__);
Qiang Xue committed
33 34 35 36 37
/**
 * This constant defines whether error handling should be enabled. Defaults to true.
 */
defined('YII_ENABLE_ERROR_HANDLER') or define('YII_ENABLE_ERROR_HANDLER', true);

w  
Qiang Xue committed
38

Qiang Xue committed
39
/**
w  
Qiang Xue committed
40
 * YiiBase is the core helper class for the Yii framework.
Qiang Xue committed
41
 *
w  
Qiang Xue committed
42
 * Do not use YiiBase directly. Instead, use its child class [[Yii]] where
Qiang Xue committed
43 44 45
 * you can customize methods of YiiBase.
 *
 * @author Qiang Xue <qiang.xue@gmail.com>
w  
Qiang Xue committed
46
 * @since 2.0
Qiang Xue committed
47 48 49 50 51
 */
class YiiBase
{
	/**
	 * @var array class map used by the Yii autoloading mechanism.
52
	 * The array keys are the class names (without leading backslashes), and the array values
Qiang Xue committed
53 54
	 * are the corresponding class file paths (or path aliases). This property mainly affects
	 * how [[autoload()]] works.
Qiang Xue committed
55 56
	 * @see import
	 * @see autoload
w  
Qiang Xue committed
57 58 59
	 */
	public static $classMap = array();
	/**
Qiang Xue committed
60 61
	 * @var boolean whether to search PHP include_path when autoloading unknown classes.
	 * You may want to turn this off if you are also using autoloaders from other libraries.
w  
Qiang Xue committed
62
	 */
Qiang Xue committed
63
	public static $enableIncludePath = true;
w  
Qiang Xue committed
64
	/**
65
	 * @var \yii\console\Application|\yii\web\Application the application instance
Qiang Xue committed
66
	 */
Qiang Xue committed
67
	public static $app;
w  
Qiang Xue committed
68 69
	/**
	 * @var array registered path aliases
Qiang Xue committed
70 71
	 * @see getAlias
	 * @see setAlias
w  
Qiang Xue committed
72
	 */
73
	public static $aliases;
Qiang Xue committed
74 75
	/**
	 * @var array initial property values that will be applied to objects newly created via [[createObject]].
Qiang Xue committed
76 77
	 * The array keys are class names without leading backslashes "\", and the array values are the corresponding
	 * name-value pairs for initializing the created class instances. For example,
Qiang Xue committed
78 79 80
	 *
	 * ~~~
	 * array(
Qiang Xue committed
81
	 *     'Bar' => array(
Qiang Xue committed
82 83 84
	 *         'prop1' => 'value1',
	 *         'prop2' => 'value2',
	 *     ),
Qiang Xue committed
85
	 *     'mycompany\foo\Car' => array(
Qiang Xue committed
86 87 88 89 90 91 92 93 94
	 *         'prop1' => 'value1',
	 *         'prop2' => 'value2',
	 *     ),
	 * )
	 * ~~~
	 *
	 * @see createObject
	 */
	public static $objectConfig = array();
Qiang Xue committed
95

Qiang Xue committed
96
	private static $_imported = array(); // alias => class name or directory
w  
Qiang Xue committed
97
	private static $_logger;
Qiang Xue committed
98 99 100 101 102 103

	/**
	 * @return string the version of Yii framework
	 */
	public static function getVersion()
	{
w  
Qiang Xue committed
104
		return '2.0-dev';
Qiang Xue committed
105 106 107
	}

	/**
Qiang Xue committed
108
	 * Imports a class by its alias.
Qiang Xue committed
109
	 *
Qiang Xue committed
110 111 112
	 * This method is provided to support autoloading of non-namespaced classes.
	 * Such a class can be specified in terms of an alias. For example, the alias `@old/code/Sample`
	 * may represent the `Sample` class under the directory `@old/code` (a path alias).
Qiang Xue committed
113
	 *
Qiang Xue committed
114 115 116 117
	 * By importing a class, the class is put in an internal storage such that when
	 * the class is used for the first time, the class autoloader will be able to
	 * find the corresponding class file and include it. For this reason, this method
	 * is much lighter than `include()`.
Qiang Xue committed
118
	 *
Qiang Xue committed
119
	 * You may import the same class multiple times. Only the first importing will count.
Qiang Xue committed
120
	 *
Qiang Xue committed
121 122 123 124
	 * @param string $alias the class to be imported. This may be either a class alias or a fully-qualified class name.
	 * If the latter, it will be returned back without change.
	 * @return string the actual class name that `$alias` refers to
	 * @throws Exception if the alias is invalid
Qiang Xue committed
125
	 */
Qiang Xue committed
126
	public static function import($alias)
Qiang Xue committed
127
	{
Qiang Xue committed
128
		if (strncmp($alias, '@', 1)) {
Qiang Xue committed
129
			return $alias;
Qiang Xue committed
130 131 132 133
		} else {
			$alias = static::getAlias($alias);
			if (!isset(self::$_imported[$alias])) {
				$className = basename($alias);
w  
Qiang Xue committed
134
				self::$_imported[$alias] = $className;
Qiang Xue committed
135
				self::$classMap[$className] = $alias . '.php';
w  
Qiang Xue committed
136
			}
Qiang Xue committed
137
			return self::$_imported[$alias];
Qiang Xue committed
138 139 140
		}
	}

141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
	/**
	 * Imports a set of namespaces.
	 *
	 * By importing a namespace, the method will create an alias for the directory corresponding
	 * to the namespace. For example, if "foo\bar" is a namespace associated with the directory
	 * "path/to/foo/bar", then an alias "@foo/bar" will be created for this directory.
	 *
	 * This method is typically invoked in the bootstrap file to import the namespaces of
	 * the installed extensions. By default, Composer, when installing new extensions, will
	 * generate such a mapping file which can be loaded and passed to this method.
	 *
	 * @param array $namespaces the namespaces to be imported. The keys are the namespaces,
	 * and the values are the corresponding directories.
	 */
	public static function importNamespaces($namespaces)
	{
		foreach ($namespaces as $name => $path) {
			if ($name !== '') {
159 160
				$name = trim(strtr($name, array('\\' => '/', '_' => '/')), '/');
				static::setAlias('@' . $name, rtrim($path, '/\\') . '/' . $name);
161 162 163 164
			}
		}
	}

Qiang Xue committed
165
	/**
w  
Qiang Xue committed
166
	 * Translates a path alias into an actual path.
m  
Qiang Xue committed
167
	 *
168
	 * The translation is done according to the following procedure:
m  
Qiang Xue committed
169
	 *
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
	 * 1. If the given alias does not start with '@', it is returned back without change;
	 * 2. Otherwise, look for the longest registered alias that matches the beginning part
	 *    of the given alias. If it exists, replace the matching part of the given alias with
	 *    the corresponding registered path.
	 * 3. Throw an exception or return false, depending on the `$throwException` parameter.
	 *
	 * For example, by default '@yii' is registered as the alias to the Yii framework directory,
	 * say '/path/to/yii'. The alias '@yii/web' would then be translated into '/path/to/yii/web'.
	 *
	 * If you have registered two aliases '@foo' and '@foo/bar'. Then translating '@foo/bar/config'
	 * would replace the part '@foo/bar' (instead of '@foo') with the corresponding registered path.
	 * This is because the longest alias takes precedence.
	 *
	 * However, if the alias to be translated is '@foo/barbar/config', then '@foo' will be replaced
	 * instead of '@foo/bar', because '/' serves as the boundary character.
	 *
	 * Note, this method does not check if the returned path exists or not.
w  
Qiang Xue committed
187
	 *
Qiang Xue committed
188
	 * @param string $alias the alias to be translated.
Qiang Xue committed
189 190
	 * @param boolean $throwException whether to throw an exception if the given alias is invalid.
	 * If this is false and an invalid alias is given, false will be returned by this method.
Qiang Xue committed
191
	 * @return string|boolean the path corresponding to the alias, false if the root alias is not previously registered.
Qiang Xue committed
192
	 * @throws InvalidParamException if the alias is invalid while $throwException is true.
w  
Qiang Xue committed
193
	 * @see setAlias
Qiang Xue committed
194
	 */
Qiang Xue committed
195
	public static function getAlias($alias, $throwException = true)
Qiang Xue committed
196
	{
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
		if (strncmp($alias, '@', 1)) {
			// not an alias
			return $alias;
		}

		$pos = strpos($alias, '/');
		$root = $pos === false ? $alias : substr($alias, 0, $pos);

		if (isset(self::$aliases[$root])) {
			if (is_string(self::$aliases[$root])) {
				return $pos === false ? self::$aliases[$root] : self::$aliases[$root] . substr($alias, $pos);
			} else {
				foreach (self::$aliases[$root] as $name => $path) {
					if (strpos($alias . '/', $name . '/') === 0) {
						return $path . substr($alias, strlen($name));
					}
Qiang Xue committed
213
				}
Qiang Xue committed
214 215
			}
		}
216

Qiang Xue committed
217 218 219 220 221
		if ($throwException) {
			throw new InvalidParamException("Invalid path alias: $alias");
		} else {
			return false;
		}
Qiang Xue committed
222 223
	}

Qiang Xue committed
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
	/**
	 * Returns the root alias part of a given alias.
	 * A root alias is an alias that has been registered via [[setAlias()]] previously.
	 * If a given alias matches multiple root aliases, the longest one will be returned.
	 * @param string $alias the alias
	 * @return string|boolean the root alias, or false if no root alias is found
	 */
	public static function getRootAlias($alias)
	{
		$pos = strpos($alias, '/');
		$root = $pos === false ? $alias : substr($alias, 0, $pos);

		if (isset(self::$aliases[$root])) {
			if (is_string(self::$aliases[$root])) {
				return $root;
			} else {
				foreach (self::$aliases[$root] as $name => $path) {
					if (strpos($alias . '/', $name . '/') === 0) {
						return $name;
					}
				}
			}
		}
		return false;
	}

Qiang Xue committed
250
	/**
w  
Qiang Xue committed
251
	 * Registers a path alias.
m  
Qiang Xue committed
252
	 *
253 254
	 * A path alias is a short name representing a long path (a file path, a URL, etc.)
	 * For example, we use '@yii' as the alias of the path to the Yii framework directory.
m  
Qiang Xue committed
255
	 *
256 257
	 * A path alias must start with the character '@' so that it can be easily differentiated
	 * from non-alias paths.
m  
Qiang Xue committed
258
	 *
259 260 261 262 263 264 265 266 267 268
	 * Note that this method does not check if the given path exists or not. All it does is
	 * to associate the alias with the path.
	 *
	 * Any trailing '/' and '\' characters in the given path will be trimmed.
	 *
	 * @param string $alias the alias name (e.g. "@yii"). It must start with a '@' character.
	 * It may contain the forward slash '/' which serves as boundary character when performing
	 * alias translation by [[getAlias()]].
	 * @param string $path the path corresponding to the alias. Trailing '/' and '\' characters
	 * will be trimmed. This can be
m  
Qiang Xue committed
269 270 271 272
	 *
	 * - a directory or a file path (e.g. `/tmp`, `/tmp/main.txt`)
	 * - a URL (e.g. `http://www.yiiframework.com`)
	 * - a path alias (e.g. `@yii/base`). In this case, the path alias will be converted into the
Qiang Xue committed
273
	 *   actual path first by calling [[getAlias()]].
Qiang Xue committed
274
	 *
Qiang Xue committed
275
	 * @throws InvalidParamException if $path is an invalid alias.
w  
Qiang Xue committed
276
	 * @see getAlias
Qiang Xue committed
277
	 */
w  
Qiang Xue committed
278
	public static function setAlias($alias, $path)
Qiang Xue committed
279
	{
280
		if (strncmp($alias, '@', 1)) {
Qiang Xue committed
281
			$alias = '@' . $alias;
282 283 284 285 286 287
		}
		$pos = strpos($alias, '/');
		$root = $pos === false ? $alias : substr($alias, 0, $pos);
		if ($path !== null) {
			$path = strncmp($path, '@', 1) ? rtrim($path, '\\/') : static::getAlias($path);
			if (!isset(self::$aliases[$root])) {
Qiang Xue committed
288 289 290 291 292
				if ($pos === false) {
					self::$aliases[$root] = $path;
				} else {
					self::$aliases[$root] = array($alias => $path);
				}
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
			} elseif (is_string(self::$aliases[$root])) {
				if ($pos === false) {
					self::$aliases[$root] = $path;
				} else {
					self::$aliases[$root] = array(
						$alias => $path,
						$root => self::$aliases[$root],
					);
				}
			} else {
				self::$aliases[$root][$alias] = $path;
				krsort(self::$aliases[$root]);
			}
		} elseif (isset(self::$aliases[$root])) {
			if (is_array(self::$aliases[$root])) {
				unset(self::$aliases[$root][$alias]);
			} elseif ($pos === false) {
				unset(self::$aliases[$root]);
			}
m  
Qiang Xue committed
312
		}
Qiang Xue committed
313 314 315 316
	}

	/**
	 * Class autoload loader.
Qiang Xue committed
317 318
	 * This method is invoked automatically when PHP sees an unknown class.
	 * The method will attempt to include the class file according to the following procedure:
w  
Qiang Xue committed
319 320 321 322 323 324 325 326
	 *
	 * 1. Search in [[classMap]];
	 * 2. If the class is namespaced (e.g. `yii\base\Component`), it will attempt
	 *    to include the file associated with the corresponding path alias
	 *    (e.g. `@yii/base/Component.php`);
	 * 3. If the class is named in PEAR style (e.g. `PHPUnit_Framework_TestCase`),
	 *    it will attempt to include the file associated with the corresponding path alias
	 *    (e.g. `@PHPUnit/Framework/TestCase.php`);
Qiang Xue committed
327
	 * 4. Search PHP include_path for the actual class file if [[enableIncludePath]] is true;
w  
Qiang Xue committed
328 329
	 * 5. Return false so that other autoloaders have chance to include the class file.
	 *
Qiang Xue committed
330 331
	 * @param string $className class name
	 * @return boolean whether the class has been loaded successfully
Qiang Xue committed
332 333
	 * @throws InvalidConfigException if the class file does not exist
	 * @throws UnknownClassException if the class does not exist in the class file
Qiang Xue committed
334 335 336
	 */
	public static function autoload($className)
	{
Qiang Xue committed
337
		$className = ltrim($className, '\\');
w  
Qiang Xue committed
338

Qiang Xue committed
339
		if (isset(self::$classMap[$className])) {
Qiang Xue committed
340 341 342 343
			$classFile = static::getAlias(self::$classMap[$className]);
			if (!is_file($classFile)) {
				throw new InvalidConfigException("Class file does not exist: $classFile");
			}
Qiang Xue committed
344
		} else {
Qiang Xue committed
345
			// follow PSR-0 to determine the class file
Qiang Xue committed
346 347
			if (($pos = strrpos($className, '\\')) !== false) {
				// namespaced class, e.g. yii\base\Component
Qiang Xue committed
348
				$path = str_replace('\\', '/', substr($className, 0, $pos + 1))
Qiang Xue committed
349 350
					. str_replace('_', '/', substr($className, $pos + 1)) . '.php';
			} else {
Qiang Xue committed
351
				$path = str_replace('_', '/', $className) . '.php';
w  
Qiang Xue committed
352
			}
Qiang Xue committed
353 354 355 356 357 358 359

			// try via path alias first
			if (strpos($path, '/') !== false) {
				$fullPath = static::getAlias('@' . $path, false);
				if ($fullPath !== false && is_file($fullPath)) {
					$classFile = $fullPath;
				}
Qiang Xue committed
360 361
			}

Qiang Xue committed
362
			// search include_path
363 364
			if (!isset($classFile) && self::$enableIncludePath && ($fullPath = stream_resolve_include_path($path)) !== false) {
				$classFile = $fullPath;
Qiang Xue committed
365 366 367 368 369
			}

			if (!isset($classFile)) {
				// return false to let other autoloaders to try loading the class
				return false;
w  
Qiang Xue committed
370
			}
Qiang Xue committed
371 372 373 374
		}

		include($classFile);

Suralc committed
375
		if (class_exists($className, false) || interface_exists($className, false) ||
376
			function_exists('trait_exists') && trait_exists($className, false)) {
Qiang Xue committed
377
			return true;
Qiang Xue committed
378
		} else {
Qiang Xue committed
379
			throw new UnknownClassException("Unable to find '$className' in file: $classFile");
w  
Qiang Xue committed
380
		}
Qiang Xue committed
381 382
	}

w  
Qiang Xue committed
383
	/**
Qiang Xue committed
384
	 * Creates a new object using the given configuration.
w  
Qiang Xue committed
385
	 *
Qiang Xue committed
386
	 * The configuration can be either a string or an array.
Qiang Xue committed
387 388
	 * If a string, it is treated as the *object class*; if an array,
	 * it must contain a `class` element specifying the *object class*, and
w  
Qiang Xue committed
389 390 391
	 * the rest of the name-value pairs in the array will be used to initialize
	 * the corresponding object properties.
	 *
Qiang Xue committed
392
	 * The object type can be either a class name or the [[getAlias()|alias]] of
w  
Qiang Xue committed
393
	 * the class. For example,
w  
Qiang Xue committed
394
	 *
Qiang Xue committed
395 396
	 * - `app\components\GoogleMap`: fully-qualified namespaced class.
	 * - `@app/components/GoogleMap`: an alias, used for non-namespaced class.
Qiang Xue committed
397 398 399
	 *
	 * Below are some usage examples:
	 *
w  
Qiang Xue committed
400
	 * ~~~
Qiang Xue committed
401
	 * $object = \Yii::createObject('@app/components/GoogleMap');
Qiang Xue committed
402 403
	 * $object = \Yii::createObject(array(
	 *     'class' => '\app\components\GoogleMap',
w  
Qiang Xue committed
404 405 406 407
	 *     'apiKey' => 'xyz',
	 * ));
	 * ~~~
	 *
Qiang Xue committed
408 409 410 411 412 413 414 415 416 417
	 * This method can be used to create any object as long as the object's constructor is
	 * defined like the following:
	 *
	 * ~~~
	 * public function __construct(..., $config = array()) {
	 * }
	 * ~~~
	 *
	 * The method will pass the given configuration as the last parameter of the constructor,
	 * and any additional parameters to this method will be passed as the rest of the constructor parameters.
w  
Qiang Xue committed
418
	 *
Qiang Xue committed
419 420
	 * @param string|array $config the configuration. It can be either a string representing the class name
	 * or an array representing the object configuration.
w  
Qiang Xue committed
421
	 * @return mixed the created object
Qiang Xue committed
422
	 * @throws InvalidConfigException if the configuration is invalid.
w  
Qiang Xue committed
423
	 */
Qiang Xue committed
424
	public static function createObject($config)
w  
Qiang Xue committed
425
	{
Qiang Xue committed
426 427
		static $reflections = array();

w  
Qiang Xue committed
428
		if (is_string($config)) {
w  
Qiang Xue committed
429
			$class = $config;
w  
Qiang Xue committed
430
			$config = array();
Qiang Xue committed
431
		} elseif (isset($config['class'])) {
w  
Qiang Xue committed
432
			$class = $config['class'];
w  
Qiang Xue committed
433
			unset($config['class']);
Qiang Xue committed
434
		} else {
Qiang Xue committed
435
			throw new InvalidConfigException('Object configuration must be an array containing a "class" element.');
w  
Qiang Xue committed
436 437
		}

w  
Qiang Xue committed
438
		if (!class_exists($class, false)) {
Qiang Xue committed
439
			$class = static::import($class);
w  
Qiang Xue committed
440 441
		}

Qiang Xue committed
442 443 444 445
		$class = ltrim($class, '\\');

		if (isset(self::$objectConfig[$class])) {
			$config = array_merge(self::$objectConfig[$class], $config);
446 447
		}

Qiang Xue committed
448
		if (($n = func_num_args()) > 1) {
Qiang Xue committed
449 450 451
			/** @var $reflection \ReflectionClass */
			if (isset($reflections[$class])) {
				$reflection = $reflections[$class];
Qiang Xue committed
452
			} else {
Qiang Xue committed
453 454 455 456
				$reflection = $reflections[$class] = new \ReflectionClass($class);
			}
			$args = func_get_args();
			array_shift($args); // remove $config
457
			if (!empty($config)) {
Qiang Xue committed
458
				$args[] = $config;
Qiang Xue committed
459
			}
Qiang Xue committed
460
			return $reflection->newInstanceArgs($args);
Qiang Xue committed
461
		} else {
462
			return empty($config) ? new $class : new $class($config);
Qiang Xue committed
463
		}
w  
Qiang Xue committed
464 465
	}

Qiang Xue committed
466
	/**
w  
Qiang Xue committed
467 468 469 470 471
	 * Logs a trace message.
	 * Trace messages are logged mainly for development purpose to see
	 * the execution work flow of some code.
	 * @param string $message the message to be logged.
	 * @param string $category the category of the message.
Qiang Xue committed
472
	 */
w  
Qiang Xue committed
473
	public static function trace($message, $category = 'application')
Qiang Xue committed
474
	{
w  
Qiang Xue committed
475
		if (YII_DEBUG) {
Qiang Xue committed
476
			self::getLogger()->log($message, Logger::LEVEL_TRACE, $category);
w  
Qiang Xue committed
477
		}
Qiang Xue committed
478 479 480
	}

	/**
w  
Qiang Xue committed
481 482 483 484 485
	 * Logs an error message.
	 * An error message is typically logged when an unrecoverable error occurs
	 * during the execution of an application.
	 * @param string $message the message to be logged.
	 * @param string $category the category of the message.
Qiang Xue committed
486
	 */
Qiang Xue committed
487
	public static function error($message, $category = 'application')
Qiang Xue committed
488
	{
Qiang Xue committed
489
		self::getLogger()->log($message, Logger::LEVEL_ERROR, $category);
w  
Qiang Xue committed
490 491 492 493 494 495 496 497 498
	}

	/**
	 * Logs a warning message.
	 * A warning message is typically logged when an error occurs while the execution
	 * can still continue.
	 * @param string $message the message to be logged.
	 * @param string $category the category of the message.
	 */
Qiang Xue committed
499
	public static function warning($message, $category = 'application')
w  
Qiang Xue committed
500
	{
Qiang Xue committed
501
		self::getLogger()->log($message, Logger::LEVEL_WARNING, $category);
Qiang Xue committed
502 503 504
	}

	/**
w  
Qiang Xue committed
505 506 507 508 509 510
	 * Logs an informative message.
	 * An informative message is typically logged by an application to keep record of
	 * something important (e.g. an administrator logs in).
	 * @param string $message the message to be logged.
	 * @param string $category the category of the message.
	 */
Qiang Xue committed
511
	public static function info($message, $category = 'application')
w  
Qiang Xue committed
512
	{
Qiang Xue committed
513
		self::getLogger()->log($message, Logger::LEVEL_INFO, $category);
w  
Qiang Xue committed
514 515 516 517 518 519 520 521 522
	}

	/**
	 * Marks the beginning of a code block for profiling.
	 * This has to be matched with a call to [[endProfile]] with the same category name.
	 * The begin- and end- calls must also be properly nested. For example,
	 *
	 * ~~~
	 * \Yii::beginProfile('block1');
Qiang Xue committed
523 524 525 526
	 * // some code to be profiled
	 *     \Yii::beginProfile('block2');
	 *     // some other code to be profiled
	 *     \Yii::endProfile('block2');
w  
Qiang Xue committed
527 528
	 * \Yii::endProfile('block1');
	 * ~~~
Qiang Xue committed
529 530
	 * @param string $token token for the code block
	 * @param string $category the category of this log message
Qiang Xue committed
531 532
	 * @see endProfile
	 */
Qiang Xue committed
533
	public static function beginProfile($token, $category = 'application')
Qiang Xue committed
534
	{
Qiang Xue committed
535
		self::getLogger()->log($token, Logger::LEVEL_PROFILE_BEGIN, $category);
Qiang Xue committed
536 537 538 539
	}

	/**
	 * Marks the end of a code block for profiling.
w  
Qiang Xue committed
540
	 * This has to be matched with a previous call to [[beginProfile]] with the same category name.
Qiang Xue committed
541 542
	 * @param string $token token for the code block
	 * @param string $category the category of this log message
Qiang Xue committed
543 544
	 * @see beginProfile
	 */
Qiang Xue committed
545
	public static function endProfile($token, $category = 'application')
Qiang Xue committed
546
	{
Qiang Xue committed
547
		self::getLogger()->log($token, Logger::LEVEL_PROFILE_END, $category);
Qiang Xue committed
548 549 550
	}

	/**
w  
Qiang Xue committed
551 552
	 * Returns the message logger object.
	 * @return \yii\logging\Logger message logger
Qiang Xue committed
553 554 555
	 */
	public static function getLogger()
	{
w  
Qiang Xue committed
556
		if (self::$_logger !== null) {
Qiang Xue committed
557
			return self::$_logger;
Qiang Xue committed
558
		} else {
Qiang Xue committed
559
			return self::$_logger = new Logger;
w  
Qiang Xue committed
560
		}
w  
Qiang Xue committed
561 562 563 564
	}

	/**
	 * Sets the logger object.
Qiang Xue committed
565
	 * @param Logger $logger the logger object.
w  
Qiang Xue committed
566 567 568 569
	 */
	public static function setLogger($logger)
	{
		self::$_logger = $logger;
Qiang Xue committed
570 571 572
	}

	/**
w  
Qiang Xue committed
573 574
	 * Returns an HTML hyperlink that can be displayed on your Web page showing Powered by Yii" information.
	 * @return string an HTML hyperlink that can be displayed on your Web page showing Powered by Yii" information
Qiang Xue committed
575 576 577 578 579 580 581 582
	 */
	public static function powered()
	{
		return 'Powered by <a href="http://www.yiiframework.com/" rel="external">Yii Framework</a>.';
	}

	/**
	 * Translates a message to the specified language.
Qiang Xue committed
583
	 *
584 585 586
	 * This is a shortcut method of [[\yii\i18n\I18N::translate()]].
	 *
	 * The translation will be conducted according to the message category and the target language will be used.
Qiang Xue committed
587 588 589 590 591 592 593 594 595 596 597 598
	 *
	 * In case when a translated message has different plural forms (separated by "|"), this method
	 * will also attempt to choose an appropriate one according to a given numeric value which is
	 * specified as the first parameter (indexed by 0) in `$params`.
	 *
	 * For example, if a translated message is "I have an apple.|I have {n} apples.", and the first
	 * parameter is 2, the message returned will be "I have 2 apples.". Note that the placeholder "{n}"
	 * will be replaced with the given number.
	 *
	 * For more details on how plural rules are applied, please refer to:
	 * [[http://www.unicode.org/cldr/charts/supplemental/language_plural_rules.html]]
	 *
599
	 * @param string $category the message category.
Qiang Xue committed
600 601 602 603 604
	 * @param string $message the message to be translated.
	 * @param array $params the parameters that will be used to replace the corresponding placeholders in the message.
	 * @param string $language the language code (e.g. `en_US`, `en`). If this is null, the current
	 * [[\yii\base\Application::language|application language]] will be used.
	 * @return string the translated message.
Qiang Xue committed
605
	 */
606
	public static function t($category, $message, $params = array(), $language = null)
Qiang Xue committed
607
	{
Qiang Xue committed
608
		if (self::$app !== null) {
609
			return self::$app->getI18N()->translate($category, $message, $params, $language);
Qiang Xue committed
610 611 612
		} else {
			return is_array($params) ? strtr($message, $params) : $message;
		}
Qiang Xue committed
613 614
	}
}
Alexander Kochetov committed
615

616
YiiBase::$aliases = array(
617 618
	'@yii' => array(
		'@yii/bootstrap' => __DIR__ . '/bootstrap',
619
		'@yii/jui' => __DIR__ . '/jui',
620 621
		'@yii' => __DIR__,
	),
622
);