You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
440 lines
24 KiB
440 lines
24 KiB
10 years ago
|
Extensiones
|
||
|
===========
|
||
|
|
||
|
Las extensiones son paquetes de software redistribuibles diseñados especialmente para ser usados en aplicaciones Yii y
|
||
|
proporcionar características listas para ser usadas. Por ejemplo, la extensión [yiisoft/yii2-debug](tool-debugger.md)
|
||
|
añade una practica barra de herramientas de depuración (debug toolbar) al final de cada página de la aplicación para
|
||
|
ayudar a comprender más fácilmente como se han generado las páginas. Se pueden usar extensiones para acelerar el
|
||
|
proceso de desarrollo. También se puede empaquetar código propio para compartir nuestro trabajo con otra gente.
|
||
|
|
||
|
> Información: Usamos el termino "extensión" para referirnos a los paquetes específicos de software Yii. Para
|
||
|
propósitos generales los paquetes de software pueden usarse sin Yii, nos referiremos a ellos usando los términos
|
||
|
"paquetes" (package) o "librerías" (library).
|
||
|
|
||
|
## Uso de Extensiones <a name="using-extensions"></a>
|
||
|
|
||
|
Para usar una extension, primero tenemos que instalarla. La mayoría de extensiones se usan como paquetes
|
||
|
[Composer](https://getcomposer.org/) que se pueden instalar mediante los dos simples siguientes pasos:
|
||
|
|
||
|
1. modificar el archivo `composer.json` de la aplicación y especificar que extensiones (paquetes Composer) se quieren
|
||
|
instalar.
|
||
|
2. ejecutar `composer install` para instalar las extensiones especificadas.
|
||
|
|
||
|
Hay que tener en cuenta que es necesaria la instalación de [Composer](https://getcomposer.org/) si no la tenemos
|
||
|
instalada.
|
||
|
|
||
|
De forma predeterminada, Composer instala los paquetes registrados en [Packagist](https://packagist.org/) que es el
|
||
|
repositorio más grande de paquetes Composer de código abierto (open source). Se pueden buscar extensiones en
|
||
|
Packagist. También se puede crear un [repositorio propio](https://getcomposer.org/doc/05-repositories.md#repository) y
|
||
|
configurar Composer para que lo use. Esto es práctico cuando se desarrollan extensiones privadas que se quieran
|
||
|
compartir a través de otros proyectos.
|
||
|
|
||
|
Las extensiones instaladas por Composer se almacenan en el directorio `BasePath/vendor`, donde `BasePath` hace
|
||
|
referencia a la [ruta base (base path)](structure-applications.md#basePath) de la aplicación. Ya que Composer es un
|
||
|
gestor de dependencias, cuando se instala un paquete, también se instalarán todos los paquetes de los que dependa.
|
||
|
|
||
|
Por ejemplo, para instalar la extensión `yiisoft/yii2-imagine`, modificamos el archivo `composer.json` como se muestra
|
||
|
a continuación:
|
||
|
|
||
|
```json
|
||
|
{
|
||
|
// ...
|
||
|
|
||
|
"require": {
|
||
|
// ... otras dependencias
|
||
|
|
||
|
"yiisoft/yii2-imagine": "*"
|
||
|
}
|
||
|
}
|
||
|
```
|
||
|
|
||
|
Después de la instalación, debemos encontrar el directorio `yiisoft/yii2-imagine` dentro del directorio
|
||
|
`BasePath/vendor`. También debemos encontrar el directorio `imagine/imagine` que contiene sus paquetes dependientes
|
||
|
instalados.
|
||
|
|
||
|
> Información: La extensión `yiisoft/yii2-imagine` es una extensión del núcleo (core) desarrollada y mantenida por el
|
||
|
equipo de desarrollo de Yii. Todas las extensiones del núcleo se hospedan en [Packagist](https://packagist.org/) y
|
||
|
son nombradas como `yiisoft/yii2-xyz`, donde `zyz` varia según la extensión.
|
||
|
|
||
|
Ahora ya podemos usar las extensiones instaladas como si fueran parte de nuestra aplicación. El siguiente ejemplo
|
||
|
muestra como se puede usar la clase `yii\imagine\Image` proporcionada por la extensión `yiisoft/yii2-imagine`:
|
||
|
|
||
|
```php
|
||
|
use Yii;
|
||
|
use yii\imagine\Image;
|
||
|
|
||
|
// genera una miniatura (thumbnail) de la imagen
|
||
|
Image::thumbnail('@webroot/img/test-image.jpg', 120, 120)
|
||
|
->save(Yii::getAlias('@runtime/thumb-test-image.jpg'), ['quality' => 50]);
|
||
|
```
|
||
|
|
||
|
> Información: Las clases de extensiones se cargan automáticamente gracias a
|
||
|
[autocarga de clases de Yii](concept-autoloading.md).
|
||
|
|
||
|
### Instalación Manual de Extensiones <a name="installing-extensions-manually"></a>
|
||
|
|
||
|
En algunas ocasiones excepcionales es posible que tengamos que instalar alguna o todas las extensiones manualmente, en lugar de utilizar Composer. Para lograrlo, debemos:
|
||
|
|
||
|
|
||
|
1. descargar los archivos de la extensión y descomprimirlos en la carpeta `vendor`.
|
||
|
2. instalar la clase de autocarga proporcionada por las extensiones, si existe.
|
||
|
3. descargar e instalar todas las extensiones dependientes como siguiendo estas mismas instrucciones.
|
||
|
|
||
|
Si una extensión no proporciona clase de autocarga pero sigue el estándar
|
||
|
[PSR-4](http://www.php-fig.org/psr/psr-4/), se puede usar la clase de autocarga proporcionada por Yii para cargar
|
||
|
automáticamente las clases de las extensiones. Todo lo que se tiene que hacer es declarar un
|
||
|
[alias de raíz (root)](concept-aliases.md#defining-aliases) para las extensiones del directorio raíz. Por ejemplo,
|
||
|
asumiendo que tenemos instalada una extensión en el directorio `vendor/mycompany/myext`, y las clases de extensión se
|
||
|
encuentran en el namespace `myext`, entonces podemos incluir el siguiente código en nuestra configuración de
|
||
|
aplicación:
|
||
|
|
||
|
```php
|
||
|
[
|
||
|
'aliases' => [
|
||
|
'@myext' => '@vendor/mycompany/myext',
|
||
|
],
|
||
|
]
|
||
|
```
|
||
|
|
||
|
## Creación de Extensiones <a name="creating-extensions"></a>
|
||
|
|
||
|
Podemos considerar la creación de una extensión cuando tengamos la necesidad de compartir nuestro código. Cada
|
||
|
extensión puede contener el código que se desee, puede ser una clase de ayuda (helper class), un widget, un módulo,
|
||
|
etc.
|
||
|
|
||
|
Se recomienda crear una extensión como [paquetes de Composer](https://getcomposer.org/) para que sea se pueda
|
||
|
instalarse más fácilmente por los otros usuarios, como se ha descrito en la anterior subsección.
|
||
|
|
||
|
Más adelante se encuentran los pasos básicos que deben seguirse para crear una extensión como paquete Composer.
|
||
|
|
||
|
1. Crear un proyecto para la extensión y alojarlo en un repositorio con VCS (Sistema de Control de Versiones), como
|
||
|
puede ser [github.com](https://github.com). El trabajo de desarrollo y el mantenimiento debe efectuarse en este
|
||
|
repositorio.
|
||
|
2. En el directorio raíz del repositorio debe encontrarse el archivo `composer.json` que es requerido por Composer. Se
|
||
|
pueden encontrar más detalles en la siguiente subsección.
|
||
|
3. Registrar la extensión en un repositorio de Composer como puede ser [Packagist](https://packagist.org/), para que
|
||
|
los otros usuarios puedan encontrarlo e instalarla mediante Composer.
|
||
|
|
||
|
### `composer.json` <a name="composer-json"></a>
|
||
|
|
||
|
Cada paquete de Composer tiene que tener un archivo `composer.json` en su directorio raíz. El archivo contiene los
|
||
|
metadatos relacionados con el paquete. Se pueden encontrar especificaciones completas acerca de este fichero en el
|
||
|
[Manual de Composer](https://getcomposer.org/doc/01-basic-usage.md#composer-json-project-setup). El siguiente ejemplo
|
||
|
muestra el archivo `composer.json` para la extensión `yiisoft/yii2-imagine`:
|
||
|
|
||
|
```json
|
||
|
{
|
||
|
// nombre del paquete
|
||
|
"name": "yiisoft/yii2-imagine",
|
||
|
|
||
|
// tipo de paquete
|
||
|
"type": "yii2-extension",
|
||
|
|
||
|
"description": "The Imagine integration for the Yii framework",
|
||
|
"keywords": ["yii2", "imagine", "image", "helper"],
|
||
|
"license": "BSD-3-Clause",
|
||
|
"support": {
|
||
|
"issues": "https://github.com/yiisoft/yii2/issues?labels=ext%3Aimagine",
|
||
|
"forum": "http://www.yiiframework.com/forum/",
|
||
|
"wiki": "http://www.yiiframework.com/wiki/",
|
||
|
"irc": "irc://irc.freenode.net/yii",
|
||
|
"source": "https://github.com/yiisoft/yii2"
|
||
|
},
|
||
|
"authors": [
|
||
|
{
|
||
|
"name": "Antonio Ramirez",
|
||
|
"email": "amigo.cobos@gmail.com"
|
||
|
}
|
||
|
],
|
||
|
|
||
|
// dependencias del paquete
|
||
|
"require": {
|
||
|
"yiisoft/yii2": "*",
|
||
|
"imagine/imagine": "v0.5.0"
|
||
|
},
|
||
|
|
||
|
// especificaciones de la autocarga de clases
|
||
|
"autoload": {
|
||
|
"psr-4": {
|
||
|
"yii\\imagine\\": ""
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
```
|
||
|
|
||
|
#### Nombre del Paquete<a name="package-name"></a>
|
||
|
|
||
|
Cada paquete Composer debe tener un nombre de paquete que identifique de entre todos los otros paquetes. El formato
|
||
|
del nombre del paquete es `nombreProveedor/nombreProyecto`. Por ejemplo, el nombre de paquete `yiisoft/yii2-imagine`,
|
||
|
el nombre del proveedor es `yiisoft` y el nombre del proyecto es `yii2-imagine`.
|
||
|
|
||
|
NO se puede usar el nombre de proveedor `yiisoft` ya que está reservado para el usarse para el código del núcleo
|
||
|
(core) de Yii.
|
||
|
|
||
|
Recomendamos usar el prefijo `yii2-` al nombre del proyecto para paquetes que representen extensiones de Yii 2, por
|
||
|
ejemplo, `minombre/yii2-miwidget`. Esto permite ver a los usuarios más fácilmente si un paquete es una extensión de
|
||
|
Yii 2.
|
||
|
|
||
|
#### Tipo de Paquete <a name="package-type"></a>
|
||
|
|
||
|
Es importante que se especifique el tipo del paquete de la extensión como `yii2-extension` para que el paquete pueda
|
||
|
ser reconocido como una extensión de Yii cuando se esté instalando.
|
||
|
|
||
|
Cuando un usuario ejecuta `composer install` para instalar una extensión, el archivo `vendor/yiisoft/extensions.php`
|
||
|
se actualizará automáticamente para incluir la información acerca de la nueva extensión. Desde este archivo, las
|
||
|
aplicaciones Yii pueden saber que extensiones están instaladas. (se puede acceder a esta información mediante
|
||
|
[[yii\base\Application::extensions]]).
|
||
|
|
||
|
#### Dependencias <a name="dependencies"></a>
|
||
|
|
||
|
La extensión depende de Yii (por supuesto). Por ello se debe añadir (`yiisoft/yii2`) a la lista en la entrada
|
||
|
`required` del archivo `composer.json`. Si la extensión también depende de otras extensiones o de terceras
|
||
|
(third-party) librerías, también se deberán listar. Debemos asegurarnos de anotar las restricciones de versión
|
||
|
apropiadas (p. ej. `1.*`, `@stable`) para cada paquete dependiente. Se deben usar dependencias estables en versiones
|
||
|
estables de nuestras extensiones.
|
||
|
|
||
|
La mayoría de paquetes JavaScript/CSS se gestionan usando [Bower](http://bower.io/) y/o [NPM](https://www.npmjs.org/),
|
||
|
en lugar de Composer. Yii utiliza el [Composer asset plugin](https://github.com/francoispluchino/composer-asset-plugin)
|
||
|
para habilitar la gestión de estos tipos de paquetes a través de Composer. Si la extensión depende de un paquete
|
||
|
Bower, se puede, simplemente, añadir la dependencia de el archivo `composer.json` como se muestra a continuación:
|
||
|
|
||
|
```json
|
||
|
{
|
||
|
// dependencias del paquete
|
||
|
"require": {
|
||
|
"bower-asset/jquery": ">=1.11.*"
|
||
|
}
|
||
|
}
|
||
|
```
|
||
|
|
||
|
El código anterior declara que tela extensión depende del paquete Bower `jquery`. En general, se puede usar
|
||
|
`bower-asset/NombrePaquete` para referirse al paquete en `composer.json`, y usar `npm-asset/NombrePaquete` para
|
||
|
referirse a paquetes NPM. Cuando Composer instala un paquete Bower o NPM, de forma predeterminada los contenidos de
|
||
|
los paquetes se instalarán en `@vendor/bower/NombrePaquete` y `@vendor/npm/Packages` respectivamente. Podemos hacer
|
||
|
referencia a estos dos directorios usando los alias `@bower/NombrePaquete` and `@npm/NombrePaquete`.
|
||
|
|
||
|
Para obtener más detalles acerca de la gestión de assets, puede hacerse referencia a la sección
|
||
|
[Assets](structure-assets.md#bower-npm-assets).
|
||
|
|
||
|
#### Autocarga de Clases <a name="class-autoloading"></a>
|
||
|
|
||
|
Para que se aplique la autocarga a clases propias mediante la autocarga de clases de Yii o la autocarga de clases de
|
||
|
Composer, debemos especificar la entrada `autoload` en el archivo `composer.json` como se puede ver a continuación:
|
||
|
|
||
|
```json
|
||
|
{
|
||
|
// ....
|
||
|
|
||
|
"autoload": {
|
||
|
"psr-4": {
|
||
|
"yii\\imagine\\": ""
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
```
|
||
|
|
||
|
Se pueden añadir una o más namespaces raíz y sus correspondientes rutas de archivo.
|
||
|
|
||
|
Cuando se instala la extensión en una aplicación, Yii creara un [alias](concept-aliases.md#extension-aliases) para
|
||
|
todos los namespaces raíz, que harán referencia al directorio correspondiente del namespace. Por ejemplo, la anterior
|
||
|
declaración `autoload` corresponderá a un alias llamado `@yii/imagine`.
|
||
|
|
||
|
### Prácticas Recomendadas <a name="recommended-practices"></a>
|
||
|
|
||
|
Dado que las extensiones están destinadas a ser utilizadas por otras personas, a menudo es necesario hacer un esfuerzo
|
||
|
extra durante el desarrollo. A continuación presentaremos algunas practicas comunes y recomendadas para la creación de
|
||
|
extensiones de alta calidad.
|
||
|
|
||
|
#### Namespaces <a name="namespaces"></a>
|
||
|
|
||
|
Para evitar colisiones de nombres y permitir que las clases usen la autocarga en extensiones propias, se deben usar
|
||
|
namespaces y nombres de clase siguiendo el [estándar PSR-4](http://www.php-fig.org/psr/psr-4/) o el
|
||
|
[estándar PSR-0](http://www.php-fig.org/psr/psr-0/).
|
||
|
|
||
|
Los namespaces de clases propias deben empezar por `NombreProveedor\NombreExtension` donde `NombreExtension` es
|
||
|
similar al nombre del paquete pero este no debe contener el prefijo `yii2-`. Por ejemplo, para la extensión
|
||
|
`yiisoft/yii2-imagine`, usamos `yii\imagine` como namespace para sus clases.
|
||
|
|
||
|
No se puede usar `yii`, `yii2` o `yiisoft` como nombre de proveedor. Estos nombres están reservados para usarse en el
|
||
|
código del núcleo de Yii.
|
||
|
|
||
|
#### Clases de Bootstrapping <a name="bootstrapping-classes"></a>
|
||
|
|
||
|
A veces, se puede querer que nuestras extensiones ejecuten algo de código durante el
|
||
|
[proceso de bootstrapping](runtime-bootstrapping.md) de una aplicación. Por ejemplo, queremos que nuestra extensión
|
||
|
responda a un evento `beginRequest` de la aplicación para ajustar alguna configuración de entorno. Aunque podemos
|
||
|
indicar a los usuarios de la extensión que añadan nuestro gestor de eventos para que capture `beginRequest`, es mejor
|
||
|
hacerlo automáticamente.
|
||
|
|
||
|
Para llevarlo a cabo, podemos crear una *clase de bootstrpping* para implementar [[yii\base\BootstrapInterface]]. Por
|
||
|
ejemplo,
|
||
|
|
||
|
```php
|
||
|
namespace myname\mywidget;
|
||
|
|
||
|
use yii\base\BootstrapInterface;
|
||
|
use yii\base\Application;
|
||
|
|
||
|
class MyBootstrapClass implements BootstrapInterface
|
||
|
{
|
||
|
public function bootstrap($app)
|
||
|
{
|
||
|
$app->on(Application::EVENT_BEFORE_REQUEST, function () {
|
||
|
// do something here
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
```
|
||
|
|
||
|
Entonces se tiene que añadir esta clase en la lista del archivo `composer.json` de la extensión propia como se muestra
|
||
|
a continuación,
|
||
|
|
||
|
```json
|
||
|
{
|
||
|
// ...
|
||
|
|
||
|
"extra": {
|
||
|
"bootstrap": "myname\\mywidget\\MyBootstrapClass"
|
||
|
}
|
||
|
}
|
||
|
```
|
||
|
|
||
|
Cuando se instala la extensión en la aplicación, Yii automáticamente instancia la clase de bootstrapping y llama a su
|
||
|
método [[yii\base\BootstrapInterface::bootstrap()|bootstrap()]] durante el proceso de bootstrapping para cada petición.
|
||
|
|
||
|
#### Trabajar con Bases de Datos<a name="working-with-databases"></a>
|
||
|
|
||
|
Puede darse el caso en que la extensión necesite acceso a bases de datos. No se debe asumir que las aplicaciones que
|
||
|
usen la extensión siempre usarán `Yii::$db` como conexión de BBDD. Se debe crear una propiedad `db` para las clases
|
||
|
que requieran acceso a BBDD. La propiedad permitirá a los usuarios de nuestra extensión elegir que conexión quieren
|
||
|
que use nuestra extensión. Como ejemplo, se puede hacer referencia a la clase [[yii\caching\DbCache]] y observar como
|
||
|
declara y utiliza la propiedad `db`.
|
||
|
|
||
|
Si nuestra extensión necesita crear tablas especificas en la BBDD o hacer cambios en el esquema de la BBDD, debemos:
|
||
|
|
||
|
- proporcionar [migraciones](db-migrations.md) para manipular el esquema de la BBDD, en lugar de utilizar archivos con
|
||
|
sentencias SQL;
|
||
|
- intentar hacer las migraciones aplicables a varios Sistemas de Gestión de BBDD;
|
||
|
- evitar usar [Active Record](db-active-record.md) en las migraciones.
|
||
|
|
||
|
#### Uso de Assets <a name="using-assets"></a>
|
||
|
|
||
|
Si nuestra aplicación es un widget o un módulo, hay posibilidades de que requiera [assets](structure-assets.md) para
|
||
|
poder funcionar. Por ejemplo, un modulo puede mostrar algunas páginas de que contengan archivos JavaScript y/o CSS.
|
||
|
Debido a que los archivos de las extensiones se encuentran en la misma ubicación y no son accesibles por la Web cuando
|
||
|
se instalan en una aplicación, hay dos maneras de hacer los assets accesibles vía Web:
|
||
|
|
||
|
- pedir a los usuarios que copien manualmente los archivos assets en un directorio público de la Web.
|
||
|
- declarar un [asset bundle](structure-assets.md) dejar que el mecanismo de publicación se encargue automáticamente de
|
||
|
copiar los archivos que se encuentren en el asset bundle a un directorio Web público.
|
||
|
|
||
|
Recomendamos el uso de la segunda propuesta para que la extensión sea más fácil de usar para usuarios. Se puede hacer
|
||
|
referencia a la sección [Assets](structure-assets.md) para encontrar más detalles acerca de como trabajar con ellos.
|
||
|
|
||
|
#### Internacionalización y Localización <a name="i18n-l10n"></a>
|
||
|
|
||
|
Puede que las extensiones propias se usen en aplicaciones que den soporte a diferentes idiomas! Por ello, si nuestra
|
||
|
extensión muestra contenido a los usuarios finales, se debe intentar [internacionalizar y localizar](tutorial-i18n.md)
|
||
|
la extensión. En particular,
|
||
|
|
||
|
- Si la extensión muestra mensajes destinados a usuarios finales, los mensajes deben mostrarse usando `Yii::t()` para
|
||
|
que puedan ser traducidos. Los mensajes dirigidos a desarrolladores (como mensajes de excepciones internas) no
|
||
|
necesitan ser traducidos.
|
||
|
- Si la extensión muestra números, fechas, etc., deben ser formateados usando [[yii\i18n\Formatter]] siguiendo las
|
||
|
reglas de formato adecuadas.
|
||
|
|
||
|
Se pueden encontrar más detalles en la sección [internacionalización](tutorial-i18n.md).
|
||
|
|
||
|
#### Testing <a name="testing"></a>
|
||
|
|
||
|
Para conseguir que las aplicaciones propias se ejecuten sin problemas y no causen problemas a otros usuarios, deben
|
||
|
ejecutarse test a las extensiones antes de ser publicadas al público.
|
||
|
|
||
|
Se recomienda crear varios casos de prueba (test cases) para probar el código de nuestra extensión en lugar de
|
||
|
ejecutar pruebas manuales. Cada vez que se vaya a lanzar una nueva versión, simplemente podemos ejecutar estos casos
|
||
|
de prueba para asegurarnos de que todo está correcto. Yii proporciona soporte para testing que puede ayudar a escribir
|
||
|
pruebas unitarias (unit tests), pruebas de aceptación (acceptance tests) y pruebas de funcionalidad
|
||
|
(functionality tests), más fácilmente. Se pueden encontrar más detalles en la sección [Testing](test-overview.md).
|
||
|
|
||
|
#### Versiones <a name="versioning"></a>
|
||
|
|
||
|
Se debe asignar un número de versión cada vez que se lance una nueva distribución. (p. ej. `1.0.1`). Recomendamos
|
||
|
seguir la práctica [Versionamiento Semántico](http://semver.org/lang/es/) para determinar que números se deben usar.
|
||
|
|
||
|
#### Lanzamientos <a name="releasing"></a>
|
||
|
|
||
|
Para dar a conocer nuestra extensión a terceras personas, debemos lanzara al público.
|
||
|
|
||
|
Si es la primera vez que se realiza un lanzamiento de una extensión, debemos registrarla en un repositorio Composer
|
||
|
como puede ser [Packagist](https://packagist.org/). Después de estos, todo lo que tenemos que hacer es crear una
|
||
|
etiqueta (tag) (p. ej. `v1.0.1`) en un repositorio con VCS (Sistema de Control de Versiones) y notificarle al
|
||
|
repositorio Composer el nuevo lanzamiento. Entonces la gente podrá encontrar el nuevo lanzamiento y instalar o
|
||
|
actualizar la extensión a mediante el repositorio Composer.
|
||
|
|
||
|
En los lanzamientos de una extensión, además de archivos de código, también se debe considerar la inclusión los puntos
|
||
|
mencionados a continuación para facilitar a otra gente el uso de nuestra extensión:
|
||
|
|
||
|
* Un archivo léame (readme) en el directorio raíz: describe que hace la extensión y como instalarla y utilizarla.
|
||
|
Recomendamos que se escriba en formato [Markdown](http://daringfireball.net/projects/markdown/) y llamarlo
|
||
|
`readme.md`.
|
||
|
* Un archivo de registro de cambios (changelog) en el directorio raíz: enumera que cambios se realizan en cada
|
||
|
lanzamiento. El archivo puede escribirse en formato Markdown y llamarlo `changelog.md`.
|
||
|
* Un archivo de actualización (upgrade) en el directorio raíz: da instrucciones de como actualizar desde lanzamientos
|
||
|
antiguos de la extensión. El archivo puede escribirse en formato Markdown y llamarlo `upgrade.md`.
|
||
|
* Tutoriales, demostraciones, capturas de pantalla, etc: son necesarios si nuestra extensión proporciona muchas
|
||
|
características que no pueden ser detalladas completamente en el archivo `readme`.
|
||
|
* Documentación de API: el código debe documentarse debidamente para que otras personas puedan leerlo y entenderlo
|
||
|
fácilmente. Más información acerca de documentación de código en
|
||
|
[archivo de Objetos de clase](https://github.com/yiisoft/yii2/blob/master/framework/base/Object.php)
|
||
|
|
||
|
> Información: Los comentarios de código pueden ser escritos en formato Markdown. La extensión `yiisoft/yii2-apidoc`
|
||
|
proporciona una herramienta para generar buena documentación de API basándose en los comentarios del código.
|
||
|
|
||
|
> Información: Aunque no es un requerimiento, se recomienda que la extensión se adhiera a ciertos estilos de
|
||
|
codificación. Se puede hacer referencia a
|
||
|
[estilo de código del núcleo del framework](https://github.com/yiisoft/yii2/wiki/Core-framework-code-style) para
|
||
|
obtener más detalles.
|
||
|
|
||
|
## Extensiones del Núcleo <a name="core-extensions"></a>
|
||
|
|
||
|
Yii proporciona las siguientes extensiones del núcleo que son desarrolladas y mantenidas por el equipo de desarrollo
|
||
|
de Yii. Todas ellas están registradas en [Packagist](https://packagist.org/) y pueden ser instaladas fácilmente como
|
||
|
se describe en la subsección [Uso de Extensiones](#using-extensions)
|
||
|
|
||
|
- [yiisoft/yii2-apidoc](https://github.com/yiisoft/yii2-apidoc):proporciona un generador de documentación de APIs
|
||
|
extensible y de de alto rendimiento.
|
||
|
- [yiisoft/yii2-authclient](https://github.com/yiisoft/yii2-authclient):proporciona un conjunto de clientes de
|
||
|
autorización tales como el cliente OAuth2 de Facebook, el cliente GitHub OAuth2.
|
||
|
- [yiisoft/yii2-bootstrap](https://github.com/yiisoft/yii2-bootstrap): proporciona un conjunto de widgets que
|
||
|
encapsulan los componentes y plugins de [Bootstrap](http://getbootstrap.com/).
|
||
|
- [yiisoft/yii2-codeception](https://github.com/yiisoft/yii2-codeception): proporciona soporte de testing basado en
|
||
|
[Codeception](http://codeception.com/).
|
||
|
- [yiisoft/yii2-debug](https://github.com/yiisoft/yii2-debug): proporciona soporte de depuración para aplicaciones
|
||
|
Yii. Cuando se usa esta extensión, aparece una barra de herramientas de depuración en la parte inferior de cada
|
||
|
página. La extensión también proporciona un conjunto de páginas para mostrar información detallada de depuración.
|
||
|
- [yiisoft/yii2-elasticsearch](https://github.com/yiisoft/yii2-elasticsearch): proporciona soporte para usar
|
||
|
[Elasticsearch](http://www.elasticsearch.org/). Incluye soporte básico para realizar consultas/búsquedas y también
|
||
|
implementa patrones de [Active Record](db-active-record.md) que permiten y permite guardar los `active records` en
|
||
|
Elasticsearch.
|
||
|
- [yiisoft/yii2-faker](https://github.com/yiisoft/yii2-faker): proporciona soporte para usar
|
||
|
[Faker](https://github.com/fzaninotto/Faker) y generar datos automáticamente.
|
||
|
- [yiisoft/yii2-gii](https://github.com/yiisoft/yii2-gii): proporciona un generador de código basado den Web altamente
|
||
|
extensible y que puede usarse para generar modelos, formularios, módulos, CRUD, etc. rápidamente.
|
||
|
- [yiisoft/yii2-imagine](https://github.com/yiisoft/yii2-imagine): proporciona funciones comunes de manipulación de
|
||
|
imágenes basadas en [Imagine](http://imagine.readthedocs.org/).
|
||
|
- [yiisoft/yii2-jui](https://github.com/yiisoft/yii2-jui): proporciona un conjunto de widgets que encapsulan las
|
||
|
iteraciones y widgets de [JQuery UI](http://jqueryui.com/).
|
||
|
- [yiisoft/yii2-mongodb](https://github.com/yiisoft/yii2-mongodb): proporciona soporte para utilizar
|
||
|
[MongoDB](http://www.mongodb.org/). incluye características como consultas básicas, Active Record, migraciones,
|
||
|
caching, generación de código, etc.
|
||
|
- [yiisoft/yii2-redis](https://github.com/yiisoft/yii2-redis): proporciona soporte para utilizar
|
||
|
[redis](http://redis.io/). incluye características como consultas básicas, Active Record, caching, etc.
|
||
|
- [yiisoft/yii2-smarty](https://github.com/yiisoft/yii2-smarty): proporciona un motor de plantillas basado en
|
||
|
[Smarty](http://www.smarty.net/).
|
||
|
- [yiisoft/yii2-sphinx](https://github.com/yiisoft/yii2-sphinx): proporciona soporte para utilizar
|
||
|
[Sphinx](http://sphinxsearch.com). incluye características como consultas básicas, Active Record, code generation,
|
||
|
etc.
|
||
|
- [yiisoft/yii2-swiftmailer](https://github.com/yiisoft/yii2-swiftmailer): proporciona características de envío de
|
||
|
correos electrónicos basadas en [swiftmailer](http://swiftmailer.org/).
|
||
|
- [yiisoft/yii2-twig](https://github.com/yiisoft/yii2-twig): proporciona un motor de plantillas basado en
|
||
|
[Twig](http://twig.sensiolabs.org/).
|