Merge branch 'master' of git://github.com/yiisoft/yii2 into pt-br-translations

.travis.yml

@@ -30,20 +30,8 @@ install:
   - tests/unit/data/travis/apc-setup.sh
   - tests/unit/data/travis/memcache-setup.sh
   - tests/unit/data/travis/cubrid-setup.sh
-# basic application:
-  - composer install --dev --prefer-dist -d apps/basic
-  - cd apps/basic && composer require --dev codeception/codeception:1.8.*@dev codeception/specify:* codeception/verify:*
-  - php vendor/bin/codecept build && cd ../..
-# advanced application:
-  - composer install --dev --prefer-dist -d apps/advanced
-  - cd apps/advanced && composer require --dev codeception/codeception:1.8.*@dev codeception/specify:* codeception/verify:*
-  - ./init --env=Development
-  - sed -i s/root/travis/ common/config/main-local.php
-  - cd backend && php ../vendor/bin/codecept build
-  - cd ../common && php ../vendor/bin/codecept build
-  - cd ../frontend && php ../vendor/bin/codecept build && cd ../../..
- # boot server
-  - cd apps && php -S localhost:8080 > /dev/null 2>&1 &
+# basic and advanced application:
+  - tests/unit/data/travis/setup-apps.sh
 
 before_script:
   - echo 'elasticsearch version ' && curl http://localhost:9200/
@@ -51,12 +39,8 @@ before_script:
   - psql -U postgres -c 'CREATE DATABASE yiitest;';
   - tests/unit/data/travis/sphinx-setup.sh
   - mongo yii2test --eval 'db.addUser("travis", "test");'
-  - mysql -e 'CREATE DATABASE yii2_advanced_acceptance;';
-  - mysql -e 'CREATE DATABASE yii2_advanced_functional;';
-  - mysql -e 'CREATE DATABASE yii2_advanced_unit;';
-  - cd apps/advanced/frontend/tests/acceptance && php yii migrate --interactive=0
-  - cd ../functional && php yii migrate --interactive=0
-  - cd ../unit && php yii migrate --interactive=0 && cd ../../../../..
+# basic and advanced application:
+  - tests/unit/data/travis/init-apps.sh
 
 script:
   - vendor/bin/phpunit --verbose --coverage-clover=coverage.clover --exclude-group mssql,oci,wincache,xcache,zenddata

CONTRIBUTING.md

@@ -2,5 +2,5 @@ Contributing to Yii2
 ====================
 
 - [Report an issue](docs/internals/report-an-issue.md)
-- [Translate documentation or messages](docs/internals/translations.md)
+- [Translate documentation or messages](docs/internals/translation-workflow.md)
 - [Contribute to the core code or fix bugs](docs/internals/getting-started.md)

docs/guide-es/README.md

+Guía Definitiva de Yii 2.0
+==========================
+
+Este tutorial está liberado bajo los [Términos de Documentación Yii](http://www.yiiframework.com/doc/terms/).
+
+Todos los derechos reservados.
+
+2014 (c) Yii Software LLC.
+
+
+Introducción
+------------
+
+* [Acerca de Yii](intro-yii.md)
+* [Actualizando desde Yii 1.1](intro-upgrade-from-v1.md)
+
+
+Comenzando
+----------
+
+* [Instalando Yii](start-installation.md)
+* [Corriendo Aplicaciones](start-workflow.md)
+* [Diciendo Hola](start-hello.md)
+* [Trabajando con Formularios](start-forms.md)
+* [Trabajando con Bases de Datos](start-databases.md)
+* [Generando Código con Gii](start-gii.md)
+* [Mirando Hacia Adelante](start-looking-head.md)
+
+
+Estructura de una Aplicación
+----------------------------
+
+* [Información General](structure-overview.md)
+* [Scripts de Entrada](structure-entry-scripts.md)
+* [Aplicaciones](structure-applications.md)
+* [Componentes de una Aplicación](structure-application-components.md)
+* [Controladores](structure-controllers.md)
+* [Modelos](structure-models.md)
+* [Vistas](structure-views.md)
+* **TBD** [Filtros](structure-filters.md)
+* **TBD** [Widgets](structure-widgets.md)
+* **TBD** [Módulos](structure-modules.md)
+* [Assets](structure-assets.md)
+* **TBD** [Extensiones](structure-extensions.md)
+
+
+Manejando Requests
+------------------
+
+* **TBD** [Bootstrapping](runtime-bootstrapping.md)
+* **TBD** [Routing](runtime-routing.md)
+* **TBD** [Requests](runtime-requests.md)
+* **TBD** [Responses](runtime-responses.md)
+* **TBD** [Sesiones y Cookies](runtime-sessions-cookies.md)
+* [Parseando y Generando URLs](runtime-url-handling.md)
+* [Manejando Errores](runtime-handling-errors.md)
+* [Logging](runtime-logging.md)
+
+
+Conceptos Clave
+---------------
+
+* [Componentes](concept-components.md)
+* [Propiedades](concept-properties.md)
+* [Eventos](concept-events.md)
+* [Comportamientos (Behaviors)](concept-behaviors.md)
+* [Configuraciones](concept-configurations.md)
+* [Alias](concept-aliases.md)
+* [Autocargando Clases](concept-autoloading.md)
+* [Localizador de Servicios (Service Locator)](concept-service-locator.md)
+* [Inyección de Dependencias](concept-di-container.md)
+
+
+Trabajando con Bases de Datos
+-----------------------------
+
+* [Data Access Objects](db-dao.md) - Conectando a una base de datos, consultas básicas, transacciones y manipulación de esquemas
+* [Query Builder](db-query-builder.md) - Consultando la base de datos utilizando una simple capa de abstracción
+* [Active Record](db-active-record.md) - El ORM Active Record, trayendo y manipulando registros y definiendo relaciones
+* [Migraciones](db-migrations.md) - Versionando tus bases de datos en el entorno de un equipo de desarrollo
+* **TBD** [Sphinx](db-sphinx.md)
+* **TBD** [Redis](db-redis.md)
+* **TBD** [MongoDB](db-mongodb.md)
+* **TBD** [ElasticSearch](db-elastic-search.md)
+
+
+Obteniendo Datos de Usuarios
+----------------------------
+
+* [Creando Formularios](input-forms.md)
+* [Validando Datos](input-validation.md)
+* **TBD** [Subiendo Archivos](input-file-upload.md)
+* **TBD** [Obteniendo Datos de Múltiples Modelos](input-multiple-models.md)
+
+
+Mostrando Datos
+---------------
+
+* **TBD** [Formato de Datos](output-formatting.md)
+* **TBD** [Paginación](output-pagination.md)
+* **TBD** [Ordenando](output-sorting.md)
+* [Data Providers](output-data-providers.md)
+* [Data Widgets](output-data-widgets.md)
+* [Utilizando Themes](output-theming.md)
+
+
+Seguridad
+---------
+
+* [Autenticación](security-authentication.md)
+* [Autorización](security-authorization.md)
+* [Trabajando con Contraseñas](security-passwords.md)
+* **TBD** [Auth Clients](security-auth-clients.md)
+* **TBD** [Buenas Prácticas](security-best-practices.md)
+
+
+Caching
+-------
+
+* [Información General](caching-overview.md)
+* [Caching de Datos](caching-data.md)
+* [Caching de Fragmentos](caching-fragment.md)
+* [Caching de Páginas](caching-page.md)
+* [Caching HTTP](caching-http.md)
+
+
+RESTful Web Services
+--------------------
+
+* [Guía Breve](rest-quick-start.md)
+* [Recursos (Resources)](rest-resources.md)
+* [Controladores](rest-controllers.md)
+* [Routing](rest-routing.md)
+* [Response Formatting](rest-response-formatting.md)
+* [Autenticación](rest-authentication.md)
+* [Límite de Rango](rest-rate-limiting.md)
+* [Versionando](rest-versioning.md)
+* [Manejando Errores](rest-error-handling.md)
+
+
+Herramientas de Desarrollo
+--------------------------
+
+* [Depurador y Barra de Herramients de Depuración](tool-debugger.md)
+* [Generando Código con Gii](tool-gii.md)
+* **TBD** [Generando Documentación de API](tool-api-doc.md)
+
+
+Testing
+-------
+
+* [Información General](test-overview.md)
+* **TBD** [Tests de Unidad](test-unit.md)
+* **TBD** [Tests Funcionales](test-functional.md)
+* **TBD** [Tests de Aceptación](test-acceptance.md)
+* [Fixtures](test-fixtures.md)
+
+
+Extendiendo Yii
+---------------
+
+* [Creando Extensiones](extend-creating-extensions.md)
+* [Personalizando el Código del Núcleo](extend-customizing-core.md)
+* [Utilizando Librerías de Terceros](extend-using-libs.md)
+* **TBD** [Utilizando Yii en Sistemas de Terceros](extend-embedding-in-others.md)
+* **TBD** [Utilizando Yii 1.1 y 2.0 Juntos](extend-using-v1-v2.md)
+* [Utilizando Composer](extend-using-composer.md)
+
+
+Temas Especiales
+----------------
+
+* [Template de Aplicación Avanzada](tutorial-advanced-app.md)
+* [Generando una Aplicación Desde Cero](tutorial-start-from-scratch.md)
+* [Comandos de Consola](tutorial-console.md)
+* [Validadores del Núcleo](tutorial-core-validators.md)
+* [Internacionalización](tutorial-i18n.md)
+* [Enviando Emails](tutorial-mailing.md)
+* [Ajustando la Performance](tutorial-performance-tuning.md)
+* **TBD** [Entorno en Hosting Compartido](tutorial-shared-hosting.md)
+* [Motores de Templates](tutorial-template-engines.md)
+
+
+Widgets
+-------
+
+* GridView: link to demo page
+* ListView: link to demo page
+* DetailView: link to demo page
+* ActiveForm: link to demo page
+* Pjax: link to demo page
+* Menu: link to demo page
+* LinkPager: link to demo page
+* LinkSorter: link to demo page
+* [Bootstrap Widgets](bootstrap-widgets.md)
+* **TBD** [Jquery UI Widgets](jui-widgets.md)
+
+
+Helpers
+-------
+
+* [Información General](helper-overview.md)
+* **TBD** [ArrayHelper](helper-array.md)
+* **TBD** [Html](helper-html.md)
+* **TBD** [Url](helper-url.md)
+* **TBD** [Security](helper-security.md)
+

docs/guide-es/intro-upgrade-from-v1.md

+Actualizando desde Yii 1.1
+==========================
+
+Existen muchas diferencias entre las versiones 1.1 y 2.0 de Yii ya que el framework fue completamente reescrito
+en su segunda versión.
+Como resultado, actualizar desde la versión 1.1 no es tan trivial como actualizar entre versiones menores. En esta
+guía encontrarás las diferencias más grandes entre estas dos versiones.
+
+Si no has utilizado Yii 1.1 antes, puedes saltear con seguridad esta sección e ir directamente a "[Comenzando con Yii](start-installation.md)".
+
+Por favor nota que Yii 2.0 introduce más características de las que son cubiertas en este resumen. Es altamente recomendado
+que leas a través de toda la guía definitiva para aprender acerca de todas ellas. Hay posibilidades de que algunas
+características que ya has desarrollado por ti mismo ahora sean parte del núcleo de Yii.
+
+
+Instalación
+------------
+
+Yii 2.0 adopta completamente [Composer](https://getcomposer.org/), el administrador de paquetes de facto de PHP.
+Tanto la instalación del núcleo del framework como las extensiones se manejan a través de Composer. Por favor consulta
+la sección [Comenzando con la Aplicación Básica](start-basic.md) para aprender a instalar Yii 2.0. Si quieres crear extensiones
+o transformar extensiones de Yii 1.1 para que sean compatibles con Yii 2.0, consulta la sección [Creando Extensiones](extend-creating-extensions.md) de la guía.
+
+
+Requerimientos de PHP
+---------------------
+
+Yii 2.0 requiere PHP 5.4 o mayor, lo que es un gran progreso ya que Yii 1.1 funcionaba con PHP 5.2.
+Como resultado, hay muchas diferencias a nivel del lenguaje a las que deberías prestar atención.
+Debajo hay un resumen de los mayores cambios en relación a PHP:
+
+- [Namespaces](http://php.net/manual/es/language.namespaces.php).
+- [Funciones anónimas](http://php.net/manual/es/functions.anonymous.php).
+- Sintáxis cortas de Arrays `[...elementos...]` es utilizado en vez de `array(...elementos...)`.
+- Etiquetas cortas de `echo`. Ahora en las vistas se usa `<?=`. Esto se puede utilizar desde PHP 5.4.
+- [SPL - Biblioteca estándar de PHP](http://php.net/manual/es/book.spl.php).
+- [Enlace estático en tiempo de ejecución](http://php.net/manual/es/language.oop5.late-static-bindings.php).
+- [Fecha y Hora](http://php.net/manual/es/book.datetime.php).
+- [Traits](http://php.net/manual/es/language.oop5.traits.php).
+- [Internacionalización](http://php.net/manual/es/book.intl.php). Yii 2.0 utiliza la extensión `intl` de PHP
+  como soporte para internacionalización.
+
+
+Namespace
+---------
+
+El cambio más obvio en Yii 2.0 es el uso de namespaces. Casi todas las clases del núcleo
+utilizan namespaces, e.j., `yii\web\Request`. El prefijo "C" no se utiliza más en los nombre de clases.
+El esquema de nombre ahora utiliza la ruta de directorios. Por ejemplo, `yii\web\Request`
+indica que el archivo de la clase correspondiente es `web/Request.php`, en el directorio de Yii.
+
+(Puedes utilizar cualquier clase del núcleo sin necesidad de incluir el archivo que la contiene, gracias
+al autoloader de Yii.)
+
+
+Component y Object
+------------------
+
+Yii 2.0 parte la clase `CComponent` de 1.1 en dos clases: [[yii\base\Object]] y [[yii\base\Component]].
+La clase [[yii\base\Object|Object]] es una clase base liviana que permite definir [propiedades de objecto](concept-properties.md)
+a través de getters y setters. La clase [[yii\base\Component|Component]] extiende de [[yii\base\Object|Object]] y soporta
+[eventos](concept-events.md) y [comportamientos (behaviors)](concept-behaviors.md).
+
+Si tu clase no necesita las utilizar características de eventos o comportamientos, puedes considerar usar
+[[yii\base\Object|Object]] como clase base. Esto es usualmente el caso de las clases que representan
+estructuras de datos básicas.
+
+
+Configuración de objetos
+------------------------
+
+La clase [[yii\base\Object|Object]] introduce una manera uniforme de configurar objetos. Cualquier clase descendiente
+de [[yii\base\Object|Object]] debería declarar su constructor (si fuera necesario) de la siguiente manera así
+puede ser propiamente configurado:
+
+```php
+class MyClass extends \yii\base\Object
+{
+    public function __construct($param1, $param2, $config = [])
+    {
+        // ... se aplica la inicialización antes de la configuración
+
+        parent::__construct($config);
+    }
+
+    public function init()
+    {
+        parent::init();
+
+        // ... se aplica la inicialización después de la configuración
+    }
+}
+```
+
+En el ejemplo de arriba, el último parámetro del constructor debe tomar un array de configuración
+conteniendo pares clave-valor para la inicialización de las propiedades al final del mismo.
+Puedes sobrescribir el método [[yii\base\Object::init()|init()]] para realizar el trabajo de inicialización
+que debe ser hecho luego de que la configuración ha sido aplicada.
+
+Siguiendo esa convención, podrás crear y configurar nuevos objetos utilizando
+un array de configuración:
+
+```php
+$object = Yii::createObject([
+    'class' => 'MyClass',
+    'property1' => 'abc',
+    'property2' => 'cde',
+], [$param1, $param2]);
+```
+
+Se puede encontrar mayor detalle acerca del tema en la sección [Configuración de objetos](concept-configurations.md).
+
+
+Eventos
+-------
+
+En Yii 1, los eventos eran creados definiendo un método `on` (e.j., `onBeforeSave`). En Yii 2, puedes utilizar cualquier nombre de evento.
+Ahora puedes disparar un evento utilizando el método [[yii\base\Component::trigger()|trigger()]]:
+
+```php
+$event = new \yii\base\Event;
+$component->trigger($eventName, $event);
+```
+
+Para conectar un manejador a un evento, utiliza el método [[yii\base\Component::on()|on()]]:
+
+```php
+$component->on($eventName, $handler);
+// Para desconectar el manejador, utiliza:
+// $component->off($eventName, $handler);
+```
+
+Hay muchas mejoras en lo que respecta a eventos. Para más detalles, consulta la sección [Eventos](concept-events.md).
+
+
+Path Alias
+----------
+
+Yii 2.0 extiende el uso de path alias tanto para archivos/directorios como URLs. Yii 2.0 ahora requiere que cada
+alias comience con el carácter `@`, para diferenciarlos de rutas o URLs normales.
+Por ejemplo, el alias `@yii` corresponde al directorio donde Yii se encuentra instalado. Los path alias
+están soportados en la mayor parte del núcleo. Por ejemplo, [[yii\caching\FileCache::cachePath]] puede tomar tanto
+una ruta de directorios normal como un alias.
+
+Un path alias está relacionado de cerca con un namespace. Se recomienda definir un path alias
+por cada namespace raíz, y así poder utilizar el autolader de Yii sin otra configuración.
+Por ejemplo, debido a que `@yii` se refiere al directorio de instalación, una clase
+como `yii\web\Request` puede ser auto-cargada. Si estás utilizando una librería de terceros,
+como Zend Framework, puedes definir un path alias `@Zend` que se refiera al directorio de instalación
+de ese framework. Una vez realizado esto, Yii será capaz de auto-cargar cualquier clase de Zend Framework también.
+
+Se puede encontrar más detalles del tema en la sección [Path Alias](concept-aliases.md).
+
+
+Vistas
+------
+
+El cambio más significativo con respecto a las vistas en Yii 2 es que la variable especial `$this` (dentro de una vista) 
+ya no se refiere al controlador o widget actual.
+En vez de eso, `$this` ahora se refiere al objeto de la *vista*, un concepto nuevo introducido en Yii 2.0.
+El objeto *vista* es del tipo [[yii\web\View]], que representa la parte de las vistas en el patrón MVC.
+of the MVC pattern. Si quieres acceder al controlador o al widget correspondiente desde la propia vista,
+puedes utilizar `$this->context`.
+
+Para renderizar una vista parcial (partial) dentro de otra vista, se utiliza `$this->render()`, no `$this->renderPartial()`.
+El llamado a `render` además tiene que ser mostrado explícitamente a través de `echo`, ya que el método `render()`
+devuelve el resultado de la renderización en vez de mostrarlo directamente. Por ejemplo:
+
+```php
+echo $this->render('_item', ['item' => $item]);
+```
+
+Además de utilizar PHP como el lenguaje de templates principal, Yii 2.0 está también equipado con soporte
+oficial de otros dos populares lenguajes: Smarty y Twig. El motor de templates de Prado ya no está soportado.
+Para utilizar esos motores, necesitas configurar el componente `view` de la aplicación, definiendo la propiedad [[yii\base\View::$renderers|View::$renderers]].
+Por favor consulta la sección [Motores de Templates](tutorial-template-engines.md) para más detalles.
+
+
+Modelos
+-------
+
+Yii 2.0 utiliza [[yii\base\Model]] como modelo base, algo similar a `CModel` en 1.1.
+La clase `CFormModel` ha sido descartada por completo. Ahora, en Yii 2 debes extender [[yii\base\Model]] para crear clases de modelos.
+
+Yii 2.0 introduce un nuevo método llamado [[yii\base\Model::scenarios()|scenarios()]] para declarar escenarios soportados,
+y para indicar bajo qué escenario un atributo necesita ser validado, puede ser considerado seguro o no, etc. Por ejemplo:
+
+```php
+public function scenarios()
+{
+    return [
+        'backend' => ['email', 'role'],
+        'frontend' => ['email', '!name'],
+    ];
+}
+```
+
+En el ejemplo anterior, se declaran dos escenarios: `backend` y `frontend`. Para el escenario `backend` son considerados seguros
+ambos atributos, `email` y `role`, y pueden ser asignados masivamente. Para el escenario `frontend`, `email` puede ser asignado
+masivamente mientras `role` no. Tanto `email` como `role` deben ser validados utilizando reglas (rules).
+
+El método [[yii\base\Model::rules()|rules()]] aún es utilizado para declara reglas de validación.
+Ten en cuenta que dada la introducción de [[yii\base\Model::scenarios()|scenarios()]], ya no existe el validador `unsafe`.
+
+En la mayoría de los casos, no necesitas sobrescribir [[yii\base\Model::scenarios()|scenarios()]] si el método [[yii\base\Model::rules()|rules()]]
+especifica completamente los escenarios que existirán, y si no hay necesidad de declarar atributos inseguros (`unsafe`).
+
+Para aprender más detalles de modelos, consulta la sección [Modelos](basic-models.md).
+
+
+Controladores
+-------------
+
+Yii 2.0 utiliza [[yii\web\Controller]] como controlador base, similar a `CWebController` en Yii 1.1.
+[[yii\base\Action]] es la clase base para clases de acciones.
+
+El impacto más obvio de estos cambios en tu código es que que cada acción del controlador debe devolver el contenido
+que quieres mostrar en vez de mostrarlo directamente:
+
+```php
+public function actionView($id)
+{
+    $model = \app\models\Post::findOne($id);
+    if ($model) {
+        return $this->render('view', ['model' => $model]);
+    } else {
+        throw new \yii\web\NotFoundHttpException;
+    }
+}
+```
+
+Por favor consulta la sección [Controllers](structure-controllers.md) para más detalles acerca de los controladores.
+
+
+Widgets
+-------
+
+Yii 2.0 utiliza [[yii\base\Widget]] como clase base de los widgets, similar a `CWidget` en Yii 1.1.
+
+Para obtener mejor soporte del framework en IDEs, Yii 2.0 introduce una nueva sintáxis para utilizar widgets.
+Los métodos estáticos [[yii\base\Widget::begin()|begin()]], [[yii\base\Widget::end()|end()]], y [[yii\base\Widget::widget()|widget()]]
+fueron incorporados, y deben utilizarse así:
+
+```php
+use yii\widgets\Menu;
+use yii\widgets\ActiveForm;
+
+// Ten en cuenta que debes pasar el resultado a "echo" para mostrarlo
+echo Menu::widget(['items' => $items]);
+
+// Pasando un array para inicializar las propiedades del objeto
+$form = ActiveForm::begin([
+    'options' => ['class' => 'form-horizontal'],
+    'fieldConfig' => ['inputOptions' => ['class' => 'input-xlarge']],
+]);
+... campos del formulario aquí ...
+ActiveForm::end();
+```
+
+Consulta la sección [Widgets](structure-widgets.md) para más detalles.
+
+
+Themes
+------
+
+Los themes funcionan completamente diferente en Yii 2.0. Ahora están basados en un mecanismo de mapeo de rutas,
+que mapea la ruta de un archivo vista de origen a uno con un theme aplicado. Por ejemplo, si el path map de un theme es
+`['/web/views' => '/web/themes/basic']`, entonces la versión con el theme aplicado del archivo
+`/web/views/site/index.php` será `/web/themes/basic/site/index.php`. Por esta razón, ahora los themes pueden ser
+aplicados a cualquier archivo de vista, incluso una vista renderizada fuera del contexto de un controlador o widget.
+
+Además, el componente `CThemeManager` ya no existe. En cambio, `theme` es una propiedad configurable del componente `view`
+de la aplicación.
+
+Consulta la sección [Utilizando Themes](tutorial-theming.md) para más detalles.
+
+
+Aplicaciones de Consola
+-----------------------
+
+Las aplicaciones de consola ahora están organizadas en controladores, tal como aplicaciones Web. Estos controladores
+deben extender de [[yii\console\Controller]], similar a `CConsoleCommand` en 1.1.
+
+Para correr un comando de consola, utiliza `yii <ruta>`, donde `<ruta>` se refiere a la ruta del controlador
+(e.j. `sitemap/index`). Los argumentos anónimos adicionales son pasados como parámetros al método de la acción correspondiente
+del controlador, mientras que los argumentos especificados son pasados de acuerdo a las declaraciones en [[yii\console\Controller::options()]].
+
+Yii 2.0 soporta la generación automática de información de ayuda de los comandos a través de los bloques de comentarios del archivo.
+
+Por favor consulta la sección [Comandos de Consola](tutorial-console.md) para más detalles.
+
+
+I18N
+----
+
+Yii 2.0 remueve el formateador de fecha y números previamente incluido en favor del [módulo de PHP PECL intl](http://pecl.php.net/package/intl).
+
+La traducción de mensajes ahora es ejecutada vía el componente `i18n` de la aplicación.
+Este componente maneja un grupo de mensajes origen, lo que te permite utilizar diferentes mensajes
+basados en categorías.
+
+Por favor consulta la sección [Internacionalización](tutorial-i18n.md) para más información.
+
+
+Filtros de Acciones
+-------------------
+
+En Yii 2.0, los filtros de acciones son implementados a través de comportamientos (behaviors). Para definir un
+nuevo filtro personalizado, se debe extender de [[yii\base\ActionFilter]]. Para utilizar el filtro, conecta la clase del filtro
+al controlador como un comportamiento. Por ejemplo, para utilizar el filtro [[yii\filters\AccessControl]], deberías tener
+el siguiente código en el controlador:
+
+```php
+public function behaviors()
+{
+    return [
+        'access' => [
+            'class' => 'yii\filters\AccessControl',
+            'rules' => [
+                ['allow' => true, 'actions' => ['admin'], 'roles' => ['@']],
+            ],
+        ],
+    ];
+}
+```
+
+Consulta la sección [Filtrando](runtime-filtering.md) para mayor detalle del tema.
+
+
+Assets
+------
+
+Yii 2.0 introduce un nuevo concepto llamado *asset bundle* que reemplaza el concepto de script package encontrado en Yii 1.1.
+
+Un asset bundle es una colección de assets (e.j. archivos JavaScript, archivos CSS, imágenes, etc.) dentro de un directorio.
+Cada asset bundle por una clase que extiende de [[yii\web\AssetBundle]].
+Al registrar un asset bundle a través de [[yii\web\AssetBundle::register()]], haces que los assets de dicho bundle sean accesibles
+vía Web. A diferencia de Yii 1, la página que registra el bundle contendrá automáticamente las referencias a los archivos
+JavaScript y CSS especificados en el bundle.
+
+Por favor consulta la sección [Manejando Assets](output-assets.md) para más detalles.
+
+
+Helpers
+-------
+
+Yii 2.0 introduce muchos comúnmente utilizados helpers estáticos, incluyendo.
+
+* [[yii\helpers\Html]]
+* [[yii\helpers\ArrayHelper]]
+* [[yii\helpers\StringHelper]]
+* [[yii\helpers\FileHelper]]
+* [[yii\helpers\Json]]
+* [[yii\helpers\Security]]
+
+Por favor consulta la sección [Información General de Helpers](helper-overview.md) para más detalles.
+
+Formularios
+-----------
+
+Yii 2.0 introduce el concepto de *campo* para construir formularios utilizando [[yii\widgets\ActiveForm]]. Un campo
+es un contenedor que consiste en una etiqueta, un input, un mensaje de error y/o texto de ayuda.
+Un campo es representado como un objeto [[yii\widgets\ActiveField|ActiveField]].
+Utilizando estos campos, puedes crear formularios más claramente que antes:
+
+```php
+<?php $form = yii\widgets\ActiveForm::begin(); ?>
+    <?= $form->field($model, 'username') ?>
+    <?= $form->field($model, 'password')->passwordInput() ?>
+    <div class="form-group">
+        <?= Html::submitButton('Login') ?>
+    </div>
+<?php yii\widgets\ActiveForm::end(); ?>
+```
+
+Por favor consulta la sección [Creando Formularios](input-forms.md) para más detalles.
+
+
+Query Builder
+-------------
+
+En Yii 1.1, la generación de consultas a la base de datos estaba dividida en varias clases, incluyendo `CDbCommand`,
+`CDbCriteria`, y `CDbCommandBuilder`. Yii 2.0 representa una consulta a la base de datos en términos de un objeto [[yii\db\Query|Query]]
+que puede ser convertido en una declaración SQL con la ayuda de [[yii\db\QueryBuilder|QueryBuilder]] detrás de escena.
+Por ejemplo:
+
+```php
+$query = new \yii\db\Query();
+$query->select('id, name')
+      ->from('user')
+      ->limit(10);
+
+$command = $query->createCommand();
+$sql = $command->sql;
+$rows = $command->queryAll();
+```
+
+Lo mejor de todo, dichos métodos de generación de consultas pueden ser también utilizados mientras se trabaja con [Active Record](db-active-record.md).
+
+Consulta la sección [Query Builder](db-query-builder.md) para más detalles.
+
+
+Active Record
+-------------
+
+Yii 2.0 introduce muchísimos cambios con respecto a [Active Record](db-active-record.md). Los dos más obvios se relacionan a
+la generación de consultas y al manejo de relaciones.
+
+La clase de Yii 1.1 `CDbCriteria` es reemplazada por [[yii\db\ActiveQuery]] en Yii 2. Esta clase extiende de [[yii\db\Query]],
+y por lo tanto hereda todos los métodos de generación de consultas.
+Para comenzar a generar una consulta, llamas al método [[yii\db\ActiveRecord::find()]]:
+
+```php
+// Para traer todos los clientes *activos* y ordenarlos por su ID:
+$customers = Customer::find()
+    ->where(['status' => $active])
+    ->orderBy('id')
+    ->all();
+```
+
+Para declarar una relación, simplemente define un método getter que devuelva un objeto [[yii\db\ActiveQuery|ActiveQuery]].
+El nombre de la propiedad definida en el getter representa el nombre de la relación. Por ejemplo, el siguiente código declara
+una relación `orders` (en Yii 1.1, las relaciones se declaraban centralmente en el método `relations()`):
+
+```php
+class Customer extends \yii\db\ActiveRecord
+{
+    public function getOrders()
+    {
+        return $this->hasMany('Order', ['customer_id' => 'id']);
+    }
+}
+```
+
+Ahora puedes utilizar `$customer->orders` para acceder a las órdenes de la tabla relacionada. También puedes utilizar el siguiente
+código para realizar al-vuelo una consulta relacionada con una condición personalizada:
+
+```php
+$orders = $customer->getOrders()->andWhere('status=1')->all();
+```
+
+Cuando se utiliza la carga temprana de la relación, Yii 2.0 lo hace diferente de 1.1. En particular, en 1.1 una declaración JOIN
+sería creada para seleccionar tanto los registros de la tabla primaria como los relacionados. En Yii 2.0, dos declaraciones SQL son ejecutadas
+sin utilizar un JOIN: la primera traer todos los modelos primarios, mientras que la segunda trae los registros relacionados
+utilizando como condición la clave primaria de los primarios.
+
+En vez de devolver objetos [[yii\db\ActiveRecord|ActiveRecord]], puedes conectar el método [[yii\db\ActiveQuery::asArray()|asArray()]]
+mientras generas una query que devuelve un gran número de registros. Esto causará que el resultado de la consulta sea devuelto como
+arrays, lo que puede reducir significativamente la necesidad de tiempo de CPU y memoria si el número de registros es grande.
+Por ejemplo:
+
+```php
+$customers = Customer::find()->asArray()->all();
+```
+
+Otro cambio es que ya no puedes definir valores por defecto a los atributos a través de propiedades publicas.
+Si lo necesitaras, debes definirlo en el método init de la clase del registro en cuestión.
+
+```php
+public function init()
+{
+    parent::init();
+    $this->status = self::STATUS_NEW;
+}
+```
+
+Solía haber algunos problemas al sobrescribir el constructor de una clase ActiveRecord en 1.1. Estos ya no están presentes en
+Yii 2.0. Ten en cuenta que al agregar parámetros al constructor podrías llegar a tener que sobrescribir [[yii\db\ActiveRecord::instantiate()]].
+
+Hay muchos otros cambios y mejoras con respecto a ActiveRecord. Por favor consulta
+la sección [Active Record](db-active-record.md) para más detalles.
+
+
+User e IdentityInterface
+------------------------
+
+La clase `CWebUser` de 1.1 es reemplazada por [[yii\web\User]], y la clase `CUserIdentity` ya no existe.
+En cambio, ahora debes implementar [[yii\web\IdentityInterface]] lo que es mucho más directo para usar.
+El template de Aplicación Avanzada provee un ejemplo así.
+
+Consulta las secciones [Autenticación](security-authentication.md), [Autorización](security-authorization.md), y [Template de Aplicación Avanzanda](tutorial-advanced-app.md) para más detalles.
+
+
+Manejo de URLs
+--------------
+
+El manejo de URLs en Yii 2 es similar al de 1.1. Una mejora mayor es que el manejador actual ahora soporta parámetros opcionales.
+Por ejemplo, si tienes una regla declarada como a continuación, entonces coincidirá tanto con `post/popular` como `post/1/popular`. 
+En 1.1, tendrías que haber creado dos reglas diferentes para obtener el mismo resultado
+
+```php
+[
+    'pattern' => 'post/<page:\d+>/<tag>',
+    'route' => 'post/index',
+    'defaults' => ['page' => 1],
+]
+```
+
+Por favor consulta la sección [Documentación del Manejo de URLs](url.md) para más detalles.
+
+Utilizando Yii 1.1 y 2.x juntos
+-------------------------------
+
+Si tienes código en Yii 1.1 que quisieras utilizar junto con Yii 2.0, por favor consulta
+la sección [Using Yii 1.1 and 2.0 Together](extend-using-v1-v2.md).
+

docs/guide-es/intro-yii.md

+¿Qué es Yii?
+============
+
+Yii es un framework PHP de alta performance, basado en componentes para desarrollar aplicaciones Web 
+modernas en poco tiempo.
+El nombre Yii significa "simple y evolutivo" en chino. También puede ser tomado como un acrónimo
+en inglés de **Yes It Is** (**Sí, eso es**)!
+
+
+¿Para qué es Mejor Yii?
+-----------------------
+
+Yii es un framework genérico para desarrollo Web, lo que significa que puede ser utilizado para desarrollar
+todo tipo de aplicaciones Web basadas en PHP. Debido a su arquitectura basada en componentes y sofisticado
+soporte de Cache, es especialmente apropiado para el desarrollo de aplicaciones de gran envergadura como portales,
+foros, sistemas de gestión de contenidos (CMS), proyectos de e-commerce, RESTful Web services y más.
+
+¿Cómo se Compara Yii con Otros Frameworks?
+------------------------------------------
+
+- Como la mayoría de frameworks PHP, Yii implementa el patrón de diseño MVC (Modelo-Vista-Controlador) y promueve
+  la organización de código basada en este patrón.
+- Yii toma la filosofía de que el código debe ser escrito de manera simple y elegante. Nunca intentará sobre-diseñar
+  las cosas por el sólo hecho de seguir determinado patrón de diseño.
+- Yii es un framework completo que provee muchas características probadas y listas para usar, como: query builders
+  y ActiveRecord, tanto para bases de datos relacionales como para NoSQL; soporte de desarrollo de RESTful APIs;
+  soporte de cache multi-tier; y más.
+- Yii es extremadamente extensible. Puedes personalizar o reemplazar practicamente cualquier pieza de código del núcleo. 
+  También puedes tomar ventaja de su sólida arquitectura de extensiones, y así utilizar o desarrollar extensiones
+  re-distribuibles.
+- La alta performance es siempre una meta principal en Yii.
+
+Yii no es un show-de-un-solo-hombre, está sustentado por un [fuerte equipo de desarrollo][] así como una gran comunidad
+con muchos profesionales constantemente contribuyendo con el desarrollo del framework. El equipo de desarrollo de Yii
+mantiene un ojo en las últimas tendencias de desarrollo Web, así como en las mejores prácticas y características
+encontradas en otros frameworks y proyectos. Las buenas prácticas más relevantes encontradas en cualquier otro lugar
+son regularmente incorporadas en el núcleo y expuestas a través de simples y elegantes interfaces.
+
+[fuerte equipo de desarrollo]: http://www.yiiframework.com/about/
+
+Versiones de Yii
+----------------
+
+Actualmente Yii tiene dos versiones mayores disponibles: 1.1 y 2.0. La versión 1.1 es la anterior generación y ahora sólo cuenta con mantenimiento.
+La versión 2.0 está completamente reescrita, y adopta las últimas tecnologías y protocolos, incluyendo Composer, PSR, namespaces, traits, y más.
+Esta versión representa la última generación del framework y su desarrollo recibirá nuestro principal esfuerzo en los próximos años.
+Esta guía es principalmente sobre la versión 2.0.
+
+
+Requerimientos y Pre-requisitos
+-------------------------------
+
+Yii 2.0 requiere PHP 5.4.0 o mayor. Puedes encontrar requerimientos más detallados para características 
+individuales corriendo el comprobador de requerimientos incluido en cada lanzamiento de Yii.
+
+Para utilizar Yii se requiere conocimientos básicos acerca de programación orientada a objetos (POO), ya que está
+basado puramente en esta tecnología.
+Yii 2.0 hace uso también de las últimas características de PHP, como [namespaces](http://www.php.net/manual/en/language.namespaces.php) y [traits](http://www.php.net/manual/en/language.oop5.traits.php).
+Entendiendo estos conceptos te ayudará a entender Yii 2.0 más fácilmente.

docs/guide-es/start-installation.md

+Instalando Yii
+==============
+
+Yii puede ser instalado de dos maneras, usando [Composer](http://getcomposer.org/) o descargando un archivo comprimido.
+Es preferible usar la primera forma, ya que te permite instalar [extensiones](structure-extensions.md) o actualizar Yii corriendo un simple comando.
+
+> Nota: A diferencia de Yii 1, la instalación estándar de Yii 2 resulta en la descarga e instalación tanto del framework como del esqueleto de la aplicación.
+
+
+Instalando a través de Composer <a name="installing-via-composer"></a>
+-------------------------------
+
+Si aún no tienes Composer instalado, puedes hacerlos siguiendo las instrucciones que se encuentran en
+[getcomposer.org](https://getcomposer.org/download/). En Linux y Mac OS X, correrás los siguientes comandos:
+
+    curl -s http://getcomposer.org/installer | php
+    mv composer.phar /usr/local/bin/composer
+
+En Windows, deberás descargar y ejecutar [Composer-Setup.exe](https://getcomposer.org/Composer-Setup.exe).
+
+Por favor consulta la [Documentación de Composer](https://getcomposer.org/doc/) si encuentras algún problema
+o quieres tener un conocimiento más profundo de su utilización.
+
+Teniendo Composer instalado, puedes instalar Yii corriendo el siguiente comando en un directorio accesible vía Web:
+
+    composer create-project --prefer-dist yiisoft/yii2-app-basic basic
+
+El comando anterior instala Yii dentro del directorio `basic`.
+
+> Tip: Si quieres instalar la última versión de desarrollo de Yii, puedes utilizar el siguiente comando,
+> que añade una [opción de estabilidad mínima](https://getcomposer.org/doc/04-schema.md#minimum-stability):
+>
+>     composer create-project --prefer-dist --stability=dev yiisoft/yii2-app-basic basic
+>
+> Ten en cuenta que la versión de desarrollo de Yii no debería ser usada para producción ya que podría romper el funcionamiento actual de la aplicación.
+
+
+Instalando desde un Archivo Comprimido <a name="installing-from-archive-file"></a>
+--------------------------------------
+
+Instalar Yii desde un archivo comprimido involucra dos pasos:
+
+1. Descargar el archivo desde [yiiframework.com](http://www.yiiframework.com/download/yii2-basic).
+2. Descomprimirlo en un directorio accesible vía Web.
+
+
+Otras Opciones de Instalación <a name="other-installation-options"></a>
+-----------------------------
+
+Las instrucciones anteriores muestran cómo instalar Yii, lo que también crea una aplicación Web lista para usar.
+Este es un buen punto de partida para pequeñas aplicaciones, o cuando apenas se comienza a aprender Yii.
+
+Pero también hay otras opciones de instalación disponibles:
+
+* Si sólo quieres instalar el núcleo del framework y entonces crear una nueva aplicación desde cero,
+  puedes seguir las instrucciones explicadas en [Generando una Aplicación desde Cero](tutorial-start-from-scratch.md).
+* Si quisieras comenzar con una aplicación más avanzada, más adecuada para un entorno de desarrollo de equipo,
+  deberías considerar instalar el [Template de Aplicación Avanzada](tutorial-advanced-app.md).
+
+
+Verificando las Instalación <a name="verifying-installation"></a>
+---------------------------
+
+Después de la instalación, puedes acceder a la aplicación instalada a través de la siguiente URL:
+
+```
+http://localhost/basic/web/index.php
+```
+
+Esta URL da por hecho que Yii se instaló en un directorio llamado `basic`, directamente bajo el directorio del Servidor Web,
+y que el Servidor Web está corriendo en tu máquina local (`localhost`). Sino, podrías necesitar ajustarlo de acuerdo a tu entorno de instalación.
+
+![Instalación Correcta de Yii](images/start-app-installed.png)
+
+Deberías ver la página mostrando "Congratulations!" en tu navegador. Si no ocurriera, por favor chequea que la instalación
+de PHP satisface los requerimientos de Yii. Esto puedes hacerlo usando cualquiera de los siguientes procedimientos:
+
+* Visitando la URL `http://localhost/basic/requirements.php` en tu navegador
+* Corriendo los siguientes comandos:
+
+  ```
+  cd basic
+  php requirements.php
+  ```
+
+Deberías configurar tu instalación de PHP para que satisfaga los requisitos mínimos de Yii. Lo que es más importante, debes tener PHP 5.4 o mayor.
+También deberías instalar la [Extensión de PHP PDO](http://www.php.net/manual/es/pdo.installation.php) y el correspondiente driver de base de datos
+(como `pdo_mysql` para bases de datos MySQL), si tu aplicación lo necesitara.
+
+
+Configurando Servidores Web <a name="configuring-web-servers"></a>
+---------------------------
+
+> Información: Puedes saltear esta sección por ahora si sólo estás probando Yii sin intención de poner la aplicación en un servidor de producción.
+
+La aplicación instalada debería estar lista para usar tanto con un [servidor HTTP Apache](http://httpd.apache.org/) o con un [servidor HTTP Nginx](http://nginx.org/),
+en Windows, Mac OS X, o Linux.
+
+En un servidor de producción, podrías querer configurar el servidor Web para que la aplicación sea accedida a través de la
+URL `http://www.example.com/index.php` en vez de `http://www.example.com/basic/web/index.php`. Tal configuración
+require apuntar el document root de tu servidor Web al directorio `basic/web`. También podrías querer ocultar `index.php`
+de la URL, como se describe en la sección [Parseo y Generación de URLs](runtime-url-handling.md).
+En esta sub-sección, aprenderás a configurar tu servidor Apache o Nginx para alcanzar estos objetivos.
+
+> Información: Al definir `basic/web` como document root, también previenes que los usuarios finales accedan
+al código privado o archivos con información sensible de tu aplicación que están incluidos en los directorios del mismo nivel
+que `basic/web`. Denegando el acceso es una importante mejora en la seguridad.
+
+> Información: En caso de que tu aplicación corra en un entorno de hosting compartido donde no tienes permisos para modificar
+la configuración del servidor Web, aún puedes ajustar la estructura de la aplicación para mayor seguridad. Por favor consulta
+la sección [Entorno de Hosting Compartido](tutorial-shared-hosting.md) para más detalles.
+
+
+### Configuración Recomendada de Apache <a name="recommended-apache-configuration"></a>
+
+Utiliza la siguiente configuración del archivo `httpd.conf` de Apache dentro de la configuración del virtual host. Ten en cuenta
+que deberás reemplazar `path/to/basic/web` con la ruta real a `basic/web`.
+
+```
+# Definir el document root de "basic/web"
+DocumentRoot "path/to/basic/web"
+
+<Directory "path/to/basic/web">
+    RewriteEngine on
+
+    # Si el directorio o archivo existe, utiliza el request directamente
+    RewriteCond %{REQUEST_FILENAME} !-f
+    RewriteCond %{REQUEST_FILENAME} !-d
+    # Sino envía el request a index.php
+    RewriteRule . index.php
+
+    # ...más configuraciones...
+</Directory>
+```
+
+
+### Configuración Recomendada de Nginx <a name="recommended-nginx-configuration"></a>
+
+Deberías haber instalado PHP como un [FPM SAPI](http://php.net/install.fpm) para utilizar [Nginx](http://wiki.nginx.org/).
+Utiliza la siguiente configuración de Nginx, reemplazando `path/to/basic/web` con la ruta real a `basic/web` y `mysite.local` con el
+hostname real del servidor.
+
+```
+server {
+    charset utf-8;
+    client_max_body_size 128M;
+
+    listen 80; ## listen for ipv4
+    #listen [::]:80 default_server ipv6only=on; ## listen for ipv6
+
+    server_name mysite.local;
+    root        /path/to/basic/web;
+    index       index.php;
+
+    access_log  /path/to/basic/log/access.log main;
+    error_log   /path/to/basic/log/error.log;
+
+    location / {
+        # Redireccionar a index.php todo lo que no sea un archivo real
+        try_files $uri $uri/ /index.php?$args;
+    }
+
+    # descomentar para evitar el procesamiento de llamadas de Yii a archivos estáticos no existente
+    #location ~ \.(js|css|png|jpg|gif|swf|ico|pdf|mov|fla|zip|rar)$ {
+    #    try_files $uri =404;
+    #}
+    #error_page 404 /404.html;
+
+    location ~ \.php$ {
+        include fastcgi.conf;
+        fastcgi_pass   127.0.0.1:9000;
+        #fastcgi_pass unix:/var/run/php5-fpm.sock;
+    }
+
+    location ~ /\.(ht|svn|git) {
+        deny all;
+    }
+}
+```
+
+Al utilizar esta configuración, también deberías definir `cgi.fix_pathinfo=0` en el archivo `php.ini`, y así
+evitar muchas llamadas innecesarias del sistema a `stat()`.
+
+Ten en cuenta también que al correr un servidor HTTPS, deberás agregar `fastcgi_param HTTPS on;` así Yii puede
+detectar propiamente si la conexión es segura.

docs/guide-fr/README.md

+Guide définitif pour Yii 2.0
+============================
+
+Ce guide est soumis aux [Conditions de la Documentation de Yii](http://www.yiiframework.com/doc/terms/).
+
+Tous droits réservés.
+
+2014 (c) Yii Software LLC.
+
+
+Introduction
+------------
+
+* [A propos de Yii](intro-yii.md)
+* [Mise à jour depuis la version 1.1](intro-upgrade-from-v1.md)
+
+
+Mise en Route
+-------------
+
+* [Installer Yii](start-installation.md)
+* [Fonctionnement des applications](start-workflow.md)
+* [Hello World](start-hello.md)
+* [Travailler avec les formulaires](start-forms.md)
+* [Travailler avec les bases de données](start-databases.md)
+* [Générer du code avec Gii](start-gii.md)
+* [En savoir plus](start-looking-head.md)
+
+
+Structure Application
+---------------------
+
+* [Vue d'ensemble](structure-overview.md)
+* [Script d'entrée](structure-entry-scripts.md)
+* [Applications](structure-applications.md)
+* [Composants application](structure-application-components.md)
+* [Controlleurs](structure-controllers.md)
+* [Modèles](structure-models.md)
+* [Vues](structure-views.md)
+* **TBD** [Filtres](structure-filters.md)
+* **TBD** [Widgets](structure-widgets.md)
+* **TBD** [Modules](structure-modules.md)
+* [Assets](structure-assets.md)
+* **TBD** [Extensions](structure-extensions.md)
+
+
+Gérer les Requêtes
+------------------
+
+* **TBD** [Amorçage (Bootstrapping)](runtime-bootstrapping.md)
+* **TBD** [Routes](runtime-routing.md)
+* **TBD** [Requêtes](runtime-requests.md)
+* **TBD** [Réponses](runtime-responses.md)
+* **TBD** [Sessions et Cookies](runtime-sessions-cookies.md)
+* [Génération et traitement des URL](runtime-url-handling.md)
+* [Gestion des erreurs](runtime-handling-errors.md)
+* [Journalisation](runtime-logging.md)
+
+
+Concepts Clés
+-------------
+
+* [Composants](concept-components.md)
+* [Propriétés](concept-properties.md)
+* [Evénements](concept-events.md)
+* [Comportements](concept-behaviors.md)
+* [Configurations](concept-configurations.md)
+* [Alias](concept-aliases.md)
+* [Auto-chargement de classes](concept-autoloading.md)
+* [Annuaire de services](concept-service-locator.md)
+* [Conteneur d'injection de dépendance](concept-di-container.md)
+
+
+Travailler avec les Bases de Données
+------------------------------------
+
+* [Objet d'accès aux données (DAO)](db-dao.md) - Connexion à une base de données, requêtes basiques, transactions et manipulation de schéma
+* [Constructeur de requête](db-query-builder.md) - Interrogation de base de données en utilisant une couche d'abstraction simple
+* [Active Record](db-active-record.md) - Active Record ORM, récupération et manipulation d'enregistrements et définition des relations
+* [Migrations](db-migrations.md) - Contrôle de version de vos bases de données dans un environnement de développement en équipe
+* **TBD** [Sphinx](db-sphinx.md)
+* **TBD** [Redis](db-redis.md)
+* **TBD** [MongoDB](db-mongodb.md)
+* **TBD** [ElasticSearch](db-elastic-search.md)
+
+
+Getting Data from Users
+-----------------------
+
+* [Créer des formulaires](input-forms.md)
+* [Valider les entrées](input-validation.md)
+* **TBD** [Télécharger des fichiers](input-file-upload.md)
+* **TBD** [Récupération de données provenant de plusieurs modèles](input-multiple-models.md)
+
+
+Afficher les données
+--------------------
+
+* **TBD** [Formattage](output-formatting.md)
+* **TBD** [Pagination](output-pagination.md)
+* **TBD** [Tri](output-sorting.md)
+* [Fournisseurs de données](output-data-providers.md)
+* [Widgets pour afficher des données](output-data-widgets.md)
+* [Thématisation](output-theming.md)
+
+
+Securité
+--------
+
+* [Authentification](security-authentication.md)
+* [Autorisation](security-authorization.md)
+* [Gestion des mots de passe](security-passwords.md)
+* **TBD** [Clients authentification](security-auth-clients.md)
+* **TBD** [Meilleures pratiques](security-best-practices.md)
+
+
+Cache
+-----
+
+* [Vue d'ensemble](caching-overview.md)
+* [Cache de données](caching-data.md)
+* [Cache de fragment](caching-fragment.md)
+* [Cache de page](caching-page.md)
+* [Cache HTTP](caching-http.md)
+
+
+Services Web RESTful
+--------------------
+
+* [Démarrage rapide](rest-quick-start.md)
+* [Ressources](rest-resources.md)
+* [Controlleurs](rest-controllers.md)
+* [Gestion des routes](rest-routing.md)
+* [Formattage des réponses](rest-response-formatting.md)
+* [Authentification](rest-authentication.md)
+* [Limiter le taux d'utilisation](rest-rate-limiting.md)
+* [Gestion des versions](rest-versioning.md)
+* [Gestion des erreurs](rest-error-handling.md)
+
+
+Outils de développement
+-----------------------
+
+* [Barre de débogage, et débogueur](tool-debugger.md)
+* [Générer du code avec Gii](tool-gii.md)
+* **TBD** [Générer une documentation API](tool-api-doc.md)
+
+
+Tests
+-----
+
+* [Vue d'ensemble](test-overview.md)
+* **TBD** [Tests unitaires](test-unit.md)
+* **TBD** [tests fonctionnels](test-functional.md)
+* **TBD** [Tests d'acceptation](test-acceptance.md)
+* [Fixtures](test-fixtures.md)
+
+
+Etendre Yii
+-----------
+
+* [Créer des extensions](extend-creating-extensions.md)
+* [Personnalisation du code du noyau](extend-customizing-core.md)
+* [Utiliser des libraires tierces](extend-using-libs.md)
+* **TBD** [Utiliser Yii dans d'autres systèmes](extend-embedding-in-others.md)
+* **TBD** [Utiliser Yii 1.1 et 2.0 ensemble](extend-using-v1-v2.md)
+* [Utiliser Composer](extend-using-composer.md)
+
+
+Sujets avancés
+--------------
+
+* [Modèle application avancée](tutorial-advanced-app.md)
+* [Créer une application à partir de zéro](tutorial-start-from-scratch.md)
+* [Commandes console](tutorial-console.md)
+* [Validateurs de base](tutorial-core-validators.md)
+* [Internationalisation](tutorial-i18n.md)
+* [Envoyer des courriels](tutorial-mailing.md)
+* [Amélioration des performances](tutorial-performance-tuning.md)
+* **TBD** [Environnement d'hébergement mutualisé](tutorial-shared-hosting.md)
+* [Moteur de gabarit](tutorial-template-engines.md)
+
+
+Widgets
+-------
+
+* GridView: link to demo page
+* ListView: link to demo page
+* DetailView: link to demo page
+* ActiveForm: link to demo page
+* Pjax: link to demo page
+* Menu: link to demo page
+* LinkPager: link to demo page
+* LinkSorter: link to demo page
+* [Widgets Bootstrap](bootstrap-widgets.md)
+* **TBD** [Widgets Jquery UI](jui-widgets.md)
+
+
+Assistants
+----------
+
+* [Vue d'ensemble](helper-overview.md)
+* **TBD** [ArrayHelper](helper-array.md)
+* **TBD** [Html](helper-html.md)
+* **TBD** [Url](helper-url.md)
+* **TBD** [Security](helper-security.md)
+

docs/guide-fr/intro-yii.md

+Qu'est ce que Yii
+=================
+
+Yii est un framework PHP hautes performances à base de composants qui permet de développer rapidement des applications Web modernes.
+Le nom Yii (pronnoncée `Yee` ou `[ji:]`) signifie "simple et évolutif" en Chinois. Il peut également 
+être considéré comme un acronyme de **Yes It Is**!
+
+
+Pour quel usage Yii est il optimal?
+-----------------------------------
+
+Yii est un framework Web générique, c'est à dire qu'il peut être utilisé pour développer tous types
+d'applications Web basées sur PHP. De par son architecture à base de composants et son système de cache sophistiqué,
+il est particulièrement adapté au développement d'applications a forte audience telles que des portails, des forums,
+des systèmes de gestion de contenu (CMS), des sites e-commerce, services Web RESTFul, etc.
+
+
+Comment se positionne Yii vis-à-vis des autres Frameworks? 
+----------------------------------------------------------
+
+- Comme la plupart des frameworks PHP, Yii est basé sur le modèle de conception MVC et encourage une
+organisation du code basée sur ce modèle.
+- Yii repose sur l'idée que le code doit être écrit de façon simple et élégante. Il ne sera jamais question de
+surcharger le code de Yii uniquement pour respecter un modèle de conception.
+- Yii est un framework complet offrant de nombreuses caractéristiques éprouvées et prêtes à l'emploi, telles que:
+constructeur de requêtes et ActiveRecord, à la fois pour les bases de données relationnelles et NoSQL; support RESTful API;
+support cache multi-niveaux; et plus. 
+- Yii est extrêmement flexible. Vous pouvez personnaliser ou remplacer presque chaque partie du code du noyau. Vous pouvez également 
+profiter de son architecture extensible solide, afin d'utiliser ou développer des extensions redistribuables. 
+- La haute performance est toujours un des principaux objectifs de Yii.
+
+Yii n'est pas un one-man show, il est soutenu par une [solide équipe de développement du noyau][] ainsi que d'une grande communauté 
+avec de nombreux professionnels qui contribuent constamment au développement de Yii. L'équipe de développeurs de Yii 
+garde un œil attentif sur les dernières tendances en développement Web, et sur ​​les meilleures pratiques et caractéristiques 
+trouvées dans d'autres frameworks ou projets. Les meilleures pratiques et caractéristiques les plus pertinentes trouvées ailleurs sont régulièrement intégrées dans le code du noyau et utilisables
+via des interfaces simples et élégantes.
+
+[solide équipe de développement du noyau]: http://www.yiiframework.com/about/
+
+Versions de Yii
+---------------
+
+Yii a actuellement deux versions majeures disponibles : 1.1 et 2.0. La version 1.1 est l'ancienne génération et est maintenant en mode maintenance. La version 2.0 est une réécriture complète de Yii, adoptant les dernières
+technologies et protocoles, y compris Composer, PSR, les espaces de noms, les traits, et ainsi de suite. la version 2.0 est la dernière 
+génération du framework et recevra nos principaux efforts de développement dans les prochaines années. 
+Ce guide est principalement pour la version 2.0.
+
+
+Configuration nécessaire
+------------------------
+
+Yii 2.0 nécessite PHP 5.4.0 ou plus. Vous pouvez trouver plus de détails sur la configuration requise pour chaque fonctionnalité
+en utilisant le script de test de la configuration inclus dans chaque distribution de Yii.
+
+Utiliser Yii requiert des connaissances de base sur la programmation objet (OOP), en effet Yii est un framework basé sur ce type de programmation.
+Yii 2.0 utilise aussi des fonctionnalités récentes de PHP, telles que les [espaces de noms](http://www.php.net/manual/fr/language.namespaces.php) et les [traits](http://www.php.net/manual/fr/language.oop5.traits.php).
+Comprendre ces concepts vous aidera à mieux prendre en main Yii.
+

docs/guide-ru/concept-aliases.md

+Псевдонимы 
+=======
+
+Псевдонимы используются для представления путей к файлам или для представления URL адресов с целью того, чтобы не приходилось полностью прописывать пути к файлам или полные URL адреса.
+Псевдоним должен начинаться со знака '@', чтобы не перепутать его с адресом файла или с URL адресом.
+Например псевдоним '@yii' указывает на папку, в которую был установлен Yii framework, а псевдоним '@web' представляет собой базовый, основной URL адрес (base URL) текущего приложения.
+
+
+Создание псевдонимов <a name="defining-aliases"></a>
+----------------
+
+Для создания псевдонима пути к файлу или псевдонима  какого либо URL адреса используется метод [[Yii::setAlias()]].
+Пример:
+
+```php
+// псевдоним пути к файлу
+Yii::setAlias('@foo', '/path/to/foo');
+
+// псевдоним URL адреса
+Yii::setAlias('@bar', 'http://www.example.com');
+```
+
+> Примечание: псевдоним пути к файлу или псевдоним URL адреса могут указывать на НЕСУЩЕСТВУЮЩИЙ файл или интернет ресурс.
+
+Если вы создали псевдоним пути, то из него можно вывести производный путь(не вызывая [[Yii::setAlias()]]) с помощью добавления знака '/' с последующим указанием необходимого пути. Псевдонимы, созданные с помощью [[Yii::setAlias()]] называются *корневыми псевдонимами (root aliases)*, тогда как производные псевдонимы называются *производными псевдонимами (derived aliases)*. 
+Например, `@foo` - это корневой псевдоним, тогда как `@foo/bar/file.php` - это производный псевдоним.
+
+Вы можете создать новый псевдоним используя ранее созданный псевдоним (независимо от того корневой он или производный):
+
+```php
+Yii::setAlias('@foobar', '@foo/bar');
+```
+
+Корневые псевдонимы как правило создаются на этапе [предварительной загрузки (bootstrapping)](runtime-bootstrapping.md) stage.
+Например вы можете вызвать [[Yii::setAlias()]] внутри [входного скрипта (entry script)](structure-entry-scripts.md).
+Для удобства использования, в [приложении (Application)](structure-applications.md) предусмотрено свойство 'aliases' , в которое возможна запись, т.е. вы можете [изменить настройки](concept-configurations.md) вашего приложения как в нижеследующем примере:
+
+```php
+return [
+    // ...
+    'aliases' => [
+        '@foo' => '/path/to/foo',
+        '@bar' => 'http://www.example.com',
+    ],
+];
+```
+
+
+Раскрытие Псевдонимов <a name="resolving-aliases"></a>
+-----------------
+
+Метод [[Yii::getAlias()]] раскрывает корневой псевдоним в путь к файлу или в URL, который изначально был скрыт за псевдонимом.
+Этот же метод используется для раскрытия производных псевдонимов в полный путь. 
+Пример:
+
+```php
+echo Yii::getAlias('@foo');               // выведет: /path/to/foo
+echo Yii::getAlias('@bar');               // выведет: http://www.example.com
+echo Yii::getAlias('@foo/bar/file.php');  // выведет: /path/to/foo/bar/file.php
+```
+
+При раскрытии производных псевдонимов происходит раскрытие корневого псевдонима, с которого начинался псевдоним. 
+
+> Примечание: Метод [[Yii::getAlias()]] не проверяет фактическое существование формируемого пути к файлу или URL адреса. 
+
+Корневой псевдоним может включать в себя знаки '/'. Метод [[Yii::getAlias()]] 
+корректно определит какая часть ссылки является корневой.
+Пример:
+
+```php
+Yii::setAlias('@foo', '/path/to/foo');
+Yii::setAlias('@foo/bar', '/path2/bar');
+Yii::getAlias('@foo/test/file.php');  // выведет: /path/to/foo/test/file.php
+Yii::getAlias('@foo/bar/file.php');   // выведет: /path2/bar/file.php
+```
+
+Если не указать `@foo/bar` в качестве корневого псевдонима, последнее выражение выведет `/path/to/foo/bar/file.php`.
+
+
+Использование псевдонимов <a name="using-aliases"></a>
+-------------
+
+Псевдонимы распознаются во многих частях Yii без необходимости вызова [[Yii::getAlias()]] для раскрытия псевдонимов. Например, [[yii\caching\FileCache::cachePath]] принимает в качестве аргумента как обычный путь к файлу, так и псевдоним, благодаря тому, что псевдонимы начинаются со знака '@'.
+
+```php
+use yii\caching\FileCache;
+
+$cache = new FileCache([
+    'cachePath' => '@runtime/cache',
+]);
+```
+
+Для того чтобы узнать, поддерживает ли необходимый вам метод или свойство класса псевдонимы в качестве аргументов обратитесь к документации API. 
+
+
+Системные псевдонимы <a name="predefined-aliases"></a>
+------------------
+
+Системные псевдонимы Yii включают в себя часто используемые пути к файлам и URL адреса.
+Список системных псевдонимов Yii:
+
+- `@yii`: папка, в которой находится файл `BaseYii.php` (директория фреймворка).
+- `@app`: [[yii\base\Application::basePath|base path]] текущего приложения.
+- `@runtime`: [[yii\base\Application::runtimePath|runtime path]] текущего приложения.
+- `@vendor`: [[yii\base\Application::vendorPath|Composer vendor directory].
+- `@webroot`: папка Web root текущего Web приложения.
+- `@web`: базовый URL (base URL) текущего приложения.
+
+Псевдоним `@yii` создается при включении файла `Yii.php` во [входной скрипт (entry script)](structure-entry-scripts.md),
+остальные псевдонимы создаются в конструкторе приложения в момент применения [конфигурации](concept-configurations.md).
+
+
+Псевдонимы расширений <a name="extension-aliases"></a>
+-----------------
+
+Для каждого [расширения](structure-extensions.md), устанавливаемого через Composer автоматически создается псевдоним.
+Имя псевдонима расширения соответствует корневому пространству имен, которое указано в файле `composer.json` расширения. Данный псевдоним указывает на корневую папку расширения.
+Например, если вы установите расширение `yiisoft/yii2-jui`, то для вас автоматически станет доступен псевдоним `@yii/jui`, создание которого будет происходить на этапе [первоначальной загрузки (bootstrapping)](runtime-bootstrapping.md) следующим образом:
+
+```php
+Yii::setAlias('@yii/jui', 'VendorPath/yiisoft/yii2-jui');
+```

docs/guide-ru/concept-autoloading.md

+Автозагрузка классов
+=================
+
+Для подключения и загрузки классов в Yii используется [автозагрузка классов](http://www.php.net/manual/ru/language.oop5.autoload.php). Автозагрузчик классов в Yii совместим со стандартом автозагрузки [PSR-4](https://github.com/php-fig/fig-standards/blob/master/proposed/psr-4-autoloader/psr-4-autoloader.md) и работает быстро.
+
+Автозагрузчик устанавливается когда вы включаете файл `Yii.php` в свой скрипт.
+
+> Примечание: Для простоты повествования мы будем говорить только об автозагрузке классов. Стоит отметить, что нижеприведенный способ может быть применен не только для автозагрузки классов, но и для автозагрузки интерфейсов(interface) и трейтов(traits).
+  
+
+
+Как использовать автозагрузчик Yii <a name="using-yii-autoloader"></a>
+------------------------
+
+Для того чтобы воспользоваться автозагрузчиком классов Yii вам нужно соблюсти два правила при создании и именовании классов:
+
+* Каждый класс должен принадлежать определенному пространству имён  (прим. `foo\bar\MyClass`).
+* Каждый класс должен находиться в отдельном файле, путь к которому будет определяться по следующему правилу:
+
+```php
+// $className - это полное имя класса, начинающееся с обратного слэша, т.е. \
+$classFile = Yii::getAlias('@' . str_replace('\\', '/', $className) . '.php');
+```
+
+Например, если полное имя класса `foo\bar\MyClass`, то  [псевдоним пути(alias)](concept-aliases.md) данного файла будет 
+`@foo/bar/MyClass.php`. Для того, чтобы данный псевдоним превратился в путь файла в файловой системе нужно чтобы либо `@foo` либо `@foo/bar` был [корневым псевдонимом(root alias)](concept-aliases.md#defining-aliases).
+
+При использовании [простого шаблона приложения (Basic Application Template)](start-basic.md), вы можете хранить свои классы в пространствах имен ниже `app`, тогда вам не понадобится указывать новый псевдоним пути для автозагрузки вашего класса. Это работает потому что
+`@app` является [системным псевдонимом](concept-aliases.md#predefined-aliases), а такое имя класса как `app\components\MyClass`
+преобразуется в путь 
+`папкавашегоприложения/components/MyClass.php`.
+
+
+В [шаблоне продвинутого приложения (Advanced Application Template)](tutorial-advanced-app.md), каждый уровень приложения обладает собственным корневым псевдонимом. Например, для front-end части корневым псевдонимом является `@frontend`, а для back-end части `@backend`. Это позволяет включать классы front-end части в пространство имен(namespace) ниже 'frontend', а для back-end части ниже 'backend'. При таком подходе ваши классы будут автоматически загружены автозагрузчиком Yii.
+
+
+Карта классов <a name="class-map"></a>
+---------
+
+Автозагрузчик Yii обладает возможностью, которая называется *карта классов*.Эта возможность позволяет указывать где необходимо искать классы в зависимости от имени файла.
+Прежде чем загрузить файл автозагрузчик проверяет есть ли правила для файла в карте классов. Если файл находится в карте классов, то данный файл будет загружен напрямую без дальнейших проверок.
+Это позволяет существенно ускорить автозагрузку. Все базовые классы Yii загружаются именно этим способом.
+
+Пример добавления класса в карту классов `Yii::$classMap`:
+
+```php
+Yii::$classMap['foo\bar\MyClass'] = 'path/to/MyClass.php';
+```
+
+[Псевдонимы](concept-aliases.md) могут быть использованы для указания пути к файлу класса. Карту классов необходимо указать в разделе [загрузки фреймворка](runtime-bootstrapping.md) т.к. карта должна быть создана до того, как будут использованы ваши классы.
+
+
+Использование других автозагрузчиков <a name="using-other-autoloaders"></a>
+-----------------------
+
+По причине того что Yii использует Composer в качестве менеджера зависимостей, рекомендуется дополнительно установить автозагрузчик Composer. Если вы использует какие то дополнительные библиотеки, в которых есть свои автозагрузчики, то автозагрузчики этих библиотек также нужно будет установить.
+
+В случаях использования дополнительных автозагрузчиков вместе с автозагрузчиком Yii, файл `Yii.php` должен быть подключен *после* установки всех дополнительных автозагрузчиков. В таком случае автозагрузчик Yii будет первым используемым автозагрузчиком из установленных при  автозагрузке. Например нижеследующий код взят напрямую из [входного скрипта(entry script)](structure-entry-scripts.md) для [Basic Application Template](start-basic.md). Первая строчка устанавливает автозагрузчик Composer, а вторая устанавливает автозагрузчик Yii.
+
+```php
+require(__DIR__ . '/../vendor/autoload.php');
+require(__DIR__ . '/../vendor/yiisoft/yii2/Yii.php');
+```
+
+Вы можете использовать автозагрузчик Composer бес использования автозагрузчика Yii. Но в таком случае скорость автозагрузки может уменьшится, также вам нужно будет соблюсти правила автозагрузки для Composer.
+
+> Информация: Если вы не хотите использовать автозагрузчик Yii, то вам нужно будет создать свою версию файла `Yii.php` 
+   и подключить его к [входному скрипту(entry script)](structure-entry-scripts.md).
+
+
+Автозагрузка классов расширений <a name="autoloading-extension-classes"></a>
+-----------------------------
+
+Автозагрузчик Yii позволяет автоматически загружать классы [расширений](structure-extensions.md). Единственное правило в таком случае - расширение должно правильно указывать раздел 'autoload' в своем файле 'composer.json'. Более подробную информацию о том как правильно  указать раздел 'autoload' вы можете узнать в [официальной документации Composer](https://getcomposer.org/doc/04-schema.md#autoload).
+
+Если вы не используете автозагрузчик Yii, то классы расширений могут быть автоматически загружены с помощью автозагрузчика Composer.
+

docs/guide-ru/start-looking-head.md

+Взгляд в будущее
+=============
+
+В итоге, вы создали полноценное приложение на Yii, и узнали, как реализовать некоторые, 
+наиболее часто используемые функции, такие, как получение данных от пользователя, 
+при помощи HTML форм, выборки данных из базы данных и их отображения в разбитом на страницы виде. 
+Так же, вы узнали,  как использовать [Gii](tool-gii.md) для автоматической генерации кода, что превращает программирование в настолько простую задачу, 
+как просто заполнить какие-либо формы. 
+В этом разделе мы обобщим ресурсы о Yii, 
+которые помогут вам быть более продуктивным при использовании Yii.
+
+* Документация
+    - Подробное руководство:
+      Как следует из названия, руководство точно определяет, 
+	  как Yii должен работать и дает вам общие указания по его использованию. 
+	  Это самый важный Yii учебник, который вы должны прочитать, прежде чем писать различный Yii код.
+    - Описание классов:
+      Определяет использование каждого класса, представленного в Yii. 
+	  Им следует пользоваться, когда вы пишете код и хотите разобраться в использовании конкретного класса, метода, свойства.
+    - Вики статьи:
+      Вики статьи, написаны пользователями Yii на основе их собственного опыта. 
+	  Большинство из них написаны как рецепты из поваренной книги, которые показывают, как решить конкретные проблемы с использованием Yii. 
+	  Причём качество этих статей может быть таким же хорошим, как Подробное руководство, 
+	  они полезны тем, что они охватывают более широкие темы и часто могут предоставить вам готовые решения для дальнейшего использования.
+    - Книги
+* [Расширения](http://www.yiiframework.com/extensions/):
+  Yii гордится библиотекой из тысяч внесённых пользователями расширений, 
+  которые могут быть легко подключены в ваши приложения и сделать разработку приложений ещё быстрее и проще.
+* Сообщество
+    - [Форум](http://www.yiiframework.com/forum/)
+    - [GitHub](https://github.com/yiisoft/yii2)
+    - [Facebook](https://www.facebook.com/groups/yiitalk/)
+    - [Twitter](https://twitter.com/yiiframework)
+    - [LinkedIn](https://www.linkedin.com/groups/yii-framework-1483367)
\ No newline at end of file

docs/guide-ru/start-workflow.md

+Запуск приложения
+====================
+
+ После установки Yii, базовое приложение будет доступно либо по URL `http://hostname/basic/web/index.php`, либо по `http://hostname/index.php`, в зависимости от настроек Web сервера. Данный раздел - общее введение в орагнизацию кода, встроенный функционал и обработку обращений приложением Yii.
+
+> Информация: Далее, в данном руководстве предполагается что Yii установлен в директорию `basic/web`, которая, в свою очередь, установлена как корневой каталог в настройках Web сервера. В результате, обратившись по URL `http://hostname/index.php` Вы получите доступ к приложению, расположенному в `basic/web`. Детальнее с процессом начальной настройки можно познакомиться в разделе [Установка Yii](start-installation.md).
+
+Функционал <a name="functionality"></a>
+---------------
+
+Установленный шаблон простого приложения состоит из четырех страниц:
+
+* домашняя страница, отображается при переходе по URL `http://hostname/index.php`
+* "About" ("О нас")
+* на странице "Contact" находится форма обратной связи, на которой пользователь может обратиться к разработчику по e-mail
+* на странице "Login" отображается форма авторизации. Попытайтесь авторизоваться с логином/паролем "admin/admin". Обратите внимание на изменение раздела "Login" в главном меню на "Logout".
+
+Эти страницы используют смежный хидер (шапка сайта) и футер (подвал). В "шапке" находится главное меню, при помощи которого пользователь перемещается по сайту. В "подвале" - копирайт и общая информация.
+
+В самой верхней части окна Вы будете видеть системные сообщения Yii - журнал, отладочную информацию, сообщения об ошибках, запросы к базе данных и т.п. Выводом данной информации руководит [встроенный отладчик](tool-debugger.md), он записывает и отображает информацию о ходе выполнения приложения.
+
+
+Структура приложения Yii <a name="application-structure"></a>
+---------------------
+
+Ниже приведен список основных директорий и файлов вашего приложения (считаем, что приложение установлено в директорию `basic`):
+
+```
+basic/                  корневой каталог приложения
+    composer.json       используется Composer'ом, содержит описание приложения
+    config/             конфигурационные файлы
+        console.php     конфигурация консольного приложения
+        web.php         конфигурация Web приложения
+    commands/           содержит классы консольных команд
+    controllers/        контроллеры
+    models/             модели
+    runtime/            файлы, которые генерирует Yii во время выполнения приложения (логи, кеш и т.п.)
+    vendor/             содержит пакеты Composer'а и, собственно, сам фреймворк Yii
+    views/              виды приложения
+    web/                корневая директория Web приложения. Содержит файлы, доступные через Web
+        assets/         скрипты, используемые приложением (js, css)
+        index.php       точка входа в приложение Yii. С него начинается выполнение приложения
+    yii                 скрипт выполнения консольного приложения Yii
+```
+
+В целом, приложение Yii можно разделить на две категории файлов: расположенные в `basic/web` и расположенные в других директориях. Первая категория доступна через Web (например, браузером), вторая не доступна из вне и не должна быть доступной т.к. содержит служебную информацию.
+
+В Yii реализована схема проектирования [модель-вид-контроллер (MVC)](http://http://ru.wikipedia.org/wiki/Model-View-Controller),
+которая соответствует структуре директорий приложения. В директории `models` находятся [Модели](structure-models.md),
+в `views` расположены [Виды](structure-views.md), а в каталоге `controllers` все [Контроллеры](structure-controllers.md) приложения.
+
+Диаграмма ниже демонстрирует внутреннее устройство приложения.
+
+![внутреннее устройство приложения](images/application-structure.png)
+
+В каждом приложении Yii есть точка входа в приложение, `web/index.php` это единственный PHP-скрипт доступный для выполнения из Web. Он принимает входящий запрос и создает экземпляр [приложения](structure-applications.md).
+[Приложение](structure-applications.md) обрабатывает входящие запросы при помощи [компонентов](concept-components.md) и отправляет запрос контроллеру. [Виджеты](structure-widgets.md) используются в [Видах](structure-views.md) для построения динамических интерфейсов сайта.
+
+
+Жизненный цикл пользовательского запроса <a name="request-lifecycle"></a>
+-----------------
+
+На диаграмме показано как приложение обрабатывает запрос.
+
+![Жизненный цикл запроса](images/application-lifecycle.png)
+
+1. Пользователь обращается к [точке входа](structure-entry-scripts.md) `web/index.php`.
+2. Скрипт загружает конфигурацию [configuration](concept-configurations.md) и создает экземпляр [приложения](structure-applications.md) для дальнейшей обработки запроса.
+3. Приложение определяет [маршрут](runtime-routing.md) запроса при помощи компонента приложения  [запрос](runtime-requests.md).
+4. Приложение создает экземпляр [контроллера](structure-controllers.md) для выполнения запроса.
+5. Контроллер, в свою очередь, создает [действие](structure-controllers.md) и накладывает на него фильтры.
+6. Если хотя бы один фильтр дает сбой выполнение приложения останавливается.
+7. Если все фильтры пройдены - приложение выполняется.
+8. Действие загружает модель данных. Вероятнее всего из базы данных.
+9. Действие генерирует вид, отображая в нем данные (в т.ч. и полученные из модели).
+10. Сгенерированный вид приложения передается как компонент [ответ](runtime-responses.md).
+11. Компонент "ответ" отправляет готовый результат работы приложения браузеру пользователя.
+

docs/guide-ru/structure-application-components.md

+Компоненты приложения
+=====================
+
+Приложения являются [сервис локаторами](concept-service-locators.md). Они хранят множество так называемых
+*компонентов приложения*, которые предоставляют различные средства для обработки запросов. Например, 
+компоненты `urlManager` ответственен за маршрутизацию веб запросов к нужному контроллеру; компонент `db` предоставляет
+средства для работы с базой данных; и т. д.
+
+Каждый компонент приложения имеет свой уникальный ID, который позволяет идентифицировать его среди других различных компонентов
+в одном и том же приложении. Вы можете получить доступ к компоненту следующим образом:
+
+```php
+\Yii::$app->ComponentID
+```
+
+Например, вы можете использовать `\Yii::$app->db` для получения [[yii\db\Connection|соединения с БД]],
+и `\Yii::$app->cache` для получения доступа к основному компоненту [[yii\caching\Cache|кэша]], зарегистрированному в приложении.
+
+Компонентами приложения могут быть любые объекты. Вы можете зарегистрировать их с помощью  
+свойства [[yii\base\Application::components]] в [конфигурации](structure-applications.md#application-configurations) приложения.
+Например,
+
+```php
+[
+    'components' => [
+        // регистрация "cache" компонента с помощью имени класса
+        'cache' => 'yii\caching\ApcCache',
+
+        // регистрация "db" компонента с помощью массива конфигурации
+        'db' => [
+            'class' => 'yii\db\Connection',
+            'dsn' => 'mysql:host=localhost;dbname=demo',
+            'username' => 'root',
+            'password' => '',
+        ],
+
+        // регистрация "search" компонента с помошью анонимной функции
+        'search' => function () {
+            return new app\components\SolrService;
+        },
+    ],
+]
+```
+
+> Информация: Хотя вы можете зарегистрировать столько компонентов в приложении сколько вам нужно, 
+  все таки стоит это делать разумно. Компоненты приложения похожи на глобальные переменные. Использование слишком
+  большого количества компонентов приложения может потенциально сделать ваш код сложным для разработки и тестирования.
+  В большинстве случаев вы можете просто создать локальный компонент и использовать его при необходимости.
+
+
+## Встроенные компоненты приложения <a name="core-application-components"></a>
+
+В Yii есть несколько *встроенных* компонентов приложения, с фиксированными ID и конфигурациями по-умолчанию. Например, 
+компонент [[yii\web\Application::request|request]] используется для сбора информации о запросе пользователя и разбора его в
+определенный [маршрут](runtime-routing.md); компонент [[yii\base\Application::db|db]] представляет собой соединение с базой данных,
+через которое вы можете выполнять запросы. Именно с помощью этих встроенных компонентов Yii приложения могут обработать
+запрос пользователя.
+
+Ниже представлен список встроенных компонентов приложения. Вы можете конфигурировать их также как и другие компоненты приложения.
+Когда вы конфигурируете встроенный компонент приложения и не указываете класс этого компонента, то значение по-умолчанию будет использовано.
+
+* [[yii\web\AssetManager|assetManager]]: используется для управления и опубликования ресурсов приложения. 
+  Более детальная информация представлена в разделе [Ресурсы](output-assets.md);
+* [[yii\db\Connection|db]]: представляет собой соединение с базой данных, через которое вы можете выполнять запросы.
+  Обратите внимание, что когда вы конфигурируете данный компонент, вы должны указать класс компонента также как и остальные
+  необходимые параметры, такие как [[yii\db\Connection::dsn]].
+  Более детальная информация представлена в разделе [Объекты доступа к данным (DAO)](db-dao.md);
+* [[yii\base\Application::errorHandler|errorHandler]]: осуществляет обработку PHP ошибок и исключений.
+  Более детальная информация представлена в разделе [Обработка ошибок](tutorial-handling-errors.md);
+* [[yii\base\Formatter|formatter]]: форматирует данные для отображения их конечному пользователю. Например, число может
+  быть отображено с различными разделителями, дата может быть отображена в формате `long`.
+  Более детальная информация представлена в разделе [Форматирование данных](output-formatting.md);
+* [[yii\i18n\I18N|i18n]]: используется для перевода сообщений и форматирования.
+  Более детальная информация представлена в разделе [Интернационализация](tutorial-i18n.md);
+* [[yii\log\Dispatcher|log]]: обработка и маршрутизация логов.
+  Более детальная информация представлена в разделе [Логирование](tutorial-logging.md);
+* [[yii\swiftmailer\Mailer|mail]]: предоставляет возможности для составления и рассылки писем.
+  Более детальная информация представлена в разделе [Отправка почты](tutorial-mailing.md);
+* [[yii\base\Application::response|response]]: представляет собой данные от сервера, которые будет направлены пользователю.
+  Более детальная информация представлена в разделе [Ответы](runtime-responses.md);
+* [[yii\base\Application::request|request]]: представляет собой запрос, полученный от конечных пользователей.
+  Более детальная информация представлена в разделе [Запросы](runtime-requests.md);
+* [[yii\web\Session|session]]: информация о сессии. Данный компонент доступен только в [[yii\web\Application|веб приложениях]].
+  Более детальная информация представлена в разделе [Сессии и куки](runtime-sessions-cookies.md);
+* [[yii\web\UrlManager|urlManager]]: используется для разбора и создания URL.
+  Более детальная информация представлена в разделе [Разбор и генерация URL](runtime-url-handling.md);
+* [[yii\web\User|user]]: представляет собой информацию аутентифицированного пользователя. 
+  Данный компонент доступен только в [[yii\web\Application|веб приложениях]].
+  Более детальная информация представлена в разделе [Аутентификация](security-authentication.md);
+* [[yii\web\View|view]]: используется для отображения представлений.
+  Более детальная информация представлена в разделе [Представления](structure-views.md).

docs/guide-ru/structure-entry-scripts.md

+Входные скрипты
+===============
+
+Входные скрипты это первое звено в процессе начальной загрузки приложения. Приложение (веб приложение или консольное приложение)
+включает единый входной скрипт. Конечные пользователи делают запросы к входному скрипту,
+который создает объекты приложения и перенаправляет запрос к ним.
+
+Входные скрипты для веб приложений должны быть сохранены в папках, доступных из веб, таким образом они могут быть
+доступны конечным пользователям. Такие скрипты обычно именуются `index.php`, но так же могут использовать другие имена,
+которые могут быть распознаны используемыми веб-серверами.
+
+Входные скрипты для консольных приложений обычно расположены в [базовой папке](structure-applications.md) приложений и имеют название 
+`yii` (с суффиксом `.php`). Они должны иметь права на выполнение, таким образом пользователи смогут запускать консольные приложения 
+через команду `./yii <маршрут> [аргументы] [опции]`.
+
+Входные скрипты в основном делают следующую работу:
+
+* Объявляют глобальные константы;
+* Регистрируют загрузчик классов [Composer](http://getcomposer.org/doc/01-basic-usage.md#autoloading);
+* Подключают файл класса [[Yii]];
+* Загружают конфигурацию приложения;
+* Создают и конфигурируют объект [приложения](structure-applications.md);
+* Вызывают метод [[yii\base\Application::run()]] приложения для обработки входящего запроса.
+
+
+## Веб приложения <a name="web-applications"></a>
+
+Ниже представлен код входного скрипта для [базового шаблона приложения](start-installation.md).
+
+```php
+<?php
+
+defined('YII_DEBUG') or define('YII_DEBUG', true);
+defined('YII_ENV') or define('YII_ENV', 'dev');
+
+// регистрация загрузчика классов Composer
+require(__DIR__ . '/../vendor/autoload.php');
+
+// подключение файла класса Yii
+require(__DIR__ . '/../vendor/yiisoft/yii2/Yii.php');
+
+// загрузка конфигурации приложения
+$config = require(__DIR__ . '/../config/web.php');
+
+// создание и конфигурация приложения, а также вызов метода для обработки входящего запроса
+(new yii\web\Application($config))->run();
+```
+
+
+## Консольные приложения <a name="console-applications"></a>
+
+Ниже представлен аналогичный код входного скрипта консольного приложения:
+
+```php
+#!/usr/bin/env php
+<?php
+/**
+ * Yii console bootstrap file.
+ *
+ * @link http://www.yiiframework.com/
+ * @copyright Copyright (c) 2008 Yii Software LLC
+ * @license http://www.yiiframework.com/license/
+ */
+
+defined('YII_DEBUG') or define('YII_DEBUG', true);
+
+// fcgi не имеет констант STDIN и STDOUT, они определяются по умолчанию
+defined('STDIN') or define('STDIN', fopen('php://stdin', 'r'));
+defined('STDOUT') or define('STDOUT', fopen('php://stdout', 'w'));
+
+// регистрация загрузчика классов Composer
+require(__DIR__ . '/vendor/autoload.php');
+
+// подключение файла класса Yii
+require(__DIR__ . '/vendor/yiisoft/yii2/Yii.php');
+
+// загрузка конфигурации приложения
+$config = require(__DIR__ . '/config/console.php');
+
+$application = new yii\console\Application($config);
+$exitCode = $application->run();
+exit($exitCode);
+```
+
+
+## Объявление констант <a name="defining-constants"></a>
+
+Входные скрипты являются наилучшим местом для объявления глобальных констант. Yii поддерживают следующие три константы:
+
+* `YII_DEBUG`: указывает работает ли приложение в отладочном режиме. Находясь в отладочном режиме, приложение будет собирать
+  больше информации в логи и покажет детальный стек вызовов если возникнет исключение. По этой причине, отладочный режим должен
+  быть использован только в процессе разработки. По-умолчанию значение `YII_DEBUG` равно false;
+* `YII_ENV`: указывает в каком окружении запущено приложение. Данная тема подробно описана в разделе [Конфигурации](concept-configurations.md#environment-constants).
+  По-умолчанию значение `YII_ENV` равно `'prod'`, означающие, что приложение запущено в производственном режиме;
+* `YII_ENABLE_ERROR_HANDLER`: указывает нужно ли включать имеющийся в Yii обработчик ошибок. По-умолчанию значение данной константы
+  равно true.
+
+При определении константы, мы обычно используем следующий код:
+
+```php
+defined('YII_DEBUG') or define('YII_DEBUG', true);
+```
+
+который равнозначен коду, приведенному ниже:
+
+```php
+if (!defined('YII_DEBUG')) {
+    define('YII_DEBUG', true);
+}
+```
+
+Первый способ является более кратким и понятным.
+
+Константы должны быть определены как можно раньше, в самом начале входного скрипта, таким образом они могут оказать влияние,
+когда остальные PHP файлы будут подключены.

docs/guide-ru/structure-overview.md

+Обзор
+=====
+
+Yii приложения организованы согласно шаблону проектирования [модель-представление-поведение (MVC)](http://ru.wikipedia.org/wiki/Model-View-Controller).
+[Модели](structure-models.md) представляют собой данные, бизнес логику и бизнес правила; [представления](structure-views.md)
+отвечают за отображение информации, в том числе и на основе данных, полученных из моделей; [контроллеры](structure-controllers.md) 
+принимают входные данные от пользователя и преобразовывают их в понятный для [моделей](structure-models.md) формат и команды, а также отвечают за отображение 
+нужного представления.
+
+Кроме MVC, Yii приложения также имеют следующие сущности:
+
+* [входные скрипты](structure-entry-scripts.md): это PHP скрипты, которые доступны напрямую конечному пользователю приложения.
+  Они отвественны за запуск и обработку входящего запроса;
+* [приложения](structure-applications.md): это глобально доступные объекты, которые осуществляют корректную работу различных 
+  компонентов приложения и их координацию для обработки запроса;
+* [компоненты приложения](structure-application-components.md): это объекты, зарегистрированные в приложении и предоставляющие
+  различные возможности для обработки текущего запроса;
+* [модули](structure-modules.md): это самодостаточные пакеты, которые включают в себя полностью все средства для MVC.
+  Приложение может быть организованно с помощью нескольких модулей;
+* [фильтры](structure-filters.md): это код, который должен быть выполнен до и после обработки запроса контроллерами;
+* [виджеты](structure-widgets.md): это объекты, которые могут включать в себя [представления](structure-views.md).
+  Они могут содержать различную логику и быть использованы в различных представлениях.
+
+Ниже на диаграмме представлена структурная схема приложения:
+
+![Static Structure of Application](images/application-structure.png)
\ No newline at end of file

docs/guide/input-validation.md

@@ -342,11 +342,11 @@ by calling `validateValue()`.
 
 ### Handling Empty Inputs <a name="handling-empty-inputs"></a>
 
-Validators often need to check if an input is empty or not. You may call [[yii\validators\Validator::isEmpty()]]
+Validators often need to check if an input is empty or not. In your validator, you may call [[yii\validators\Validator::isEmpty()]]
 to perform this check. By default, this method will return true if a value is an empty string, an empty array or null.
 
 Users of validators can customize the default empty detection logic by configuring
-the [[yii\validators\Validator::isEmpty]] property. For example,
+the [[yii\validators\Validator::isEmpty]] property with a PHP callable. For example,
 
 ```php
 [
@@ -356,6 +356,16 @@ the [[yii\validators\Validator::isEmpty]] property. For example,
 ]
 ```
 
+When input data are submitted from HTML forms, you often need to assign some default values to the inputs
+if they are empty. You can do so by using the [default](tutorial-core-validators.md#default) validator. For example,
+
+```php
+[
+    // set "level" to be 1 if it is empty
+    ['level', 'default', 'value' => 1],
+]
+```
+
 
 ## Client-Side Validation <a name="client-side-validation"></a>
 

docs/guide/intro-upgrade-from-v1.md

@@ -158,7 +158,7 @@ Views
 The most significant change about views in Yii 2 is that the special variable `$this` in a view no longer refers to
 the current controller or widget. Instead, `$this` now refers to a *view* object, a new concept
 introduced in 2.0. The *view* object is of type [[yii\web\View]], which represents the view part
-of the MVC pattern. In you want to access the controller or widget in a view, you can use `$this->context`.
+of the MVC pattern. If you want to access the controller or widget in a view, you can use `$this->context`.
 
 To render a partial view within another view, you use `$this->render()`, not `$this->renderPartial()`. The call to `render` also now has to be explicitly echoed, as the `render()` method returns the rendering
 result, rather than directly displaying it. For example:

docs/guide/start-installation.md

@@ -25,7 +25,7 @@ With Composer installed, you can install Yii by running the following command un
 
     composer create-project --prefer-dist yiisoft/yii2-app-basic basic
 
-The above command installs Yii as a directory named `basic`.
+The above command installs Yii in a directory named `basic`.
 
 > Tip: If you want to install the latest development version of Yii, you may use the following command,
 > which adds a [stability option](https://getcomposer.org/doc/04-schema.md#minimum-stability):
@@ -68,7 +68,7 @@ http://localhost/basic/web/index.php
 ```
 
 This URL assumes you have installed Yii in a directory named `basic`, directly under the Web server's document root directory,
-and that the Web server is running on your local machine(`localhost`), you may have to adjust it to your installation environment.
+and that the Web server is running on your local machine (`localhost`). You may need to adjust it to your installation environment.
 
 ![Successful Installation of Yii](images/start-app-installed.png)
 
@@ -108,7 +108,7 @@ In this subsection, you'll learn how to configure your Apache or Nginx server to
 your private application code and sensitive data files that are stored in the sibling directories
 of `basic/web`. Denying access to those other folders is a producent security improvement.
 
-> Info: If your application will run in a shared hosting environment where you do not have  permission
+> Info: If your application will run in a shared hosting environment where you do not have permission
 to modify its Web server configuration, you may still adjust the structure of your application for better security. Please refer to
 the [Shared Hosting Environment](tutorial-shared-hosting.md) section for more details.
 
@@ -138,7 +138,7 @@ DocumentRoot "path/to/basic/web"
 
 ### Recommended Nginx Configuration <a name="recommended-nginx-configuration"></a>
 
-You should have installed PHP as an [FPM SAPI](http://php.net/install.fpm) to use  [Nginx](http://wiki.nginx.org/).
+You should have installed PHP as an [FPM SAPI](http://php.net/install.fpm) to use [Nginx](http://wiki.nginx.org/).
 Use the following Nginx configuration, replacing `path/to/basic/web` with the actual path for `basic/web` and `mysite.local` with
 the actual hostname to serve.
 

docs/guide/structure-entry-scripts.md

@@ -71,7 +71,7 @@ defined('STDOUT') or define('STDOUT', fopen('php://stdout', 'w'));
 // register Composer autoloader
 require(__DIR__ . '/vendor/autoload.php');
 
-// load application configuration
+// include Yii class file
 require(__DIR__ . '/vendor/yiisoft/yii2/Yii.php');
 
 // load application configuration

docs/internals/translation-teams.md

@@ -11,10 +11,15 @@ German
 ------
 
 - Carsten Brandt, [@cebe](https://github.com/cebe), mail@cebe.cc
- 
+
 Russian
 -------
 
 - **Alexander Makarov, [@samdark](https://github.com/samdark), sam@rmcreative.ru**
 - [@MUTOgen](https://github.com/MUTOgen)
 - [@prozacUa](https://github.com/prozacUa)
+
+Spanish
+-------
+
+- [@lucianobaraglia](https://github.com/lucianobaraglia)

extensions/debug/views/default/view.php

@@ -65,6 +65,7 @@ $this->title = 'Yii Debugger';
                         echo ButtonGroup::widget([
                             'buttons' => [
                                 Html::a('All', ['index'], ['class' => 'btn btn-default']),
+                                Html::a('Latest', ['view', 'panel' => $activePanel->id], ['class' => 'btn btn-default']),
                                 ButtonDropdown::widget([
                                     'label' => 'Last 10',
                                     'options' => ['class' => 'btn-default'],

extensions/sphinx/Schema.php

@@ -453,8 +453,9 @@ class Schema extends Object
             $columns = $this->db->createCommand($sql)->queryAll();
         } catch (\Exception $e) {
             $previous = $e->getPrevious();
-            if ($previous instanceof \PDOException && $previous->getCode() == '42S02') {
+            if ($previous instanceof \PDOException && strpos($previous->getMessage(), 'SQLSTATE[42S02') !== false) {
                 // index does not exist
+                // https://dev.mysql.com/doc/refman/5.5/en/error-messages-server.html#error_er_bad_table_error
                 return false;
             }
             throw $e;

framework/CHANGELOG.md

@@ -44,6 +44,7 @@ Yii Framework 2 Change Log
 - Bug #3751: Fixed postgreSQL schema data for enum values, do not add values if there are none (makroxyz)
 - Bug #3752: `QueryBuilder::batchInsert()` does not typecast input values (qiangxue)
 - Bug #3756: Fix number formatting error for `\yii\base\Formatter` by converting strings to float (kartik-v)
+- Bug #3817: `yii\rbac\PhpManager::getChildren()` returns null instead of expected empty array (qiangxue)
 - Bug: Fixed inconsistent return of `\yii\console\Application::runAction()` (samdark)
 - Bug: URL encoding for the route parameter added to `\yii\web\UrlManager` (klimov-paul)
 - Bug: Fixed the bug that requesting protected or private action methods would cause 500 error instead of 404 (qiangxue)
@@ -81,6 +82,7 @@ Yii Framework 2 Change Log
 - Enh #3631: Added property `currencyCode` to `yii\i18n\Formatter` (leandrogehlen)
 - Enh #3636: Hide menu container tag with empty items in `yii\widgets\Menu` (arturf)
 - Enh #3643: Improved Mime-Type detection by using the `mime.types` file from apache http project to dected mime types by file extension (cebe, pavel-voronin, trejder)
+- Enh #3773: Added `FileValidator::mimeTypes` to support validating MIME types of files (Ragazzo)
 - Enh: Added support for using sub-queries when building a DB query with `IN` condition (qiangxue)
 - Enh: Supported adding a new response formatter without the need to reconfigure existing formatters (qiangxue)
 - Enh: Added `yii\web\UrlManager::addRules()` to simplify adding new URL rules (qiangxue)
@@ -103,6 +105,7 @@ Yii Framework 2 Change Log
 - Chg #3544: Added `$key` as a parameter to the callable specified via `yii\grid\DataColumn::value` (mdmunir)
 - Chg #3640: All cookies are now httpOnly by default in order to increase overall security (samdark)
 - Chg #3687: Default `sourceLanguage` and `language` are now `en-US` in order for i18n formatter to work correctly (samdark)
+- Chg #3804: Added `fileinfo` PHP extension to the basic requirement of Yii (Ragazzo)
 - Chg: Replaced `clearAll()` and `clearAllAssignments()` in `yii\rbac\ManagerInterface` with `removeAll()`, `removeAllRoles()`, `removeAllPermissions()`, `removeAllRules()` and `removeAllAssignments()` (qiangxue)
 - Chg: Added `$user` as the first parameter of `yii\rbac\Rule::execute()` (qiangxue)
 - Chg: `yii\grid\DataColumn::getDataCellValue()` visibility is now `public` to allow accessing the value from a GridView directly (cebe)

framework/db/mysql/Schema.php

@@ -188,8 +188,9 @@ class Schema extends \yii\db\Schema
             $columns = $this->db->createCommand($sql)->queryAll();
         } catch (\Exception $e) {
             $previous = $e->getPrevious();
-            if ($previous instanceof \PDOException && $previous->getCode() == '42S02') {
+            if ($previous instanceof \PDOException && strpos($previous->getMessage(), 'SQLSTATE[42S02') !== false) {
                 // table does not exist
+                // https://dev.mysql.com/doc/refman/5.5/en/error-messages-server.html#error_er_bad_table_error
                 return false;
             }
             throw $e;

framework/rbac/PhpManager.php

@@ -410,7 +410,7 @@ class PhpManager extends BaseManager
      */
     public function getChildren($name)
     {
-        return (isset($this->_children[$name])) ? $this->_children[$name] : null;
+        return isset($this->_children[$name]) ? $this->_children[$name] : [];
     }
 
     /**

tests/unit/data/travis/init-apps.sh

+#!/bin/sh
+
+if (php --version | grep -i HHVM > /dev/null); then
+  echo "skipping application init on HHVM"
+else
+
+    mysql -e 'CREATE DATABASE yii2_advanced_acceptance;';
+    mysql -e 'CREATE DATABASE yii2_advanced_functional;';
+    mysql -e 'CREATE DATABASE yii2_advanced_unit;';
+    cd apps/advanced/frontend/tests/acceptance && php yii migrate --interactive=0
+    cd ../functional && php yii migrate --interactive=0
+    cd ../unit && php yii migrate --interactive=0 && cd ../../../../..
+
+fi

tests/unit/data/travis/memcache-setup.sh

@@ -3,6 +3,7 @@
 if (php --version | grep -i HHVM > /dev/null); then
   echo "skipping memcache on HHVM"
 else
+  mkdir -p ~/.phpenv/versions/$(phpenv version-name)/etc
   echo "extension=memcache.so" >> ~/.phpenv/versions/$(phpenv version-name)/etc/php.ini
   echo "extension=memcached.so" >> ~/.phpenv/versions/$(phpenv version-name)/etc/php.ini
 fi

tests/unit/data/travis/setup-apps.sh

+#!/bin/sh
+
+if (php --version | grep -i HHVM > /dev/null); then
+  echo "skipping application setup on HHVM"
+else
+
+    # basic application:
+
+    composer install --dev --prefer-dist -d apps/basic
+    cd apps/basic && composer require --dev codeception/codeception:1.8.*@dev codeception/specify:* codeception/verify:*
+    php vendor/bin/codecept build && cd ../..
+
+
+    # advanced application:
+
+    composer install --dev --prefer-dist -d apps/advanced
+    cd apps/advanced && composer require --dev codeception/codeception:1.8.*@dev codeception/specify:* codeception/verify:*
+    ./init --env=Development
+    sed -i s/root/travis/ common/config/main-local.php
+    cd backend && php ../vendor/bin/codecept build
+    cd ../common && php ../vendor/bin/codecept build
+    cd ../frontend && php ../vendor/bin/codecept build && cd ../../..
+
+    # boot server
+    cd apps && php -S localhost:8080 > /dev/null 2>&1 &
+
+fi

tests/unit/extensions/imagine/ImageImagickTest.php

@@ -15,6 +15,8 @@ class ImageImagickTest extends AbstractImageTest
     {
         if (!class_exists('Imagick')) {
             $this->markTestSkipped('Skipping ImageImagickTest, Imagick is not installed');
+        } elseif (defined('HHVM_VERSION')) {
+            $this->markTestSkipped('Imagine does not seem to support HHVM right now.');
         } else {
             Image::setImagine(null);
             Image::$driver = Image::DRIVER_IMAGICK;

tests/unit/framework/rbac/ManagerTestCase.php

@@ -45,6 +45,18 @@ abstract class ManagerTestCase extends TestCase
 
         // todo: check duplication of name
     }
+
+    public function testGetChildren()
+    {
+        $user = $this->auth->createRole('user');
+        $this->auth->add($user);
+        $this->assertCount(0, $this->auth->getChildren($user->name));
+
+        $changeName = $this->auth->createPermission('changeName');
+        $this->auth->add($changeName);
+        $this->auth->addChild($user, $changeName);
+        $this->assertCount(1, $this->auth->getChildren($user->name));
+    }
 /*
     public function testRemove()
     {

tests/unit/framework/rbac/PhpManagerTestCase.php → tests/unit/framework/rbac/PhpManagerTest.php

@@ -9,7 +9,7 @@ use yii\rbac\PhpManager;
  * @group rbac
  * @property \yii\rbac\PhpManager $auth
  */
-class PhpManagerTestCase extends ManagerTestCase
+class PhpManagerTest extends ManagerTestCase
 {
     protected function setUp()
     {
@@ -32,7 +32,7 @@ class PhpManagerTestCase extends ManagerTestCase
     {
         $this->prepareData();
         $this->auth->save();
-        $this->auth->clearAll();
+        $this->auth->removeAll();
         $this->auth->load();
         // TODO : Check if loaded and saved data are the same.
     }