Actualizadas las correcciones de la semana

Author: gitnacho

_sources/book/doctrine.txt

@@ -202,7 +202,10 @@ Para que *Doctrine* sea capaz de hacer esto, sólo hay que crear "metadatos", o
 
 .. caution::
 
-    Ten cuidado de que tu nombre de clase y propiedades no estén asignados a un área protegida por palabras clave de ``SQL`` (tal como ``group`` o ``user``). Por ejemplo, si el nombre de clase de tu entidad es ``group``, entonces, de manera predeterminada, el nombre de la tabla será ``group``, lo cual provocará un error en algunos motores ``SQL``. Consulta la `Documentación de palabras clave reservadas por SQL`_ para que sepas cómo escapar correctamente estos nombres.
+    Ten cuidado de que tu nombre de clase y propiedades no estén asignados a un área protegida por palabras clave de ``SQL`` (tal como ``group`` o ``user``). Por ejemplo, si el nombre de clase de tu entidad es ``group``, entonces, de manera predeterminada, el nombre de la tabla será ``group``, lo cual provocará un error en algunos motores ``SQL``. Consulta la `Documentación de palabras clave reservadas por SQL`_ para que sepas cómo escapar correctamente estos nombres. Alternativamente, si estás en libertad de elegir el esquema
+    de tu base de datos, simplemente asigna un diferente nombre
+    de tabla o columna. Ve las `Clases persistentes`_ y la `Asignación de propiedades`_
+    en la documentación de *Doctrine*.
 
 .. note::
 
@@ -1112,3 +1115,5 @@ Para más información acerca de *Doctrine*, ve la sección *Doctrine* del :doc:
 .. _`Asignando propiedades`: http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/basic-mapping.html#property-mapping
 .. _`Ciclo de vida de los eventos`: http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/events.html#lifecycle-events
 .. _`Documentación de palabras clave reservadas por SQL`: http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/basic-mapping.html#quoting-reserved-words
+.. _`Clases persistentes`: http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/basic-mapping.html#persistent-classes
+.. _`Asignación de propiedades`: http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/basic-mapping.html#property-mapping

_sources/book/translation.txt

@@ -694,7 +694,7 @@ Al traducir un mensaje, *Symfony2* utiliza la configuración regional de la peti
         'fr_FR',
     );
 
-    $this->get('translator')->trans(
+    $this->get('translator')->transChoice(
         '{0} There are no apples|{1} There is one apple|]1,Inf[ There are %count% apples',
         10,
         array('%count%' => 10),

_sources/bundles/DoctrineMongoDBBundle/index.txt

@@ -22,48 +22,38 @@ Está disponible el paquete que integra el *ODM MongoDB de Doctrine* en *Symfony
 Instalando
 ----------
 
-Para utilizar el *ODM MongoDB*, necesitarás dos bibliotecas proporcionadas por *Doctrine* y un paquete que las integra en *Symfony*. Si estás usando la distribución estándar de *Symfony*, agrega lo siguiente al archivo ``deps`` en la raíz de tu proyecto:
+Para utilizar el *ODM MongoDB*, necesitarás dos bibliotecas proporcionadas por *Doctrine* y un paquete que las integra en *Symfony*.
 
-.. code-block:: text
+Instalando el paquete con ``Composer``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    [doctrine-mongodb]
-        git=http://github.com/doctrine/mongodb.git
+Para instalar ``DoctrineMongoDBBundle`` con ``Composer`` sólo tienes que añadir lo siguiente a tu archivo `` :file:`composer.json`::
 
-    [doctrine-mongodb-odm]
-        git=http://github.com/doctrine/mongodb-odm.git
-
-    [DoctrineMongoDBBundle]
-        git=http://github.com/doctrine/DoctrineMongoDBBundle.git
-        target=/bundles/Doctrine/Bundle/MongoDBBundle
+    {
+        require: {
+            "doctrine/mongodb-odm-bundle": "dev-master"
+        }
+    }
 
-Ahora, actualiza las bibliotecas de proveedores ejecutando:
+Luego, puedes instalar las nuevas dependencias ejecutando la orden ``update`` de ``Composer`` desde el directorio donde se encuentra el archivo ``composer.json``:
 
 .. code-block:: bash
 
-    $ php bin/vendors install
+    php composer.phar update
 
-A continuación, agrega los espacios de nombres ``Doctrine\ODM\MongoDB`` y ``Doctrine\MongoDB`` al archivo ``app/autoload.php`` para que estas bibliotecas se puedan cargar automáticamente.
-Asegúrate de añadirlas en cualquier lugar *por encima* del espacio de nombres *Doctrine* (cómo se muestra aquí)::
+Ahora, ``Composer`` automáticamente descargará todos los archivos necesarios y los instalará por ti.
 
-    // app/autoload.php
-    $loader->registerNamespaces(array(
-        // ...
-        'Doctrine\\Bundle'          => __DIR__.'/../vendor/bundles',
-        'Doctrine\\Common'          => __DIR__.'/../vendor/doctrine-common/lib',
-        'Doctrine\\ODM\\MongoDB'    => __DIR__.'/../vendor/doctrine-mongodb-odm/lib',
-        'Doctrine\\MongoDB'         => __DIR__.'/../vendor/doctrine-mongodb/lib',
-        'Doctrine'                  => __DIR__.'/../vendor/doctrine/lib',
-        // ...
-    ));
+Registrando las anotaciones y el paquete
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 A continuación, registra la biblioteca de anotaciones añadiendo las siguientes acciones al cargador (debajo de la línea ``AnnotationRegistry::registerFile`` existente)::
 
     // app/autoload.php
     AnnotationRegistry::registerFile(
-        __DIR__.'/../vendor/doctrine-mongodb-odm/lib/Doctrine/ODM/MongoDB/Mapping/Annotations/DoctrineAnnotations.php'
+        __DIR__.'/../vendor/doctrine/mongodb-odm/lib/Doctrine/ODM/MongoDB/Mapping/Annotations/DoctrineAnnotations.php'
     );
 
-Por último, activa el nuevo paquete en el núcleo::
+Todo lo que resta por hacer es actualizar tu archivo :file:`AppKernel.php`, y registrar el nuevo paquete::
 
     // app/AppKernel.php
     public function registerBundles()
@@ -99,7 +89,7 @@ Para empezar, necesitarás una estructura básica que configure el gestor de doc
 
 .. note::
 
-    Por supuesto, también tienes que asegurarte de que se ejecute en segundo plano el servidor *MongoDB*. Para más información, consulta la `Guía de inicio rápido`_ de *MongoDB*.
+    Por supuesto, también te tienes que asegurar de que el servidor *MongoDB* se ejecute en segundo plano. Para más información, consulta la `Guía de inicio rápido`_ de *MongoDB*.
 
 Un sencillo ejemplo: Un producto
 --------------------------------
@@ -468,7 +458,7 @@ A continuación, agrega un nuevo método --- ``findAllOrderedByName()`` --- a la
 
 Puedes utilizar este nuevo método al igual que los métodos de búsqueda predeterminados del repositorio::
 
-    $product = $this->get('doctrine.odm.mongodb.document_manager')
+    $products = $this->get('doctrine.odm.mongodb.document_manager')
         ->getRepository('AcmeStoreBundle:Product')
         ->findAllOrderedByName();
 
@@ -583,7 +573,7 @@ En *Symfony*, puedes registrar un escucha o suscriptor creando un :term:`servici
             ));
             $container->setDefinition('my_doctrine_listener', $definition);
 
-*   **suscriptor de evento**: Usa la etiqueta ``doctrine.odm.mongodb.event_subscriber`` para un suscriptor. Los suscriptores son responsables de implementar al ``Doctrine\Common\EventSubscriber`` y suplir un método que devuelva los eventos que escuchará. Por esta razón, esta etiqueta no tiene el atributo ``event``;
+*   **suscriptor de evento**: Usa la etiqueta ``doctrine.odm.mongodb.event_subscriber`` para registrar un suscriptor. Los suscriptores son responsables de implementar al ``Doctrine\Common\EventSubscriber`` y suplir un método que devuelva los eventos que escuchará. Por esta razón, esta etiqueta no tiene el atributo ``event``;
     No obstante, dispone de los atributos ``connection``, ``priority`` y ``lazy``.
 
 .. note::
@@ -593,7 +583,7 @@ En *Symfony*, puedes registrar un escucha o suscriptor creando un :term:`servici
 Integrando el ``SecurityBundle``
 --------------------------------
 
-Un proveedor de usuario está disponible para los documentos ``MongoDB``, trabajando exactamente igual que el proveedor de ``entidad`` descrito en el :doc:`recetario </cookbook/security/entity_provider>`
+Hay disponible un proveedor de usuarios para tus proyectos *MongoDB*, trabaja exactamente igual que el proveedor de entidades descrito en el :doc:`recetario </cookbook/security/entity_provider>`
 
 .. configuration-block::
 
@@ -616,9 +606,9 @@ Un proveedor de usuario está disponible para los documentos ``MongoDB``, trabaj
 Resumen
 -------
 
-Con *Doctrine*, te puedes enfocar en los objetos y la forma en que son útiles en tu aplicación y en segundo lugar preocuparte por la persistencia a través de *MongoDB*. Esto se debe a que *Doctrine* te permite utilizar cualquier objeto *PHP* para almacenar los datos y confía en la información de asignación de metadatos para asignar los datos de un objeto a una colección *MongoDB*.
+Con *Doctrine*, te puedes enfocar en los objetos y la forma en que son útiles en tu aplicación y en segundo lugar preocuparte de su persistencia a través de *MongoDB*. Esto se debe a que *Doctrine* te permite utilizar cualquier objeto *PHP* para almacenar los datos y confía en la información de asignación de metadatos para asignar los datos de un objeto a una colección *MongoDB*.
 
-Y aunque *Doctrine* gira en torno a un concepto simple, es increíblemente poderoso, permitiéndote crear consultas complejas y suscribirte a los eventos que te permiten realizar diferentes acciones conforme los objetos recorren su ciclo de vida en la persistencia.
+Y aunque *Doctrine* gira en torno a un concepto simple, es increíblemente potente, permitiéndote crear consultas complejas y suscribirte a los eventos que te permiten realizar diferentes acciones conforme los objetos recorren su ciclo de vida en la persistencia.
 
 Aprende más en el recetario
 ---------------------------

_sources/components/console.txt

@@ -306,7 +306,7 @@ Llamar a una orden desde otra es sencillo::
         // ...
     }
 
-En primer lugar, :method:`Symfony\\Component\\Console\\Command\\Command::find` busca la orden que deseas ejecutar pasando el nombre de la orden.
+En primer lugar, tu :method:`Symfony\\Component\\Console\\Application::find` busca la orden que deseas ejecutar pasando el nombre de la orden.
 
 Entonces, es necesario crear una nueva clase :class:`Symfony\\Component\\Console\\Input\\ArrayInput` con los argumentos y opciones que desees pasar a la orden.
 

_sources/components/dependency_injection/compilation.txt

@@ -17,14 +17,48 @@ Para crear un pase del compilador tienes que implementar la interfaz :class:`Sym
 
 El pase del compilador debe tener el método ``process`` que se pasa al contenedor compilado::
 
-    public function process(ContainerBuilder $container)
+    class CustomCompilerPass
     {
-       //--
+        public function process(ContainerBuilder $container)
+        {
+           //--
+        }
     }
 
 Los parámetros del contenedor y las definiciones se pueden manipular usando los métodos descritos en :doc:`/components/dependency_injection/definitions`.
 Una cosa común por hacer en un pase del compilador es buscar todos los servicios que tienen una determinada etiqueta, a fin de procesarla de alguna manera o dinámicamente conectar cada una con algún otro servicio.
 
+Registrando un pase del compilador
+----------------------------------
+
+Necesitas registrar tu pase personalizado del compilador en el contenedor. El método procesará la llamada cuando el contenedor es compilado::
+
+    use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+    $container = new ContainerBuilder();
+    $container->addCompilerPass(new CustomCompilerPass);
+
+Controlando el orden de los pases
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Los pases predeterminados del compilador se agrupan en pases de optimización y pases de remoción. Los pases de optimización se ejecutan primero e incluyen tareas como la resolución de referencias con las definiciones. Los pases de remoción realizan tareas tales como la eliminación de alias privados y servicios no utilizados. Puedes elegir en qué orden se ejecutará cualquier pase personalizado que añadas. De manera predeterminada, se ejecutará antes de los pases de optimización.
+
+Puedes utilizar las siguientes constantes como segundo argumento al registrar un pase en el contenedor para controlar en qué orden va:
+
+* ``PassConfig::TYPE_BEFORE_OPTIMIZATION``
+* ``PassConfig::TYPE_OPTIMIZE``
+* ``PassConfig::TYPE_BEFORE_REMOVING``
+* ``PassConfig::TYPE_REMOVE``
+* ``PassConfig::TYPE_AFTER_REMOVING``
+
+Por ejemplo, para correr tu pase personalizado después de quitar el pase predeterminado tienes que ejecutar::
+
+    use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+    $container = new ContainerBuilder();
+    $container->addCompilerPass(new CustomCompilerPass, PassConfig::TYPE_AFTER_REMOVING);
+
+
 Gestionando la configuración con extensiones
 --------------------------------------------
 
@@ -42,3 +76,70 @@ Las extensiones no agregan configuración a los contenedores cuando se añaden,
     Si necesitas manipular la configuración cargada por una extensión, entonces no lo puedes hacer desde otra extensión, ya que esta utiliza un contenedor nuevo.
     En su lugar, debes utilizar un pase del compilador que trabaje con el contenedor completo después de haber procesado las extensiones. 
 
+Vertiendo la configuración para mejorar el rendimiento
+------------------------------------------------------
+
+Puede ser mucho más fácil entender el uso de los archivos de configuración para gestionar el contenedor de servicios que usar *PHP* una vez que hay una gran cantidad de servicios. Esta facilidad tiene un costo, aunque cuando se trata de rendimiento, puesto que los archivos de configuración se tienen que analizar y la configuración de *PHP* construida desde ellos. El proceso de compilación hace más eficiente al contenedor pero toma tiempo su ejecución. Puedes tener lo mejor de ambos mundos aunque usando archivos de configuración y, luego vertiendo y almacenando en caché la configuración resultante. El ``PhpDumper`` fácilmente vierte el contenedor compilado::
+
+    use Symfony\Component\DependencyInjection\ContainerBuilder;
+    use Symfony\Component\Config\FileLocator;
+    use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
+    use Symfony\Component\DependencyInjection\Dumper\PhpDumper
+
+    $container = new ContainerBuilder();
+    $loader = new XmlFileLoader($container, new FileLocator(__DIR__));
+    $loader->load('services.xml');
+
+    $file = __DIR__ .'/cache/container.php';
+
+    if (file_exists($file)) {
+        require_once $file;
+        $container = new ProjectServiceContiner();
+    } else {
+        $container = new ContainerBuilder();
+        //--
+        $container->compile();
+
+        $dumper = new PhpDumper($container);
+        file_put_contents($file, $dumper->dump());
+    }
+
+``ProjectServiceContiner`` es el nombre predefinido dado a la clase contenedora vertida, lo puedes cambiar con la opción ``class`` cuando lo viertes::
+
+    // ...
+    $file = __DIR__ .'/cache/container.php';
+
+    if (file_exists($file)) {
+        require_once $file;
+        $container = new MyCachedContainer();
+    } else {
+        $container = new ContainerBuilder();
+        //--
+        $container->compile();
+
+        $dumper = new PhpDumper($container);
+        file_put_contents($file, $dumper->dump(array('class' => 'MyCachedContainer')));
+    }
+
+Ahora obtendrás la velocidad del contenedor *PHP* configurado con ---los fáciles de usar--- archivos de configuración. En el ejemplo anterior tendrás que borrar los archivos del contenedor memorizados en caché cada vez que hagas algún cambio. Añadir una comprobación por una variable que determina si estás en modo de depuración te permite mantener la velocidad del contenedor memorizado en caché en la producción, sino consiguiendo una actualización de la configuración, mientras desarrollas tu aplicación::
+
+    // ...
+
+    // establece $isDebug basándose en algo de tu proyecto
+
+    $file = __DIR__ .'/cache/container.php';
+
+    if (!$isDebug && file_exists($file)) {
+        require_once $file;
+        $container = new MyCachedContainer();
+    } else {
+        $container = new ContainerBuilder();
+        //--
+        $container->compile();
+
+        if(!$isDebug) 
+            $dumper = new PhpDumper($container);
+            file_put_contents($file, $dumper->dump(array('class' => 'MyCachedContainer')));
+        }
+    }
+

_sources/components/dependency_injection/index.txt

@@ -7,6 +7,7 @@ Inyección de dependencias
     introduction
     definitions
     compilation
+    tags
     factories
     parentservices
 

_sources/components/dependency_injection/introduction.txt

@@ -326,10 +326,3 @@ Ahora obtendrás la velocidad del contenedor *PHP* configurado con ---los fácil
             file_put_contents($file, $dumper->dump(array('class' => 'MyCachedContainer')));
         }
     }
-
-Aprende más de este componente
-------------------------------
-
-* :doc:`/components/dependency_injection/definitions`
-* :doc:`/components/dependency_injection/factories`
-* :doc:`/components/dependency_injection/parentservices`